Summer of Code - General Info

The general information for GSoC and CS is now found at SoC

Summer of Code - Project ideas

As CrystalSpace is a 3D engine, there should be plenty of opportunities for interesting projects. If the intended end result is nice and shiny, it's probably a project candidate ;). So feel free to submit your own ideas, or discuss them some of the administrators/mentors if you want some more guidance. At this point no specific project has been assigned to any specific mentor, so if you cannot find "the" mentor for your questions, try to talk to Jorrit, Frank (res2k) or Marten (thebolt) and they will help you out.

Below you will find our proposals for things to do within the Crystal Space project.

Lighter2 improvements

Crystal Space new(er) lightmap calculation 'lighter2' has over the last years been improved to a state where it can replace the older lightmapping system and generate nice-looking static lighting. However to fully compete in quality with commercial alternatives it does need a set of improvements.

At this moment, the most interesting parts in 'lighter2' to look at are:

  • More memory efficient data representations. At the moment the data needed for computing the lighting takes massive amount of memory (multi-GB on big levels) and the techniques needed to handle it (explicit swapping, compression etc) slows the process down. A student with strong interest in data structures should be able to find a more memory efficient data representation.
  • Multi-threading / multi-computer usage for calculations. To speed up the execution of lightmapping, which is an inherently parallel process, we would like 'lighter2' to be able to utilize more than one processor; both via multithreading (taking advantage of multicore) and across multiple processors. A SoC project here could include either or both parts.
  • Using OpenCL (ideally) or CUDA, implement support for GPGPU computation in lighter2. This would *require* you to have or be able to get a graphics card which supports GPGPU (Nvidia 8+ generation or AMD/ATI equiv). However if you have a great proposal but no card, apply anyway.
  • Continue the work on radiosity. Some work has been made in previous GSOC toward a photon mapper in lighter2, but it is not yet fully usable. Description of the work made can be found here, and the code is accessible  there.
  • Light probes: sample information in incoming light at different points in space. A full implementation would include a lighter2 part (generation of light probes) as well as an engine part (loading light probes, and setting information on meshes from the light probes). In fact, a framework for light probes would be a more interesting result than a fancy light probe style. (Light probes here means information about incoming lighting at some points in space. Think of it as kind of a lightmap in 3D. "HDR light probes" are _not_ meant here.)
  • Improve directional lightmaps: lighter2 already has support for that, but the implementation isn't great - it could use a cleanup. And, of course, some improvements: e.g. right now, directional LMs are enabled globally, per-object control would be desireable. They should also be "future-proofed" so e.g. photon mapping can be dropped in easily. -- This is more of a "janitorial" task, but it would be great for people that don't like to juggle much with maths, but love to solve real-life implementation problems ;)
  • Improve lightmap packing: the current algo leaves a lot of unused space, implementing e.g. a tetris packer would help a lot. Also somewhat janitorial. Could be connect with something else (as an "optional" goal or with some other optional goals).
  • Implementation of area lights. Full implementation and support would be desirable for quality of lighting. Might relate to photon mapping.

'Lighter2' subproject is not realtime per se and can offer other interesting areas to look at for a student that is more interested in offline rendering than realtime rendering.

Visibility culling improvements

Visibility culling is the act of deciding which objects to actually render and which to ignore because they are either outside the view or they are occluded. Crystal Space at the moment implements two visibility cullers:

  • Frustivs - Only does visibility culling to the view frustum (removes things outside the view).
  • Dynavis - A partial implementation of original dPVS (earlier by Hybrid, now known as Umbra) which also does software occlusion culling.

Both these cullers gets the job done, but they are not the most efficient pieces of code around. Also since the introduction of dPVS in 2000 the way graphics cards work have changed and so has the requirements of the cullers. Also new cards have hardware features to allow for quick implementations of occlusion culling that Crystal Space at the moment does not take advantage of.

A SoC project in the area of visibility culling would be to develop a new, more "modern", culler ground up. Efficiency is a major concern as visibility culling is something that has to be done every frame. Thus we expect the student to look into the latest research in the area and then implement a new dynamic or dynamic/static culler utilizing frustum culling, occlusion culling either in hardware with software fallbacks and possibly precomputed visibility for static geometry.

There have been a lot published on culling, esp occlusion culling, in the last few years. Some examples  GPU Gems 1,  GPU Gems 2,  CHC++ and  loads of papers.

Environmental effects

One important part in rendering realistic environments is the rendering of environmental effects such as clouds, dust, rain, other atmospheric effects etc. Crystal Space today has a very advanced shader system, and with the new render manager almost finished good support for rendering to texture and post-processing effects which allows you to render these kinds of effects however at the moment it's all up to the user to implement this.

We would like to see at least an example implementation within Crystal Space itself to act as a starting point for those of our users that wish to utilize environmental effects. Inspiration for algorithms and/or effects can be found from  Nvidia,  ATI,  GDC presentations and papers:  paper1. Improvements can also be made to the previous GSOC projects on clouds and ocean.

