@baldurk baldurk released this Mar 6, 2018

Assets 3

Version v1.0

For those keeping track, it's been a while since the last stable release of RenderDoc. Work has not been idle, as today marks a new milestone in RenderDoc's development: a mostly arbitrary version number has been reached!

It's been a bit over 4 years since RenderDoc was first launched and the project has grown significantly over that time. Even though this release hits the 1.0 mark, there is still a long road ahead and many improvements still to come. Stay tuned!

A list of improved features and changes are listed below, although there have been many more smaller and behind the scenes changes than are listed here. Thank you to everyone who has helped get RenderDoc to this point as well as everyone who continues to report bugs, contribute fixes and features or simply share the tool with others.

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

Capture Compatibility

A quick note - captures made in v0.x builds of RenderDoc will not open in v1.0, and vice-versa.

I've created a standalone rdcconvert utility which can convert a v0.x capture into a v1.x compatible capture. Binaries are available here (Win x64Win x86Linux x64) or else you can build it yourself from that tree. To use, you can just run the rdcconvert executable and it will prompt you for the new 1.0 renderdoc.dll if it can't find it automatically, then prompt you for the .rdc to convert. The resulting file is output next to the rdcconvert executable. You can also specify the .rdc file on the command line: rdcconvert path/to/file.rdc and optionally append --silent as the last parameter to suppress any unnecessary dialog boxes.

The conversion is best-effort so may not be perfect, e.g. the capture will have no thumbnail and the swapcahin backbuffer will show up as a normal render target, but otherwise the capture will be usable on v1.0.

There is also a final v0.92 release which contains all the final bugfixes on the v0.x branch. This is the last release on the v0.x branch and all new development and bugfixes will happen on v1.0.

Analytics

From v1.0 the tool now contains some very limited and anonymous analytics. These analytics are optional, but I'd please request that if at all possible you leave them enabled. Having a better idea of how people use the tool will help me to prioritise work and decide what features, APIs and platforms should be worked on.

The analytics are completely anonymous and are sent once a month securely to https://renderdoc.org/analytics. You can see a list of the analytics being gathered in your build, and almost entirely these are simple true/false flags indicating which features have been used. No data is gathered at all during capture time, the analytics code only exists in the replay UI and doesn't store or transmit any frame-specific data.

For those who would like to compile the code to remove any possible trace of the analytics gathering, look in qrenderdoc/Code/Interface/Analytics.h and change the #define RENDERDOC_ANALYTICS_ENABLE 1 to #define RENDERDOC_ANALYTICS_ENABLE 0.

