OpenGL

Current Status

At the moment RenderDoc should support OpenGL 3.2 - 4.4, and some of 4.5 (mostly ARB_dsa isn't supported, but a couple of other things aren't supported). Also persistent mapped buffers a la AZDO aren't supported yet.

Only core profiles of 3.2 and above are supported, so old compatibility features like fixed function, luminance/alpha textures, assembly shaders etc etc are not supported and there are no plans from my side to support anything that far back.

I'm currently testing as many programs as I can get my hands on to get application compatibility improved. Then I'm going to improve the replay application as many features and kinds of support are missing.

To do

• As above, persistent mapped buffers and ARB_dsa to complete 4.5 support.
• Multiple frame capture
• The mesh viewer might as well not work.
• Overlays work on simple programs, but will often break (e.g. won't work with separable programs).
• No shader debugging :).
• Plenty optimisation, there are a lot of slow functions that could be vastly sped up.
• Many other things.

Current hacks/bugs/workarounds

I've had to work around a few weird or inconsistent behaviours, or bugs (confirmed or otherwise) on different vendors. I'm listing them here although they're all centrally located in the code, just for visibility.

• GL_VERTEX_BINDING_BUFFER isn't recognised on AMD, but fortunately there's another bug that means GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING behaves incorrectly and does what we want.
  • Known/reported bug.
  • Detected by doing this query and checking for error. To work around use GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING instead.
• I've seen a case where querying for the compressed size of GL_TEXTURE_CUBE_MAP_POSITIVE_X will return the size of the whole cubemap, not just that face. I haven't seen this recently so I'm not sure if it was a bug in my code, but I was fairly sure it happened. It's harmless to have the check in, so I've left it.
  • Not reported until I can reproduce consistently.
  • Detected by querying for the size of a known dimension cubemap, and looking at the returned size. If it's returned the cubemap size, divide by 6 whenever doing future queries.
• GL_POLYGON_MODE is incorrectly reported as removed from core profile on AMD.
  • Known/reported bug.
  • Detected by doing this query and checking for error. To work around just assume GL_FILL always instead (pretty safe assumption, but could be wrong in rare circumstances).
• Doing a glCopyImageSubData on compressed mips less than the block size throws GL_INVALID_VALUE on AMD. I'm not sure based on the spec exactly how you should copy these, but the only sane way seems to be to specify their size in texels even when it's not a whole block size.
  • Known/reported bug.
  • Detected by doing a copy on a 1x1 compressed texture and checking for error. If detected we do a slow readback to the CPU and reupload to GPU for those mips. Maybe there's another way to copy on the GPU.
• On some implementations, FBOs or VAOs are shared between contexts. This might not be a bug but just a weird quirk of EXT_framebuffer_object specifying them as shared.
  • Not reported, might be valid.
  • We detect this by creating shared contexts and seeing if glIs returns true on the shared context for FBOs/VAOs created on the main context. To work around we just treat them as shared objects, like we do for textures etc.
• On nvidia, copying a D32_S8 texture with glCopyImageSubData can cause extreme problems.
  • Reported (via email).
  • We can't detect this given the nature of the problems, so for now we don't copy these textures until I can find a workaround.
• On nvidia at least (not tested the others much) mixing and matching old style glVertexAttrib*Pointer functions and new vertex attrib + vertex buffer binding functions seems buggy.
  • Not reported (need solid repro and at the moment it's just 'in renderdoc').
  • Can't easily be detected, so we just use the spec definition of those functions in terms of the new vertex attrib + vertex buffer semantics, and apply that definition ourselves manually.
• AMD doesn't report entry point glVertexArrayVertexAttribDivisorEXT for EXT_direct_state_access + ARB_vertex_attrib_binding.
  • Not reported (trivial, easy to work around)
  • If the function isn't present just do it manually by push/popping VAO binding.
• AMD throws an error when calling glGetProgramPipelineiv with pname=GL_COMPUTE_SHADER.
  • Known/reported bug.
  • We just detect if this query fails on startup, and skip doing it. It's only used to find the program to fetch uniform subroutine values and no-one uses them anyway. If we needed to, we could fetch the program for that stage ourselves from our cached data.

Assumptions and limitations

• We don't actually check for core vs compatibility profile but just go on assuming only core functionality will be used. This is fine and is a bit more app-compatible, but could run into problems down the line which would require being stricter.
• We assume that all objects that can be shared are shared - this means every context is assumed to share with every other via some set of connections. There's support in there to potentially handle isolated groups of shared objects, but it's not supported right now.

Tested support

Sample packs/tutorials/demos

• g_truc sample pack. Mostly working, except *-texture-pixel-store (some pixel store commands not supported correctly), and several 440- demos that use persistent mapped buffers. Windows and linux tested.
• Superbible 6 samples. All working, windows and linux tested.
• bgfx samples. All working aside from bkaradzic/bgfx#209. Windows tested.

Games

• RAGE - uses compatibility functions, not supported.
• Wolfenstein: The new Order - uses compatibility functions, not supported.
• The Evil Within - Another id tech 5 game. Pending testing, as I don't own the game.
• Starbound - captures & replays successfully, windows tested.
• UE4 - captures & replays successfully, provided UBO and VB direct writes (persistent mapped buffers) are disabled. Elemental demo tested, windows and linux tested. (Linux captures replay on linux & windows).
• Tropico 5 - captures & replays mostly successfully, a few minor bugs with UI text.
• Clockwork Empires - captures & replays successfully as of a974380, windows tested.
• Metro Redux - pending testing, confirmed to be 4.x core.
• Planetary Annihilation - captures & replays successfully, but uses persistent coherent maps so is likely buggy.