Personal tools

H3D

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(Added OpenSG link and comment on my own code.)
m (Fixed bullets for new wiki)
Line 14: Line 14:
 
If you're willing to contribute (in any way: code, idea's, feedback, even money ;)) to this project, please add your name below. (no strings attached)
 
If you're willing to contribute (in any way: code, idea's, feedback, even money ;)) to this project, please add your name below. (no strings attached)
   
* [http://haskell.org/hawiki/KennethHoste boegel] (project idea, creator of this wiki)
+
* [http://haskell.org/hawiki/KennethHoste boegel] (project idea, creator of this wiki)
* bourbaki (L-systems and Ogre3D idea)
+
* bourbaki (L-systems and Ogre3D idea)
* sylvan (scene graph idea)
+
* sylvan (scene graph idea)
* Also, it might be worthwhile to exploit the ongoing convergence of high-end scanline renderers (a la Pixar) and consumer hardware. Next gen hardware (and even current high-end) could definatly produce movie-quality (honestly!) renderings with about the same throughput as a 1000-machine rendering farm, but with much less latency (one computer producing frames every two seconds, instead of a thousand computers producing one frame each every thirty minutes) which is definatly preferably from an artists standpoint.
+
** Also, it might be worthwhile to exploit the ongoing convergence of high-end scanline renderers (a la Pixar) and consumer hardware. Next gen hardware (and even current high-end) could definatly produce movie-quality (honestly!) renderings with about the same throughput as a 1000-machine rendering farm, but with much less latency (one computer producing frames every two seconds, instead of a thousand computers producing one frame each every thirty minutes) which is definatly preferably from an artists standpoint.
* ["shelarcy"] (introduce Japanese page and write that summary)
+
* ["shelarcy"] (introduce Japanese page and write that summary)
* Pseudonym (follow Renderman interface)
+
* Pseudonym (follow Renderman interface)
* pipe (wolfgang8k):
+
* pipe (wolfgang8k):
* write your own scanline renderer in Haskell, use OpenGL for real-time stuff (or write a renderer yourself)
+
** write your own scanline renderer in Haskell, use OpenGL for real-time stuff (or write a renderer yourself)
* start with a scenegraph (Haskell type) and a simple command line interface
+
** start with a scenegraph (Haskell type) and a simple command line interface
* use the CLI for basic operations on the scenegraph (adding stuff)
+
** use the CLI for basic operations on the scenegraph (adding stuff)
* create a GUI with buttons which are bound to function like addSphere :: Scene -> Scene
+
** create a GUI with buttons which are bound to function like addSphere :: Scene -> Scene
* keep a list a scenes for undo/redo purposes (a lot of memory, but very simple)
+
** keep a list a scenes for undo/redo purposes (a lot of memory, but very simple)
* figure out a system for selecting objects (selection = list of integers, indices of objects in the scene)
+
** figure out a system for selecting objects (selection = list of integers, indices of objects in the scene)
* functions like translate, scale, rotate of type Scene -> [Int] -> (dx,dy,dz) -> Scene
+
** functions like translate, scale, rotate of type Scene -> [Int] -> (dx,dy,dz) -> Scene
* system for editing attributes of objects (radius of a Sphere, intensity of a light source)
+
** system for editing attributes of objects (radius of a Sphere, intensity of a light source)
* with OpenGL, you only need a function in IO monad which takes a Scene value and renders it
+
** with OpenGL, you only need a function in IO monad which takes a Scene value and renders it
  +
** marcusl : maybe interested in providing some scene graph bindings.
   
 
=== Open questions and suggestions ===
 
=== Open questions and suggestions ===
   
* ''What do we want ?''
+
* ''What do we want ?''
   
 
An open source application that has to do with 3D modelling. Probably something real-time (like Maya and Blender), but not just
 
An open source application that has to do with 3D modelling. Probably something real-time (like Maya and Blender), but not just
 
another 3D modeller. We want to show off Haskell's strengths, and use techniques unique to Haskell and functional programming.
 
another 3D modeller. We want to show off Haskell's strengths, and use techniques unique to Haskell and functional programming.
   
* ''What can we use that is already available ?''
+
* ''What can we use that is already available ?''
   
 
Ogre3D: open source graphics engine; G3D: http://g3d-cpp.sourceforge.net/; L-systems: technique to create plants, feathers and the lot; SDL bindings (Lemmih); HOpenGL: OpenGL binding for Haskell; Monads (in Haskell) -> http://haskell.org/hawiki/MonadsAsContainers
 
Ogre3D: open source graphics engine; G3D: http://g3d-cpp.sourceforge.net/; L-systems: technique to create plants, feathers and the lot; SDL bindings (Lemmih); HOpenGL: OpenGL binding for Haskell; Monads (in Haskell) -> http://haskell.org/hawiki/MonadsAsContainers
   
* ''Where do we begin ?''
+
* ''Where do we begin ?''
   
 
First idea: build an L-system, then create a simple Ogre3D binding to visualize stuff
 
First idea: build an L-system, then create a simple Ogre3D binding to visualize stuff
Line 48: Line 48:
 
Second idea: start with a scene graph, and implement simple stuff like polygon soups and parametric surfaces at first
 
Second idea: start with a scene graph, and implement simple stuff like polygon soups and parametric surfaces at first
   
* How do we use Ogre3D from within Haskell ?
+
* How do we use Ogre3D from within Haskell ?
   
 
Use a C interface that doesn't exist yet :-)
 
Use a C interface that doesn't exist yet :-)
Line 56: Line 56:
 
or use Hacanon to call C++ code from within Haskell: [http://haskell.org/hawiki/Hacanon]
 
or use Hacanon to call C++ code from within Haskell: [http://haskell.org/hawiki/Hacanon]
   
* ''How far will we go with this ?''
+
* ''How far will we go with this ?''
   
 
Don't know, as long as it's fun !
 
Don't know, as long as it's fun !
   
* ''More open questions ?''
+
* ''More open questions ?''
   
 
boegel
 
boegel
Line 70: Line 70:
 
just push the meshes and such into the engine.
 
just push the meshes and such into the engine.
   
* http://www.cs.wpi.edu/~emmanuel/courses/cs563/write_ups/bradg/feathers/featherpaper.htm#intro
+
* http://www.cs.wpi.edu/~emmanuel/courses/cs563/write_ups/bradg/feathers/featherpaper.htm#intro
* http://www.geocities.com/blenderdungeon/lsystem/
+
* http://www.geocities.com/blenderdungeon/lsystem/
* http://www.nbb.cornell.edu/neurobio/land/OldStudentProjects/cs490-94to95/hwchen/
+
* http://www.nbb.cornell.edu/neurobio/land/OldStudentProjects/cs490-94to95/hwchen/
* http://en.wikipedia.org/wiki/L-system
+
* http://en.wikipedia.org/wiki/L-system
* http://algorithmicbotany.org/papers/
+
* http://algorithmicbotany.org/papers/
* http://algorithmicbotany.org/virtual_laboratory/
+
* http://algorithmicbotany.org/virtual_laboratory/
* http://citeseer.lcs.mit.edu/deussen98realistic.html
+
* http://citeseer.lcs.mit.edu/deussen98realistic.html
   
 
This would make it necessary to write a good and flexible mesh class.
 
This would make it necessary to write a good and flexible mesh class.
Line 88: Line 88:
   
 
Here are some ideas (feel free to add !):
 
Here are some ideas (feel free to add !):
* boegel's ray tracing application HRay: http://www.elis.ugent.be/~kehoste/Haskell/HRay
+
* boegel's ray tracing application HRay: http://www.elis.ugent.be/~kehoste/Haskell/HRay
* boegel's HaskLS (L-System implementation in Haskell): http://www.elis.ugent.be/~kehoste/Haskell/HaskLS
+
* boegel's HaskLS (L-System implementation in Haskell): http://www.elis.ugent.be/~kehoste/Haskell/HaskLS
* bourbaki's spline renderer: http://codemages.sf.net/homotopy1.hs
+
* bourbaki's spline renderer: http://codemages.sf.net/homotopy1.hs
* benny's ray tracing application hrayt: http://benny.kramekweb.com/hrayt/
+
* benny's ray tracing application hrayt: http://benny.kramekweb.com/hrayt/
* Andy's Htrace: http://www.nobugs.org/developer/htrace/
+
* Andy's Htrace: http://www.nobugs.org/developer/htrace/
* Bernie's bjpop-ray: http://www.cs.mu.oz.au/~bjpop/code.html
+
* Bernie's bjpop-ray: http://www.cs.mu.oz.au/~bjpop/code.html
* tanakh's glexcess demo: http://d.hatena.ne.jp/tanakh/20050324
+
* tanakh's glexcess demo: http://d.hatena.ne.jp/tanakh/20050324
* summary for this page: tanakh port http://www.glexcess.com/ demo for haskell (http://fxp.infoseek.ne.jp/haskell/glexcess_haskell.zip). He knows that is ported for D language by yaneurao (http://www.sun-inet.or.jp/~yaneurao/) too. He ported only Scene1 and Scene2. He is tired this work - port C code to Haskell by functionality code. He already developed demo framwork, so he hope other person try to develop full scene.
+
** summary for this page: tanakh port http://www.glexcess.com/ demo for haskell (http://fxp.infoseek.ne.jp/haskell/glexcess_haskell.zip). He knows that is ported for D language by yaneurao (http://www.sun-inet.or.jp/~yaneurao/) too. He ported only Scene1 and Scene2. He is tired this work - port C code to Haskell by functionality code. He already developed demo framwork, so he hope other person try to develop full scene.
* tanakh and his friend - nushio made Haskell shooting game. this game use only wireframe for character : http://www.geocities.jp/takascience/
+
* tanakh and his friend - nushio made Haskell shooting game. this game use only wireframe for character : http://www.geocities.jp/takascience/
* summary for this page: this game name is Shu-thing. this page has 4 screen shot and game with source (http://www.geocities.jp/takascience/windows/shu-thing.zip). Command : move - cursor key, shoot - y, quite this game - q. english translation of the page available at(http://www.geocities.jp/takascience/index_e.html).
+
** summary for this page: this game name is Shu-thing. this page has 4 screen shot and game with source (http://www.geocities.jp/takascience/windows/shu-thing.zip). Command : move - cursor key, shoot - y, quite this game - q. english translation of the page available at(http://www.geocities.jp/takascience/index_e.html).
* wolfgang's POV-Ray's object viewer VOP: http://www.kfunigraz.ac.at/imawww/thaller/wolfgang/vop-intro.html
+
* wolfgang's POV-Ray's object viewer VOP: http://www.kfunigraz.ac.at/imawww/thaller/wolfgang/vop-intro.html
* Conal Elliot's Vertigo: (http://conal.net/Vertigo/). Could ideas be taken from this to get a flexible material system?
+
* Conal Elliot's Vertigo: (http://conal.net/Vertigo/). Could ideas be taken from this to get a flexible material system?
* Marcus' HSpark: http://www.yar.nu/macke/hspark/ . But you can't get latest code, you can get only older version that can't use with sample code. (Code on semi-broken HDD. Will try to get some data off it. /Marcus)
+
* Marcus' HSpark: http://www.yar.nu/macke/hspark/ . But you can't get latest code, you can get only older version that can't use with sample code. (Code on semi-broken HDD. Will try to get some data off it. /Marcus)
* You might check out [http://www.cairographics.org/hscairo hscairo]. From Cairo's description: "Cairo is a vector graphics library designed to provide high-quality display and print output. Currently available backends include the X Window System, OpenGL (via [WWW]glitz), Quartz, win32, in-memory image buffers, PNG images, PostScript, and PDF files."
+
* You might check out [http://www.cairographics.org/hscairo hscairo]. From Cairo's description: "Cairo is a vector graphics library designed to provide high-quality display and print output. Currently available backends include the X Window System, OpenGL (via [WWW]glitz), Quartz, win32, in-memory image buffers, PNG images, PostScript, and PDF files."
* Lemmih's [http://www.libsdl.org SDL] binding: darcs get http://scannedinavian.org/~lemmih/SDLstable/
+
* Lemmih's [http://www.libsdl.org SDL] binding: darcs get http://scannedinavian.org/~lemmih/SDLstable/
* Check out Wings 3d, open source modeler written in Erlang: http://www.wings3d.com/
+
* Check out Wings 3d, open source modeler written in Erlang: http://www.wings3d.com/
* Banyan: a 3D modeller with shared repository http://www.schemearts.com/banyan/wiki
+
* Banyan: a 3D modeller with shared repository http://www.schemearts.com/banyan/wiki
* open source modeller: http://k3d.sourceforge.net/ (Pseudonym)
+
* open source modeller: http://k3d.sourceforge.net/ (Pseudonym)
* Pseudonym's fluid simulator
+
* Pseudonym's fluid simulator
* Another simple raytracer, written by someone (can't remember who) and extended by Pseudonym to use proper sampling strategies: http://andrew.bromage.org/rt.hs
+
* Another simple raytracer, written by someone (can't remember who) and extended by Pseudonym to use proper sampling strategies: http://andrew.bromage.org/rt.hs
* follow the RenderMan interface: http://www.rendermanacademy.com
+
* follow the RenderMan interface: http://www.rendermanacademy.com
* sylvan mentioned OpenSceneGraph as a possible inspiration: http://www.openscenegraph.org/
+
* sylvan mentioned OpenSceneGraph as a possible inspiration: http://www.openscenegraph.org/
* shelarcy mentioned Open Inventor, yet another 3D toolkit (C++,Java)
+
* shelarcy mentioned Open Inventor, yet another 3D toolkit (C++,Java)
* marcusl thinks http://opensg.vrsource.org/ is a very nice open source scene graph.
+
* marcusl thinks http://opensg.vrsource.org/ is a very nice open source scene graph.
 
   
 
Any suggestions are welcome !
 
Any suggestions are welcome !

Revision as of 20:40, 3 October 2006

Contents

1 H3D

Welcome to the H3D wiki. This page is meant for gathering ideas and suggestions for a 3D modelling application written in Haskell. Writing it should be about exploring the possibilites of Haskell, and adding stuff no other language else has.

Current work: getting L-systems (["HaskLS"]) working in Haskell, and going on from there...

1.1 Contributors

Please mention your nickname on #haskell, for future reference.

Also, that way we can determine how many people are willing to work on this project in the future.

If you're willing to contribute (in any way: code, idea's, feedback, even money ;)) to this project, please add your name below. (no strings attached)

  • boegel (project idea, creator of this wiki)
  • bourbaki (L-systems and Ogre3D idea)
  • sylvan (scene graph idea)
    • Also, it might be worthwhile to exploit the ongoing convergence of high-end scanline renderers (a la Pixar) and consumer hardware. Next gen hardware (and even current high-end) could definatly produce movie-quality (honestly!) renderings with about the same throughput as a 1000-machine rendering farm, but with much less latency (one computer producing frames every two seconds, instead of a thousand computers producing one frame each every thirty minutes) which is definatly preferably from an artists standpoint.
  • ["shelarcy"] (introduce Japanese page and write that summary)
  • Pseudonym (follow Renderman interface)
  • pipe (wolfgang8k):
    • write your own scanline renderer in Haskell, use OpenGL for real-time stuff (or write a renderer yourself)
    • start with a scenegraph (Haskell type) and a simple command line interface
    • use the CLI for basic operations on the scenegraph (adding stuff)
    • create a GUI with buttons which are bound to function like addSphere :: Scene -> Scene
    • keep a list a scenes for undo/redo purposes (a lot of memory, but very simple)
    • figure out a system for selecting objects (selection = list of integers, indices of objects in the scene)
    • functions like translate, scale, rotate of type Scene -> [Int] -> (dx,dy,dz) -> Scene
    • system for editing attributes of objects (radius of a Sphere, intensity of a light source)
    • with OpenGL, you only need a function in IO monad which takes a Scene value and renders it
    • marcusl : maybe interested in providing some scene graph bindings.

1.2 Open questions and suggestions

  • What do we want ?

An open source application that has to do with 3D modelling. Probably something real-time (like Maya and Blender), but not just another 3D modeller. We want to show off Haskell's strengths, and use techniques unique to Haskell and functional programming.

  • What can we use that is already available ?

Ogre3D: open source graphics engine; G3D: http://g3d-cpp.sourceforge.net/; L-systems: technique to create plants, feathers and the lot; SDL bindings (Lemmih); HOpenGL: OpenGL binding for Haskell; Monads (in Haskell) -> http://haskell.org/hawiki/MonadsAsContainers

  • Where do we begin ?

First idea: build an L-system, then create a simple Ogre3D binding to visualize stuff

Second idea: start with a scene graph, and implement simple stuff like polygon soups and parametric surfaces at first

  • How do we use Ogre3D from within Haskell ?

Use a C interface that doesn't exist yet :-)

http://www.ogre3d.org/phpBB2/viewtopic.php?p=76429#76429

or use Hacanon to call C++ code from within Haskell: [1]

  • How far will we go with this ?

Don't know, as long as it's fun !

  • More open questions ?

boegel


One suggestion i would like to make is to use an existing 3D engine like www.ogre3d.org and just write a wrapper in haskell. So one can do all the fancy math stuff in haskell and just push the meshes and such into the engine.

This would make it necessary to write a good and flexible mesh class. I would prefer something with which you can do fancy things like glueing two meshes. Maya has some interesting features that could easily be implemented that way.

bourbaki

1.3 Suggestions - idea's - stuff we can use

Here are some ideas (feel free to add !):

Any suggestions are welcome !


boegel


Note to self:

L-system information

* http://www.inf.ed.ac.uk/teaching/courses/inf1/fp/assignments/ex3.pdf
* http://planet.plt-scheme.org/
* http://matt.blissett.me.uk/uni/course/computing/firstyear/declarative_programming/lSystem/

Useing Hray to render the Lsystems maybe useing metaballs for the branches