Main highlights

  • The Qt RenderDoc UI is now shipping on Windows, the previous .NET winforms UI has been completely deprecated and removed. Aside from better consistency between platforms this comes with a number of benefits to Windows users.
    • Texture view Pixel history & shader debug
    • Mesh viewer Pipeline viewer & constants
    • Qt natively supports high-dpi displays, which should 'just work' including per-monitor DPI awareness.
    • The Qt UI doesn't require an interoperability copy-layer between C++ and C# so should be more efficient.
    • Likewise Qt's rendering and updating is generally faster and the UI should feel more responsive.
    • Qt being C++ greatly increases my abililty to diagnose crashes from crash dumps as I actually get a minidump, not just an exception callstack.
  • RenderDoc now supports Android, with both OpenGL ES 2.0 - 3.2 and Vulkan 1.0, thanks to contributions from Samsung and Google.
    • Android - Desktop side
    • Android - On device
    • Any android application is supported as long as it is built as debuggable, there is no patching or setup step needed, you just select your device and run the application. A step-by-step guide is available in the docs.
    • The workflow is deliberately almost identical to the familiar process on Desktop. Aside from selecting the Android device as the active replay context, you browse to the desired package, launch it, and when you open captures they appear to open locally even though the replay happens on the device.
    • All standard features for GL and Vulkan are supported on android, subject to hardware support for certain features.
    • This also comes with the same requirements as GL, such as all contexts being created as shared.
  • The internal serialisation system used for saving captures has been completely rewritten to be much more flexible and future-proof. This enables a lot of nice features in this release and opens the door for some interesting features in future. This is the reason behind v1.0 not being able to open v0.x captures.
    • It's now possible to export capture files to another format, such as human readable xml. This XML lists all of the function calls recorded in the capture and all the parameters and structures. This XML can be edited, added to, changed, and then re-imported back into a capture file for replay. Future RenderDoc versions may include more formats.
    • RenderDoc capture exported as XML
    • Previously any GL calls that were serialised the same way - e.g. glTexImage2D, glTextureImage2D, glTextureImage2DEXT, glTextureImage2DARB were all serialised and displayed as one of these, regardless of which you called. Now gl functions correspond to the exact function called.
    • Errors that happen during loading of a capture can now in most cases be caught and gracefully propagated to the UI. This means instead of the whole program crashing, you at least get a message indicating that there's a problem replaying the capture.
    • RenderDoc now saves thread IDs, timestamps, and durations for every function call. This can be exported in chrome tracing format, and in future may be displayed in-UI.
  • Resource Inspector
    • Resource Inspector
    • As a side bonus of the above serialisation refactor, there is a new centralised resource inspector panel. This panel contains a list of all resources available in the capture, and lists the details of the functions used to create and initialise them.
    • It also shows the links back and forth between related or dependent resources.
    • Resources with special viewers like buffers, textures and shaders have links from the resource inspector to go to those viewers.
    • Everywhere in the UI that resources are mentioned, they link back to the central resource inspector panel.
  • The RenderDoc python API has been revamped to be an explicitly designed and carefully documented interface into RenderDoc's internals
    • Python Shell
    • The previous API was autogenerated from reflected C# internals, which meant that any internal warts were exposed and there was no documentation beyond code commenting.
    • The new API has been designed to be more naturally pythonic where possible and present a more consistent and unified interface.
    • Likewise all API endpoints and structures are documented with python docstrings for help(), as well as being generated into the sphinx documentation.
  • RenderDoc now has features for annotating capture files
    • Capture Comments
    • A general capture comments system now allows saving some arbitrary text with a capture, and it will be displayed first and foremost when opening a new capture. This could be used for storing a build date or version, some reproduction information, or other metadata that is useful to store embedded in the capture file.
    • Bookmarks can be saved with the capture, so that you can save an important event with the capture before sharing it, making it easier for someone else (or you in the future) to jump to the most useful event.
    • The resource inspector allows for renaming of any resource, which can be used both to give names to important resources that only have an autogenerated name, as well as renaming resources based on how they are used within the particular capture. If one buffer in particular is related to a bug, it can be renamed to highlight it.
  • AMD have provided performance counter integration into RenderDoc. This includes both access to all of their hardware counters on all APIs that RenderDoc supports, but also a simple sortable table view of counters for browsing the results and finding hot drawcalls.
    • Performance Counter Viewer
    • This does not mean RenderDoc is a full-featured profiler! However it can be useful to obtain these counters on existing RenderDoc frame captures.
  • The bug reporting system is much improved. As well as being a more streamlined experience, it tries to help users provide more useful bug reports.
    • New bug reporter
    • Most bug reports without contact information and without a reproduction capture cannot be resolved and end up getting ignored, only a small fraction end up resulting in actual fixes.
    • To address this, the bug reporter encourages users to put in their email address and stores it for any future bugs.
    • The user is also able to opt-in to upload the most recently loaded capture file. If able to share this will greatly help with reproducing any bug.

