The open-source game engine and graphics engine for multiplayer, cross-platform, real-time 3D action

This page lists ideas for projects enhancing the Cafu Engine that we consider interesting to work on, important for the Cafu open-source software project, its users and community, and that are suitable for student projects (e.g. in the Google Summer of Code).

If you have any questions, please let us know. Even if you're not in a student program, feel free to pick one of these ideas and implement it. They are all valuable to us and we'll be ready and happy to help. Have fun!

Port to Mac OS X

Cafu already runs on Windows and Linux, but there is no port for Mac OS yet. The goal of this project is to make all programs related to Cafu work on Mac OS X, especially the Cafu 3D Engine and the graphical level editor CaWE.

To a large degree, the Mac OS port shares and uses the same source code as the Windows and Linux versions, these parts of the source code may however require adaption to Mac OS specifics: Examples include simple things like augmenting for proper #include statements, but also more sophisticated ones like accounting for Mac OS user interface guidelines in CaWE. Some files (such as the code for creating a full-screen window and initializing OpenGL) must be created anew, specific to the platform.

Skills needed: Given some programming experience on Mac OS X in C++ and basic knowledge about OpenGL programming for Mac OS X, this is a relatively easy to moderate project. Knowledge of the wxWidgets library is helpful, but can also be obtained in the course of the project.

OpenGL 4.x Renderer

The Cafu rendering system is implemented flexibly and modularly in Renderers. For the implementation, a Cafu Renderer can employ an arbitrary programming interface (API) such as OpenGL or DirectX. At present, there are renderers for OpenGL 1.2, OpenGL with Cg with NV2X profiles, OpenGL with Cg with NV3X profiles, and OpenGL with the "ARB vertex and fragment programs" extension.

The Cafu Engine decides on each new program start which renderer is the best match for the available hardware, and then loads this renderer for the graphics output. This approach puts Cafu into the position to support both very old or limited systems (e.g. with OpenGL 1.2) as well as very new ones (e.g. with OpenGL 4.1) optimally. Even future systems only require a new renderer in order to experience complete support for their latest features.

The goal of this project is to add a new Renderer that is implemented with OpenGL 4.x, with an emphasis on integrating the features of OpenGL 4.x with the Cafu Material System so that they are useful for creating maps, models and other 3D elements.

Skills needed: Basic understanding of C++, good knowledge of OpenGL (any version) and of programming GPU vertex and fragment shaders are a requirement.

DirectX 11 Renderer

Conceptually similar to writing a renderer for OpenGL 4.x as described above, writing a renderer for DirectX 11 is the goal of this project, with an emphasis on integrating the features of DirectX 11 with the Cafu Material System so that they are useful for creating maps, models and other 3D elements.

Skills needed: A basic understanding of C++, good knowledge of the DirectX API (recent versions, i.e. 9 to 11) and programming GPU vertex and fragment shaders are a requirement.

Large-scale Vegetation with Shadows and Lighting

Cafu features basic support for plants ("vegetation objects") as shown in the image at the right: Plants can be placed in the editor CaWE and the Cafu Engine can display a large number of them, using appropriate level-of-detail techniques.

The goal of this project is to enhance the rendering of vegetation, especially to add dynamic lighting and shadows using an appropriate shadow mapping technique. Additional work can involve improvements of the level-of-detail rendering and special effects such as wind.

Skills needed: Basic skills in C++, OpenGL, OpenGL extensions, and dynamic lighting and shadows are required.

Multi-Threading and Parallelization

Most code in Cafu doesn't make use of multi-threading and parallelization yet, even though there are several opportunities where serial algorithms can be turned into parallel counterparts for good effect. The goal of this project is to identify algorithms that are suitable for parallelization and to parallelize them by using a portable technique.

Candidates for parallelization include the Radiosity computations (CaLight), the binary space partitioning and potential visibility set programs (CaBSP and CaPVS), the Cafu Engine itself, and the level editor CaWE (e.g. real-time terrain editing). The task also includes basic performance profiling: it should be possible to run the parallel programs with a custom number of threads and basic statistic should be gathered. The implementation should be portable, e.g. using PThread, OpenCL or Intel TBB, but we're happy to discuss vendor-specific approaches as well.

Skills needed: This project requires an understanding of the algorithms to be parallelized (e.g. the Radiosity implementation in CaLight), and a good understanding of the basics (and pitfalls) of multi-threaded programming. A interesting challenge for advanced students.

Add demo recording and playback, with OggTheora and/or VP8

Cafu supports multi-player games over a network like the Internet or a LAN. It employs a server-client network model (that is active also for single-player games) and uses a custom protocol on top of UDP.

The goal of this project is to record the network traffic between a client and the server, and to add the ability to playback the demo by playing back the network packets. Playback options should include real-time (runs at the same speed as the recording), timedemo (runs as fast as possible, for benchmarks / performance profiling), and create-movie. The last option means that the frames of the demo are rendered "offline" in given intervals, e.g. 1/30th of a second, and saved as a movie, using for example the OggTheora codec, or Googles VP8/WebM.

Skills needed: Given intermediate programming skills in C++, this is an easier project that involves serialization and unserialization, network protocols, video codecs, and software design.

Model Editor

A key feature of a 3D engine is its support for models that are used for player characters and other detail objects in the worlds. Cafu can import many model file formats already for direct use, but it needs a "Model Editor" that implements the following tool chain:

1. Import animated or static models from any supported file format (inclusive Collada).
2. Internally represent the model in a Cafu specific model data structures.
3. Provide an interface that allows the user to assign Cafu specific features. For example, assign materials (shaders) to body parts (submeshes), assign special points to skeletons (e.g. for holding weapons or items, or other combinations with other models), etc.
4. Save the result in a Cafu-specific model file format that is used for rendering and game play by the Cafu Engine.

Skills needed: This is an easier project, requiring basic skills in C++ and an overview of skeleton-based model file formats. Knowledge of the wxWidgets library is helpful, but can also be obtained in the course of the project. Experience with 3D modeling software such as 3D Studio Max, Maya, etc. is helpful, but not a requirement.

Your Ideas

The above list is not meant to be complete – we're happy if you submit your own project ideas! While you can use the roadmap items as a starting point, even those are only a suggestion: Entirely new and fresh ideas are equally welcome. Just bring it up at the forums or the cafu-dev mailing list and we'll be happy to discuss it.

Contact

You can contact us at any time at the cafu-dev mailing list, the forums, or via This e-mail address is being protected from spambots. You need JavaScript enabled to view it .

We wish you a lot of fun, and are looking forward hearing from you!