Difference between revisions of "H3D"

From HaskellWiki
Jump to navigation Jump to search
(Added links to HOgre and HGamer3D-Ogre-Binding packages)
Line 90: Line 90:
 
and just write a wrapper in haskell. So one can do all the fancy math stuff in haskell and
  
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.
  
just push the meshes and such into the engine.
  +
  +
Peter Althainz:
  +
There are different wrappers existing for Ogre on hackage:
  +
HOgre (http://hackage.haskell.org/package/hogre)
  +
HGamer3D-Ogre-Binding (http://hackage.haskell.org/package/HGamer3D-Ogre-Binding)
  +
In my opinion, to get started with 3D graphics/animation, using an existing library is a good approach. Writing an own one has its own interesting aspects, but will use up a lot of time and resource. Also with a well structure library, usage can be quite granular.
   
 
[The problem with this approach is that it constrains one to use the features of that engine. It is far more interesting to write new kinds of renderers.]
  
[The problem with this approach is that it constrains one to use the features of that engine. It is far more interesting to write new kinds of renderers.]
Line 140: Line 146:
 
* Try to be modular: Ability to combine different modelers, rendering engines &c. built on a minimal shared base (SceneGraph?) with also minimal interfaces. This helps innovation, because if you rewrite one part of the pipeline, the rest doesn't break.
  
* Try to be modular: Ability to combine different modelers, rendering engines &c. built on a minimal shared base (SceneGraph?) with also minimal interfaces. This helps innovation, because if you rewrite one part of the pipeline, the rest doesn't break.
 
* A 3D render engine written in Haskell: [http://www.haskell.org/haskellwiki/LambdaCubeEngine Lambda-Cube]
  
* A 3D render engine written in Haskell: [http://www.haskell.org/haskellwiki/LambdaCubeEngine Lambda-Cube]
  +
* HGamer3D Ogre Binding - http://hackage.haskell.org/package/HGamer3D-Ogre-Binding
   
 
Any suggestions are welcome !
  
Any suggestions are welcome !

Revision as of 18:27, 22 January 2012

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.
  • Haskell SceneGraph

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.
  • markw: See SceneGraph. Currently looking at OpenSceneGraph and started looking at CrystalSpace. Both of these target different uses - OSG is for virtual landscapes whilst CS is for games (and so includes 'out of the box' interaction and entity control). Both of these are C++ libraries and libraries to scripting languages have been developed using SWIG (hence my post on Haskell cafe asking if anyone had used SWIG with Haskell). They look like well crafted class libraries but but a missing the next level of abstraction. Haskell can offer a bridge to a higher level of abstraction; what that is doesn't seem to be obvious but a least Haskell will enable experimentation using, for instance, Conal's work. I am particularly interested in algorithmic generation of landscapes and game maps and how you can mimic the natural (and non-natural) process that sculpt the land (ie as the next level of abstraction).
  • lazor: I like the idea. I'm just generally interested in 3D modelling, I'm using wings3d right now. I would use whatever comes out of this effort, test it, write bug reports, etc., maybe even code some stuff. The possibility of collaborative modelling would make me happy.
  • hcube: bullet physics haskell wrapper, blender developer and user, fun project stunts remake, 3d render engine in haskell: LambdaCube
  • subw: I have had an interest in 3D (rendering & modelling) for a long time. I've used several different 3D packages (Cinema 4D, Lightwave) a few years back, I could test, and file bugs. Coding maybe when I know more math :-)
  • jfischoff: New to Haskell. I've been in the game industry for a few years now. Used to work for Emergent Game Technologies on their Gamebryo Engine. Written two little game engines for different companies. I think getting a COLLADA importer written and a pure way to render to images are two tasks I would like to work on first.

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.
    • Library of geometric processing functions. Delaunay triangulation, triangle stripification, subdivsion, etc.
    • Pure Haskell linear algebra
    • Interpolated curve and surface library. Bézier, NURBS, subdivision surfaces, etc.
    • Mesh deformation library: smooth skinning, morph target, ffd, etc.
    • Pure Haskell Renderer. Texture mapped meshes as base, build towards shader based global illumination.
    • Key-frame based animation library. Various forms of interpolation. Build to clip based non-linear animation.
    • Transform hierarchies for bones, scenes, etc.


  • What can we use that is already available ?


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

Peter Althainz: There are different wrappers existing for Ogre on hackage: HOgre (http://hackage.haskell.org/package/hogre) HGamer3D-Ogre-Binding (http://hackage.haskell.org/package/HGamer3D-Ogre-Binding) In my opinion, to get started with 3D graphics/animation, using an existing library is a good approach. Writing an own one has its own interesting aspects, but will use up a lot of time and resource. Also with a well structure library, usage can be quite granular.

[The problem with this approach is that it constrains one to use the features of that engine. It is far more interesting to write new kinds of renderers.]

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

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/programming/haskell/lsystem/

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


Retrieved from "https://wiki.haskell.org/index.php?title=H3D&oldid=44124"