Version v0.33

Just in time for GDC, here's the latest RenderDoc release! The main focus in this release has been greatly improved support for linux and GL, but there's hopefully something here for everyone.

At the same time, I've made public a new homepage for RenderDoc with an easy to find link to the latest version, as well as news and any articles I write that might be interesting. If you're looking to link to RenderDoc, then that's the URL to use - https://renderdoc.org/

As always if you run into any problems or have suggestions then you can file an issue on github or contact me.

Version v0.33

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

The Qt UI on linux is missing python support as I'm planning to design & document a proper python API for interop with renderdoc, but otherwise everything should pretty much be working. There's an issue on github tracking remaining polish tasks and things like that.

Work will continue on the Qt UI to get this polish complete so that it's at the same level of quality as the windows UI, and once it's at that level then the Qt UI will be rolled out across all platforms.

Also on the GL front, RenderDoc no longer requires hardware GL 4.3 support and EXT_direct_state_access/ARB_buffer_storage to replay (although that does mean some features will be disabled if they rely on functionality that isn't available). Instead it requires just 3.2 and a handful of extensions:

• GL_ARB_vertex_attrib_binding
• GL_ARB_program_interface_query
• GL_ARB_shading_language_420pack
• GL_ARB_separate_shader_objects
• GL_ARB_explicit_attrib_location
• GL_ARB_sampler_objects

Largely these don't require actual hardware support, and any decent GL implementation will support them in software regardless of the hardware. This means you can use RenderDoc on the software mesa implementation without requiring the latest drivers:

Features/Improvements

• The Linux Qt UI is now comparable to the windows UI in feature set, and stable enough for everyday use.
• As mentioned above the GL support will now work correctly on any recent mesa (I tested against ~10.5 or 10.6). This means both fixing bugs in RenderDoc that mesa caught, as well as significantly lowering the requirements from 4.3 + EXT_direct_state_access + ARB_buffer_storage to 3.2 + a few non-hw extensions.
• Added support for VK_NV_external_memory* and VK_NV_dedicated_allocation Vulkan extensions, which are needed for VR rendering.
• New GPU counters are available on D3D11, D3D12 and GL - Primitives processed, shader invocations, rasterizer invocations. These counters are not currently exposed in the API but can be queried through the python shell. Thanks to @victor-moya for these.
• Add drawcall timings for copy/resolve/blit type operations in vulkan.
• When shader debugging add functions to run to the next texture operation, or run to the next floating point exception (instruction that generates a NaN/Inf). Thanks to @michaelkvance for this.
  
• Include the duration column when exporting data from the event browser.
• Add a warning for python if the libraries aren't loaded (only relevant for dev builds).
• When self-hosting RenderDoc (capturing it with itself) some new tool menu items appear in the UI to start/stop captures. There are also now some marker regions added during replay.
• Add some verification for GL buffers being bound, so that invalid buffer names won't crash immediately.
• Add support for the Vulkan extension VK_AMD_negative_viewport_height
• Add support for Vulkan extensions released in 1.0.39: VK_KHR_get_physical_device_properties2, VK_KHR_maintenance1, VK_EXT_direct_mode_display, VK_EXT_acquire_xlib_display, VK_EXT_display_surface_counter, VK_EXT_shader_subgroup_ballot, VK_EXT_shader_subgroup_vote, VK_EXT_swapchain_colorspace, and VK_KHR_shader_draw_parameters.
• When the global hook is active, prevent closing the program to avoid leaving a stale hook active.
• Add Map() buffer overwrite handling for OpenGL, using tinyfiledialogs for cross-platform messageboxes.
• When shader debugging, don't replay the capture commands at all. This means that when the shader debug happens it contains the same data as was visible in the capture before debugging, which can be different if there's non-deterministic behaviour like append/consume or atomics.
• Added a new option to hide any marker regions which only contain "API Calls" placeholders and not real drawcalls, for example if there are only queries inside the marker region.
• In the capture connection window, you can rename the label on captures.
  
• When a GL buffer contains padding, the struct definition reflected out will include dummy padding elements.
• When replaying D3D12 upload heap buffers, allocate them on a default heap instead if they're large. This prevents extreme slowdown when copying data to them as it must be memcpy'd instead of uploaded to the GPU and copied there.
• Added multi-instance picking, so if you are rendering multiple instances at once you can pick a vertex from any of them and the corresponding instance will be activated.
• Support for yet another new marker format for D3D, this time PIX3 for D3D12 only. Thanks to @tiago-rodrigues.
• Eliminate a performance cliff that could happen if a vulkan resource with a large number of subresources (e.g. a cubemap array with lots of mips) was split apart for the purposes of processing barriers, and then never recombined again during replay producing a lot of redundant barriers.
• When copy-pasting a quoted path into the capture dialog, the quotes are removed.
• Callstack entries that don't have any matching symbols will now be something like module.dll+0x0ff5 instead of 0x627ddff5.
• Added $ORIGIN/../lib/ to rpath for renderdoccmd and qrenderdoc, and similar change to setting LD_LIBRARY_PATH when capturing, so that the file structure in linux tarballs will work as-is.
• If we see SwapBuffers() being called a lot with no context active, add a log message about the problem.
• Added support for depth & stencil overlays on cubemap, array and renderbuffer targets.
• Add handling for InstanceStepRate values above 1 in vertex debugging.

Bugfixes

• Fix a bug that would cause an instant crash loading any D3D12 capture on nvidia, due to an API requirement that's undocumented, unexplained and not mentioned by validation checking.
• Fixed a long-standing edge-case refcounting bug that could lead to pure virtual function calls or other funkiness while binding resources due to D3D hazard tracking. The explanation for this bug and the fix is kind of interesting but too long, so you can read more details in the first commit that revealed the bug and the second commit that actually fixed it.
• Work around an nvidia driver bug where D3D11_USAGE_IMMUTABLE buffers wouldn't apply an offset properly when calling CopySubresourceRegion. This could manifest a few ways, most often by incorrect values fetched for shader debugging, but also in the buffer viewer if a byte/row offset was specified.
• Fix hooking child processes when CreateProcess was imported from an API set. This could affect functions like execve which did that internally.
• Fixed a case where you had a 64-bit RenderDoc that ran a 32-bit process which then launched a 64-bit process (e.g a 32-bit launcher for a 64-bit game). Only going from higher bitness to lower bitness was supported previously.
• Added a fallback case for if D3D12 versioned root signature functions aren't available, which can depend on your OS build version even if you have D3D12.
• Implement missing QueryInterface for IDXGISwapChain4.
• Fix capture on DirectComposition swapchains, by forcing a fake HWND value.
• Handle non-NULL terminated strings in D3D11's SetPrivateData.
• Implement a workaround for executing programs on apple where environ can't be modified, search PATH manually and call execve.
• Support re-compilation and re-linking of programs in GL during capture.
• Correct the value used for base vertex when fetching post-VS data on GL.
• Mark a couple of GL draws as instanced that weren't properly flagged.
• Ensure that GL persistent maps are always intercepted, and don't make GL maps persistent on replay.
• Check that programs exist in a GL capture when setting uniforms.
• Fix sRGB calculation when applying 'fake' gamma curve to texture data.
• glVertexArrayElementBuffer behaves weirdly with respect to GL_ELEMENT_ARRAY_BUFFER_BINDING, so we always emulate it with a non-DSA version
• Fix GLSL shader patching with comments on a preprocessor line.
• Fix a crash with Vulkan descriptors referring to deleted buffers with invalid IDs.
• Fix GL texture overlays rendering with multisampled textures.
• When copying attrib bindings between GL programs, re-link the program afterwards.
• Fix a crash trying to render the quad overdraw overlay on a 1x1 texture.
• Fix a crash with the options in the context menu on the pixel con...

Version v0.32

Time for another RenderDoc release! This time coming with support for D3D12.

With the survey a few months ago it was very clear that a lot of people were looking for D3D12 support, and the back-end in RenderDoc is now ready for prime-time. I've tested it on every D3D12 program I can lay hands on, so if you run into any issues then do file a bug about it.

Version v0.32

Binaries for this release are up on the downloads page for Windows and x64 linux as a binary tarball.

The D3D12 support comes with a few provisos - it currently doesn't support multiple GPUs (i.e. NodeMask must be 0 everywhere), and it doesn't support tiled/reserved resources. This functionality will be filled in in the future, but given the high complexity to relatively low usage, it's prioritised appropriately.

Likewise shader debugging and pixel history is currently not yet implemented for D3D12, but all other RenderDoc features should be working. Again file a bug with anything that seems broken!

Aside from D3D12 there are a bunch of bugfixes and a few cool new features like a triangle size overlay which you can use to diagnose missing LODs or other super dense meshes.

Looking ahead to future versions, there's a refactored serialisation system coming in the pipeline which will enable a bunch of really cool new features. The downside is that it will break capture backwards compatibility. I'll give more details in future, but it's possible that v0.33 may be the last version that supports captures made on current versions.

Also, the linux build this time comes with a very early preview of qrenderdoc, the Qt UI. It is very much work in progress, many things are not yet implemented or buggy, but if you feel like trying it out then it's there. This will be the UI on windows eventually too, but only once it has reached feature and quality parity with the existing winforms UI.

Features/Improvements

• Added beta D3D12 support! This should now be usable for day-to-day use, and has been tested on all the D3D12 things I could get my hands on, including a number of D3D12 games.

  It's listed as beta primarily because it hasn't yet had widespread testing. Note also that some features are not yet implemented on D3D12, notably shader debugging and pixel history.

• Vertex picking is improved, thanks to @Velro. The mesh viewer now does a ray-cast per triangle and picks the closest vertex to the cursor on the best matching triangle, instead of just picking the closest vertex anywhere.

• New triangle size overlay, showing a heat value for the size of a triangle. Any triangle above 4x4 pixels in area is the coolest value, and then 'heat' increases exponentially to triangles that are 1/16th a pixel in area.

  

• Improved the accuracy of shader debugging in a number of cases by running transcendental functions on the GPU to precisely emulate the floating point accuracy of the current GPU. sin, cos, and others should now match the results from the real GPU and avoid slight ULP variances which could be amplified (e.g. by multiplying the result with a huge number for a rand()).

• Early support for D3D9 overlay. Not all D3D9 programs will get an overlay yet, but where possible an overlay will display showing clearly that the API is unsupported. Work is ongoing in a separate fork.

• Improved the 'inject into process' UI. Added a window title column, column sorting, fixed the missing refresh button and added a find-as-you-type filter.

  

  I still strongly recommend using the normal launch-to-capture workflow wherever possible, as injecting only works when the process hasn't used any target APIs, and has other drawbacks. It is useful in a small minority of cases.

• Process injection now supports environment variable changes.

• Added some error messages and detection if an invalid object is passed into GL functions. In general renderdoc doesn't do API validation, but some slight bullet-proofing will catch low hanging fruit problems.

• If a launched process dies during startup, a more friendly/obvious error is printed to the logfile.

• The replay no longer creates a debug context when replaying a GL capture.

• Added support for an external SPIR-V disassembler tool, which can be configured to generate compilable glsl from SPIR-V directly, if the original source isn't available or isn't glsl.

• Some slight improvements to the enumeration of remote hosts.

• Implemented debug output muting on GL.

• Detect and suppress any drawcalls that happen outside of render passes in Vulkan. Previously this would crash the program, but now the drawcall is skipped and an error message is added.

• Display whether a DSV is depth or stencil read-only in D3D11 pipeline state.

• Added support for remapping texture formats across APIs. This is useful in particular for e.g. Android replay with an ASTC texture that can't be natively displayed on a Windows UI, so it needs to be internally remapped to a format that can be displayed.

• Added a tool menu option to start the Android remote server.

• Support hooking libraries loaded with RTLD_DEEPBIND on linux.

• Improved compression quality and size on capture thumbnails, and added a preview panel to the capture connection. E.g. this allows easy checking if the frame you just captured shows the bug you were after or not.

  

• Min/max and histogram calculation now use custom visualisation shaders as their inputs instead of the real texture values.

• Improved debug logging. All processes launched from a single instance of the UI now log to the same file - using appropriate OS mechanisms to ensure logs are distinct. This means the Help -> View Diagnostic Log File menu option is more useful.

• Temporary files are now stored in a subdirectory - $TEMP/RenderDoc instead of spraying out in the root $TEMP folder

• Added previous/next buttons to the event browser. These also have global shortcut keys ctrl-left/ctrl-right which work anywhere.

• Added experimental support for WGL_NV_dx_interop to use DX textures in GL.

• Exported the full GLX function set, to comply with ABI requirements for libGL.so.

• In addition, added exports for unsupported GL1.0-1.2 deprecated functions, to allow a program to query for them and receive a valid function pointer. Note they aren't implemented, so it would still not work to call them.

• Added wrapping for DXGI 1.5 and improved DXGI wrapping to have better compatibility with programs querying interfaces back and forward.

• Multiple fixes and improvements to support capturing Direct2D in all known cases. This one is a bit funky, and DXGI is a complete mess of an API, so if you find a case that breaks then please report it as it may still be possible to support it.

• Added easy support for self-hosting - ie. capturing RenderDoc's replay program with RenderDoc, and then debugging the replay.

• Added a hover popup over tree views (e.g. the event browser) to show the full text of a line that is truncated for space

  

• Added the ability to discard the alpha channel when saving to TGA/PNG, even though the format supports it.

• Added support for multisampled image initial states in Vulkan, so that the data from previous frames is saved and restored. This also allows the display of multisampled images over a remote host connection.

• Added a backdoor UUID - {3FC4E618-3F70-452A-8B8F-A73ACCB58E3D} - which returns the real unwrapped ID3D11InfoQueue from the D3D11 device. This allows custom filtering of messages, but you must be very careful not to use this to query for other interfaces as they will be returned unwrapped. Likewise any messages filtered out will not be retrieved or saved by RenderDoc's built-in API validation tracking. The debug layer must still be enabled via the capture options.

• When serialising GL memory barriers, display the bitfield values as strings instead of a hex number.

• Sort tree list values before copy-pasting, as the selection is stored by default in the order they were selected (possibly reversed).

• Don't accumulate ResolveSubresource calls over time if we can't deduplicate them, but instead just mark the resource as dirty.

Bugfixes

• Fixed a crash that could happen if GetProcAddress was called for either itself or LoadLibrary, commonly happening in .NET programs that used P/Invoke for either function.
• Fixes for the display and saving of 3D textures, in particular for at mip levels above 0.
• Allowed hooking of delay-loaded ordinal imports. Mostly applicable for delay-loaded d3d12.dll.
• Fixed the wrong operand being used in some sample operations - particularly comparison operations.
• The arrow key nudge-by-1-pixel in the texture viewer accounts for mip level instead of requiring 2^n presses to move a texel in a mip.
• Ampersands in event names no longer try to become shortcuts.
• Calculation of uniform buffer sizes is fixed for arrays/structs in SPIR-V.
• Fixed the RENDERDOC_TEMP override on linux not working properly.
• Fixed cases where a buffer that's modified mid-frame in GL would not correctly restore its contents at the start of the frame, or where it could have the incorrect contents at the start of the frame if it's not modified before use.
• Forced 'viewed' textures to have initial contents saved out, as there's no good way for the underlying texture to know if it was modified through a texture view or not.
• Fixed event IDs from error messages being incorrect.
• Fixed a case where interna...

Version v0.31

The results from last month's survey are now up for anyone interested to see the aggregated results! There are definitely some interesting conclusions to be drawn, and the effects of any change in direction will start to appear in the coming months.

As a result of the survey responses, I will be creating a detailed proposal for both anonymous telemetry and an expanded crash reporter. These will be posted as a request for comments to allow for any tweaking and also a more concrete idea for people to raise specific objections against. As mentioned in the survey, these will still be easily opt-outable and respectful of user privacy.

Thank you once more to everyone who filled this out, I am very appreciative of the time taken to give so many responses, and I hope the results are interesting to you!

Version v0.31

The downloads of this release are now up on the builds page including new linux binaries. These are x64 and might not work for everyone, although hopefully they should have wide compatibility. Right now I've not set up .deb/.rpm packages although that might come in future.

The primary focus of this release is a stepping stone towards further platform compatibility. Although RenderDoc has technically had support for network capture and replay for a while, this release sees a significant polish and tweaking applied to make the process as smooth and easy as possible. While obviously not as powerful as a native UI on non-windows platforms, this will help those targeting those platforms from a windows development machine.

If you're interested in debugging on linux from windows, this release also comes with linux binaries (although of course you can build your own from source) and documentation/instructions on how to do that. As I mentioned, this is an intermediate step - the next being a native Qt UI for non-windows platforms.

There are a couple of small backwards-compatible breaking changes in this version. If you have captures made on older versions of RenderDoc that use deferred command lists in D3D11 and were using the RestoreDeferredContextState == TRUE parameter to ID3D11DeviceContext::FinishCommandList this will no longer replay correctly so results may diverge. You will have to capture again with v0.31 for it to work. Otherwise old captures should continue to work.

Also the python shell core object is now exposed as pyrenderdoc, to make room for renderdoc mapping as a python module to the internal renderdoc C# namespace, allowing creation and referencing of C# types much more easily.

If you run into any problems or have suggestions for improvements, please file an issue or contact me directly to let me know! I'm always happy to help out with whatever I can.

Features/Improvements

• Retooled the workflow and software support for network capture and replay. The documentation available gives all the details of how to set up and use this feature, and there's also a short video tutorial showing the simple steps visually.

  

  

• Captures now include a coarse machine identifier (such as operating system, CPU architecture and bitness). This is used to prompt users to replay remotely.

  

• Added a 'TDR' style timeout to shader debugging. After 100,000 cycles the debugging will prompt the user to abort as this is likely an infinite or very long running loop. If you hit this limit with working shaders, let me know!

• Heavily refactored handling of deferred contexts in D3D11. Previously there was a lot of ugly code to try and handle replaying separately on the immediate context and on a particular deferred context, now deferred commands are simply flattened into the immediate context at execute time.
  

  Please report any bugs you run into with handling of deferred contexts, as I have precious few real test cases to verify that everything is working.

• On vulkan, debug output is now muted by default to prevent applications from firing on false positive validation layer warnings or errors that are added by the capturing.

• Report only a single queue in the single family in Vulkan (previous releases would still report multiple queues available).

• Update notes for new versions are now formatted as RTF to allow links/bold/headers.

• When compiling for linux, support for xlib/xcb optional and can be compiled out to remove any reference to those libraries.

• Added the ability to specify environment variable modifications when launching a program - operations supported are 'set', 'append' and 'prepend', with append/prepend optionally supporting ; and : separators.

  

• Added VK_KHR_display support on Vulkan for direct framebuffer access.

• Added an option in the settings window to specify a default folder for saving captures.

• Improved proxying behaviour on GL, to handle BGRA and various some other non-uniform texture formats.

• On linux renderdoccmd version will print which windowing and rendering APIs were included at compile time.

• renderdoccmd on linux now will detect if the vulkan layer is registered properly and prompt the user to register it or fix the situation.

• Shaders can now be saved to disk from the pipeline state. This is most useful for retrieving binary shaders from D3D11/Vulkan for external examination, on OpenGL it concatenates all source files together.

• The drawcall column on the Event Browser now shows a range of drawcalls, the same as EID, for marker regions.

  

• Serialise and display parameters to IDXGISwapChain::Present.

• Add F3/shift-F3 for searching forward and backwards in event browser.

Bugfixes

• Fixed a bug that hit a number of people in v0.30 - if multiple mesh viewers were open in the default window layout, the docking toolkit I use would crash on opening.
• Fixed a common cause of crashes on AMD, if using the DX extensions this would cause a driver crash on replay. Now the DX extensions will be hooked and returned as unavailable/failing to initialise.
• Fix loading of EXR files, and improve error messages when failing to load images (don't refer to them confusingly as 'logfiles').
• Save EXR images in ABGR channel order which seems more compatible with viewers.
• Fix an incorrect saturate on D3D11's fake gamma curve, causing slight clamp of white pixels.
• Fix a potential crash if GetProcAddress failed on a function that we would in theory be able to hook.
• Fixed multisampled renderbuffers in GL not displaying correctly.
• Stopped a leaking capture where glBindSamplers would be recorded even when not mid-frame.
• Fixed a few cases of invalid GL use in edge-cases.
• Corrected recording of 'VAO 0' to properly reference the buffers bound to it.
• Fix pixel highlight boxes being off by one in the pixel context view.
• Fixed an odd interface-casting bug that lead to ID3D11DeviceContext::GetDevice returning an invalid pointer.
• Several improvements for control colours under high contrast themes.
• Fix potential crash if selecting a non-drawcall with empty items enabled in the pipeline state view.
• Make sure buffer view clamping to 200k max rows, even if a view specifies more than that.
• Fixed handling of matching source with blank lines when the shader was compiled with old (SPDB) D3D debug format.
• Speculative fixes for some crashes in texture viewer, by clamping previously selected mip/slice.
• Fix for reconstructing constant buffer sizes without reflection data.
• Fix an erroneous failure to capture if a GL frame contained no commands whatsoever.
• Fixed network capture/replay between mismatched 32-bit and 64-bit executables.
• Fix a crash when reading off the end of a buffer on D3D11, instead of clamping.
• Fixed incorrect socket error handling on linux not looking for EAGAIN and EINPROGRESS.
• Fix incorrect calls of select() on linux.
• Add a search for a matching X visual ID when creating GLX window.
• Fix a crash if a barrier event happens not within a drawcall.
• Fixed vulkan debug texture rendering (used for display or saving texture data) being clipped to 4k accidentally.
• Some fixes to handling of texture views without trying to copy or save their contents.
• Fix a crash with vulkan shader edit & replace.
• Fix a crash in vulkan pipeline state export to html.
• Fix a possible case where the GL in-application overlay wouldn't render text properly.
• Fixed inconsistent y-flipping of textures for GL. It's still an inevitable mess, but slightly less of one now.
• Handle SOSetTargets() being called with a NULL list of buffers and non-zero buffer count, which is apparently valid and means each buffer is NULL.
• Fixes to cubemap rendering on GL not properly restoring FBO attachments as the right face. Also at the same time fixed some issues with array slices being bound to FBO attachments.
• On D3D11 only include matching mip/slice events in pixel history, and get the right before and after pixel values.
• Fixed handling of byte address buffers - name them properly, and detect them when reconstructing stripped reflection info.
• Handle a crash if StaticExports.GetVersionString() is not present when detecti...

Version v0.30

NOTE: There's a crash with certain saved UI layouts, if you had multiple mesh views open at once. If v0.30 crashes whenever you open it, delete %APPDATA%\renderdoc\DefaultLayout.config

I started working on RenderDoc in 2012 as a hobby project just working in my spare time. Now since June this year I've been contracting with Valve to focus full-time on RenderDoc, allowing significantly more work and improvement on the tool. I'm thankful to everyone who has helped me get here as I'm very privileged to be in this position.

In order to make sure that I do the best work I can and focus on what is important to people using the tool, I have put together a short survey to find out who is using the tool and why, as well as gather opinion on ways I'd like to improve the tool with better crash reporting and anonymous telemetry.

Please take a few minutes to fill out this anonymous survey

The survey is now complete! The results are now available

It will make a big difference to understand the answers to these questions so please fill it out. There's no personal information or login required, and all of the questions are optional. If you have any questions or concerns about the survey or anything else RenderDoc related, feel free to email me at any time and I'll be glad to help.

Version v0.30

As always downloads of this release are now up on the builds page.

Note that I've decided to retire the beta builds, since for the last several versions they have simply been in lockstep with the stable builds. They may return in a different form in future, but for now I've removed them from the page as they have no historical interest (compared to nightly builds at least), and the <1% of users on beta versions will be automatically prompted to update to the latest stable version if they don't do so manually.

This release brings a bunch of improved functionality to Vulkan, as well as smaller features and bug-fixes across the board including something that's been on the backburner for a while - display of view formats of typeless resources and view parameters like a sub-range of mips or slices. I'm not entirely sure if this implementation is ideal, so please give me feedback on what you think of it!

The in-application API has been updated to v1.1.0. Following semantic versioning this adds new functionality in a backwards compatible way - specifically the returned pointer to a function table contains an extra entry on the end, and since it's not caller allocated it is safely backwards compatible with v1.0.x code.

If you run into any problems, please open an issue or contact me to let me know - I can't fix what I don't know about!

Features/Improvements

• When a bound resource doesn't just bind the whole resource but a sub-set, or if the resource is bound as a different type than it actually is (format casting, or if the resource itself is typeless and always cast), this is highlighted in the pipeline state and a tooltip shows the difference.
  
  
• The source code has now been formatted by a .clang-format file to make for easier contributions (ie. without me nitpicking style problems).
• Added Vulkan support for immutable samplers
• Added Vulkan support for stepping through both multidraw (drawindirect with drawcount > 1) and secondary command buffers.
• Implement saving multisampled textures to disk in Vulkan.
• Added support for SPIR-V specialization constants.
• Implemented mesh picking for Vulkan.
• Implemented custom display shaders, and shader edit-and-replace for Vulkan.
• On vulkan, image initial states are kept as buffers in CPU memory to reduce the device memory requirements and lessen the chances of out of memory errors (necessary for capturing DOOM).
• For the moment on Vulkan, pretend to report only the single most capable queue and suppress the others, so that applications don't use multiple queues (also necessary for DOOM).
• Added pipeline export to HTML for GL.
• "Create Debug Device" capture option has been renamed to "API Validation" since it makes more sense cross-API.
• Return dummy/stub interface for ID3D11Debug the same as for ID3D11InfoQueue
• Added a button to zoom to 100% so that pixels are 1:1.
• The 'attach to running instance' dialog now shows running programs much faster rather than checking and waiting on the timeout for all possible programs before showing anything.
• Dragging an executable into the window anywhere will now pop it into the capture dialog, instead of trying to open it and complaining it's not a recognised capture log.
• Supported marker colours in the UI, which is used by the D3D11 and Vulkan marker extensions. This can be disabled in the options if e.g. your code passes only one colour for all markers (opaque and transparent black are ignored if all markers have the same colour).
  
• Added a mode to show all instances in a draw in the mesh output. Also adjusted the colouring between current instance, other instances, and previous draws to make it clear which mesh is which and avoid changing colours when viewing a single draw or viewing multiple.
• Add copy-paste support from shader debugger registers.
• Added support (largely untested though due to lack of samples!) for newer D3D11 (11.3 and 11.4) and DXGI (1.4 and 1.5) versions. If you run into bugs with this please let me know as there is little code using it, but at least this should allow proper capturing without crashes.
• The buffer viewer should now save its internal layout, so if you rearrange the 3D preview or data panels, it will remember that.
• Marker regions in the event viewer are now display the range of events they cover, not just the last one.
  
• For the separate unstripped shader debug info feature added in v0.28, allow relative paths to be matched up to search paths in the UI.
• Likewise this feature now supports lz4 compressing blobs, since they are often primarily text (containing source code) so they compress well.
• The documentation is now generated through reStructuredText and sphinx - thanks @Anteru!
• Added text file export of the entire event tree, to more easily batch-process.
• Image barriers are now displayed in the timeline bar, as well as in the resource usage drop-downs. The current image state is shown in a tooltip in the pipeline state view.
• Show the required size of a constant buffer vs the provided size, and highlight any that don't provide enough data.
• Better display of multisample count, byte/structured buffer type, and image swizzles in pipeline state.
• SNORM textures now display in the range [-1, 1] instead of [0, 1] by default.
• Added support for importing by ordinal on windows, which is needed for D3D12 hooking.
• Add a menu item to jump from a given pixel history event directly to the matching primitive.
  
• The renderdoccmd command line program has been revamped to have a more friendly and intuitive interface, and more useful options for e.g. launching programs specifying capture options or a working directory.
• Improved underlying technical work behind remote replay and capture, and running on linux in general. The UX still needs work though.
• Tweaked logging output to stdout/stderr not to include such long line prefixes.
• Added a SIGINT handler to linux to shut down the remote replay host cleanly.
• Added a feature to capture N successive frames. This won't necessarily help in some cases where bugs are timing related, as the frames will run very slow during capture. However it can be useful if it's known that a bug happens every second frame or so.
• Improved float formatting when in exponential notation, as previously it could print a lot of unnecessary trailing 0s.
• Add a small popup in the TextureViewer to go to a particular pixel. It's accessible in the toolbar, or via CTRL-G
  
• The buffer viewer (mesh or raw buffer view) will now try to size columns to fit likely content.
• When using per-texture settings (the default option), then the visualisation type (RGBA vs RGBM vs custom) and selected custom shader is also saved per-texture.
• Custom visualisation shaders are provided the selected slice as well as the selected sample from the UI. On GL, they are now also provided with [0, 1] UVs for convenience.

Bugfixes

• Fix an error where an update could fail if the renderdoc.dll module was injected into a program while the update process is on-going. This would commonly happen if the UI was launched from a program like the Unity or Unreal editor, and then the update was found. It left the UI and core module on inconsistent versions, which lead to crashes/bad behaviour.
• Fixed a long-standing bug where a Win32Exception could be thrown creating some handles. I still don't know what the problem is or why the fix works, but this seems to be corrected now by simply forcing handles to create at creation time instead of lazily.
• Several fixes for pixel history on D3D11 - a bug causing all events after the first failed pixel to be dropped, s...

Version v0.29

Binary downloads of this release are now up on the builds page.

Version v0.29

Since v0.28 was released a couple of weeks ago, a bug or two cropped up that were just on the border of being serious enough to warrant an urgent bugfix release. To that end v0.29 is a small release primarily aimed at patching those up as a number of people were running into at least one on v0.28 - a fatal error that happened when inspecting a D3D11 compute dispatch that used a structured buffer UAV.

It also brings with it support for the newly release VK_EXT_debug_marker extension for Vulkan, which allows common API debug functionality like naming objects and marking off regions of commands for hierarchical browsing.

There are a few other changes, so even if you're not hitting bugs in v0.28 it's worth updating. As always please get in touch if you run into any problems or have comments or suggestions to improve the tool!

Features/Improvements

• Support for VK_EXT_debug_marker in Vulkan.
• Added support for the 'create debug device' capture option in Vulkan. This will force-enable the validation layers, and display any debug messages recorded for the events and API calls in a frame.
• Object labels in GL applied to shaders, programs and pipelines will be displayed in the pipeline state view.
• When saving textures, updating the file type dropdown will change the filename (if present) to match the extension, and vice-versa when editing the filename box if the extension is changed it will update the file type dropdown.
• Some improvements to the new statistics pane added in v0.28.

Bugfixes

• Fix a fatal error that happened when inspecting a D3D11 compute dispatch that used a structured buffer UAV.
• Fixed a bug where a failed call to wglCreateContextAttribs (e.g. if requesting a higher version than is supported) would cause subsequent calls not to be hooked.
• Fixed a mistaken offset calculation when fetching constant buffer data into shader debugging on D3D11.
• Fix a divide by zero error if average framerate isn't yet calculated by first Present().
• When capturing manually without a swapchain, ensure that each capture has a frame number incrementing from 1, instead of all being frame 0.
• Fix a case where the profile mask could be missed when parsing the attribs list when creating a context in GL.
• Fix input layouts not being marked referenced when bound to the render state - causes them not to be included if they are bound at the start of the frame, but not bound in the frame.
• Handle VK_WHOLE_SIZE being passed as the memory range size in vkFlushMappedMemoryRanges
• Filter out unsupported Vulkan extensions before the application sees them.
• Don't replay with the Vulkan validation layers enabled even if the application enabled them.
• Ensure the WSI extensions are requested when replaying a Vulkan log even if the application didn't use WSI.
• Fix some erroneous warnings about descriptor sets not being bound when referenced by a shader.

Version v0.28

Binary downloads of this release are now up on the builds page.

Version v0.28

This release is mostly a collection of bugfixes from the last few months - a large number are Vulkan related, but some are from crash uploads and other bug reports. There are a few new features though!

For those who compile the code or are interested in development there have been some behind the scenes improvements - things like better organisation of build configurations, a new assert macro, extra warning levels enabled and the removal of the crash when no debugger is present if a non-release build fails an assert or hits an error message. If you're curious try building the code and have a poke around - that's the beauty of open source after all!

Features/Improvements

• A button on the texture viewer to open the texture contents in the buffer viewer for custom raw formatting and inspect. Be careful not to make too many columns (you might be tempted to create texture_width columns) as the .NET control crashes hard 😢.
• Support for separate unstripped shader debug info - thanks to Arne Schober!
  • This allows a workaround for shaders needing embedded debug info but normal builds not wanting that disk size overhead. Instead you can compile the shaders in debug, save the unstripped blobs somewhere on disk, and then annotate the stripped blob with a file path. Then RenderDoc will know to find the unstripped blobs from elsewhere.
  • You can also specify the file path at runtime with SetPrivateData. For more information see the docs!
• .cap files can be opened via file->open and drag & drop.
• A new button to abort the running of a python script.
• When buffer viewers are opened from an API's pipeline state, any offset or length from the views is applied to the initial layout.
• A new experimental statistics view - thanks to Michael Vance!
  • Adds a new pane with rudimentary API surface area statistics, such as draw call counts, resource sets, sampler & constant buffer updates, etc.
  • This functionality is currently only supported on DX11.
  • Information is currently presented in a primitive text-based view, but we plan to move to a proper set of UI primitives in the future.
  • API coverage is incomplete but covers the majority of the pipeline.
  • Future work will be centered around completing API coverage, enhancing detection of redundancy, proper UI support, and automation of capture and export of API statistics.
• Input layouts now pick up names set with SetPrivateData.
• The pan is kept consistent for textures with an integer multiple of dimensions. So when you're looking at a downsample chain that goes from 256x256 to 128x128 to 64x64, you won't have to re-zoom and re-pan when switching between these textures.

General Bugfixes

• The installer now packages and runs the appropriate VS2010 redistributable in case you don't already have it.
• When y-flip was enabled, texture pixel picking co-ordinates were off by one.
• Fixed some depth textures not displaying as depth and instead just as if they were red-green.
• When editing and replacing shaders, the pipeline state instantly refreshes, instead of needing you to manually select another drawcall then back to the first.
• An OpenGL performance regression is fixed - push/pop debug labels were spamming out debug messages to the log file and tanking framerate.
• When saving logs they're immediately added to the recent files list.
• Fixed a bug that caused calling glUseProgramStages mid-frame for different stages to not replay correctly.
• D3D11 input layouts are now dependency tracked instead of all being included in the replay
• Fixes for calling glBindTexture with ID 0 - on replay the texture would not be correctly unbound.
• Fixes for separablee shader patching.
• In the API view glSamplerParameter and similar enum parameters now display as strings.
• Fix for glShaderSoruce being passed multiple negative lengths - thanks to @olvaffe!
• Treat baseVertex correctly as signed instead of unsigned, fixing crashes when it was negative
• Fixes for some OpenGL context creation failures and broken attrib list parsing.
• Some OpenGL shader compile fixes for intel.
• Fix for EXT_depth_bounds_test not being available.
• Some D3D11 constant buffer packing fixes.
• Fix to allow capturing oculus programs - D3D11 fix to QueryInterface() of IUnknown - thanks to Jamie Hayes!
• Reduce stack size in log function - previously it was allocating 4kb of stack which could cause pressure on threads with small stacks.
• Fix an OpenGL crash when using custom shaders in the texture view.
• A speculative OpenGL fix for a crash when functions like glTextureImage2D was called with no texture bound.
• Fix a crash copy-pasting in the UI with nothing selected in the pipeline view.
• Fix a failure when saving really low resolution images as JPG.
• Several fixes for saving 2-component textures.
• Minor fixes for quad overdraw ramp decoding on extreme overdraw amounts (>= 64).

Vulkan Bugfixes

• Fix a crash when passing oldSwapchain to swapchain creation - typically on resize.
• Fix a random crash exposed by changes in the post-release loader versions around physical device enumeration.
• Fix the vulkan nag message on the capture screen not working properly with RenderDoc installs on UNC paths.
• Fixes for sparse descriptor sets where not all bindings are used contiguously.
• Reduced compute workgroup size for running on older cards with lower limits.
• Support for an implicit memory unmap before free.
• Fix a crash if swapchains are created with invisible windows.
• Some protection against invalid/misconfigured code.
• Fixes for 32-bit - it just plain didn't work before!
• Improvements to the API view to show flags/masks as strings.
• Fix for vkCmdDispatch calls not working when stepping through a frame.
• Many more code validity improvements.
• Many improvements and fixes to SPIR-V reflection and disassembly.

Version v0.27

Binary downloads of this release are now up on the builds page.

Version v0.27

It's been about 12 months since I posted that I was adding OpenGL support - and that was 1 year after RenderDoc's release. It's fitting then that just a little before RenderDoc's 2 year anniversary I can happily reveal support for the recently released Vulkan 1.0 API. I've been working since last september on including Vulkan support in RenderDoc at the same time as the launch of the API.

This is the reason why development has been quiet on github recently, as most work was happening behind the scenes. There are some other features and improvements in this release as well, so check the notes below to see them all.

The RenderDoc installer is also shipped in the Vulkan SDK - this is absolutely identical to what you download above or build from code here, just repackaged seamlessly into the SDK.

Side note: The in-application API was bumped to 1.0.1 for a minor bugfix. Going by semantic versioning, this is a backwards-compatible change so any code loading 1.0.0 will get 1.0.1 and everything will work.

Features/Improvements

• Vulkan 1.0 support!
• Added a warning if D3D11.1 calls are captured and the replay is not able to run them.
• If SetResourceName is called on the same resource many times, we de-duplicate and only serialise the last.
• When viewing a really massive buffer the UI could have trouble displaying enough rows. Instead, we clamp the row count to 200,000 and display a warning to view other sections with the row/byte offset.
• Support added for displaying and picking S8 textures on GL.
• GL errors are cleared after operations that might potentially generate them (such as RenderDoc's fetch/apply state vector).
• GL hooks are added for wglSwapBuffers, wglSwapLayerBuffers and wglSwapMultipleBuffers.
• When viewing an image rather than a capture, added a retry when reloading the file on change, in case the change is detected while the file is still locked by another program.
• Picking vertices in the mesh viewer will enable synchronisation between the input and output views.
• Buffer viewer elements that are NaN/Inf will display properly.
• Images saved with only one channel visible are saved as greyscale instead.
• If a custom shader is used to view a texture, then the results of that custom visualisation will be displayed, rather than the source texture.
• Viewport/scissor overlay should now hopefully be clearer to see.
• Added support for reverse-z projection matrices in mesh viewer unprojection
• When StartFrameCapture() is called from the API, if there is a window identified (i.e. it's not just NULL, NULL) then make that window active.
• The texture viewer input thumbnails now show inputs from all shader stages, not just pixel shader.

Bugfixes

• Fixed a crash if an update check was ongoing when the main window was closed.
• Fixed a common crash on shutdown when closing D3D11 captures that began happening, due to a mismanaged refcount on ID3D11DeviceContext.
• Fix GL crash with glMultiDrawElements.
• Fix some incorrect GL state setting.
• Fix IsFrameCapturing API to return true for captures triggered with TriggerCapture().
• Add mutex around destruction code that could be run on multiple threads at the same time.
• Possible fix for crash on linux depending on global initialisation order.
• Fix an edge-case with wglShareLists by avoiding creating any internal GL data for overlay rendering until the last possible minute in SwapBuffers.
• Stop an erroneous warning firing while shader debugging.
• Fix find-in-files not properly clearing previous results.
• Fix a GL crash if buffer orphaning isn't properly detected.
• Remove queries to GL_TEXTURE_COMPRESSED and decide for ourselves based on the internal format.
• Improve handling of difficult GL context juggling between threads when capturing.
• Fixed a case where compute debugging would incorrectly complain that the thread index was out of bounds.
• When glUseProgramStages is called mid-frame, we now correctly replay it instead of caching it incorrectly.
• When depth or stencil test is disabled, the overlay now shows all-green instead of what would have happened.
• Added an overlay 'clear before draw/pass' that shows only the results of the selection on the current RT.
• Fixed an overly-strict check for compatibility between IA bytecode and VS bytecode input signature.
• When modifying GLSL, we now handle whitespace better around #version and other directives
• Changed the shortcut for File -> Exit as it was clashing with File -> Recent Capture Settings
• Fixed pixel history on depth-stencil targets from going badly wrong.
• When saving a log, change the window title from the temporary filename.
• Fixed texture viewer scrollbars being inconsistent and annoying, which caused them not to map properly to the full range of scrolling.
• Fixed a crash if a find dialog is open when the shader window closes
• Fixed a possible failure in the version updater when it goes to restart the program.
• Always return typed component format for images, fixes a potential problem saving e.g. EXR images from typeless formatted textures.
• Fix a case on GL where FBO attachments of a specific mip wouldn't properly be restored on replay.

Version v0.26

As always, you can find binary downloads of this release on the builds page.

Version v0.26

This is a smaller release but there are a couple of key features included. The main one is that the serialised capture format has changed. The new format should be more flexible and extensible for adding new features (to come in a later release), and it also has built-in compression, so that capture files are smaller on disk with minimal overhead for loading and saving.

This version will be backwards compatible, such that logfiles from older versions (back to v0.20) will load. Captures made in v0.26 will not load in older versions. In the future these old logfiles will not work, but hopefully after this there should be no need to make a backwards-compatible breaking change.

In this version there is a new stable RenderDoc application API, which is designed to be forwards and backwards compatible and is strongly supported. If you were integrating RenderDoc before you will need to update your code before it will work with v0.26.

Features

• Updated capture file format, to compress the captured data, and support addition of arbitrary data - more details to follow in a future release.
• Added stable in-application API. See the renderdoc_app.h file - included in all binary distributions.
• Added a new application updater, that will automatically download and install new versions when detected at the click of a button.
• IronPython standard library embedding now just distributes a .zip file rather than trying to compile into a .NET dll assembly. This means importing the standard library should be much more reliable.
• Empty viewports are now highlighted more obviously in the pipeline state view
• Compute UAV slots now use shader variable name where available.
• Copy, dispatch and resolve calls now show the relevant inputs and outputs, rather than the current graphics bindings.
• Add support for some new GL ARB extensions
• Improved support for many shader source files when debugging - on the left hand side of the shader panel there is now a list of all source files, that you can click to quickly jump to those files. In addition, ctrl-shift-f will open a 'find in all files' window.
• Shader disassembly now happens lazily, which should mean improvements to log loading and shader creation during capture.
• Added more fallbacks for detecting position input elements in the mesh view, and made sure that no matter what at least some element will be selected.
• GL captures should now not be susceptible to results from later in the capture 'leaking' backwards into earlier in the capture, if e.g. a texture is written and read from without ever being cleared at the start of the frame.
• GL function names in the event browser have been tidied up to be more readable - now only counts and important parameters are displayed, the topology, index width, offsets etc are not displayed.
• Added a tips dialog, that is accessible via Help -> Show Tips. The tips are also linkable online

Bugfixes

• Fixed an unfortunate crash that snuck into 0.25, where viewing DDS files caused a 100% crash.
• Fixed a crash trying to pick a vertex in a drawcall with no vertices.
• Fixed some cases where function pointers on GL could be called without being verified as present properly.
• Updated checks for GL on replay - ARB_buffer_storage is required as well as 4.3 + EXT_direct_state_access.
• Fixed an edge case crash handling nested drawcall markers.
• Fixed crashes where bad mesh data (inf, NaN, etc) would cause a crash when calculating the bounding box.
• Fixed a race condition where C++ to C# marshalling could fight on multiple threads.
• Handle invalid filename characters in shader filenames from debug info
• Corrected bounds checking of ld_structured_indexable
• Changed imm_atomic_consume used in ConsumeStructuredBuffers to do a prefix instead of postfix decrement.
• Corrected behaviour where if a cwd-relative pathname was passed to the in-application API for where to store captures, the UI would not be able to locate it.
• Create any parent directories in the path specified for captures to be stored.
• Fixed GL to not crash when RenderDoc is injected after GL has been initialised and used - instead RenderDoc will do nothing and capture nothing, which is consistent with D3D11 behaviour.
• Fix an incorrect serialise of glCompressedTex_Image3D_() calls
• Make sure to render GL overlay to the backbuffer.
• Handle unsized formats better in GL texture calls.
• Speculative workaround for nvidia driver crash
• Fix case where a geometry shader with streamout would fail to create if numStrides == 0
• Fix for a marshalling crash if struct field order wasn't returned in layout order
• Several crash report bug fixes and speculative fixes.
• Fixed a case where loading of DDS files failed due to a flag bit being set
• If a machine doing a renderdoc capture has no D3D11 runtime installed, fall back to using d3dcompiler from the renderdoc installation.
• Call SetLastError(0) after renderdoc WGL functions to avoid leaking out error codes that shouldn't be there.
• Protect against crashes or bad behaviour if FinishCommandList is called on an immediate context.

Version v0.25

Binary zips and installers for this release (and others) can be found on the builds page. Both stable and beta builds are up to date with this release, but beta builds can be updated more regularly. You can choose which type of release you want to install and receive updates for.

Version v0.25

This version brings some new features, tweaks to existing functionality and the bugfixes that have happened since v0.24. As always feel free to get in touch with me or post an issue here on github if you encounter a problem, or if you have feedback or a feature request.

Highlights include multiple OpenGL frame capture and dependency tracking, bookmarked events in the replay UI, improvements to the mesh preview window and iteration on pixel history and shader debugging for further accuracy.

OpenGL captures will not be backwards compatible as work has continued on that front, but D3D11 captures are backwards compatible with captures from previous versions.

In the source tree there's progress being made on OpenGL functionality and Linux support - glslang is now compiled into the distribution for compiling GLSL to SPIR-V. It's currently disabled in release builds but this will ultimately be used to support shader debugging on OpenGL. Likewise there is a Qt UI currently being built that will eventually be supported on Linux with the same functionality as the current .NET UI. Potentially in future the .NET UI will be retired, if the Qt version ever reaches parity.

Features

• You can now make bookmarks in the event browser. Clicking on the bookmark button or Ctrl-B will add a new bookmark at the current event. Then you can either click on the shortcut buttons in the bookmark toolbar, or anywhere in the program you can press Ctrl-1 through Ctrl-0 to jump to the first 10 bookmarks.
• This allows rapid jumping between interesting drawcalls, particularly useful if you are comparing two drawcalls back and forth.
• 
• OpenGL applications can now capture many frames without needing to restart the application.
• OpenGL captures now do proper dependency tracking, which means that like D3D11 logs only the resources needed for the captured frame are included in the capture file, not all resources that are live at that point.
• Several improvements to the pixel history view, which will now show fragments that shader clip in a list of several drawing in one drawcall. You can also run the pixel history on a particular mip or array slice in cases where rendering happens to only one.
• A bunch of improvements to the user experience in the mesh preview window.
  • The window now uses 4x MSAA by default (since there's barely any pixel work going on, this hopefully should not be a significant performance hit for anyone).
  • The arcball controls are now improved and are based around the bounding box calculated and rendered for each mesh component.
  • You can right click on the mesh to 'pick' vertices and select them in the raw data tables. Note that for when you have several vertices that have the same position but different UVs or normals, the first will be selected.
• 
• The log loading progress bar should hopefully now be a bit more representative rather than remaining mostly static and jumping several times.
• Textures can now be zoomed up to 25600%
• Constant buffer data can now be exported to a CSV file
• The RenderDoc in-application API file has been simplified to remove typedefs and STL include, and a couple of new API convenience functions were added.
• When single-stepping in a shader debugger, if a register tooltip is open it will now live-update instead of becoming stale.
• Views of resources in D3D11 now have their lifetimes tracked separately. Previously if a resource continually had views created and released they would all be stored and replayed, causing slight overhead on capture and potentially significant slowdown on loading the capture.
• Registers and constants are now highlighted in the register windows when selected in the disassembly view.
• 
• Ctrl-F3 and Ctrl-Shift-F3 will search for the currently selected word in shader editors.
• If pixel debugging fails, instead of popping up a dialog saying that the current drawcall doesn't write to that pixel, instead launch the pixel history.
• When RenderDoc is displaying an image, if the image is changed on the filesystem the data will be reloaded and displayed with the pan and zoom otherwise staying identical. Note that if the image dimensions or format change the results might be unexpected.

Bugfixes

• Fix QueryInterface for IRenderDoc_uuid returning the wrong pointer and causing problems on Release() (thanks @zao). Also the proper ID3D11Device* pointer is now used for identifying a window, it was wrongly casted.
• When editing shaders, #include file searching is case insensitive.
• If cbuffers have identical names, use the order to identify which one is which
• Fixed a case where the currently active window being removed would mean no window is active.
• Fixed pixel history on a depth-stencil texture not working properly.
• Fixed a case where unpack state was inconsistent on loading GL texture data.
• When an array of shader resources overlaps with a single shader resource in terms of register binding, the single shader resource has priority.
• Fixed serialising GL program uniforms incorrectly
• Report ARB_direct_state_access as a supported texture
• Handle Luminance/Alpha texture formats in glTexStorage functions (kind of crazy that someone would do that, but not hard to support).
• Hide extra refcounts on D3D11 resources for being bound to the pipeline from the user, as some naughty code would rely on the undefined refcounts and error message.
• Register renaming for constants now supports arrays properly and structure heirarchies better.
• Fixed a copy-paste mistake on GL that would cause an undesired dependency on ARB_direct_state_access
• Right-clicking on auto-fit will re-fit whenever the texture selection changes, even if the event stays the same.
• A variety of crash fixes both real and speculative from uploaded crash reports.
• Using the arrow keys to nudge the selected pixel now works when the pixel context view is in focus as well as when the main texture view is in focus.
• Fixed a memory leak that could happen with buffer orphaning using glBufferData
• Fixed D3DCompiler register packing insanity when using arrays of float or float2 interpolators.
• Fixed a case where NaNs in a texture's alpha would cause the texture to display incorrectly even when the alpha channel should not be visible.
• When changing a value in the range control and deselecting the change is now committed rather than being left at a misleading value.
• Fixed buffers as resources showing up as 'unbound' instead of using a default image and displaying their name.

Version v0.24

Binary zips and installers for this release (and others) can be found on the builds page. Both stable and beta builds are up to date with this release, but beta builds will be updated more regularly. You can choose which type of release you want to install and receive updates for.

Version v0.24

This release is by and large a collection of bugfixes both from crash reports that people sent in and other bugs that have been reported. There's not much new functionality as I was busy for most of April moving country for my new job.

OpenGL captures are not backwards compatible and old captures will not load in this version - once GL support is fully completed this will not happen so often. D3D11 captures are backwards compatible, and old captures will open in v0.24.

Features

• OpenGL contexts that aren't created via CreateContextAttribs will now be disallowed for capturing, as they are very likely to be pre-3.2. RenderDoc will use super-old fixed function GL to display the text overlay, so that even 2.0 or older contexts will work. Contexts created via CreateContextAttribs will be captured, regardless of whether they are compatibility or core profile, to allow more programs to use RenderDoc. This is a bit dubious as RenderDoc still only supports core profile OpenGL, but hopefully this line in the sand will prevent most old programs will allowing through few incompatible programs. (sort of a feature!)
• A few places in the UI now use a monospaced font, such as mesh output and constant buffer viewer. There is a new option in the general category to display all data everywhere (such as pipeline state viewer, event browser, etc) in a monospaced font.
• GL draw elements calls will now support passing indices as a direct memory pointer, as a concession to old GL code. Note that all vertex data must still be in vertex buffers in a VAO, direct memory pointers are not supported here.
• Resources are now tracked by usage in OpenGL, so the timeline bar will correctly indicate reads and writes per resource, as well as the thumbnail right-click menus in the texture viewer.
• RenderDoc should now handle having multiple APIs alive in a program, which in this case means GL and D3D11. Cycling between active windows will cycle between all APIs alive.
• Added in-API ways to detect RenderDoc. GL via this extension and D3D11 via querying the device for UUID A7AA6116-9C8D-4BBA-9083-B4D816B71B78.

Bugfixes

• GL cubemap and array textures weren't properly showing the slice or face for mips above level 0.
• When invalid indices like 0xcccccccc or 0xbaadf00d etc were used (probably by accident - but this is a debugger after all) for the Post VS mesh data we would stream-out all indices between the minimum e.g. 0 and that value, even if only a small subset were used. This caused out of memory and driver crashes. Instead we now only stream-out the indices used.
• Fixed a crash when debugging such an invalid index.
• Fixed a crash if vertex instance rate is 0 for instanced data (which is valid - the first element is used for every vertex).
• Copy, Resolve and GenerateMips calls will now show up with draw calls in the event browser, to make it more clear where these events happen in the frame.
• Fixed a crash if the constant buffer viewer is still open when a log is closed.
• Fixed a crash if for some reason a shader debug trace comes back with no states.
• Crash fix with CopySubresourceRegion if a box is specified.
• Fix depth render target being larger than the colour render targets in D3D11 (was detected as invalid, but D3D11 allows this).
• Fix from @vvuk - Present1() was using the wrong DXGI interface.
• Fix a crash introduced in previous version, where SetPredication(NULL) would not be replayed and predicates would be left bound - which caused driver crashes.
• Fixed some crashes if an index buffer wasn't multiple of 4 bytes, and fixed GL unsigned byte indices.
• Fixed a couple of problems with the "remove empty marker groups" option - a crash if a marker group has an empty group as a child, and fixed calculating timings completely screwing up the drawcall list.
• ld_structured was incorrectly looking at only UAVs to calculate its stride, instead it should check for the matching resource.
• A few DX bytecode instructions assign to a scalar destination from a vector source, and these needed a fixup in the debugging to properly handle swizzles.
• Fixed some crashes and problems with shader editing when the source has multiple files with #includes
• With the SPDB debug chunk (which is produced by new d3dcompiler versions) #defines that are specified on the command line or to D3DCompile are now used when editing, to recompile the shader.
• Executing python scripts that Invoke onto the render thread will now catch any python exceptions that are thrown on that thread, instead of crashing with an uncaught exception.
• Shader debugging variable tooltips now show hex as well as int and float, and the register windows now show the tooltips as well as the source window.
• Fixed some crashes if ctrl-c is pressed without a log loaded, and added copy-paste handlers to the GL pipeline state view.
• Fixed a crash with the GL text overlay in-program, if the string is formatted very long and/or the glMap fails.
• When redeclaring gl_in and gl_out in a GL shader only one of the redeclarations would be added, this is fixed.
• Fixed shader debugging 'run to' command checking instruction number against trace length - which could be different whenever flow control occurs.
• Outputting matrices from a shader in GL will now be listed correctly in the mesh output.
• Clamped mips in textures without mips (but that aren't created immutable) to correctly bind when calculating min/max or histogram.
• ID3D11Debug interface is wrapped, so that querying for ID3D11InfoQueue via it will return our dummy info queue.
• The disassembly source window has a custom right-click menu now with relevant controls.
• Temporary captures from a program connection window are kept around for longer even when saving them to a file. This prevents captures from being lost if a user saves them, then deletes the saved capture, and wants to save the capture again.
• Fix a crash if an invalid filename is passed to D3DCompile as the source filename.
• Fixed mesh preview window for geometry & tessellation output.
• MultiDraw drawcalls now correctly create a nested section in timeline bar.
• Fixed a crash if glUseProgramStages is called with program=0 to unbind.
• Fixed an edge case where RenderDoc would incorrectly cause a program to run out of D3D11 state objects by caching them aggressively, if the program creates many temporary objects that are all unique.