From delta3d Wiki
Jump to: navigation, search

The table below has the ideas that we at Delta3D would like to see developers pursue to help improve the engine. If you have interest in any of these, we ask that you send an e-mail to info (at) delta3d dot org prior to starting. While we appreciate any contribution, if there is a dialog prior to beginning the project, we can discuss exactly what we have in mind and any ideas we have to make building and integrating it into Delta3D easier.

Topic Requirements
Bundle level resources together into a compressed format. Find all referenced resources from a Map and bundle into a compressed/uncompressed package. This will enable us to redistribute things like audio files or 3D models from standard web-purchased sites. This would involve treating the compressed bundle as a virtual file system for the purposes of finding resources such as maps, static meshes, and audio files. This is a major hurdle to projects that use art and audio assets from stock providers because their licensing almost always insists that releases cannot be in the original, unedited format. C++, OpenGL not required. Understanding of file parsing and compression technology a plus.
Creation of a tool to procedurally generate terrain.

Create a graphical tool using Qt (similar to the current set of Delta3D tools) to enable the generation of terrain geometry through various methods starting with parameterization from a height map (black and white texture representing scale of the height at the sampled pixel) and the ability to refine/modify the generated geometry after creation to achieve the desired results. An ideal candidate for procedural creation is Terrain Synthesis from Digital Elevation Models (http://www.howardzzh.com/research/terrain/)

C++, OpenGL
Develop a particle system for Delta3D. Open Scene Graph has a particle system that is outdated, constrained, and very inefficient. Take the elements of the OSG particle system and develop a new particle system directly for Delta3D. It should allows features such as direct hardware support, physical interaction with the scene, not drawn in immediate mode, motion control over particles more than just linear and simple forces (ex circular motions), ability to correctly cap the number of particles, and the ability to correctly distribute the placement of particles across a timeslice (vice bursting all at once).
implementing a proper nav mesh (defining a graph of continuous regions of walkable space, rather than discrete points) which will improve pathfinding performance and make AI path planning far more robust, realistic, and adaptable, as well as solving many existing unresolved issues involving collision detection -- as per this article: http://www.ai-blog.net/archives/000152.html C++, graph algorithm experience
Complete the physics abstraction layer (dtPhysics) and integrate into Delta3D Currently, dtCore is coded to use Open Dynamics Engine directly. Work has begun to develop dtPhysics, which uses the Physics Abstraction Layer project to isolate the API from the underlying physics engine. Identify the remaining tasks in dtPhysics, finish the work, and research how best to employ it into Delta3D Proper. Open Dynamics Engine, Physics Abstraction Layer, C++
Add the ability to precompute global illumination for a scene and output the results as light maps ("baked" lighting and shadows) from the Delta3D editor STAGE

Many popular game engines allow global scene lighting to be computed offline for each map/level from within the game's editor. This allows the use of non-realtime methods to calculate the distribution of light in a static scene and store the results in texture maps (light maps). See http://www.flipcode.com/archives/Light_Mapping_Theory_and_Implementation.shtml or http://www.irrlicht3d.org/pivot/entry.php?id=351

c++, OpenGL, understanding of lighting and radiosity
Add to STAGE a mechanism (perhaps a plug-in?) for compositing Actors from ActorComponents. Currently, GameActors have the ability to contain ActorComponents, but they have to be hard-coded in. This work would include treating ActorComponents like plugins (dynamically loading, have a "type", etc.) and creating UI to load, select, and assemble the components. C++, Qt, knowledge of dynamic linkage
Creating a Cinema editor that can be used to create cinematics in dtDirector. This will be much like the Matinee editor used in Unreal. C++, Qt, knowledge of dynamic linking.
Full integration of shadowing into the engine utilizing osg's Light Space Perspective Shadow Maps. osgShadow, Delta3D Scene
A UI for the dtAI Planning system. Currently, the dtAI planning system is a very powerful feature which requires lots of hard coding small classes. Design and implement a UI system which allows a user to assemble the States, Operations, and Preconditions graphically. UI (Qt?), C++, dtAI Planning System, dtDirector(?)
A Delta3D xml parsing wrapper class, to isolate Xerces API from the end user. Delta3D performs xml parsing in numerous places, relying directly on Xerces API. Create a generic XML parser, perhaps wrapping Xerces, to hide the parsing details. Also convert all existing Delta3D Xerces parsing code to use the wrapper. Xerces, C++, Functors, xml
Add support for loading VBS2 files The Virtual Battle Space training system is used by numerous government agencies for simulations and training. Add the ability to parse and load existing VBS2 files (scenario? mesh?) into Delta3D. C++, knowledge of the VBS2 engine and file formats, OSG file loading.
Provide language agnostic scripting language. Currently, only some of the C++ is exposed to Python. A better solution would be to allow use with other scripting languages such as Lua. Perhaps use SWIG to generate the bindings? C++, Python, SWIG
Delta3D has its own Qt UI system for editing ActorProperties. Investigate if this should be replaced by the native property editing solutions found in Qt's Designer (PropertyEditor) or the Qt Solutions Property Browser. If feasible, integrate with the Delta tools. C++, Qt, Delta3D's dtQt
Create a system for "soft" particles:

Particle sprites are widely used in most games. They are used for a variety of semitransparent effects such as fog, smoke, dust, magic spells and explosions. However, sprites commonly produce artifacts – unnaturally sharp edges – where they intersect the rest of the scene. Integrate "soft" methods into the Delta3D particle system to alleviate these issues. See: http://developer.download.nvidia.com/whitepapers/2007/SDK10/SoftParticles_hi.pdf

c++, OpenGL

--Pmcdowell 06:07, 10 March 2010 (UTC)