SummerOfCode Project Ideas        
Print

Image

General

This page lists some GSoC project ideas that the Ogre team considers especially relevant and that the team deemed manageable within the limited time frame of GSoC.

If you are interested in one of the ideas or have further questions, please feel free to create a thread in the GSoC Ogre forum section(external link) (please take the application template into account). The same applies if you have additional ideas that you either want to propose to potential GSoC students or might even consider tackling yourself.

Note: Please do not add entries to this list without having proposed and discussed them in the GSoC Ogre forum section!

Additional inspiration:
There is also a legacy project ideas page from past years as well as a dedicated list from 2015 that contain some other potential projects. However, the ones listed on this page are considered much more relevant and are therefore have a much higher chance to be accepted by the team.

Additionally, there is a dedicated forum thread(external link) discussing more potential ideas from the community.

 

Ideas

 

Level of Detail (LOD)

A previous GSoC project did all the LOD'ing stuff. The algorithm is great, but it only supports v1 objects. Ogre::v2 objects no longer allow "manual lod" the usual way, however it supports using custom models as LOD and exchanging with automatic LODs seamlessly, which is superior. We need tools for artists to make the LOD generation (both manual and auto) work quick, easy, and friendly.
For example, suppose you have Sinbad.mesh, SinbadLOD1.mesh and SinbadLOD2.mesh. We need a tool that allows its user to create a single mesh SinbadFinal.mesh which internally contains:

  • LOD 0: Sinbad.mesh
  • LOD 1: Auto LOD from Sinbad.mesh
  • LOD 2: Read from SinbadLOD1.mesh
  • LOD 3: Auto LOD from SinbadLOD1.mesh
  • LOD 4: Auto LOD from Sinbad.mesh
  • LOD 5: Read from SinbadLOD2.mesh

 
This is now possible with v2 objects (Items), but not possible with v1 objects (Ogre::Entity).

Ideally there should be a library interface, and a command line tool for batch processing and a simple GUI to set the settings interactively (load external meshes, generate automatic LODs from which LOD, etc).

Knowledge Prerequisite: C++, Ogre, MeshLodGenerator Component, Toolkit knowledge (Qt / wxWidgets / C# / Python / etc.)
Difficulty: Medium. There's a big demand for this!

 

Distance Field Fonts

Signed distance field rendering is a technique used in Team Fortress 2. It allows you to render bitmap fonts without jagged edges even at high magnifications. Furthermore the student should create an fast method to render many fonts (batching).

URL: http://www.valvesoftware.com/publications/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf(external link)
Knowledge Prerequisite: C++, Ogre, Shaders (DX/OGL)
Difficulty: Easy / Medium

 

2D drawing interfaces

Right now we have Ogre::Rectangle2D (which is not suitable for rendering large amounts of sprites) and Ogre::Overlay (which has a lot of design issues with Ogre 2.1 and is quite hard to use / over-engineered).
2D rendering should support sprite animation (at best can import direct from texture packer tool), ninepatches, lines, paths.
Everything should be done with performance in mind.

Knowledge Prerequisite: C++, Ogre, Shaders (DX/OGL)
Difficulty: Medium / Hard

 

Port the GLSLES 3.0 renderer

Atm the GLSLES renderer is not working with OGRE 2.1. The student needs to review the current functionality
which is used inside OGL3+ and decide how we can replicate or emulate it with GLSL3.0.

Knowledge Prerequisite: C++, Ogre, GLSL, GLSLES, OGL
Difficulty: Hard

 

Finish the Metal renderer

We started on a metal renderer for OGRE 2.1, but its not finished yet. The student will resume
the work and will get a detailed list whats exactly is missing and whats needs to be done to finish the renderer.

Knowledge Prerequisite: C++, Ogre, iOS, XCode, Metal (nice to have)
Difficulty: Hard

 

Remotery integration

Remotery is a real-time CPU/D3D/OpenGL/CUDA profiler with a web browser viewer.
The student will attempt to integrate it into OGRE (DX, GL3+). This means extending both rendersystems
and our CMake build chain.

URL: https://github.com/Celtoys/Remotery(external link)
Knowledge Prerequisite: C++, Ogre, Javascript
Difficulty: Medium

 

Port pose animations to Ogre::v2 (aka. facial animations)

Items (v2 objects) don't support pose animations. One still has to use Entity (v1 object) which operates in legacy mode.
The task is to write a more lightweight system that can store position and normal offsets for each animation and each affected vertex into plain old array.
The system should also be capable of importing the pose animations from v1 Entity into Item.
Implementation could support:

  • SW: Accumulate pose offsets all from all animations in CPU (using multi-threading!) and upload them every frame to a texture buffer. The Hlms' vertex shader will lookup the texture buffer for the final offset to apply.
  • HW: Use use a single compute shader run to accumulate all the pose offsets into a single list, which will be later used by the vertex shader in the same way as the SW one.

 
Knowledge Prerequisite: C++, a bit of Ogre Hlms understading, Pose animations, GLSL and HLSL, Compute Shaders
Difficulty: Medium / Hard

 

Port DualQuaternion Skinning to v2

Dual Quaternion Skinning support was added by a previous GSoC project.
Items (v2 objects) don't support DualQuaternion animations. One still has to use Entity (v1 object) which operates in legacy mode.
Hlms implementations should automatically modify the vertex shader so that it uses the proper math to support DualQuaternion blending. The math code should be in its own Hlms piece files for clarity and modularity.
Due to performance concerns inside the Hlms implementation (evaluating whether the mesh uses skeletal animation with regular blending or dual quaternion blending for every skeletally animated object); this feature should be toggleable from CMake, so that it doesn't penalize those who don't want this feature.

This idea may be too simple for a 3-month schedule as it doesn't require that long considering a previous GSoC did all the heavy lifting. Students should look into other easy ideas in the list to complement.

Knowledge Prerequisite: C++, Ogre Hlms, GLSL and HLSL, DualQuaternion and 4x4 matrices
Difficulty: Easy

 

OpenGEX Importer

We want to officially support OGEX as the main format for importing meshes into Ogre, as it is really looking good and gaining traction throughout the industry. After a more thorough evaluation we believe this is a perfect 3-month project for students.

Links:
Reference implementation: http://opengex.org/OpenGex-Import.zip(external link)
3rd party parser: https://github.com/kimkulling/openddl-parser/(external link)

Knowledge Prerequisite: C++, Debugging skills for breaking down / reverse engineering the reference implementation, JSON background would be great(*), nice to have: familiarity with the OpenGEX and OpenDDL specs and their code samples
Difficulty: Easy

(*) OGEX is not JSON, but it is very similar.

 





Contributors to this page: spacegaier6073 points  and wolfmanfx398 points  .
Page last modified on Friday 19 of February, 2016 16:05:23 UTC by spacegaier6073 points .


The content on this page is licensed under the terms of the Creative Commons Attribution-ShareAlike License.
As an exception, any source code contributed within the content is released into the Public Domain.