Smaller Features/Improvements

  • When editing a shader, the mesh output now updates correctly to reflect the changes.
  • Check vulkan memory binding compatibility between capture and replay, and fail gracefully if it's incompatible.
  • Saving textures can now opt to save the texture overlay results instead of the actual texture.
  • Improved tracking of active APIs in injected applications, and added better guidance if an API isn't detected due to lack of window presentation.
  • On new vulkan loaders (1.0.68 and above) filter unsupported instance extensions out of enumerated lists.
  • Improve formatting of matrices in constant buffer view, previewing directly instead of requiring expansion and displaying row/column major status.
  • Track barrier usage on resources as well as reads and writes.
  • Optimised 'bindless' style D3D12 descriptor binds with huge descriptor table ranges, where huge is defined as over 1000 descriptors.
  • Change home vulkan layer path to use $XDG_DATA_HOME if present.
  • Added hooking for CreateProcessAsUser and CreateProcessWithLogon used by some browsers to change privileges in child processes.
  • Speed up linux process connection to connect as soon as possible and apply any queued commands.
  • renderdoccmd on windows tries to re-use the parent console and output there, when run from the command line.
  • Added Catch.hpp for unit testing.
  • Use native line-endings for logging, such that e.g. on windows notepad can open debug logs OK.
  • Mesh output fetching on Vulkan has been refactored, instead of writing to an SSBO from a vertex shader (which may not be supported on all devices) the vertex shader is transformed to compute.
  • The VS2015 solution will now fetch the git commit automatically without any need for external scripts.
  • Delta-encode remote replay transfer of image and buffer data so that less data needs to be transferred across the connection.
  • Added a progress meter on the RenderDoc UI to see how far the capture is getting.
  • Allow queuing a sequence of frames before capture rather than just a single frame.
  • Don't spam warnings when unknown GUIDs are requested from D3D interfaces. This avoids hugely bloated debug logs and probable performance issues when the application is requesting unknown interfaces many times per frame.

