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