Difference between revisions of "H3D"

From HaskellWiki
Jump to: navigation, search
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://scannedinavian.org/~boegel/HRay
  * boegel's ray tracing application HRay:  http://www.elis.ugent.be/~kehoste/Haskell/HRay
  * boegel's HaskLS (L-System implementation in Haskell): http://scannedinavian.org/~boegel/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/

Revision as of 12:52, 13 April 2006


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...


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

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 :-)


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 ?


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.

* http://www.cs.wpi.edu/~emmanuel/courses/cs563/write_ups/bradg/feathers/featherpaper.htm#intro
* http://www.geocities.com/blenderdungeon/lsystem/
* http://www.nbb.cornell.edu/neurobio/land/OldStudentProjects/cs490-94to95/hwchen/
* http://en.wikipedia.org/wiki/L-system
* http://algorithmicbotany.org/papers/
* http://algorithmicbotany.org/virtual_laboratory/
* http://citeseer.lcs.mit.edu/deussen98realistic.html

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.


Suggestions - idea's - stuff we can use

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

* 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
* bourbaki's spline renderer: http://codemages.sf.net/homotopy1.hs
* benny's ray tracing application hrayt: http://benny.kramekweb.com/hrayt/
* Andy's Htrace: http://www.nobugs.org/developer/htrace/
* Bernie's bjpop-ray: http://www.cs.mu.oz.au/~bjpop/code.html
* 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.
* 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).
* 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?
* Marcus's 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.
* You might check out 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 SDL binding: darcs get http://scannedinavian.org/~lemmih/SDLstable/
* 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
* open source modeller: http://k3d.sourceforge.net/ (Pseudonym)
* 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
* follow the RenderMan interface: http://www.rendermanacademy.com
* sylvan mentioned OpenSceneGraph as a possible inspiration: http://www.openscenegraph.org/
* shelarcy mentioned Open Inventor, yet another 3D toolkit (C++,Java)

Any suggestions are welcome !


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