Advanced rendering techniques with shaders

This project would involve implementing one or more cutting edge rendering technique, utilizing both CPU and GPU. Examples might be  Relaxed Cone Step Mapping,  Skin,  Trees,  Hairs and Cloth. It would be great if those effects would enhance the rendering of the new 'Krystal' model, e.g. with nice hairs.

Another related idea is to integrate support for shaders developed through the Blender's node system. (Take a look at:  http://www.blender.org/development/release-logs/blender-242/blender-composite-nodes/). This might be able to be accomplished through exporting from Blender to COLLADA, and adding support for COLLADA FX into the existing COLLADA implementation in Crystal Space.

More advanced lighting and shading

Crystal Space today mainly utilize direct and precomputed indirect lighting via the Blinn-Phong shading model. While being fairly efficient it does not always give the desired surface "feeling".

In this SoC project we would propose looking at alternative shading models such as  Cook Torrance or  Oren-Nayar and how to efficiently implement them for Crystal Space, both in the runtime part (shaders) and precomputation (lighter2). It would also be interesting to look at implementation of lighting algorithms, especially lighting approximations such as  Screen Space Ambient Occlusion (SSAO).

Another important improvement may be the addition of the infrastructure for  deferred shading. This would allow for the rendering of complex scenes with many vertices and many dynamic lights.

Hardware skinning and improvement of Animesh

Crystal Space has recently got a new mesh object, the iAnimatedMesh, for skeletal meshes animated by an animation blending tree. There are already many animation nodes available, such as ragdoll, lookat, speed, Finite State Machine, and many other nodes are planned to be added in some near future. The animesh is however still lacking some features before getting really fully usable, and this project would focus on implementing those missing features.

A first feature to be added would be the implementation of hardware skinning for the animesh. It would involve writing a shader computing the position of the vertices of the mesh depending on the bone transforms and weights, and on the current morph targets, with a fallback to the software skinning in case the hardware cannot handle that. Also, the current morph targets are defined for the whole vertices of the mesh while morph targets usually apply only on a small portion of the mesh. A better data structure would be needed for that (e.g. morph targets defined by submeshes, or through the list of modified vertices).

Other ideas may be the addition of soft bodies for clothes (i.e. meshes deformed procedurally by the physics engine), decal support, collision detection (through user defined hit-boxes of the bones), hard transform of the mesh, sub-mesh and sub-skeleton reparenting, LOD management.

Improved tools support

Support for various modelling tools is lacking in CS. In particular our animesh system has no exporter for tools such as 3dsmax and maya, and there are no exporters at all for the bodymesh (the physical description of the animesh), nor for the hit boxes of the bones. This project would be to implement mesh exporters for one or more modeling applications.

Progressive LOD

We currently have a good imposters implementation in CS, however our general LOD solution for our main mesh type requires a lot of manual work. This project would involve implementing a progressive automated LOD solution for the genmesh mesh type. Some ideas can be found  here,  here,  here and  here. Either or both of a precalculated (offline) or runtime calculated (online) solution would be acceptable, and it is better if it uses the GPU.

Fill In Your Own Idea Here

There's some graphics effect CS doesn't do? You know of some paper and want to implement it in a real environment? You've noticed that some CS feature is not that elegant to use? Feel free to submit your own ideas!

Ideas for projects related to CS

While not part of "core" Crystal Space the software projects mentioned here are part of the Crystal Space community and SoC projects for them could be handled under the "Crystal Space umbrella".

CEL

Artificial Intelligence & path finding

A possible project would be to work on artificial intelligence property classes for semi-intelligent behaviour of NPC's. There are already some property classes and tutorial applications for behavior tree support, path finding and steering behaviors. They should be tested further and improved, and also be documented in the manual.

The current path finding uses the classical A* algorithm, but better solutions may be used. CEL is also heavily missing a tool that is able to generate automatically navigation points for a given map. All of this may be made using the ' Recast & Detour' library. See here for more info on what has already be made on this topic during the GSOC 2007.

The  behavior tree property class would need other decorators. See here for more info on what has already be made on this topic during the GSOC 2009.

Other ideas:

  • Implements AI planning for multi-agent NPCs.
  • Reinforcement learning for more complex types of behaviour.
  • More  steering behaviors

Networking

  • There is a network layer that has been implemented in CEL. An API has been designed for the network management of CEL entities and property classes, and a first TCP plugin was written, but it is still missing some features before being usable. A first need would be to define and implement a system so that the whole networking behavior is defined through property classes, e.g. so that a CEL game can become a networked game simply by adding some specific entities and property classes. Another need would be to define for each existing property classes how they update efficiently to/from the network.
  • It would be nice to have a UDP plugin too for faster-paced games, which could handle packet loss.

CrystalArchitect

CrystalArchitect is a CrystalSpace IDE. We are advancing well, but more hands are needed if we want to have fancy features soon !

Ideas are kept on an external wiki:  http://wiki.kyanite-studios.org/doku.php?id=org:gsoc2009