Bugfixes

  • Add handling for min10float and min16float precision values in DXBC bytecode.
  • Fix implementation of round_ne in D3D shader debugging
  • When binding a buffer SRV with no format to a Buffer<float4> fetch type info from shader.
  • Ensure texture overlay updates when selecting a different texture.
  • Use glXGetProcAddress to fetch glXCreateContextAttribsARB, fixes problems on some linux systems.
  • Only unwrap values in VkDescriptorImageInfo that are actually used - if sampler is unused, don't unwrap possible garbage.
  • If we can't create a sRGB capable framebuffer config on GLX, fallback to non-SRGB and warn the user.
  • Fix incorrect replay of Vulkan secondary command buffers that are executed in more than one primary command buffer.
  • Add an equivalent framebuffer for every internal vulkan renderpass that requires strict compatibility.
  • Fix vulkan crash when serialising changes to a map that was created with a memory offset, and was accidentally offset twice.
  • Fix some cases where dangling references would be left on a D3D swapchain after use if it was still bound to the pipeline, and then couldn't be resized.
  • Fix texture remapping on vulkan for saving 3D texture slices.
  • Ensure we round upwards when selecting which event to replay from in an ambiguous situation, fixes a crash on Vulkan.
  • Fix exponential slowdown when applying initial contents of a vulkan array image.
  • Fetch dispatch thread dimension even if not disassembling, fixes a problem dispatching compute shaders claiming valid thread IDs are out of bounds.
  • Correct VK_KHR_get_memory_requirements2 being marked mistakenly as an instance extension.
  • Fix a problem on mesa copying between GL_RGBA and GL_RGBA8 textures.
  • Fix a check for whether a drawcall was inside a renderpass that broke on secondary command buffers.
  • Don't execute occlusion query or pipeline statistics queries on vulkan when not needed to fetch counters.
  • Fix tracking of dynamic offsets when binding multiple descriptor sets
  • Fix histogram/minmax calculation and mip-level display on 3D textures.
  • Fix a problem opening captures over 2GB in size on windows.
  • Don't display unused bindings in vulkan that overlap with used bindings.
  • Fix a backwards comparison that would strip away device extensions on vulkan when replaying.
  • Fix a potential crash in glVertexArrayVertexBuffers if an optional NULL array is passed.
  • Fix some crashes around handling of D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL and D3D11_KEEP_UNORDERED_ACCESS_VIEWS.
  • Align thumbnails to 4-pixel multiples to avoid corruption on GL.
  • Don't multiply mesh output size required by number of instances twice on GL.
  • Clear the D3D11 immediate context state immediately before executing a command list so that state doesn't leak in incorrectly.
  • Fix calculation of mip data size when proxy-replaying for a remote context.
  • Fix an unusual case where a dll filename containing the substring 'renderdoc.dll' could interfere with the injection process on windows.
  • Fix as crash if a D3D12 descriptor that used a NULL description struct to initialise also ended up with a NULL resource on replay.
  • Ensure multi-plane resource descriptors on D3D12 are valid on replay.
  • Fixed some cases where remapping physical devices between capture and replay wouldn't match up if the number of devices changed.
  • Handle vulkan base pipelines correctly by creating dependencies from the base to the created pipeline.
  • Add a large padding to memory requirements on AMD as the memory requirements can change between capture and replay at random.
  • Fix emulation of glMapNamedBuffer passing the wrong map flags.
  • Fix crashes when using Intel's DX11 extensions
  • Fix the sampler register use in gather4_po_c in D3D shader debugging.
  • Check for ARB_texture_storage in CopyTex2DMSToArray as we need it for ARB_texture_view.
  • Handle NULL being passed to glClear*Buffer and glClear*Tex meaning just zero values.
  • Handle fetching mesh output data on GL if the application was already using transform feedback at the time of the draw.
  • Fix some edge cases where different optimisation of GL programs could create incompatible uniform remapping tables.
  • Account for UAV mip slice specified in descriptor when fetching 2D texture data for D3D shader debugging.
  • Add an intermediate resolve to a temporary buffer to allow for format conversion, since technically resolve does not allow format conversion of any kind.
  • Fix image viewing with GL as the local replay API on linux.
  • Fix implementation of firstbit_(s)hi for D3D shader debugging.
  • Fix GLSL shader editing with multiple shader sources.
  • Handle negative viewport height when calculating aspect ratio in vulkan mesh viewer.
  • Handle multi-dimensional arrays in input/output variables when disassembling SPIR-V.
  • Ensure that D3D11 debug manager is available on capture even if running headless with no swapchains.
  • When opening buffer viewers for index/vertex buffers bound to the pipeline, calculate the right byte offset for the index width.
  • Consider external memory images to be dirty as soon as they're created, and fetch their contents at the start of the frame.
  • Added PVRTC support on Vulkan.
  • Fill query pools with dummy data on creation so that queries don't have undefined results during replay.
  • Set USAGE_SIMULTANEOUS_USE_BIT on secondary cmd bufs to work around mesa driver bug.
  • Fix bfrev instruction in D3D shader debugging.
  • Shader edits on Vulkan/D3D12 now apply across the whole capture instead of only within the currently selected command buffer.
  • Improved handling of predication in D3D11. Predication is always skipped during replay, so objects will render, but the pipeline state will show whether predication was passing or failing.
  • Fix corruption with offsets being incorrectly applied to glFlushMappedBufferRange relative to the buffer, rather than relative to the mapped range.
  • Handle a GL context deleting and removing all its child resources. This prevents ambiguity when the context is re-created and objects end up appearing as duplicates because they weren't removed before.
  • Add hackish fix for cases where the vulkan ICD is pointing at libGL.so and we've intercepted the library, and need to act like a vulkan ICD ourselves.
  • Fix some cases where AMD GCN disassembly wouldn't display on D3D shaders that had reflection and debug data stripped.
  • Fix some unpredictable crashes on D3D12 when re playing full frames.
  • Fix mesh picking when a drawcall has index/vertex offsets.
  • Render mesh data from instanced properties correctly.
  • Batch Vulkan memory allocations where possible and suballocate to avoid going over the memory object limit.
  • Fix use of vulkan images that are flagged as transient attachments.
  • Fix a case where replay would fail on D3D11 creating too many state objects, if more than 4096 total are created over the lifetime of an application.
  • Handle primitive restart in vulkan mesh input/output preview.
  • Fix a crash when switching between texture targets of different resolution with a texture overlay enabled.
  • Fix column major matrix transpose when reading uniform values on Vulkan.
  • Fix RGBM display on Vulkan.