Post-merge TODO

  • Additional transform feedback functionality (GL_ARB_transform_feedback2, GL_ARB_transform_feedback3)
    • stream buffers (GL_ARB_transform_feedback3) presents several problems:
      1. not a single good example on the web (g-truc samples only use a single stream!)
      2. since each stream buffer can have a different vertex count, it is unclear how feedback works - presumably only a single stream buffer can be used as input into a vertex shader, so perhaps the use case is to feed each stream to a different vertex shader that takes in only those particular variables.
      3. requires that individual output stream data formats be specified via RenderingToVertexBuffer, in addition to the already cumbersome specification of the input vertex buffer data formatting.
    • so the new rendering to vertex buffer API is:
      1. specify input vertex buffer data format and each output stream buffer data format. If no output buffers are specified, assume single output stream buffer with same format as input.
      2. somehow specify output passes so that each stream buffer can be directed to its respective pass (may be the same transform feedback pass, a different transform to feedback pass, a regular rasterization pass, etc.)
    • The ideal solution is to abstract function composition in OGRE so that screen composition (render to fragment texture) and vertex composition (rendering to vertex buffer) use the same API and compositor scripts.
  • SDL2
    1. SDL window support (via CMake)
    2. windowing plugin system
    3. SampleBrowser input
  • Provide the ability for OpenGL shaders to perform random access reads, writes, and atomic memory operations on variables stored in a buffer object (ARB_shader_storage_buffer_object)
  • Support for “indirect subroutine calls”, where a single shader can include many subroutines and dynamically select through the API which subroutine is called from each call site (GL_ARB_shader_subroutine)
  • Cube map array textures, 2-dimensional array textures that may contain many cube map layers. Each cube map layer is a unique cube map image set (GL_ARB_texture_cube_map_array)
  • Multisampled textures and texture samplers for specific sample locations (GL_ARB_texture_multisample)
  • ensure image load/store and atomic counters still work
  • add any necessary material transforms for this project
  • update OGRE tutorial framework to be completely shader based, using as little or no RTSS


GL4 Rendering Pipeline

  • Render many draws using MultiDrawIndirect (see previous discussion). (GL_ARB_multi_draw_indirect)
    • Figure out efficient way to bin draws with same API state (same bindings, depth test, blend function, etc.).
    • Means to index draw data per-draw (and per-vertex if buffers used for vertex data).
    • Store uniform (and possibly vertex) data in uniform or shader storage buffers.
    • Store textures using bindless textures in the above uniform blocks. (GL_ARB_bindless_texture)
    • Look into whether depth test and blend function states change often in practice and if they can be efficiently binned.
    • Require über-shaders since shaders cannot be changed in the same multidraw. Use shader subroutines or switches to take different material paths. Suggest splitting radically different shaders up and binning draws accordingly.
    • Either require all vertex data of a given call to be in the same format or request users with mixed formats to stick to shader storage buffers for passing vertex data.
    • All vertex indices need to be in one buffer for entire sequence of draws handled by MultiDrawElementsIndirect.
  • Traverse scene graph using multi-thread CPU, compute shader or transform feedback to create draw calls for MultiDrawIndirect.

OpenGL 4.4 features

  • add GL 4.4 features to transform feedback, particularly shader specified feedback variables
  • possibly restore material support for transform feedback if 4.4 adoption is slow (transform block within material pass listing feedback variable names and types)


  • port EGL window system from GLES RS


  • compositor
  • deferred shading (may be fixed upstream)
  • dual quaternion skinning (RTSS issues)
  • endless terrain (complex problems)
  • facial animation
  • grass (cg material mistakenly being selected)
  • mesh LOD (Athena needs texture - probably wait until after GSOC merge)
  • PN triangles (needs implementing)
  • particle effects (aureola effect does not look right)
  • shader system (easy & hard fixes)
  • shader system - textured fog (background not initially set, lighting might need to be added?)
  • shader system - multi light (lighting has bars going through it)
  • shadows (seriously borked)
  • sky box (corners of box show white)
  • sky dome (fish textures missing or black)
  • sky plane (dragon wings visible on one side, not the other)
  • terrain (sky does not appear correctly, possible lighting/shadows problem)
  • volume csg (texture is missing)
  • volume terrain (lighting and triplanar texturing broken - seems that normals are not correctly passed to shader)
  • volume textures (was working, now a mess of fog with floating white rectangles and a combed square)
  • water (water 0, 3, 4 thoroughly borked)

Visual Tests (GL & GL3+) - see original reference images and recent reference images

  • TODO create new list prior to merge

NEW Visual Tests

  • tessellation (port tessellation sample to visual test, then replace sample with something cool)
  • transform feedback (render to vertex buffer)
  • shader storage block + uniform block
  • atomic counters
  • compute shader
  • image load/store
  • and more...


  • add note in Visual Unit Testing Framework about nograb option causing results to be non-deterministic
  • transform feedback currently requires feedback variables to be named oPos for position, oUvX for X texture index, and so on

Known Bugs

  • Examples/Aureola from the billboard particle system sample originally used PF_BYTE_LA (grayscale luminance alpha) format which requires a byte per channel, but FreeImage read the file as 32 bpp implying that either the file needs to be converted to 16 bpp (8 bit per channel, with channels being luminance & alpha) or FreeImage has a bug. Since GIMP reports the PNG image as grayscale transparent, I am inclined to think this is a FreeImage bug, crazy as that sounds.

Bonus GL3+ Goals

This is a list of problems I would like to solve during my GSoC, but may not get around to until afterwards.


  • General code review needs to be done
  • Unify redundant mappings (OGRE type to string, GL type to string, GL type to OGRE type, visa versa, etc.)
  • Investigate effect on driver serialization (shim + server flush and sync) of glGet(...), glGetError, functions that return a value, and functions that copy a non-determinable amount of client memory (see slides 50-51 of NVIDIA/Valve porting to Linux talk).
  • See if GL3+ render engine is making any of the common mistakes.
  • rename Tesselation -> Tessellation throughout Ogre
  • add material script support for uniform arrays (of the form int5, float8, etc.) in ScriptTranslator so that you can write int5 1 2 3 4 5
  • add material script support for bool and uint in shared_param_named
  • ensure GL command cache is merged (pull request)


  • Add some form of exception handling to Ogre string utility library (discuss cost/benefit of alternative means, use profiling)
  • Grass - determine why GL and GL3+ fall back on the plain texture technique when perfectly fine techniques are available in the material script

Visual Tests

  • BSP - To fix BSP vtest, it must be moved from PlayPen to VTest or else RTSS needs to be setup in PlayPen. Alternatively, however non-RTSS BSP shaders are constructed could be fixed. It is looking for textures in the wrong places within the PK3 archive. Currently only RTSS created shaders correctly locate the texture files.
  • Distortion - upgrade material parser to determine when asm passes are ARB or DirectX when determining if a technique is supported; see Ogre::Technique::checkHardwareSupport. Best means is adding an 'arb' format and assuming 'asm' is DirectX assembly. When this is done, re-enable old technique in Examples/FresnelReflectionRefraction
  • add additional debugging messages and create interface for markers and groups for khr_debug

General TODO

  • Make BaseApplication use shaders
  • General SWIG wrapper (for Python, Go, D, C#, etc.)
  • Allow per-entity uniforms in material manager (see previous discussion)
  • Document GL3+ and GSoC features using Doxygen and OGRE manual

Community TODO

  • Add texi2html OGRE manual generation to CMakeLists
  • Fix the second tutorial to mention proper resource usage!
person wrote:

The 'dist' directory is only a sample.
It contains the minimum you need to make use of the sdk trays GUI and to load the Ogre head.
If you need more, you need to add it yourself. :-)

However, maybe it would be a good idea to add a note to the tutorial in question explaining how to add the Ninja to the 'dist'.
I'll put that on a todo.