Introduction

Welcome to RenderDoc - a graphics debugger currently available for Vulkan, D3D11, D3D12, OpenGL, and OpenGL ES development on Windows, Linux, Android, and Nintendo Switch TM.

This document serves as reference guide, introductory document and explanation of which features are available in RenderDoc and how to best use them.

The latest information and discussion is always available on the GitHub repository.

License

RenderDoc is released under the MIT license, so there are no restrictions on your use of it either commercially or non-commercially. This includes the source release available on GitHub.

Details of the licenses of third party software used in RenderDoc are included in the LICENSE file in the RenderDoc directory as well as in the Credits & Acknowledgements.

How to browse this documentation

If you just want to dive straight in and learn how to get started using RenderDoc consider looking at the Quick Start section which gives a simple introduction on how to get started. Afterwards there are reference pages on each of the windows available in RenderDoc which can be referred to as you use the program, or skimmed to get a feel for the functionality available.

Those of you familiar with other graphics debuggers will likely find much of RenderDoc recognisable, you might want to check out the FAQ, Features, Tips & Tricks or browse the How do I …? sections which detail how some common tasks are accomplished.

Regardless of your experience or patience for documentation it’s recommended that you read the Gotchas & Known Issues as this details current limitations of the program.

Important notes

  • RenderDoc is generally stable but you will still likely encounter bugs depending on your use case, especially as with graphics there is a lot of potential surface area and interactions. I am always happy to spend time to fix bugs, but bear in mind that I need information about how to reproduce your specific situation. If you’re able to provide public reproducible steps please file an issue on GitHub, or if you need to share information privately please email me.
  • On the other side of the coin, please do give feedback when RenderDoc works for you and request features that would make your life easier or improve your workflow.
  • There are a few common issues you might run into, so if you have any problems check the FAQ, or the GitHub issues list to see if it’s been reported.

Documentation and Tutorials

Aside from the documentation that you are reading, I have recorded some YouTube video tutorials showing the use of some basic features and an introduction/overview. Note that these are quite old, from the first release of RenderDoc, but the basic workflows and operation is still similar.

There is also a great presentation by @Icetigris which goes into some details of how RenderDoc can be used in real world situations: Slides are available here

Contact info, Feedback, Bug reports

If you want to get in touch with any feature requests, suggestions, comments etc then feel free to contact me: Contact me.

Bug reports can be submitted directly via email, or also on the GitHub issues list where you can also find the full source code.

The Builds page always has the latest stable build downloads, as well as builds made from the source code each night for the bleeding edge. Stable releases update every two months or so and are the typical releases to stick to for the most reliable experience.

See Also

  • RenderDoc Homepage
  • Builds page
Next Previous

© Copyright 2024, Baldur Karlsson.

Built with Sphinx using a theme provided by Read the Docs.


Credits & Acknowledgements

RenderDoc wouldn’t have been possible without both the tools and libraries that were used in its construction, as well as the many people who helped and contributed to make it the program it is today.

3rd Party Credits

The following libraries and components are incorporated into RenderDoc, listed here in no particular order. Thanks go out to the developers and contributors behind each of these libraries who generously donated their work to other free projects!

  • Google Breakpad - Copyright 2006 Google Inc, distributed under the New BSD License (3 Clause).

    Crash handling and report preparation system.

  • miniz - Released to the Public Domain by Rich Geldreich.

    Used for zip read/write in several places.

  • ILM’s half implementation - Copyright 2002 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC, distributed under BSD license.

    Used for decoding half data for display.

  • jpeg-compressor - Released to the Public Domain by Rich Geldreich.

    Used for jpg reading and writing.

  • lz4 - Copyright 2013 Yann Collet, distributed under the BSD 2-Clause license.

    Used for fast compression where speed is more important than compression ratio.

  • stb - Released to the Public Domain by Sean Barrett.

    Used to read, write and resize various image formats.

  • Source Code Pro - Copyright 2010, 2012 Adobe Systems Incorporated, distributed under the SIL Open Font License 1.1.

    Font used for the in-program overlay.

  • tinyexr - Copyright 2014 Syoyo Fujita, distributed under the New BSD License (3 Clause).

    Used for the OpenEXR file loading and saving.

  • glslang - Copyright 2002-2005 3Dlabs Inc. Ltd, Copyright 2012-2013 LunarG, Inc, distributed under the New BSD License (3 Clause).

    Used for compiling GLSL to SPIR-V.

  • Qt - Copyright 2015 The Qt Company Ltd, distributed under the GNU Lesser General Public License (LGPL) version 2.1.

    Used for QRenderDoc replay UI program.

  • cmdline - Copyright 2009 Hideyuki Tanaka, distributed under the New BSD License (3 Clause).

    Used for parsing command line arguments to renderdoccmd.

  • include-bin - Copyright 2016 Eveline Jarosz, distributed under the zlib license.

    Used to compile in data files embedded into the source on non-Windows platforms.

  • plthook - Copyright 2013-2014 Kubo Takehiro, distributed under the 2-clause BSD license.

    Used for hooking some libraries loaded with DEEPBIND on linux.

  • tinyfiledialogs - Copyright (c) 2014 - 2016 Guillaume Vareille, distributed under the zlib license.

    Used to display message boxes cross-platform from the non-UI core code.

  • AMD GPUPerfAPI - Copyright (c) 2016-2018 Advanced Micro Devices, Inc., distributed under the MIT license.

    Provides hardware-specific counters over and above what individual hardware-agnostic graphics APIs are able to provide.

  • Farm-Fresh Web Icons - Copyright (c) 2009-2014 FatCow Web Hosting, distributed under Creative Commons Attribution 3.0 License.

    Providing higher-resolution icons than the famfamfam Silk set, these icons allow scaling to those using high-DPI displays.

  • AMD Radeon GPU Analyzer - Copyright (c) 2015-2018 Advanced Micro Devices, Inc., distributed under the MIT license.

    Provides the ability to disassemble shaders from any API representation into compiled GCN ISA for lower level analysis.

  • Catch - Copyright (c) 2012 Two Blue Cubes Ltd., distributed under the Boost Software License.

    Implements unit testing during development.

  • zstd - Copyright (c) 2016-present, Facebook, Inc., distributed under the BSD License.

    Compresses capture files at a higher rate of compression off-line (not at capture time).

  • pugixml - Copyright (c) 2006-2017 Arseny Kapoulkine, distributed under the MIT License.

    Used for converting capture files to and from xml.

  • AOSP - Copyright (c) 2006-2016, The Android Open Source Project, distributed under the Apache 2.0 License.

    Used to simplify Android workflows by distributing some tools from the android SDK, as well as patching android manifest files to enable debugging.

  • interceptor-lib - Copyright (c) 2017, Google Inc., distributed under the Apache 2.0 License.

    Taken from the GAPID project, used to inject hooks into android library functions if LLVM is available at build-time.

  • LLVM - Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign, distributed under the University of Illinois/NCSA Open Source License.

    Used to support interceptor-lib to inject hooks into android library functions.

  • OpenSSL - Copyright (c) 1998-2018 The OpenSSL Project. Copyright (C) 1995-1998 Eric Young. Distributed under the double license of the OpenSSL and SSLeay licenses.

    Used to connect securely to RenderDoc’s servers for update checks and bug reports.

  • Microsoft PDB Information - Copyright (c) 2015 Microsoft Corporation. Distributed under the MIT License.

    Used to recover debug information from DXBC shaders on D3D11/D3D12.

  • Compressonator - Copyright (c) 2018 Advanced Micro Devices, Inc. Copyright (c) 2004-2006 ATI Technologies Inc. Distributed under the MIT License.

    Used to provide shell thumbnail previews for block compressed DDS files.

  • nvapi open source SDK - Copyright (c) 2019, NVIDIA CORPORATION. Distributed under the MIT License.

    Used to intercept nvapi calls on D3D11/D3D12.

  • half.hpp - Copyright (c) 2012-2019 Christian Rau. Distributed under the MIT License.

    Used to emulate half-precision operations in shader debugging.

  • Superluminal - Copyright (c) 2019-2020 Superluminal. Distributed under the BSD License.

    Used to emit profiling events in development builds.

  • AGS - Copyright (c) 2020 Advanced Micro Devices, Inc. Distributed under the MIT License.

    Used to intercept and test AGS calls on D3D11/D3D12.

  • md5 hashing - Released to the Public Domain by Alexander Peslyak.

    Used for calculating DXBC container hash.

  • NVIDIA Nsight Perf SDK - Redistributable portions distributed under the NVIDIA Nsight Perf SDK license available in the RenderDoc source repository or in the SDK.

    Provides hardware-specific counters over and above what individual hardware-agnostic graphics APIs are able to provide.

Thanks

Screenshots in this documentation are from Sascha Willems’ Vulkan demos.

There have been many people who have helped in the creation of RenderDoc. Whether testing, providing feedback, or contributing artwork and design critique everyone listed here and many more besides have been invaluable in taking RenderDoc from an idea on paper to its current state. Greets fly out to the following people, listed in no particular order.

  • Chris Bunner, Charlie Cole, James Chilvers, Andrew Khan, Benjamin Hill, Jake Turner, Alex Weighell and the rest of the Crytek UK R&D team.
  • Colin Bonstead, Marco Corbetta, Pascal Eggert, Marcel Hatam, Sascha Hoba, Theodor Mader, Mathieu Pinard, Chris Raine, Nicolas Schulz, Tiago Sousa, Sean Tracy, Carsten Wenzel, and everyone else at the rest of the Crytek Studios.
  • Daniel Sexton
  • Jason Mendel
  • Jacob Kapostins
  • Iain Cantlay
  • Luke Lambert
  • Gareth Thomas
  • George Ilenei
  • Matías N. Goldberg
  • Louis De Carufel
  • Steve Marton
  • Elizabeth Baumel
  • Jon Ashburn
  • Greg Fischer
  • Karen Ghavem
  • Jens Owen
  • Derrick Owens
  • Jon Kennedy
  • Matthäus G. Chajdas
  • Dan Ginsburg
  • Dean Sekulic
  • Rolando Caloca Olivares
  • Arne Schober
  • Michael Vance
  • Dominik Witczak
  • Chia-I Wu
  • Cory Bloor
  • John McDonald
  • Pierre-Loup Griffais
  • Jason Mitchell
  • Michael Rennie
  • Ian Elliot
  • Callan McInally
  • Gordon Selley
  • Cody Northrop
  • Dominik Baumeister
  • Adrian Bucur
  • Peter Gal
  • Janos Pantos
  • Marton Tamas
  • Nat Duca
  • Ben Clayton
  • Aliya Pazylbekova
  • Benson Joeris
  • Haiyu Zhen
  • Alex Kharlamov
  • Steve Karolewics
  • Kevin McCullough
  • Ting Cai
  • Zi Ming He
  • Orson Baines
  • John Kattukudiyil
  • Tony Tascioglu

Contributors

The following list highlights notable open source contributions. Many other people have contributed individual bug fixes and tweaks, which can be seen on github !

  • Michael Vance - Implemented a sophisticated frame statistics system for D3D11 around binding and draw API calls.
  • Matthäus G. Chajdas - Converted this documentation from sandcastle to sphinx.
  • Michael Rennie, Peter Gal, and Janos Pantos at Samsung - Added support for Android platform capture as well as Vulkan and OpenGL ES support.
  • Adrian Bucur - Added custom SPIR-V disassembler support.
  • James Fulop - Updated the vertex picking algorithm.
  • Balazs Torok - Implemented the RenderDoc in-application overlay for D3D9.
  • Steve Karolewics - Implemented DXBC shader debugging support for D3D12.
  • Aliya Pazylbekova - Implemented pixel history support for Vulkan.
  • Orson Baines, Zi Ming He, John Kattukudiyil, Ting Cai, Tony Tascioglu - Implemented pixel history support for OpenGL.
  • Steve Karolewics, Jovan Ristic - Implemented pixel history support for D3D12.


Getting started

  • Quick Start
  • FAQ
  • Gotchas & Known Issues
  • Features
  • Tips & Tricks


Quick Start

This document serves as a brief introduction to how to use RenderDoc to capture and analyse your application. It doesn’t go into much detail about exactly what functionality is available for digging into things, as this can be found elsewhere. Instead it focuses on just the workflow from start to finish and roughly where to look for different things.

For this tutorial we will be using the debugmarker sample from Sascha Willems’ Vulkan samples repository..

Capturing a frame

To capture a frame, begin by selecting File → Launch Application. By default this will open a new docked window where you can configure different settings that will be used when capturing. You may find this window is already available.

Launching an executable

The defaults work pretty well in most situations, so you can just either browse to or drag in your exe into the Executable box. If the working directory box is empty then the executable’s directory will be used. Enter any command line you may need and click Launch to launch the application with RenderDoc.

More details of the specific options and their functionality can be found in the details page for the Capture Dialog.

Note

You should choose the build of RenderDoc to match your OS - 64-bit for Windows x64 and vice-versa

You can only capture a 64-bit process with a 64-bit build of RenderDoc. A 32-bit process can be captured by either build of RenderDoc.

RenderDoc in-app

RenderDoc has a fairly minimal in-app overlay, just to indicate that RenderDoc has successfully loaded and is ready to capture a frame.

When ready, press the Capture Key (F12 or Print Screen) and the next frame after the keypress will be captured, and this will show up on the overlay to let you know that a frame has been successfully saved.

The in-application RenderDoc Overlay

When the application exits, if you captured a frame it will automatically start to open in the RenderDoc UI. If you didn’t capture a frame then nothing will happen and the RenderDoc UI will be back as it was when you clicked Launch.

If you made multiple captures you will see a thumbnail list that allows you to open (in the current instance or a new instance to compare side-by-side), save and delete them as you wish. You can also access this view while the program is still running, see Capture Connection for more information on taking multiple frame captures. Note however that for the simple use-case, you don’t need to worry about this!

RenderDoc layout

RenderDoc’s layout can be customised fairly heavily so this section will only cover the default layout. We’ll go over the windows that are open by default and how each can be used in analysing your program.

Each of these windows has a section that is much more in depth and gives details about every function and feature, for the more complex windows such as the texture viewer you may well wish to skim these to get an idea of what is available and use them as reference in the future.

Texture Viewer

The Texture Viewer

More details can be found on the Texture Viewer page.

The texture viewer does pretty much what you’d expect - it allows you to inspect textures and render targets in your application.

There are various visualisation controls that allow you to select different channels, mip levels or other aspects of the texture, and more detail is available in the above page. Here we’ll just touch on the highlights:

  • The thumbnail strip (by default to the right) lists either the output targets, or shader inputs bound and used at present. Selecting each of these (the red outline on the thumbnail indicating which is selected) will follow whatever resource is bound to that slot as you browse through the scene.

    E.g. if you select render target 0 then the texture display will update to show the currently bound render target 0 regardless of which texture that is. If the slot you are following becomes unbound or unused, the previous texture will still be displayed up until you select a different pipeline slot, or the slot is bound again. Unbound texture slots show up with Unbound listed under their thumbnail.

    To open a specific texture and watch it even as it changes slots or becomes unbound, you can open it in a new locked tab. Double click on it, right click on it and ‘open in new locked tab’, or open it by name.

  • The format and dimensions of the texture are displayed on the status bar just below the texture display itself. Also on this status bar you can see the current pixel co-ordinate that you are hovering over, as well as the ‘picked’ pixel value which can be inspected by right clicking anywhere on the texture display.

  • Further to this, there is a small zoomed section of context around the last picked pixel available in the bottom right of the texture viewer window. From here you can also launch the pixel history or debugger, as detailed in How do I debug a shader?.

  • The last thing we will highlight is the range control. This is a fairly flexible tool that allows you to adjust the visible range in the image. This is particular useful when viewing HDR images with a range outside of [0, 1].

    To use the range control you can drag the white and black points to make fine adjustments or type values to change the values of the white and black points (by default 0 and 1 respectively). There are also some useful controls to the right of the range control itself, which are detailed again in the Texture Viewer page.

Event Browser

The Event Browser

More details can be found on the Event Browser page.

The Event Browser is the primary method of stepping through the frame and browsing the events that occurred within. The first column EID (Event ID) indicates which event or API call this was in the frame, chronologically.

By default the events which are listed here are those known as actions. Draws and dispatches are examples of actions, but also events that modify resources like clears and copies. State setting and other CPU-update calls like Maps are not included and are available in the API Calls view (see below). You can use the filter field to include or exclude events as you wish, for more information see How do I filter visible events?.

The columns can be customised and reordered, the [image] select columns button (or right-click) will allow you to choose which columns are displayed.

Standard performance markers are available and create the hierarchy/labels as you would expect. These can be expanded or collapsed and keyboard browsing is available through normal controls - left and right go higher or lower in the hierarchy, and up and down goes up and down through siblings. For more information on these markers, see How do I annotate a capture?.

The ‘current’ event - i.e. the event at which we are inspecting the graphics state - is highlighted with a green Flag [image] and the row is highlighted. As any row is selected it immediately becomes the new current event.

While the Event Browser is selected, you can press the shortcut keys CTRL-F to find find a given event or action. You can enter a number to jump to that given EID.

The [image] bookmark button will allow you to bookmark an event, the shortcut key is CTRL-B.

A list of bookmarked events will show up on a toolbar at the top of the event browser, they and the shortcut keys CTRL-1 to CTRL-0 will jump to the respective bookmarked EID. These shortcuts will work anywhere in the application.

Bookmarks can be saved with the capture and shared with others. For more on this see the How do I annotate a capture? page.

API Inspector

The API Calls + Callstack Panel

More details can be found on the API Inspector page.

The API Calls window updates as a new event is selected. It shows the individual API calls and their parameters. If an action is selected, the list shows all API calls between the previous action and this action and the last entry in this list always corresponds to the action itself. Each row can be expanded to show the parameters that were passed to that API call.

At the bottom of the window is an optional expandable section which shows the callstack (if available and recorded) from the application code into the API function.

In order to view these callstacks you must first resolve the symbols recorded with the capture. To do this click on Resolve Symbols under the Tools menu. More details on this process can be found in the guide: How do I capture callstacks?.

Timeline Bar

The Timeline Bar

More details can be found on the Timeline Bar page.

The timeline bar is essentially an alternate view of the frame, with the horizontal axis being time in the frame. The horizontal axis is scaled evenly by API calls, such that every API call has the same width at any given zoom level.

The frame marker hierarchy is top-down in this case, and can be expanded or collapsed by clicking on each section. In this image, “Render Scene” and “Toon shading draw” are both expanded, but the other sections remain collapsed. Each action is rendered as a blue pip underneath the section of the hierarchy that it is a child of. The current action (if visible) is rendered as a green circle.

There is a vertical line around the current action, as well as a [image] above, and a gray outline around the event where the mouse is hovering.

When the currently selected texture is used in the frame, each action that references it draws a marker below the bar. The different colours of marker indicate whether the action at that point is writing to the texture, reading, both reading & writing simultaneously, etc. If the markers are too close together they will space themselves to be readable and will not necessarily line up to a particular action unless you zoom in.

This can be a very useful tool to trace data through a frame, as well as highlighting potential redundancy or errors if a target is being written to where it should not.

Pipeline State

The Pipeline State Viewer

More details can be found on the Pipeline State page.

The Pipeline State window is perhaps the most detailed but also the simplest to understand. This window simply lists every stateful aspect of the graphics pipeline and what value or object is present at the current event.

By default the pipeline will not contain empty or unused entries - i.e. if a shader only reads from resources 0 and 1, even if something is bound to slot 2 it will not be displayed. Likewise say slots 3-128 are empty - they will also not be displayed. This behaviour can be modified by the Show Unused Items and Show Empty Items toggles on the toolbar. Show Unused will show slot 2 even if the shader does not read from it. Show Empty will show slots 3-128. This behaviour varies significantly by API since the shader binding model is often quite different.

One important thing to note is that most things in the sections for each pipeline stage can be expanded to view in more detail. Look for the Go Icon ( [image]) to indicate that a more detailed view is available. Typically this will mean for shaders the shader source/disassembly will be opened, for texture-type resources the texture viewer will open a new tab for that resource, and for buffers it will open either the Mesh Viewer window, a raw view of that buffer, or a popup with the constant contents - depending on where the buffer is bound.

Another useful convention is that anywhere an API object is mentioned, its name is written in bold followed by a link. This is a clickable link to the Resource Inspector window which allows you to examine in more detail how the object is defined and what other API objects it is linked to.

For more details, check out the how-to: How do I view details of an object?.

Mesh Viewer

Mesh Viewer

More details can be found on the Mesh Viewer page.

Mesh Viewer allows you to inspect the geometry data as it passes through the pipeline. Both raw data in a grid view and 3D inspection is possible. The tabs in the preview window allow you to choose at which part of the pipeline you’d like to visualise the data.

By default the preview shows a wireframe rendering of the mesh, but you can choose different visualisations. This can either be simple shading, a vertex exploder utility, or using a secondary attribute as color. Right clicking on any column allows you to choose the secondary attribute for rendering.

You can also select which attribute is the position, in case either the auto-detection failed or you want to visualise another attribute like texture co-ordinates in 3D space.

You can hold or click the right mouse button on the mesh preview to select the vertex in the mesh data tables.

The default view for final vertex output data (which you can reset to with the reset button [image]) shows the camera at the view origin looking out through the viewport. By default the output attempts to guess a perspective matrix from the output data, but this can be refined or changed to an orthographic view by opening up the options cog and entering more accurate or corrected values.

Closing Notes

Obviously what you accomplish in the program will vary a lot by what you need to investigate, but hopefully this gives you an overview of the functionality available. There are many more detailed features that are available, and the rest of this help will aid you in finding those.

It is probably a good idea to check out the Tips & Tricks page which lists several useful notes that aren’t obvious but might save you a lot of time.


FAQ

Here is a list of commonly asked questions about RenderDoc. Feel free to contact me if you have another question that isn’t covered here or in this document.

What are the details of RenderDoc’s Anonymous Analytics?

RenderDoc has some very light anonymous analytics to allow analysis of which features and platforms are used more, to prioritise and guide future development.

The complete details of the analytics can be found in the page about Analytics, but the brief outline is that RenderDoc records data only in the replay program and does not record any data that is specific to any captured programs. The data recorded is primarily boolean flags indicating whether or not a given feature, API, or platform is used or not. You can see the precise list of data gathered on your current RenderDoc build in the settings menu under the Anonymous Analytics section.

The analytics data is summarised and transmitted securely and anonymously to RenderDoc’s server. The aggregated statistics are available for anyone to see at the analytics homepage.

Enabling the analytics is greatly appreciated, if you have any concerns about the data gathered you can choose to manually verify each report before it’s submitted.

How do I do some particular task?

Many specific tasks or functions are detailed in the “How Do I… ?” sections. These sections each take a feature or element of a workflow and explain how it fits into the program as a whole as well as any details of how it works.

If the task you have in mind isn’t listed there you might find something similar, or you might find a related feature which can be used to do what you want. If you have a workflow which isn’t supported at all, feel free to open an issue on github to request a new feature. Make sure to describe clearly what you are trying to do and what workflow you want to support, not just the specific feature you want. That way the problem can be better understood.

Why did you make RenderDoc?

Although several tools do already exist for graphics debugging, none of them quite suited the functionality I desired and I would often find myself wishing for a feature of one in another and vice versa.

In addition to this, although the functionality overlaps to some degree many of these tools were primarily designed around the profiling of applications rather than debugging. While being able to inspect the state and contents of resources does often suffice for debugging, it’s not necessarily the ideal workflow and often it can become cumbersome.

In principle I didn’t see any reason why I couldn’t write a home-brew graphics debugger with some fairly simple operating principles. While there were a whole lot of caveats and little stumbling blocks along the way, the original design has pretty much stayed consistent since the project was started back in July 2012. If you’re interested you might want to read about How RenderDoc works.

Where did the name come from?

All of the good names were taken :-(.

Who can I contact about bugs, feature requests, other queries?

At the moment there’s just me at the wheel - feel free to contact me if you have anything you’d like to ask or suggest. I use a GitHub repository for tracking bugs and feature requests so that’s the best place to file an issue.

I work on RenderDoc full time contracting for Valve Software, and I am happy to help with anything and work with you if you have any issues that need attention.

In particular I’m used to working with people who have strong NDA protection over their projects - as long as you are able to spend time to diagnose the issue by running builds and debugging by suggestion, it’s not a requirement to send me a repro case - which may be impossible.

How can I associate RenderDoc’s file extensions with the program?

On Windows if you installed RenderDoc via the msi installer, the option is available there to associate RenderDoc’s file extensions with the program.

On linux the binary tarball comes with files to place under /usr/share to associate RenderDoc with files. This obviously also requires qrenderdoc to be available in your PATH.

RenderDoc can be associated with .rdc and .cap files. The .rdc files are the frame capture containers generated from your application. .cap files describe the set up of a particular capture, and can be used to quickly re-launch a capture preset.

There is also a thumbnail handler available for .rdc so that while browsing through files you will get a thumbnail preview of the capture where available.

What APIs does RenderDoc support?

Currently RenderDoc supports Vulkan 1.2, D3D11 (up to D3D11.4), D3D12, OpenGL 3.2+, and OpenGL ES 2.0 - 3.2. Note that OpenGL (and similarly OpenGL ES) is a complex & sprawling API, so see the details of what is supported in its own page. In particular on desktop only modern GL is supported - legacy GL that is only available via the compatibility profile in OpenGL 3.2 is not supported.

Vulkan support has a few notes, as does D3D12.

Future API support is at this point not clear; Metal, WebGL, and perhaps D3D9/D3D10 all being possible. Support for new APIs will be balanced against all other work such as features for existing APIs, bugfixes. So if you care strongly about support for a new API make sure to file an issue on GitHub or comment on an existing issue to register your interest.

How can I backup or restore my settings?

RenderDoc stores data in two folders:

The UI stores data in a qrenderdoc folder underneath your OS’s user settings folder. On windows this is %APPDATA% and on linux this will be somewhere in your home directory, perhaps in ~/.local/share. Nothing in this data is machine specific aside from paths, so you can back up and restore this directory at will.

Deleting this folder will also reset the RenderDoc UI to the defaults - if you uninstall RenderDoc this folder will not be deleted.

The core code may save cached data in a renderdoc folder - either %APPDATA%/renderdoc or ~/.renderdoc/ but this doesn’t contain settings, so is not important to back up.

RenderDoc doesn’t install any registry keys on windows aside from those required to set up file associations.

Which network ports does RenderDoc use?

RenderDoc uses TCP and UDP ports 38920-38927 consecutively for remote access and control (i.e. capturing remotely) for each new program that is opened on a machine. Note that even if you initiate a capture locally these ports are still opened for listening. These are the ports that are probed on a remote host to see if a connection exists.

RenderDoc also uses TCP and UDP ports 39920 for remote replay connections, for when a remote host is used to replay and analyse the capture.

Where can I get the source to RenderDoc?

RenderDoc is licensed under the MIT license and the source is available on GitHub.

What are the requirements for RenderDoc?

Currently RenderDoc expects Feature Level 11.0 hardware and above for D3D11 and D3D12. Lower levels will capture successfully, but on replay RenderDoc will fall back to WARP software emulation which will run quite slowly.

For OpenGL RenderDoc will only capture core profile applications, in general, and expects at minimum to be able to create a core 3.2 context which includes a few key extensions. For more details see OpenGL & OpenGL ES Support.

With Vulkan, RenderDoc should fully support any Vulkan application. However replaying a Vulkan capture may not work if the hardware used to capture it is different - portability of captures between hardware is not guaranteed.

Why does my capture say “Failed to capture frame: Uncapped command list”?

On D3D11, RenderDoc only begins capturing deferred command lists at the point that you trigger a capture. If you replay command lists that were recorded before the captured frame, RenderDoc will fail to capture the frame and try again next frame (and eventually give up after a few retries).

To change this behaviour, enable the Capture all cmd lists option - see Capture Dialog for more details. This will capture all command lists recorded from the start of the program, ready for when you decide to capture a frame. This currently has a fair amount of overhead.

Why does my capture say “Failed to capture frame: Uncapped Map()/Unmap()”?

If you start a Map() before a Present() call then call Unmap() after the Present() during the frame RenderDoc wants to capture, RenderDoc won’t have intercepted this call and so will fail to capture this frame and try again next time. This usually only invalidates the first frame you try to capture, but if you Map() many resources, and Unmap() them one by one in subsequent frames, you could hit this failed capture scenario many times in a row.

Currently the only solution to this is to change the pattern of Map()/Unmap() such that they are contained within a frame.

Gamma display of linear data, or “Why doesn’t my texture look right?”

Gamma/sRGB correctness is a rather painful subject. If we could all just agree to store everything in 32bit float data we could probably do away with it. Until that time we have to worry about displaying textures while making sure to respect the color space it’s stored in.

For texture formats that explicitly specify that they contain sRGB data this isn’t a problem and everything works smoothly. Note that RenderDoc shows picked texel values in linear float format, so if you pick a pixel that is 0.5, 0.5, 0.5, the actual bytes might be stored as say 186, 186, 186.

For other textures it’s more difficult - for starters they may actually contain sRGB data but the correction is handled by shaders so there’s no markup. Or indeed the application may not be gamma-correct so the data is sRGB but uncorrected. If we display these textures in a technically correct way, such that the data is not over or under gamma-corrected, the result often looks ‘wrong’ or unintuitively different from expected.

Nothing is actually wrong here except perhaps that when visualising linear data it is often more convenient to “over-correct” such that the data is perceptually linear. A good example to use is a normal map: The classic deep blue of (127,127,255) flat normals is technically incorrect as everyone is used to visualising these textures in programs that display the data as if it were sRGB (which is the convention for normal images that do not represent vectors).

You can override this behaviour on any texture that isn’t listed as explicitly sRGB with the gamma (γ) button - toggle this off and the over-correction will be disabled.

RenderDoc makes my bug go away! Or causes new artifacts that weren’t there

For various tedious reasons RenderDoc’s replay isn’t (and in most cases can’t be) a perfect reproduction of what your code was executing in the application when captured, and it can change the circumstances while running.

During capture the main impact of having RenderDoc enabled is that timings will change, and more memory (sometimes much more) will be allocated. There are also slight differences to the interception of Map() calls as they may go through an intermediate buffer to be captured. Generally the only problem this can expose is that when capturing a frame, if something is timing dependent RenderDoc causes one or two very slow frames, and can cause the bug to disappear.

RenderDoc also isn’t intended to handle invalid API use - this is better caught by each API’s built-in validation features. If your program is using the API in an invalid way it may break RenderDoc in the same way that it may break a driver.

I can’t launch my program for capture directly. Can I capture it anyway?

There is an option for capturing programs using RenderDoc where you can’t easily set up a direct launch of the process.

More details can be found in the capture options page which details how to use it, however you should take care to read the warnings! The global process hooking option isn’t without its risks, so you need to be sure you know what you’re doing before using it. It should always be used as a last resort when there is no other option.

I’d like to use RenderDoc’s texture viewer for dds files, or other images. Can I?

Yes you can!

Simply drag in an image file, or open it via file → open. RenderDoc will open the image if it is supported, and display it as if there were a capture open with only one texture.

RenderDoc supports these formats: .dds, .hdr, .exr, .bmp, .jpg, .png, .tga, .gif, .psd. For .dds files RenderDoc supports all DXGI formats, compressed formats, arrays and mips - all of which will display as expected.

Any modifications to the image while open in RenderDoc will be refreshed in the viewer. However if the image metadata changes (dimension, format, etc) then this will likely cause artifacts or incorrect rendering, and you’ll have to re-open the image.

I think I might be overwriting Map() boundaries or relying on undefined buffer contents, can I check this?

RenderDoc can be configured to insert a boundary marker at the end of the memory returned from a Map() call. If this marker gets overwritten during a captured frame then a message box will pop up alerting you, and clicking Yes will break into the program in the debugger so that you can investigate the callstack.

It will also fill buffers with undefined contents on creation with a marker value, to help catch the use of undefined contents that may be assumed to be zero.

To enable this behaviour, select the Verify Buffer Access option when capturing.

Note this is only supported on D3D11 and OpenGL currently, since Vulkan and D3D12 are lower overhead and do not have the infrastructure to intercept map writes.

RenderDoc is complaining about my OpenGL app in the overlay - what gives?

The first thing to remember is that RenderDoc only supports Core Profile 3.2 and above OpenGL. If your app is using deprecated compatibility profile features from before 3.2 it almost certainly won’t work as most functionality is not supported. A couple of things like not creating a VAO (which is required in core profile) and using luminance textures (which don’t exist in core profile) are allowed, but none of the fixed function pipeline will work, etc.

If your app is not using the CreateContextAttribs API then RenderDoc will assume your program uses legacy functionality and it will completely refuse to capture. The overlay will display text to this effect using the simplest fixed-function pipeline code, so it will run on any OpenGL app, even on a 1.4 context or similar.

If your app did use the CreateContextAttribs API, RenderDoc will allow you to capture, but compatibility profiles will have a warning displayed in the overlay - this is because you could easily use old functionality which is still available in the context.

Can I tell via the graphics APIs if RenderDoc is present at runtime?

Yes indeed. Some APIs offer ways to do this already - D3DPERF_GetStatus(), ID3DUserDefinedAnnotation::GetStatus() and ID3D11DeviceContext2::IsAnnotationEnabled().

In addition to those the simplest way is to see if the RenderDoc module is loaded, using GetModuleHandleA("renderdoc.dll") != NULL or dlopen("librenderdoc.so, RTLD_NOW | RTLD_NOLOAD) != NULL. There are also API specific ways to query:

Querying an ID3D11Device or ID3D12Device for UUID {A7AA6116-9C8D-4BBA-9083-B4D816B71B78} will return an IUnknown* and S_OK when RenderDoc is present.

GL_EXT_debug_tool is implemented on RenderDoc, which is an extension I’ve proposed for this purpose (identifying when and which tool is injected in your program). It allows you to query for the presence name and type of a debug tool that’s currently hooked. At the time of writing only RenderDoc implements this as I’ve only just proposed the extension publicly, but in future you can use the queries described in that spec.

Note

It’s unlikely the extension will ever be ‘made official’, so these enumerants can be used:

#define GL_DEBUG_TOOL_EXT                 0x6789
#define GL_DEBUG_TOOL_NAME_EXT            0x678A
#define GL_DEBUG_TOOL_PURPOSE_EXT         0x678B

On Vulkan VK_EXT_tooling_info will return an entry for RenderDoc. This extension will always be available when running under RenderDoc.

My shaders have ‘cbuffer0’ and unnamed variables, how do I get proper debug info?

If you get textures that are just named texture0 and texture1 or constant/uniform buffers named cbuffer2 then this indicates that you have stripped optional reflection/debug information out of your shaders.

This optional information is generated by the compiler, but is not required for API correctness so some codebases will strip the information out after processing it offline, and so it will not be available for RenderDoc to fetch. This also includes shader source for source-level shader debugging on APIs that support it.

The simplest solution is just to avoid stripping the data when using RenderDoc. If you can enable debugging information to be embedded when building your shaders that’s all that is necessary. All APIs will allow this data in the shader blob, but the way it is generated varies by API and shader compiler.

It’s not always simple to avoid that stripping, and in some cases it may not be desirable as debug information can be quite a storage and memory overhead, it may instead be better to separate out the debug information and store it in a disk cache, with only a path or identifier remaining in the stripped blob so that RenderDoc can identify the matching debug information later.

For more information on how to do this, see How do I use shader debug information?.

I want to debug a child process that my program launches, how can I inject RenderDoc?

When launching a process in RenderDoc, by default only this process is debugged and any children it launches are not affected. This better ensures compatibility for the most common case where you are able to start the process to be debugged directly.

In the case where your program launches sub-processes that you would like to debug, you can enable the Capture Child Processes capture option, which causes RenderDoc to recursively inject itself into all children (and grand-children, and so on). When you open a capture connection, the child processes will be displayed and you can open a connection to each child to locate the process you wish to debug.

There are more details available in the documentation for the Capture Dialog window.

I’m debugging a program using an OpenGL ES emulator, how can I capture the underlying API?

Wherever possible on Windows RenderDoc will capture OpenGL ES natively and ignore any underlying API calls it makes. For libraries such as ANGLE that emulate GLES on windows using calls to D3D11, this means the GLES itself gets captured and debugged.

If you don’t want this to happen and you’d prefer OpenGL ES to be ignored during capture you can set the RENDERDOC_HOOK_EGL environment variable to 0.

Note

This toggle only has effect on windows. On other platforms GLES is always natively captured as it is expected to have system-level support rather than being emulated.

When I launch my application through RenderDoc, why can’t I access the API validation?

API validation layers are controlled by RenderDoc when it’s active. This means that enabling the API validation from your application will have no effect, it will be controlled by the Enable API Validation capture option. For more information see Capture Options.

Note

On D3D11 if you know what you are doing you can access the underlying ID3D11InfoQueue using the separate UUID {3FC4E618-3F70-452A-8B8F-A73ACCB58E3D}. Be aware that accessing this interface is done at your own risk and may break the RenderDoc capture. If you need to use the API validation directly it’s recommended that you do so without RenderDoc active.

If I have multiple GPUs available, which one is used by RenderDoc? Can I change that?

By default RenderDoc will try to use the closest matching GPU to the one used on capture, which is controlled by the application. For example if a system has both Nvidia and AMD GPUs, then if the capture was made on an AMD GPU then the AMD GPU will be used on replay.

If a compatible GPU cannot be found - e.g. if the capture was made on an Intel GPU then the default - then the system default will be used.

This selection process can be overridden using the GPU selection replay option on a per-capture or global basis.

What is an Action?

RenderDoc uses ‘action’ as an umbrella term to cover events like draws, dispatches, copies, clears, resolves, and other calls that cause the GPU to do work or can affect memory and resources like textures and buffers. This is sometimes referred to as a drawcall, but the term action is used to be less ambiguous compared to actual rasterization drawing.

This means that when browsing in the event browser by default only actions will be shown, meaning you can only see the list of actions and user-defined markers.


Gotchas & Known Issues

Here are some things to note, with known limitations of RenderDoc or uncommon gotchas that may cause problems.

Things to Note

  • Vulkan captures are not portable between different vendor GPUs, or possibly even between different GPUs from the same vendor if the hardware changes significantly enough.

  • OpenGL is only supported from 3.2 on, so legacy GL features from 2.0 and before that were deprecated in 3.2 will not work. Similarly OpenGL ES is only supported from 2.0 and above.

  • When capturing, only one swapchain is captured at any given time. The in-app overlay renders to all swapchains but only one is considered “active” at any given time - this can be cycled with the F11 key. The capture key will trigger a capture at the next swap of the currently active swapchain.

  • RenderDoc relies on saving out the graphics command stream and replaying it back at inspection time. This means if a bug is timing, machine or driver specific it is in no way guaranteed to reproduce the bug on a different machine or driver.

    RenderDoc has few runtime dependencies, and should run anywhere that a normal application will run. In particular it has no dependencies on any SDKs being installed and will run on Artist or QA machines.

    Currently RenderDoc also assumes feature level 11+ hardware for the replay app. It can capture applications running at a lower feature level, but when replaying if 11+ hardware isn’t available, RenderDoc will fall back to WARP software emulation and will run slowly.

  • If capturing callstacks from the app, ensure that dbghelp.dll is not loaded or used by the application as this can easily interfere with RenderDoc’s use and cause undefined or empty results. More information on this can be found in How do I capture callstacks?.

  • RenderDoc can have a significant memory overhead, especially when a lot of resources are allocated as shadow copies in main memory are created.

    If running in 32bit, it’s possible that an application can run out of memory - particularly when capturing, as this causes a significant spike in memory use. It’s recommended to use 64bit, or to limit captures to lower resolutions or simple scenes wherever possible.


Features

This page documents the current feature set of RenderDoc. This gives an overview of what RenderDoc is capable of, and where it is in its development.

Currently RenderDoc supports Vulkan, D3D11, D3D12, OpenGL, and OpenGL ES on Windows, Linux, Android, and Nintendo Switch TM. The UI runs in Qt and will work on any desktop platform.

RenderDoc can also double as an image viewer in a simplistic fashion, separate to its functionality as a debugger. Drag in or open any of a variety of image file formats and RenderDoc will display them as if they were the only texture in a capture. This way it can be used as a simple e.g. dds viewer, with support for all sorts of formats, encodings and things typical image viewers don’t tend to handle like mips, cubemaps and arrays.

Current Common Feature set

  • Trimming capture - capture file only contains data necessary for replaying the frame in question, not all textures & buffers ever created in the lifetime of the app.

  • Optional network support. The main way RenderDoc is used is capture & replay on the same machine, but you can also attach over the network, and replay on a remote host.

  • Multiple frame capture with ability to open side-by-side to compare.

  • Event browsing, with API standard tree of markers.

  • Full graphics pipeline state display.

    • Resources bound to the pipeline are trimmed to what is actually in use, e.g. if a shader only references a texture in the first binding slot, textures in other binding slots will not be displayed by default.
    • Where available through the API, friendly debug names are displayed along with reflection data with the shader to clarify usage.
    • Export of the pipeline to HTML file.

  • Shader source display (where possible - i.e. debug info available) and otherwise disassembly where appropriate (when the API has a concept of a compiled binary representation).

  • Timeline bar of the scene hierarchy.

    • Displays scene left-to-right in time, event hierarchy top-to-bottom.
    • Not scaled based on time of each action
    • Individual actions are shown as dots when the tree is full expanded.
    • The currently selected resource in the texture viewer is highlighted below individual actions visible that use it - e.g. orange for ‘used for read’, pale blue for ‘used for write’

  • Flexible resource inspector.

    • Anywhere in the UI that a resource is mentioned by name or handle, it is linked back to the resource inspector.
    • Contains full list of all resources and API objects.
    • Each resource is linked to any parent or child object, visualising construction dependencies.
    • The API calls used to create the object before its use in the frame are displayed.
    • Any object can be renamed, and its name automatically updates everywhere in the UI.

  • For each action, a list of all API calls (state/resource setting) is available, with each call optionally having a complete callstack to locate where it came from in-app.

  • Mesh buffer inspection and visualisation before/after vertex shader and at the end of the geometry pipeline (after GS or DS, whichever is later). All views have arcball and flycam controls, Projected data is not limited to the 2D viewport, RenderDoc attempts to unproject to allow viewing in world-space.

  • More advanced mesh visualisation such as viewing other components as position (e.g. to render a mesh in UV space), and visual mesh picking from both input and output panes.

  • ‘Raw’ buffer inspection for buffers. Custom format can be set with HLSL-lite or GLSL-lite syntax.

  • Buffer export to CSV or raw binary blob and texture saving to DDS.

  • Texture/render target viewer.

    • List of textures/RTs in the frame, and filtering system.
    • Standard visualisation controls - zoom/fit to window, mip/face/slice selection.
    • RGBA channels or depth/stencil selection as appropriate for the type of resource.
    • Flexible ‘range’ selection tool, to set custom black/white points (default to 0 and 1).
    • Currently set RT/textures thumbnail strip - updates as you move through the frame. Follows the currently selected pipeline slot as it changes, rather than remaining on the given texture.
    • Tabbed view for locking a view of a particular resource over time.
    • Pixel value picking.
    • Save (in theory) any type of texture and format to various formats, dds as well as regular png/jpg.
    • Several debug overlays for render targets - Wireframe, Depth pass/fail, Stencil pass/fail, Clipping (below black/above white points), NaN/-ve/INF highlight, quad overdraw, triangle size.

  • Custom visualisation shader support - e.g. decode custom packed formats or gbuffers.

  • Hot shader editing and replacement.

  • Auto-range fitting to min/max values in texture data, and histogram display.

  • Simple per-action timings and tabular view of GPU counter data.

  • Python scripting console with full documented API, giving complete access to RenderDoc internals, core data structures, and the Qt UI itself.

  • Import and Export of captures

    • Captures have an internal in-memory representation containing the full serialised data of all function calls, as well as associated metadata.
    • This capture representation can be used to export an .rdc file to another form that’s easier for external tools to work with such as .xml.
    • If the external format contains full expression of data, it can then be imported again back into an .rdc after modification.
    • This also allows generation of RenderDoc captures from arbitrary data into a standard format.

Most of these should be intuitive if you’ve used a graphics debugger before.

D3D11

  • Support for D3D11 up to D3D11.4, Windows Vista and above. Where hardware support isn’t available for feature level 11, WARP will be used.
  • Debug marker support comes from any available D3D interface (ID3DUserDefinedAnnotation, D3DPERF_ functions, etc)
  • Pixel history view.
  • Vertex, Pixel and Compute shader debugging.
  • Detailed statistics on API call usage throughout the frame.

D3D12

  • Support for D3D12 up to D3D12.9, Windows 10 and above, and D3D12On7 on Windows 7.
  • Debug marker uses the SetMarker/BeginEvent/EndEvent functions on the command list or queue.
  • Vertex, Pixel and Compute shader debugging for DXBC/fxc shaders.

Vulkan

  • Support for Vulkan 1.3 on Windows, Linux, and Android.
  • Event markers and object naming both come from VK_EXT_debug_utils or deprecated VK_EXT_debug_marker.

Captures have a very limited amount of portability between machines. Many hardware-specific feature uses are baked into captures, and portability depends on how similar the capture and replay hardware are, whether these feature uses can map the same in both cases. Captures are however completely portable between different OSes with sufficiently comparable hardware.

OpenGL & OpenGL ES

  • Support for OpenGL Core profile 3.2 - 4.6 on Windows and Linux.
  • Support for OpenGL ES 2.0 - 3.2 on Linux, Windows, and Android.
  • Tree hierarchy of events defined by any of the standard or vendor-specific extensions, and KHR_debug object labels used for object naming.


Tips & Tricks

This page is a random hodge-podge of different tips and tricks that might not be obvious and aren’t practical to make clear in the UI - e.g. keyboard shortcuts, edge cases and suchlike.

  1. RenderDoc can be used as an image viewer! If you drag in or use file → open, you can open images in a variety of formats - .dds, .hdr, .exr, .bmp, .jpg, .png, .tga, .gif, .psd. The image will load up in RenderDoc’s texture viewer and you can use the normal controls to view it as if it were the only texture in a capture. Note that .dds files support all DXGI formats, compressed formats, arrays and mips - all of which will display as expected. If the file is modified, RenderDoc will reload it and display it. Note that changing the image’s dimensions or format will likely cause problems.

  2. If a .cap file is saved with the “auto-start” option enabled, launching RenderDoc by opening this file will cause RenderDoc to automatically trigger a capture with the given options. This is useful for saving a common path & set of options that you regularly re-run.

    For more information check out the Capture Dialog page.

  3. If you’d like to see the geometry data visualised in 3D and with each component separated out and formatted, either open “Mesh Viewer” under the window menu, or click the Go Arrow [image] on the vertex input attributes in the Pipeline State.

  4. Right clicking on one of the channel buttons in the texture viewer (R, G, B, A) will either select only that channel, or if it’s already the only one selected it will select all of the others. This is useful e.g. to toggle between viewing RGB and alpha, or for looking at individual channels in a packed texture or render target.

  5. Similarly, right-clicking on the ‘auto-fit’ button wand will auto-fit whenever the texture or event changes, so that the visible range is maintained as you move through the frame. This can be useful if jumping between places where the visible range is very different. Note though that by default the range will be remembered or each texture, so once you have fitted the range once for each texture you should be able to flip back and forth more easily.

  6. You can double click on a thumbnail in the texture viewer to open a locked texture tab

  7. You can close tabs by middle clicking on them.

  8. You can trigger a capture from code. renderdoc.dll exports an In-application API for this purpose, defined in renderdoc_app.h in the distributed builds.

  9. To get API debug or error messages, enable “Enable API validation” when capturing then check out the Debug Messages window.

  10. You can annotate a capture by adding bookmarks, renaming resources, and adding comments. These can all be saved and embedded in the capture, so that when you share it with someone else.

  11. Dragging an executable onto the RenderDoc window anywhere will open the Launch Executable panel with the executable path filled in.

  12. Detecting RenderDoc from your code can either be done by trying to load and use the renderdoc In-application API, or through API specific ways:

    // For D3D11 / D3D12:
ID3D11Device *devicePointer = ...;
IUnknown *unk = NULL;
HRESULT hr = devicePointer->QueryInterface(MAKE_GUID({A7AA6116-9C8D-4BBA-9083-B4D816B71B78}), &unk);
if(SUCCEEDED(hr)) { /* renderdoc is present; */ }

// For OpenGL:
// if GL_EXT_debug_tool is present (see https://renderdoc.org/debug_tool.txt)
glIsEnabled(GL_DEBUG_TOOL_EXT);

// Use reserved enumerants as the extension will not become official
#define GL_DEBUG_TOOL_EXT                 0x6789
#define GL_DEBUG_TOOL_NAME_EXT            0x678A
#define GL_DEBUG_TOOL_PURPOSE_EXT         0x678B

// For Vulkan
// VK_EXT_tooling_info will be available, see the Vulkan specification

  13. RenderDoc can be informed about separated debug shader blobs through API specific ways - see How do I use shader debug information? for more details.

  14. More coming soon hopefully :).

Keyboard Shortcuts

  1. In the texture viewer you can hit Ctrl-G to open a popup that lets you jump to a particular pixel co-ordinate.
  2. In the texture viewer, after selecting a pixel you can use the arrow keys to ‘nudge’ one pixel at a time in any direction to fine-tune the selection.
  3. To close a capture, press Ctrl-F4. This will prompt to save if there are any unsaved changes.
  4. Anywhere in the UI, you can use Ctrl-Left and Ctrl-Right to jump to the previous or next action.
  5. If you add some bookmarks you can globally press any key from Ctrl-1 to Ctrl-0 to jump to the first 10 bookmarks.


Behind the scenes

  • Analytics
    • What data is gathered
  • How RenderDoc works
    • Capturing Frames
    • Replaying & Analysing Captures
  • OpenGL & OpenGL ES Support
    • Capture requirements
    • Replay requirements
    • Multiple contexts & multithreading
    • Extension support
    • OpenGL remaining work
    • Android
    • OS X
    • See Also
  • Vulkan Support
    • Vulkan capture
    • Performance notes
    • Current support
    • Android
    • See Also
  • D3D12 Support
    • Performance notes
    • Current support
    • See Also


Analytics

RenderDoc has some very minimal analytics gathering. The data is gathered only in the UI and not during capture. It is not personally identifiable and contains absolutely no data from captures.

The source is freely available and auditable. If desired, a single #define RENDERDOC_ANALYTICS_ENABLE can be set to 0 in that linked file to disable all analytics code.

A report is generated monthly and sent securely to RenderDoc’s server. If you want, you can choose to manually approve each report before it’s sent.

If you wish to opt-out entirely then no statistics will be gathered or reported. However please consider this carefully as it will make it harder for me to decide which features to prioritise.

To see a complete list of what data is gathered, go to the Settings Window in your build and under the Anonymous Analytics there will be a link to open a description of the currently gathered data. You can change your mind at any point in the settings window.

For more information go to the analytics homepage.

What data is gathered

The precise data gathered may vary by build, but the principle is to gather as little data as possible while maximising the value of the data that is obtained.

Each report will contain metadata such as operating system version, RenderDoc version, which APIs have been used, which GPU vendor is in use (AMD, Intel, nVidia, etc) and whether a development or release build was run.

It may also include a handful of counters such as the average time taken to load a captured frame, and how many days in the month (as a number from 1-31) the program was used, to give a rough idea of how often people use RenderDoc.

Otherwise the majority of data is simple boolean flags. For each feature in the UI a flag is kept - these flags are left as false by default, and if the feature is ever used then the flag is set to true. There is nothing that stores how often the feature is used, or what it’s used for.


How RenderDoc works

RenderDoc works on very simple operating principles. This page outlines the basic idea behind its functioning to give people a better idea of what’s going on.

Capturing Frames

Leaving aside the relatively uninteresting matter of injecting the RenderDoc DLL and calling functions to configure it in the target process, we begin by looking at how RenderDoc captures a capture file.

We will use D3D11 as an example of a driver for RenderDoc - the driver layer is responsible both for faithfully capturing the application’s API usage, as well as then replaying and analysing it later. Essentially anything built on top of a driver layer can be used agnostically of the API the application in question is using.

When the driver initialises it will hook into every entry point into the API such that when application uses the API it passes through the driver wrapper. In the case of D3D11 this is the D3D11CreateDevice and CreateDXGIFactory functions.

After this point all accesses to the API remain wrapped and the driver essentially sets itself up as a “man-in-the-middle” between the application and the real API.

The driver initialises in a background capture state. In this state it’s up to the specific implementation about what it serialises. As a general rule, creation and deletion type actions are always serialised, and data-upload calls can sometimes be serialised. In some cases the driver might choose to optimise out some of the data-upload calls and lazy initialise the contents of some resources to save on background overhead.

This serialised data is stored in-memory in a chunk-based representation. Although it’s up to the driver implementation it is generally refcounted such that resources which end up becoming unbound and destroyed will have their memory overhead deleted.

When the capture button is hit the driver will enter active capturing upon the beginning of the next frame. In this state every API call is serialised out in order and any initial contents and states are saved.

Once the frame completes, this frame capture is serialised to disk along with the in-memory data for any resources that are referenced - by default resources which are not referenced are not included in the capture.

Replaying & Analysing Captures

The replay process is ostensibly simple, but as with the capturing the devil is in the details.

When replaying, the initial section of the capture (up to the beginning of the frame) is read and executed verbatim. Each resource created is mapped to the live version and vice versa so later parts of the capture can obtain the replayed representation of the original resource.

RenderDoc then does an initial pass over the captured frame. This allows us to build up a list of all the actions, analyse dependencies and check which resources are used at each action for read, write, and so on. An internal tree is built up similar to what you see in the Event Browser & API Inspector, as well as a linked list with the linear sequence of actions, since both representations are useful for iterating over the frame.

After this point most work is done in response to user actions. The basic building block is replaying a partial frame. Most analysis tools are built out of either replaying up to the current event, replaying up to the event - not including the current action - and replaying only the current action.

Care is taken to minimise this as much as possible as this tends to be the slowest operation given the overheads of serialisation and decoding the command stream.

When replaying from the beginning of a frame (and not a partial subset of the frame) the initial states of all resources are applied, and the initial pipeline state is restored. Resources which did not have a serialised initial state (e.g. gbuffer textures) have an initial state saved before the first replay of the frame, and this is restored. That way you don’t get effects ‘leaking’ from later in a frame into an earlier point.

For example, let’s assume the user has the ‘depth test’ overlay enabled, and selects a new event. This is the order of events that occur for the Texture Viewer - other viewers follow similar patterns, with a certain degree of sharing to reduce redundant replays:

  1. The capture is replayed up to, but not including, the selected action. After doing this the current pipeline state and contents of all resources exactly match the state at the point of this action.
  2. We then save a copy of the pristine depth buffer, save the current pipeline state, and set the reversed depth test. Replacing the pixel shader with one that just writes red, we repeat the action to draw all the areas that fail the depth test.
  3. Restoring the depth buffer and repeating this with a pixel shader which writes green, we fill in the overlay. Both of these renders happen to an off-screen buffer.
  4. After restoring the pipeline state we finally replay the original action to get the final image.
  5. When we want to re-paint the viewed texture (either regular painting, or if the user changed a visualisation option which is just a constant buffer value) we bind the current render target as a resource and render it to the texture viewer control, then render the overlay texture on top of that.


OpenGL & OpenGL ES Support

This page documents the support of OpenGL & OpenGL ES in RenderDoc. This gives an overview of what RenderDoc is capable of, and primarily lists information that is relevant. You might also be interested in the full list of features.

Capture requirements

RenderDoc only supports the core profile of OpenGL - from 3.2 up to 4.6 inclusive. This means any compatibility profile functionality will generally not be supported. There are a couple of concessions where it was easy to do so - like allowing the use of VAO 0, or luminance/intensity formats, but this in general will not happen.

Note

To be more compatible with applications, RenderDoc will still attempt to capture on a compatibility context, but it will not replay successfully unless the given subset of functionality is used.

On OpenGL ES, any context version 2.0 and above is supported.

Replay requirements

RenderDoc assumes a certain minimum feature set on replay. On desktop this means you must be able to create a 3.2 core context.

Also note that this is the minimum required functionality to replay, some analysis features will be disabled unless you have more capable hardware features such as GL_ARB_shader_image_load_store, GL_ARB_compute_shader and GL_ARB_gpu_shader5.

On OpenGL ES, you must be able to create a GLES 3 context to replay.

Multiple contexts & multithreading

RenderDoc assumes that all GL commands (with the exception of perhaps a SwapBuffers call) for frames will come from a single thread. This means that e.g. if commands come from a second thread during loading, or some time during initialisation, this will be supported. However during frame capture all commands are serialised as if they come from a single thread, so interleaved rendering commands from multiple threads will not work.

Extension support

RenderDoc supports many ARB, EXT and other vendor-agnostic extensions - primarily those that are either very widespread and commonly used but aren’t in core, or are quite simple to support. In general RenderDoc won’t support extensions unless they match one of these requirements, and this means most vendor extensions will not be supported.

OpenGL remaining work

There is one place where OpenGL is not at feature parity with other APIs.

  • Shader debugging is not supported on any shader stage.

Android

OpenGL ES capture and replay on Android is natively supported. For more information on how to capture with Android see How do I use RenderDoc on Android?.

OS X

OS X is not supported.

See Also

  • Features


Vulkan Support

This page documents the support of Vulkan in RenderDoc. This gives an overview of what RenderDoc is capable of, and primarily lists information that is relevant. You might also be interested in the full list of features.

Vulkan capture

RenderDoc’s Vulkan support uses the sophisticated layering mechanism built into the Vulkan API. This means that once RenderDoc has registered its capture layers, there is no need for invasive process hooking - we can simply launch the target process with an environment variable set.

The one requirement of this however is that the layer does need to be registered in an OS specific way - on windows this is in the registry, on linux this is in /usr/share/vulkan/implicit_layer.d, /etc/vulkan/implicit_layer.d, or $HOME/.local/share/vulkan/implicit_layer.d. That way the Vulkan loader can scan and initialise the layer.

Usually this will happen for you if you install RenderDoc with a proper installer, or update from a previous version. However if you are compiling RenderDoc yourself or running a loose unzipped build, the capture panel will show a warning indicating that the layers need to be registered. Just click this and the registration will be applied.

Vulkan Layer Registration

Performance notes

Vulkan is intended as a high-performance low CPU overhead API, and RenderDoc strives to maintain that performance contract at a reasonable level. While some overhead is inevitable RenderDoc aims to have no locks on the ‘hot path’ of command buffer recording, minimal or no allocation, and in general to have low performance overhead while not capturing.

Some patterns of access are more or less conducive to good performance on RenderDoc, so if you are having trouble with slow capture, large memory/disk overhead or slow replay you might want to try eliminating use of persistent maps of memory from coherent heaps by mapping and unmapping them around changes, or reduce the number of submits you make while you have coherent memory persistently mapped.

Likewise try to avoid making very large memory allocations in the range of 1GB and above. By its nature RenderDoc must save one or more copies of memory allocations to enable proper capture, so having allocations limited to only a few 100s of megabytes can help gain granularity of management and limit the memory overhead RenderDoc adds. There may be optimisation of this in future on RenderDoc’s side but there are no easy guarantees.

Current support

RenderDoc has support for Vulkan version 1.2, as well as a number of extensions, but it contains some caveats. In addition, not all replay features are currently supported, but this is being actively worked on.

  • RenderDoc assumes that even if multiple GPUs are present, that only one VkDevice will be created and used.
  • RenderDoc captures will in general not be portable between different systems, only currently supporting capture and replay on the same or similar enough machines.

Android

Vulkan capture and replay on Android is natively supported. For more information on how to capture with Android see How do I use RenderDoc on Android?.

See Also

  • Features


D3D12 Support

This page documents the support of D3D12 in RenderDoc. This gives an overview of what RenderDoc is capable of, and primarily lists information that is relevant. You might also be interested in the full list of features.

Performance notes

D3D12 is intended as to have low CPU overhead and be fully threadable, and RenderDoc strives to maintain that performance as much as possible. While some overhead is inevitable RenderDoc aims to have no locks on the ‘hot path’ of command buffer recording, minimal or no allocation, and in general to have low performance overhead while not capturing.

Some patterns of access are more or less conducive to good performance on RenderDoc, so if you are having trouble with slow capture, large memory/disk overhead or slow replay you might want to try eliminating use of persistent maps of resources. If you do have persistent maps, ensure that either the memory allocation is small or that you have only a few queue submits during the frame - since RenderDoc must compare the whole allocation at every submit to determine what might have changed and save out the delta.

Likewise try to avoid making very large memory allocations in the range of 1GB and above. By its nature RenderDoc must save one or more copies of memory allocations to enable proper capture, so having allocations limited to only a few 100s of megabytes can help gain granularity of management and limit the memory overhead RenderDoc adds. There may be optimisation of this in future on RenderDoc’s side but there are no easy guarantees.

Current support

RenderDoc has initial support for D3D12, but it contains some caveats. In addition, not all replay features are currently supported, but this will eventually reach parity with other APIs.

  • RenderDoc assumes that even if multiple GPUs are present, that only one will be used - i.e. NodeMask is always 0. Multiple queues are supported.
  • RenderDoc captures may not be portable between different systems, only currently supporting capture and replay on the same or similar enough machines.
  • Shader debugging is not supported for DXIL shaders.

See Also

  • Features


In-application API

Reference for RenderDoc in-application API version 1.6.0. This API is not necessary to use RenderDoc by default, but if you would like more control or custom triggering of captures this API can provide the mechanism to do so.

Make sure to use a matching API header for your build - if you use a newer header, the API version may not be available. All RenderDoc builds supporting this API ship the header in their root directory.

This page describes the RenderDoc API exposed to applications being captured, both in overall organisation as well as a specific reference on each function.

To begin using the API you need to fetch the RENDERDOC_GetAPI function. You should do this dynamically, it is not recommended to actually link against RenderDoc’s DLL as it’s intended to be injected or loaded at runtime. The header does not declare RENDERDOC_GetAPI, it declares a function pointer typedef pRENDERDOC_GetAPI that you can use.

The recommended way to access the RenderDoc API is to passively check if the module is loaded, and use the API if it is. This lets you continue to use RenderDoc entirely as normal, launching your program through the UI, but you can access additional functionality to e.g. trigger captures at custom times. When your program is launched independently it will see that the RenderDoc module is not present and safely fall back.

To do this you’ll use your platforms dynamic library functions to see if the library is open already - e.g. GetModuleHandle on Windows, or dlopen with the RTLD_NOW | RTLD_NOLOAD flags if available on *nix systems. On most platforms you can just search for the module name - renderdoc.dll on Windows, or librenderdoc.so on Linux, or libVkLayer_GLES_RenderDoc.so on Android should be sufficient here, so you don’t need to know the path to where RenderDoc is running from. This will vary by platform however so consult your platform’s OS documentation. Then you can use GetProcAddress or dlsym to fetch the RENDERDOC_GetAPI function using the typedef above.

int RENDERDOC_GetAPI(RENDERDOC_Version version, void **outAPIPointers)

This function is the only entry point actually exported from the RenderDoc module. You call this function with the desired API version, and pass it the address of a pointer to the appropriate struct type. If successful, RenderDoc will set the pointer to point to a struct containing the function pointers for the API functions (detailed below) and return 1.

Note that version numbers follow semantic versioning which means the implementation returned may have a higher minor and/or patch version than requested.

Example code:

#include "renderdoc_app.h"

RENDERDOC_API_1_1_2 *rdoc_api = NULL;

// At init, on windows
if(HMODULE mod = GetModuleHandleA("renderdoc.dll"))
{
    pRENDERDOC_GetAPI RENDERDOC_GetAPI =
        (pRENDERDOC_GetAPI)GetProcAddress(mod, "RENDERDOC_GetAPI");
    int ret = RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_1_2, (void **)&rdoc_api);
    assert(ret == 1);
}

// At init, on linux/android.
// For android replace librenderdoc.so with libVkLayer_GLES_RenderDoc.so
if(void *mod = dlopen("librenderdoc.so", RTLD_NOW | RTLD_NOLOAD))
{
    pRENDERDOC_GetAPI RENDERDOC_GetAPI = (pRENDERDOC_GetAPI)dlsym(mod, "RENDERDOC_GetAPI");
    int ret = RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_1_2, (void **)&rdoc_api);
    assert(ret == 1);
}

// To start a frame capture, call StartFrameCapture.
// You can specify NULL, NULL for the device to capture on if you have only one device and
// either no windows at all or only one window, and it will capture from that device.
// See the documentation below for a longer explanation
if(rdoc_api) rdoc_api->StartFrameCapture(NULL, NULL);

// Your rendering should happen here

// stop the capture
if(rdoc_api) rdoc_api->EndFrameCapture(NULL, NULL);
param RENDERDOC_Version version:
is the version number of the API for which you want the interface struct.
param void** outAPIPointers:
will be filled with the address of the API’s function pointer struct, if supported. E.g. if eRENDERDOC_API_Version_1_1_1 is requested, outAPIPointers will be filled with RENDERDOC_API_1_1_1* or any newer version that is compatible with API 1.1.1, but nothing lower.
return: The function returns 1 if the API version is valid and available, and the struct pointer is filled. The function returns 0 if the API version is invalid or not supported, or the pointer parameter is invalid.
void GetAPIVersion(int *major, int *minor, int *patch)

This function returns the actual API version of the implementation returned. Version numbers follow semantic versioning which means the implementation returned may have a higher minor and/or patch version than requested: New patch versions are identical and backwards compatible in functionality. New minor versions add new functionality in a backwards compatible way.

Parameters:
  • int* major – will be filled with the major version of the implementation’s version.
  • int* minor – will be filled with the minor version of the implementation’s version.
  • int* patch – which will be filled with the patch version of the implementation’s version.
Returns:

None
int SetCaptureOptionU32( RENDERDOC_CaptureOption opt, uint32_t val)

Set one of the options for tweaking some behaviours of capturing. Note that each option only takes effect from after it is set - so it is advised to set these options as early as possible, ideally before any graphics API has been initialised.

Parameters:
  • RENDERDOC_CaptureOption opt – specifies which capture option should be set.
  • uint32_t val – the unsigned integer value to set for the above option.
Returns:

The function returns 1 if the option is valid, and the value set on the option is within valid ranges. The function returns 0 if the option is not a RENDERDOC_CaptureOption enum, or the value is not valid for the option.
int SetCaptureOptionF32( RENDERDOC_CaptureOption opt, float val)

Set one of the options for tweaking some behaviours of capturing. Note that each option only takes effect from after it is set - so it is advised to set these options as early as possible, ideally before any graphics API has been initialised..

Parameters:
  • RENDERDOC_CaptureOption opt – specifies which capture option should be set.
  • float val – the floating point value to set for the above option.
Returns:

The function returns 1 if the option is valid, and the value set on the option is within valid ranges. The function returns 0 if the option is not a RENDERDOC_CaptureOption enum, or the value is not valid for the option.
enum RENDERDOC_CaptureOption

Many values in this enum correspond to options in the Capture Dialog window, so more documentation about their meaning can be found there. Some values here are only available programmatically through this API.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_AllowVSync

specifies whether the application is allowed to enable vsync. Default is on.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_AllowFullscreen

specifies whether the application is allowed to enter exclusive fullscreen. Default is on.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_APIValidation

specifies whether (where possible) API-specific debugging is enabled. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureCallstacks

specifies whether each API call should save a callstack. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureCallstacksOnlyActions

specifies whether - if CaptureCallstacks is enabled - callstacks are only saved on actions. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_DelayForDebugger

specifies a delay in seconds after launching a process to pause, to allow debuggers to attach. This will only apply to child processes since the delay happens at process startup. Default is 0.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_VerifyBufferWrites

specifies whether any mapped memory updates should be bounds-checked for overruns, and uninitialised buffers are initialised to 0xdddddddd to catch use of uninitialised data. Only supported on D3D11 and OpenGL. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_HookIntoChildren

specifies whether child processes launched by the initial application should be hooked as well - commonly if a launcher process is needed to run the application. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_RefAllResources

specifies whether all live resources at the time of capture should be included in the capture, even if they are not referenced by the frame. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureAllCmdLists

specifies whether all command lists should be captured on D3D11 where multithreaded submission is not optimal, rather than only capturing those recorded after frame capture begins. Default is off.

enumerator RENDERDOC_CaptureOption::eRENDERDOC_Option_DebugOutputMute

specifies whether to mute any API debug output messages when APIValidation is enabled, and not pass them along to the application. Default is on.

uint32_t GetCaptureOptionU32( RENDERDOC_CaptureOption opt)

Gets the current value of one of the different options listed above in SetCaptureOptionU32().

Parameters: RENDERDOC_CaptureOption opt – specifies which capture option should be retrieved.
Returns: The function returns the value of the capture option, if the option is a valid RENDERDOC_CaptureOption enum. Otherwise returns 0xffffffff.
float GetCaptureOptionF32( RENDERDOC_CaptureOption opt)

Gets the current value of one of the different options listed above in SetCaptureOptionF32().

Parameters: RENDERDOC_CaptureOption opt – specifies which capture option should be retrieved.
Returns: The function returns the value of the capture option, if the option is a valid RENDERDOC_CaptureOption enum. Otherwise returns -FLT_MAX.
void SetFocusToggleKeys( RENDERDOC_InputButton *keys, int num)

This function changes the key bindings in-application for changing the focussed window.

Parameters:
  • RENDERDOC_InputButton* keys – lists the keys to bind. If this parameter is NULL, num must be 0.
  • int num – specifies the number of keys in the keys array. If 0, the keybinding is disabled.
enum RENDERDOC_InputButton
enumerator RENDERDOC_InputButton::eRENDERDOC_Key_0

eRENDERDOC_Key_0 to eRENDERDOC_Key_9 are the number keys. The values of these match ASCII for ‘0’ .. ‘9’.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_A

eRENDERDOC_Key_A to eRENDERDOC_Key_Z are the letter keys. The values of these match ASCII for ‘A’ .. ‘Z’.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Divide

is the Divide key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Multiply

is the Multiply key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Subtract

is the Subtract key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Plus

is the Plus key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_F1

eRENDERDOC_Key_F1 to eRENDERDOC_Key_F12 are the function keys.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Home

is the Home key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_End

is the End key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Insert

is the Insert key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Delete

is the Delete key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_PageUp

is the PageUp key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_PageDn

is the PageDn key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Backspace

is the Backspace key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Tab

is the Tab key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_PrtScrn

is the PrtScrn key.

enumerator RENDERDOC_InputButton::eRENDERDOC_Key_Pause

is the Pause key.

void SetCaptureKeys( RENDERDOC_InputButton *keys, int num)

This function changes the key bindings in-application for triggering a capture on the current window.

Parameters:
  • RENDERDOC_InputButton* keys – lists the keys to bind. If this parameter is NULL, num must be 0.
  • int num – specifies the number of keys in the keys array. If 0, the keybinding is disabled.
uint32_t GetOverlayBits()

This function returns the current mask which determines what sections of the overlay render on each window.

Returns: A mask containing bits from RENDERDOC_OverlayBits.
enum RENDERDOC_OverlayBits
enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_Enabled

is an overall enable/disable bit. If this is disabled, no overlay renders.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_FrameRate

shows the average, min and max frame time in milliseconds, and the average framerate.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_FrameNumber

shows the current frame number, as counted by the number of presents.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_CaptureList

shows how many total captures have been made, and a list of captured frames in the last few seconds.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_Default

is the default set of bits, which is the value of the mask at startup.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_All

is equal to ~0U so all bits are enabled.

enumerator RENDERDOC_OverlayBits::eRENDERDOC_Overlay_None

is equal to 0 so all bits are disabled.

void MaskOverlayBits(uint32_t And, uint32_t Or)

This function modifies the current mask which determines what sections of the overlay render on each window.

Parameters:
  • uint32_t And – is a 32-bit value the mask is binary-AND’d with before processing Or.
  • uint32_t Or – is a 32-bit value the mask is binary-OR’d with after processing And.
void RemoveHooks()

This function will attempt to remove RenderDoc and its hooks from the target process. It must be called as early as possible in the process, and will have undefined results if any graphics API functions have been called.

Note

This process is only possible on Windows, and even then it is not well defined so may not be possible in all circumstances. This function is provided at your own risk.

Note

This function was renamed, in earlier versions of the API it was declared as Shutdown. This rename is backwards compatible as the function signature did not change.

void UnloadCrashHandler()

This function will remove RenderDoc’s crash handler from the target process. If you have your own crash handler that you want to handle any exceptions, RenderDoc’s handler could interfere so it can be disabled.

void SetCaptureFilePathTemplate(const char *pathtemplate)

Set the template for new captures. The template can either be a relative or absolute path, which determines where captures will be saved and how they will be named. If the path template is my_captures/example then captures saved will be e.g. my_captures/example_frame123.rdc and my_captures/example_frame456.rdc. Relative paths will be saved relative to the process’s current working directory. The default template is in a folder controlled by the UI - initially the system temporary folder, and the filename is the executable’s filename.

Parameters: const char* pathtemplate – specifies the capture path template to set, as UTF-8 null-terminated string.

Note

This function was renamed, in earlier versions of the API it was declared as SetLogFilePathTemplate. This rename is backwards compatible as the function signature did not change.

const char *GetCaptureFilePathTemplate()

Get the current capture path template, see SetCaptureFilePathTemplate().

Returns: the current capture path template as a UTF-8 null-terminated string.

Note

This function was renamed, in earlier versions of the API it was declared as GetLogFilePathTemplate. This rename is backwards compatible as the function signature did not change.

uint32_t GetNumCaptures()

This function returns the number of frame captures that have been made.

Returns: the number of frame captures that have been made
uint32_t GetCapture(uint32_t idx, char *filename, uint32_t *pathlength, uint64_t *timestamp)

This function returns the details of a particular frame capture, as specified by an index from 0 to GetNumCaptures() - 1.

Parameters:
  • uint32_t idx – specifies which capture to return the details of. Must be less than the return value of GetNumCaptures().
  • char* filename – is an optional parameter filled with the UTF-8 null-terminated path to the file. There must be enough space in the array to contain all characters including the null terminator. If set to NULL, nothing is written.
  • uint32_t* pathlength – is an optional parameter filled with the byte length of the above filename including the null terminator. If set to NULL, nothing is written.
  • uint64_t* timestamp – is an optional parameter filled with the 64-bit timestamp of the file - equivalent to the time() system call. If set to NULL, nothing is written.
Returns:

Returns 1 if the capture index was valid, or 0 if it was out of range.

Note

It is advised to call this function twice - first to obtain pathlength so that sufficient space can be allocated. Then again to actually retrieve the path.

The path follows the template set in SetCaptureFilePathTemplate() so it may not be an absolute path.

void TriggerCapture()

This function will trigger a capture as if the user had pressed one of the capture hotkeys. The capture will be taken from the next frame presented to whichever window is considered current.

uint32_t IsTargetControlConnected()

This function returns a value to indicate whether the RenderDoc UI is currently connected to the current process.

Returns: Returns 1 if the RenderDoc UI is currently connected, or 0 otherwise.

Note

This function was renamed, in earlier versions of the API it was declared as IsRemoteAccessConnected. This rename is backwards compatible as the function signature did not change.

uint32_t LaunchReplayUI(uint32_t connectTargetControl, const char *cmdline)

This function will determine the closest matching replay UI executable for the current RenderDoc module and launch it.

Parameters:
  • uint32_t connectTargetControl – should be set to 1 if the UI should immediately connect to the application.
  • const char* cmdline – is an optional UTF-8 null-terminated string to be appended to the command line, e.g. a capture filename. If this parameter is NULL, the command line will be unmodified.
Returns:

If the UI was successfully launched, this function will return the PID of the new process. Otherwise it will return 0.
uint32_t ShowReplayUI()

This function requests that the currently connected replay UI raise its window to the top. This is only possible if an instance of the replay UI is currently connected, otherwise this function does nothing. This can be used in conjunction with IsTargetControlConnected and LaunchReplayUI to intelligently handle showing the UI after making a capture.

Given OS differences it is not guaranteed that the UI will be successfully raised even if the request is passed on. On some OSs it may only be highlighted or otherwise indicated to the user.

Returns: If the request to be shown was passed onto the UI successfully this function will return 1. If there is no UI connected currently or some other error occurred it will return 0.

Note

Added in API version 1.5.0

void SetActiveWindow(RENDERDOC_DevicePointer device, RENDERDOC_WindowHandle wndHandle)

This function will explicitly set which window is considered active. The active window is the one that will be captured when the keybind to trigger a capture is pressed.

Parameters:
  • RENDERDOC_DevicePointer device – is a handle to the API ‘device’ object that will be set active. Must be valid.
  • RENDERDOC_WindowHandle wndHandle – is a handle to the platform window handle that will be set active. Must be valid.

Note

RENDERDOC_DevicePointer is a typedef to void *. The contents of it are API specific:

  • For D3D11 it must be the ID3D11Device device object.
  • For D3D12 it must be the ID3D12Device device object.
  • For OpenGL it must be the HGLRC, GLXContext, or EGLContext context object.
  • For OpenGLES it must be the EGLContext context object.
  • For Vulkan it must be the dispatch table pointer within the VkInstance. This is a pointer-sized value at the location pointed to by the VkInstance. NOTE - this is not the actual VkInstance pointer itself. You can use the RENDERDOC_DEVICEPOINTER_FROM_VKINSTANCE helper macro defined in the renderdoc header to obtain this pointer from any VkInstance.

RENDERDOC_WindowHandle is a typedef to void *. It is the platform specific Windows HWND, Xcb xcb_window_t, Xlib Window / Drawable, Wayland wl_surface*, or Android ANativeWindow*.

void StartFrameCapture(RENDERDOC_DevicePointer device, RENDERDOC_WindowHandle wndHandle)

This function will immediately begin a capture for the specified device/window combination.

Parameters:
  • RENDERDOC_DevicePointer device – is a handle to the API ‘device’ object that will be set active. May be NULL to wildcard match.
  • RENDERDOC_WindowHandle wndHandle – is a handle to the platform window handle that will be set active. May be NULL to wildcard match.

Note

RENDERDOC_DevicePointer and RENDERDOC_WindowHandle are described above in SetActiveWindow(). device and wndHandle can either or both be set to NULL to wildcard match against active device/window combinations. This wildcard matching can be used if the handle is difficult to obtain where frame captures are triggered.

For example if device is NULL but wndHandle is set, RenderDoc will begin a capture on the first API it finds that is active on that window.

If the wildcard match has multiple possible candidates, it is not defined which will be chosen. Wildcard matching should only be used when e.g. it is known that only one API is active on a window, or there is only one window active for a given API.

If no window has been created and all rendering is off-screen, NULL can be specified for the window handle and the device object can be passed to select that API. If both are set to NULL, RenderDoc will simply choose one at random so is only recommended for the case where only one is present.

uint32_t IsFrameCapturing()

This function returns a value to indicate whether the current frame is capturing.

Returns: Returns 1 if the frame is currently capturing, or 0 otherwise.
uint32_t EndFrameCapture(RENDERDOC_DevicePointer device, RENDERDOC_WindowHandle wndHandle)

This function will immediately end an active capture for the specified device/window combination.

Parameters:
  • RENDERDOC_DevicePointer device – is a handle to the API ‘device’ object that will be set active. May be NULL to wildcard match.
  • RENDERDOC_WindowHandle wndHandle – is a handle to the platform window handle that will be set active. May be NULL to wildcard match.
Returns:

Returns 1 if the capture succeeded, and 0 if there was an error capturing.

Note

RENDERDOC_DevicePointer and RENDERDOC_WindowHandle are described above in SetActiveWindow(). device and wndHandle can either or both be set to NULL to wildcard match against active device/window combinations. This wildcard matching can be used if the handle is difficult to obtain where frame captures are triggered.

Wildcard matching of device and wndHandle is described above in StartFrameCapture().

There will be undefined results if there is not an active frame capture for the device/window combination.

uint32_t DiscardFrameCapture(RENDERDOC_DevicePointer device, RENDERDOC_WindowHandle wndHandle)

This function is similar to EndFrameCapture() but the capture contents will be discarded immediately, and not processed and written to disk. This will be more efficient than EndFrameCapture() if the frame capture is not needed.

Parameters:
  • RENDERDOC_DevicePointer device – is a handle to the API ‘device’ object that will be set active. May be NULL to wildcard match.
  • RENDERDOC_WindowHandle wndHandle – is a handle to the platform window handle that will be set active. May be NULL to wildcard match.
Returns:

Returns 1 if the capture was discarded, and 0 if there was an error or no capture was in progress.

Note

RENDERDOC_DevicePointer and RENDERDOC_WindowHandle are described above in SetActiveWindow(). device and wndHandle can either or both be set to NULL to wildcard match against active device/window combinations. This wildcard matching can be used if the handle is difficult to obtain where frame captures are triggered.

Wildcard matching of device and wndHandle is described above in StartFrameCapture().

There will be undefined results if there is not an active frame capture for the device/window combination.

Note

Added in API version 1.4.0

void SetCaptureTitle(const char *title)

This function sets a given title for the currently in-progress capture, which will be displayed in the UI. This can be used either with a user-defined capture using a manual start and end, or an automatic capture triggered by TriggerCapture() or a keypress.

If multiple captures are ongoing at once, the title will be applied to the first capture to end only. Any subsequent captures will not get any title unless the function is called again.

This function can only be called while a capture is in-progress, after StartFrameCapture() and before EndFrameCapture(). If it is called elsewhere it will have no effect. If it is called multiple times within a capture, only the last title will have any effect.

Note

Added in API version 1.6.0

void TriggerMultiFrameCapture(uint32_t numFrames)

This function will trigger multiple sequential frame captures as if the user had pressed one of the capture hotkeys before each frame. The captures will be taken from the next frames presented to whichever window is considered current.

Each capture will be taken independently and saved to a separate file, with no reference to the other frames.

Parameters: uint32_t numFrames – the number of frames to capture, as an unsigned integer.

Note

Added in API version 1.1.0

void SetCaptureFileComments(const char *filePath, const char *comments)

This function adds an arbitrary comments field to an existing capture on disk, which will then be displayed in the UI to anyone opening the capture.

Parameters:
  • const char* filePath – specifies the path to the capture file to set comments in, as UTF-8 null-terminated string. If this path is NULL or an empty string, the most recent capture file that has been created will be used.
  • const char* comments – specifies the comments to set in the capture file, as UTF-8 null-terminated string.

Note

Added in API version 1.2.0


Python API

RenderDoc exposes APIs to python at two different levels:

  1. The base replay API, the renderdoc module, which provides low level access to handling capture files, replaying frames and obtaining analysis information. The UI is built entirely on top of this API, so it provides the full power of RenderDoc, however is does not have many convenience abstractions.
  2. The RenderDoc UI API, the qrenderdoc module, which exposes the abstractions and panels within the UI tool.

Within RenderDoc - when either running scripts on the command line, or via the Python Shell - both modules are pre-imported and available automatically.

It is also possible to build the renderdoc module standalone which can be loaded into python and used for scripting directly without the UI program. Due to the inherent difficulty of distributing C python modules this isn’t included by default in distributed builds at the time of writing, but is generated by default in source builds - renderdoc.pyd on windows or renderdoc.so elsewhere. Use of this module is strictly a convenience and is not supported.

Note

Due to Android being inherently an unstable and unreliable platform, using the python scripting on Android devices is not recommended or supported. It may work, but you’ll be on your own with any problems encountered as they are too likely to be caused by problems on Android.

You must use exactly the same version of python to load the module as was used to build it.

On windows by default RenderDoc builds against python 3.6 which is what it’s distributed with.

This can be overridden by setting an overridden path under the Python Configuration section in the properties of the qrenderdoc project and pyrenderdoc_module project. It must point to a python installation.

RenderDoc requires pythonXY.lib, include files such as include/Python.h, as well as a .zip of the standard library. If you installed python with an installer you have the first two, and can generate the standard library zip by zipping the contents of the Lib folder. If you downloaded the embeddable zip distribution you will only have the standard library zip, you need to obtain the include files and .lib file separately.

Note

RenderDoc only supports Python 3.4+, Python 2 is not supported.

This documentation contains information on getting started with the scripting, as well as tutorials and examples outline how to perform simple tasks.

Each example has a simple motivating goal and shows how to achieve it using the interfaces provided. They will not show every possible use of the interfaces, but instead give a starting point to build on. Further information about exactly what functionality is available can be found in the API reference below as well as using the python built-in help() function.

  • Getting Started (python)
    • Loading the Module
    • Loading a Capture
    • Accessing Capture Analysis
    • Example Source
  • Getting Started (RenderDoc UI)
    • Loading a Capture
    • Accessing Capture Analysis
  • Python development environment
    • Building RenderDoc
    • Installing PyCharm
    • Configuring python module
    • Troubleshooting
  • Writing UI extensions
    • First steps
    • Adding a window and capture viewer
    • Calling onto replay thread
    • Conclusion
  • Basic Interfaces
    • Replay Basics
      • ReplayController
      • ReplayOutput
    • RenderDoc UI Basics
  • renderdoc Examples
    • Iterate Action tree
      • Example Source
    • Fetch Shader details
      • Example Source
    • Fetch GPU Counter Data
      • Example Source
    • Save a texture to disk
      • Example Source
    • Decoding Mesh Data
      • Example Source
    • Display texture in window
      • Example Source
    • Remote Capture and Replay
      • Example Source
  • qrenderdoc examples
    • Display buffer with format
      • Example Source
  • renderdoc API Reference
  • qrenderdoc API Reference


Getting Started (python)

Note

This document is aimed at users getting started with loading a capture and getting access from the renderdoc module, and is generally not relevant when running within the RenderDoc UI.

The same APIs are available in the UI, so you can follow these steps. Be aware that loading captures while purely from script may interfere with a capture that is loaded in the UI itself, so this is not recommended.

Loading the Module

For this section we assume you have built a copy of RenderDoc and have the module (renderdoc.pyd or renderdoc.so depending on your platform). For information on how to build see the GitHub repository.

Note

You must use exactly the same version of python to load the module as was used to build it.

On windows by default RenderDoc builds against python 3.6 which is what it’s distributed with.

This can be overridden by setting an overridden path under the Python Configuration section in the properties of the qrenderdoc project and pyrenderdoc_module project. It must point to a python installation.

RenderDoc requires pythonXY.lib, include files such as include/Python.h, as well as a .zip of the standard library. If you installed python with an installer you have the first two, and can generate the standard library zip by zipping the contents of the Lib folder. If you downloaded the embeddable zip distribution you will only have the standard library zip, you need to obtain the include files and .lib file separately.

Once you have the module, either place the module within your python’s default library search path, or else insert the location of the python module into the path in your script. You can either set the PYTHONPATH environment variable or do it at the start of your script:

import sys

sys.path.append('/path/to/renderdoc/module')

Additionally, the renderdoc python module needs to be able to load the main renderdoc library - the module library it self just contains stubs and python wrappers for the C++ interfaces. You can either place the renderdoc library in the system library paths, or solve it in a platform specific way. For example on windows you can either place renderdoc.dll in the same directory as the python module, or append to PATH. On Python 3.8 and above PATH is no longer searched by default so you need to explicitly add the DLL folder:

import os, sys

os.environ["PATH"] += os.pathsep + os.path.abspath('/path/to/renderdoc/native/library')
if sys.platform == 'win32' and sys.version_info[1] >= 8:
    os.add_dll_directory("/path/to/renderdoc/native/library")

On linux you’d perform a similar modification to LD_LIBRARY_PATH.

Assuming all has gone well, you should now be able to import the renderdoc module:

import renderdoc as rd

# Prints 'CullMode.FrontAndBack'
print(rd.CullMode.FrontAndBack)

Loading a Capture

Given a capture file test.rdc we want to load it, begin the replay and get ready to perform analysis on it.

Before doing anything, we must initialise the replay API. We do that by calling InitialiseReplay(). Generally no special configuration is needed so passing a default GlobalEnvironment and an empty list of arguments is fine.

rd.InitialiseReplay(rd.GlobalEnvironment(), [])

To begin with, we use OpenCaptureFile() to obtain a CaptureFile instance. This gives us access to control over a capture file at a meta level. For more information see the CaptureFile reference - the interface can also be used to create.

To open a file, use OpenFile() on the CaptureFile instance. This function allows conversion from other formats via an importer, but here we’ll use it just for opening a regular rdc file. It returns a ResultDetails which can be used to determine what went wrong in the event that there was a problem. We then check that the capture uses an API which can be replayed locally - for example not every platform supports D3D11, so on linux this would return no local replay support.

# Open a capture file handle
cap = rd.OpenCaptureFile()

# Open a particular file - see also OpenBuffer to load from memory
result = cap.OpenFile('test.rdc', '', None)

# Make sure the file opened successfully
if result != rd.ResultCode.Succeeded:
    raise RuntimeError("Couldn't open file: " + str(result))

# Make sure we can replay
if not cap.LocalReplaySupport():
    raise RuntimeError("Capture cannot be replayed")

Accessing Capture Analysis

Once the capture has been loaded, we can now begin the replay analysis. To do that we use OpenCapture() which returns a tuple of ResultDetails and ReplayController.

This function call will open the capture and begin to replay it, and initialise the analysis. The ReplayController returned is the interface to the majority of RenderDoc’s replaying functionality.

# Initialise the replay
result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

if result != rd.ResultCode.Succeeded:
    raise RuntimeError("Couldn't initialise replay: " + str(result))

# Now we can use the controller!
print("%d top-level actions" % len(controller.GetRootActions()))

Once we’re done with the interfaces, we should call the Shutdown function on each, this allows the C++ interface to release the resources allocated.

Once all work is done we can shutdown the replay API.

# Shutdown the controller first, then the capture file
controller.Shutdown()

cap.Shutdown()

rd.ShutdownReplay()

Example Source

The full source for this example is available below:

import renderdoc as rd

rd.InitialiseReplay(rd.GlobalEnvironment(), [])

# Open a capture file handle
cap = rd.OpenCaptureFile()

# Open a particular file - see also OpenBuffer to load from memory
result = cap.OpenFile('test.rdc', '', None)

# Make sure the file opened successfully
if result != rd.ResultCode.Succeeded:
    raise RuntimeError("Couldn't open file: " + str(result))

# Make sure we can replay
if not cap.LocalReplaySupport():
    raise RuntimeError("Capture cannot be replayed")

# Initialise the replay
result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

if result != rd.ResultCode.Succeeded:
    raise RuntimeError("Couldn't initialise replay: " + str(result))

# Now we can use the controller!
print("%d top-level actions" % len(controller.GetRootActions()))

controller.Shutdown()

cap.Shutdown()

rd.ShutdownReplay()


Getting Started (RenderDoc UI)

Note

This document is aimed at users getting started with scripting within the RenderDoc UI.

The module used here (qrenderdoc) is not available as a stand-alone module.

When working within the RenderDoc UI, the renderdoc and qrenderdoc modules are implicitly imported when any script runs. In addition to this, an additional global pyrenderdoc is always available. It is an instance of CaptureContext and it represents the interface into the UI interface.

Loading a Capture

Unlike when using the base module directly, within the UI it is strongly recommended that you load captures using the UI interfaces itself rather than doing it entirely within python code, otherwise there is a risk of conflict between the two loaded captures in the same program.

To load a capture programmatically, we can use the pyrenderdoc global variable and call LoadCapture(). When loading a local capture some of the parameters are redundant - we don’t need to specify a different “actual” file vs the loaded file, and it is not a temporary handle. These parameters are primarily used by the UI itself when loading captures from remote hosts or immediately after they are generated while they are still stored temporarily on disk and the user needs to be prompted to save or delete them on close.

filename = 'test.rdc'

# Load a file, with the same 'original' name, that's not temporary, and is local
pyrenderdoc.LoadCapture(filename, renderdoc.ReplayOptions(), filename, False, True)

This will close any capture that is already loaded, but to just close an open capture you can use CloseCapture().

As part of opening the capture, RenderDoc will begin replay automatically and populate the various panels and internal data structures for easy access. It will also handle prompting the user if any errors happen or if replay isn’t supported.

Once the capture is opened, all of the RenderDoc UI accessible data is immediately available and can be accessed directly, see RenderDoc UI Basics.

Accessing Capture Analysis

To access the ReplayController and any related core interfaces, a little bit of extra work is required. Within the UI, the replay work happens on a separate thread to prevent long-running tasks from causing the UI to become unresponsive. That means the ReplayController is not immediately available, but is provided to a callback on the right thread.

To invoke onto the right thread, you can use BlockInvoke() and pass it a callback that will be called with a single parameter - the ReplayController instance for the currently open capture.

Warning

There is another invoke function AsyncInvoke(), but due to Python’s limited threading capability the callback can’t be called while the script is executing, meaning this has limited use. For Python it is recommended to use BlockInvoke().

def myCallback(controller):
    print("%d top-level actions" % len(controller.GetRootActions()))

pyrenderdoc.Replay().BlockInvoke(myCallback)

If there is no replay active, the callback will be silently dropped.


Python development environment

This document outlines how to set up a development environment with suitable IDE type information for the RenderDoc modules. It’s entirely optional, and you can write your python code in whichever way makes most sense for you. We will be configuring the PyCharm IDE to have autocomplete for all RenderDoc types.

Building RenderDoc

The first step is to build RenderDoc from source to ensure you have a matching python module and RenderDoc build. Due to binary incompatibilities the python module can’t be widely distributed since it is linked against a specific python minor version.

Build instructions for your platform are available on github. Take note of the python version that you build against, since this will need to be used later.

Note

On windows by default RenderDoc builds against python 3.6 which is what it’s distributed with.

This can be overridden by setting an overridden path under the Python Configuration section in the properties of the qrenderdoc project and pyrenderdoc_module project. It must point to a python installation.

RenderDoc requires pythonXY.lib, include files such as include/Python.h, as well as a .zip of the standard library. If you installed python with an installer you have the first two, and can generate the standard library zip by zipping the contents of the Lib folder. If you downloaded the embeddable zip distribution you will only have the standard library zip, you need to obtain the include files and .lib file separately.

Once you have compiled RenderDoc copy the python module into the same folder as the main renderdoc library. On windows this means copying out of the pymodules subdirectory, on linux this will likely be the case already. We do this to keep things simple, so the python module can load the library without needing to change PATH.

Installing PyCharm

Now install PyCharm, for this document we will install 2020.3.2. Any version is fine, though newer versions may require modification to work properly.

Before you run PyCharm, we will replace one file in it to generate better type information for RenderDoc. In the RenderDoc repository there’s a pycharm_helpers folder. Copying the content of the plugins folder over the folder in your PyCharm installation will update the file that is customised. You can back it up beforehand at this path: plugins/python-ce/helpers/generator3/module_redeclarator.py.

If you’re using a different version of PyCharm you can try to apply the patch also available in that folder.

Configuring python module

You can now launch PyCharm and open or create the python project where you’ll be writing code. Now we’ll configure the python interpreter. This must match the python version that you built against above - the same major and minor version, and the same bitness (32-bit to 32-bit or 64-bit to 64-bit).

Go into File enter Settings. On the left you can go into the project and to Python Interpreter.

In the first entry click the gear next to Python Interpreter and choose Add if the interpreter you want isn’t available. You can now configure a System Interpreter with the correct version as above.

Once you’ve chosen the correct interpreter we’ll also tell it where to find the RenderDoc libraries since they won’t be in the default python path. Go back to the gear wheel but this time select Show All. With your chosen interpreter selected click on the tree icon at the bottom labeled Show paths for the selected interpreter and add the directory where you have the renderdoc and qrenderdoc modules, as well as the renderdoc library.

If everything went well, PyCharm should load that interpreter for the project and discover the renderdoc python modules. It will then generate stubs for them with correct typing information so you can benefit from proper autocomplete while writing python code.

Troubleshooting

If you get an error about “No module named ‘renderdoc’” then something has gone wrong with how the interpreter finds and loads the python module. Ensure you have the right path specified and that the interpreter is the correctly matching version for the python module you compiled.

To regenerate the generated python stubs delete your python_stubs folder in the JetBrains local cache. On windows this is in %LOCALAPPDATA%/JetBrains.


Writing UI extensions

This document outlines how to get started writing a UI extension. For information on how to configure, register and install a UI extension see How do I register a python extension?.

First steps

We start off with the basic registration function. Create an __init__.py in your extension’s root and fill it out:

import qrenderdoc as qrd

extiface_version = ''

def register(version: str, ctx: qrd.CaptureContext):
    global extiface_version
    extiface_version = version

    print("Registering my extension for RenderDoc version {}".format(version))

def unregister():
    print("Unregistering my extension")

Here we create the minimum register() and unregister() functions required for an extension to load, that just print a message. We store the interface version in a global which we can use in future to do version-checks if we want to be compatible with more than one RenderDoc version, since the python interface is not fully forwards and backwards compatible.

This doesn’t really do much, let’s register a tool menu item:

def menu_callback(ctx: qrd.CaptureContext, data):
    ctx.Extensions().MessageDialog("Hello from the extension!", "Extension message")

def register(version: str, ctx: qrd.CaptureContext):
    # as above ...

    ctx.Extensions().RegisterWindowMenu(qrd.WindowMenu.Tools, ["My extension"], menu_callback)

Now we have a new menu item which when clicked produces a popup message dialog!

Python extension generating a message box

This is a good proof of concept, but really we want something more directly usable. Instead of showing a message box, let’s show a window which reacts to the selected action by showing a series of breadcrumbs for marker labels.

Adding a window and capture viewer

First we create a class to handle our window and to derive from qrenderdoc.CaptureViewer to get callbacks for events.

class Window(qrd.CaptureViewer):
    def __init__(self, ctx: qrd.CaptureContext, version: str):
        super().__init__()

        self.mqt: qrd.MiniQtHelper = ctx.Extensions().GetMiniQtHelper()

        self.ctx = ctx
        self.version = version
        self.topWindow = self.mqt.CreateToplevelWidget("Breadcrumbs", lambda c, w, d: window_closed())

        ctx.AddCaptureViewer(self)

    def OnCaptureLoaded(self):
        pass

    def OnCaptureClosed(self):
        pass

    def OnSelectedEventChanged(self, event):
        pass

    def OnEventChanged(self, event):
        pass

Here we implement stubs for the different events. More information on when they are sent can be found in the class documentation. We use the qrenderdoc.MiniQtHelper to create a top-level window for ourselves with the ‘breadcrumbs’ title, then register oureslves as a capture viewer. The mini-Qt helper is useful to provide simple access to Qt widgets in a portable way from the RenderDoc UI, without relying on full Qt python bindings that may not be available depending on how RenderDoc was built.

We will need to unregister ourselves as a capture viewer when the window is closed, which happens in the window_closed() callback that we’ll define later.

An empty window is not very useful, so let’s give ourselves a label. More complex layouts and widgets are of course possible but for the moment we’ll keep it simple:

vert = self.mqt.CreateVerticalContainer()
self.mqt.AddWidget(self.topWindow, vert)

self.breadcrumbs = self.mqt.CreateLabel()

self.mqt.AddWidget(vert, self.breadcrumbs)

And finally we can fill in the event functions to set the breadcrumbs. We use @1234 syntax for events which causes them to be clickable links that jump to that event. You can also convert a renderdoc.ResourceId to a string with str() and it will similarly provide a link for that resource named with the current debug name.

def OnCaptureLoaded(self):
    self.mqt.SetWidgetText(self.breadcrumbs, "Breadcrumbs:")

def OnCaptureClosed(self):
    self.mqt.SetWidgetText(self.breadcrumbs, "Breadcrumbs:")

def OnSelectedEventChanged(self, event):
    pass

def OnEventChanged(self, event):
    action = self.ctx.GetAction(event)

    breadcrumbs = ''

    if action is not None:
        breadcrumbs = '@{}: {}'.format(action.eventId, action.customName)

        while action.parent is not None:
            action = action.parent
            breadcrumbs = '@{}: {}'.format(action.eventId, action.customName) + '\n' + breadcrumbs

    self.mqt.SetWidgetText(self.breadcrumbs, "Breadcrumbs:\n{}".format(breadcrumbs))

Finally we’ll register a new menu item to display the window. We only allow one window at once, so if it still exists we’ll just raise it. Otherwise we create a new one. This is also where we unregister the capture viewer:

from typing import Optional

cur_window: Optional[Window] = None

def window_closed():
    global cur_window
    if cur_window is not None:
        cur_window.ctx.RemoveCaptureViewer(cur_window)
    cur_window = None

def open_window_callback(ctx: qrd.CaptureContext, data):
    global cur_window

    mqt = ctx.Extensions().GetMiniQtHelper()

    if cur_window is None:
        cur_window = Window(ctx, extiface_version)
        if ctx.HasEventBrowser():
            ctx.AddDockWindow(cur_window.topWindow, qrd.DockReference.TopOf, ctx.GetEventBrowser().Widget(), 0.1)
        else:
            ctx.AddDockWindow(cur_window.topWindow, qrd.DockReference.MainToolArea, None)

    ctx.RaiseDockWindow(cur_window.topWindow)

def register(version: str, ctx: qrd.CaptureContext):
    # as above ...

    ctx.Extensions().RegisterWindowMenu(qrd.WindowMenu.Window, ["Extension Window"], open_window_callback)

def unregister():
    print("Unregistering my extension")

    global cur_window

    if cur_window is not None:
        # The window_closed() callback will unregister the capture viewer
        cur_window.ctx.Extensions().GetMiniQtHelper().CloseToplevelWidget(cur_window.topWindow)
        cur_window = None

With that we now have a new little breadcrumbs window that docks itself above our event browser to show where we are in the frame:

Python extension showing the current action’s breadcrumbs

Calling onto replay thread

So far this has worked well, but we’re only using information available on the UI thread. A good amount of useful information is cached on the UI thread including the current pipeline state and actions, but for some work we might want to call into the underlying analysis functions. When we do this we must do it on the replay thread to avoid blocking the UI if the analysis work takes a long time.

This can get quite complex so we will do something very simple, in the message box callback that we created earlier instead of displaying the message box immediately we will first figure out the minimum and maximum values for the current depth output or first colour output and display that.

To start with we can identify the resource on the UI thread, so let’s do that:

import renderdoc as rd

def menu_callback(ctx: qrd.CaptureContext, data):
    texid = rd.ResourceId.Null()
    depth = ctx.CurPipelineState().GetDepthTarget()

    # Prefer depth if possible
    if depth.resourceId != rd.ResourceId.Null():
        texid = depth.resourceId
    else:
        cols = ctx.CurPipelineState().GetOutputTargets()

        # See if we can get the first colour target instead
        if len(cols) > 1 and cols[0].resourceId != rd.ResourceId.Null():
            texid = cols[0].resourceId

    if texid == rd.ResourceId.Null():
        ctx.Extensions().MessageDialog("Couldn't find any bound target!", "Extension message")
        return

This all happens as before on the UI thread using UI-cached pipeline state data. If we can’t find a resource we just bail out, but otherwise we have texid with the texture we want to analyse.

To do this we invoke onto a different thread twice - first the UI thread invokes onto the replay thread to calculate the minimum and maximum values. Then that callback invokes back onto the UI thread to display a message.

if texid == rd.ResourceId.Null():
    ctx.Extensions().MessageDialog("Couldn't find any bound target!", "Extension message")
    return
else:
    mqt = ctx.Extensions().GetMiniQtHelper()
    texname = ctx.GetResourceName(texid)

    def get_minmax(r: rd.ReplayController):
        minvals, maxvals = r.GetMinMax(texid, rd.Subresource(), rd.CompType.Typeless)

        msg = '{} has min {:.4} and max {:.4} in red'.format(texname, minvals.floatValue[0], maxvals.floatValue[0])

        mqt.InvokeOntoUIThread(lambda: ctx.Extensions().MessageDialog(msg, "Extension message"))

    ctx.Replay().AsyncInvoke('', get_minmax)

Now that we’ve done that correctly our extension will be able to run in-depth replay analysis without calling functions from the wrong thread or stalling the UI.

Conclusion

Hopefully now from that worked example you have an idea of the basics of writing UI extensions. More complex examples can be found at the community contributed repository and the source code for this extension is available in the github repository


Basic Interfaces

This document explains some common interfaces and their relationship, which can be useful as a primer to understand where to get started, as well as for reference to look back on from later examples.

Replay Basics

ReplayController

The primary interface for accessing the low level of RenderDoc’s replay analysis is ReplayController.

From this interface, information about the capture can be gathered, using e.g. GetRootActions() to return the list of root-level actions in the frame, or GetResources() to return a list of all resources in the capture.

Some methods like the two above return information which is global and does not vary across the frame. Most functions however return information relative to the current point in the frame.

During RenderDoc’s replay, you can imagine a cursor that moves back and forth between the start and end of the frame. All requests for information that varies - such as texture and buffer contents, pipeline state, and other information will be relative to the current event.

Every function call within a frame is assigned an ascending eventId, from 1 up to as many events as are in the frame. Within the action list returned by GetRootActions(), each action contains a list of events in events. These contain all of the eventId that immediately preceeded the action. The details of the function call can be found by using chunkIndex as an index into the structured data returned from GetStructuredFile(). The structured data contains the function name and the complete set of parameters passed to it, with their values.

To change the current active event and move the cursor, you can call SetFrameEvent(). This will move the replay to represent the current state immediately after the given event has executed.

At this point you can use GetBufferData() and GetTextureData() to obtain the contents of a buffer or texture respectively. The pipeline state can be accessed via Get*PipelineState for each API - to determine the current capture’s pipeline type you can fetch the API properties from GetAPIProperties().

There is also an API-agnostic pipeline abstraction to return information that is the same across APIs. Using GetPipelineState() returns a PipeState which has accessors for fetching the current vertex buffers, shaders, and colour outputs. This allows you to write generic code that will work on any API that RenderDoc supports. The API-specific pipelines are still available through Get*PipelineState.

For more examples of how to fetch data, see the concrete examples below.

ReplayOutput

While ReplayController provides methods for obtaining data directly, it doesn’t provide any functionality for displaying to a window. For this the ReplayOutput class allows you to bind to a window and configure the output.

First you need to gather the platform-specific windowing information in a WindowingData. This class is opaque to python, but you can create it using helper functions such as CreateWin32WindowingData() and CreateXlibWindowingData(). The parameters to these are platform specific, and are typically accepted as integers where they refer to a windowing handle.

To then create an output for a window, CreateOutput() can create different types of outputs.

Once created, you can configure the output with SetMeshDisplay() and SetTextureDisplay() to update the configuration, and then call Display() to display on screen.

RenderDoc UI Basics

The RenderDoc UI provides a number of useful abstractions over the lower level API, which can be convenient when developing scripts. In addition it gives access to the different panels to allow limited control over them. The pyrenderdoc global is available to all scripts running within the RenderDoc UI, and it provides access to all of these things.

Each single-instance panel such as the TextureViewer or PipelineStateViewer has accessors within the CaptureContext.

Functions such as GetTextureViewer() will return a valid handle to the texture viewer, but if the texture viewer was closed then although it will be created it will not be immediately visible. You need to call ShowTextureViewer() first which will bring the texture viewer to the front and make sure it is visible and docked if it wasn’t already.

You can also create new instances of windows such as buffer or shader viewers using ViewBuffer() or ViewShader().

The CaptureContext interface also provides useful utility functions such as GetTexture() or GetAction() to look up objects by id instead of needing your own caching and lookup from the lists returned by the lower level interface.


renderdoc Examples

Here we have some examples of the lower level renderdoc API. Some may be only relevant when using the module directly, but most are general and can be followed either when running in python or in the UI.

In order to help with this, the examples are organised such that most code is written within a function that accepts the replay controller, and the code from Getting Started (python) runs only when standalone and not within the UI:

Note

While some of the samples will work within the UI, because they directly access the lower level API and skip the UI’s API, it may cause some state inconsistencies. See qrenderdoc examples for examples using the UI API directly.

def sampleCode(controller):
    print("Here we can use the replay controller")

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    cap,controller = loadCapture('test.rdc')

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()
  • Iterate Action tree
    • Example Source
  • Fetch Shader details
    • Example Source
  • Fetch GPU Counter Data
    • Example Source
  • Save a texture to disk
    • Example Source
  • Decoding Mesh Data
    • Example Source
  • Display texture in window
    • Example Source
  • Remote Capture and Replay
    • Example Source


Iterate Action tree

In this example we will show how to iterate over actions.

The actions returned from GetRootActions() are actions or marker regions at the root level - with no parent marker region. There are multiple ways to iterate through the list of actions.

The first way illustrated in this sample is to walk the tree using children, which contains the list of child actions at any point in the tree. There is also parent which points to the parent action.

The second is to use previous and next, which point to the previous and next action respectively in a linear fashion, regardless of nesting depth.

In the example we use this iteration to determine the number of passes, using the action flags to denote the start of each pass by a starting clear call.

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

# Define a recursive function for iterating over actions
def iterAction(d, indent = ''):
    # Print this action
    print('%s%d: %s' % (indent, d.eventId, d.GetName(controller.GetStructuredFile())))

    # Iterate over the action's children
    for d in d.children:
        iterAction(d, indent + '    ')

def sampleCode(controller):
    # Iterate over all of the root actions
    for d in controller.GetRootActions():
        iterAction(d)

    # Start iterating from the first real action as a child of markers
    action = controller.GetRootActions()[0]

    while len(action.children) > 0:
        action = action.children[0]

    # Counter for which pass we're in
    passnum = 0
    # Counter for how many actions are in the pass
    passcontents = 0
    # Whether we've started seeing actions in the pass - i.e. we're past any
    # starting clear calls that may be batched together
    inpass = False

    print("Pass #0 starts with %d: %s" % (action.eventId, action.GetName(controller.GetStructuredFile())))

    while action != None:
        # When we encounter a clear
        if action.flags & rd.ActionFlags.Clear:
            if inpass:
                print("Pass #%d contained %d actions" % (passnum, passcontents))
                passnum += 1
                print("Pass #%d starts with %d: %s" % (passnum, action.eventId, action.GetName(controller.GetStructuredFile())))
                passcontents = 0
                inpass = False
        else:
            passcontents += 1
            inpass = True

        # Advance to the next action
        action = action.next
        if action is None:
            break

    if inpass:
        print("Pass #%d contained %d actions" % (passnum, passcontents))

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return cap,controller

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    cap,controller = loadCapture(sys.argv[1])

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()

    rd.ShutdownReplay()

Sample output:

1: Scene
2: ID3D11DeviceContext::ClearRenderTargetView()
3: ID3D11DeviceContext::ClearDepthStencilView()
9: ID3D11DeviceContext::ClearRenderTargetView()
10: ID3D11DeviceContext::ClearRenderTargetView()
11: ID3D11DeviceContext::ClearDepthStencilView()
13: GBuffer
        25: Floor
        28: ID3D11DeviceContext::DrawIndexed()
        29: empty label
                30: ID3DUserDefinedAnnotation::EndEvent()
        40: Base
        43: ID3D11DeviceContext::DrawIndexed()
        53: Center sphere
        56: ID3D11DeviceContext::DrawIndexed()
        66: Cone
        69: ID3D11DeviceContext::DrawIndexed()
        79: Cone
        82: ID3D11DeviceContext::DrawIndexed()
        92: Cone
        95: ID3D11DeviceContext::DrawIndexed()
        105: Cone
        108: ID3D11DeviceContext::DrawIndexed()
        118: Cone
        121: ID3D11DeviceContext::DrawIndexed()
        131: Cone
        134: ID3D11DeviceContext::DrawIndexed()
        144: Cone
        147: ID3D11DeviceContext::DrawIndexed()
        157: Cone
        160: ID3D11DeviceContext::DrawIndexed()
        170: Cone
        173: ID3D11DeviceContext::DrawIndexed()
        183: Cone
        186: ID3D11DeviceContext::DrawIndexed()
        196: Sphere
        199: ID3D11DeviceContext::DrawIndexed()
        209: Sphere
        212: ID3D11DeviceContext::DrawIndexed()
        222: Sphere
        225: ID3D11DeviceContext::DrawIndexed()
        235: Sphere
        238: ID3D11DeviceContext::DrawIndexed()
        248: Sphere
        251: ID3D11DeviceContext::DrawIndexed()
        261: Sphere
        264: ID3D11DeviceContext::DrawIndexed()
        274: Sphere
        277: ID3D11DeviceContext::DrawIndexed()
        287: Sphere
        290: ID3D11DeviceContext::DrawIndexed()
        300: Sphere
        303: ID3D11DeviceContext::DrawIndexed()
        313: Sphere
        316: ID3D11DeviceContext::DrawIndexed()
        317: ID3DUserDefinedAnnotation::EndEvent()
319: ID3D11DeviceContext::ClearDepthStencilView()
321: Shadowmap
        330: Floor
        333: ID3D11DeviceContext::DrawIndexed()
        334: empty label
                335: ID3DUserDefinedAnnotation::EndEvent()
        342: Base
        345: ID3D11DeviceContext::DrawIndexed()
        352: Center sphere
        355: ID3D11DeviceContext::DrawIndexed()
        362: Cone
        365: ID3D11DeviceContext::DrawIndexed()
        372: Cone
        375: ID3D11DeviceContext::DrawIndexed()
        382: Cone
        385: ID3D11DeviceContext::DrawIndexed()
        392: Cone
        395: ID3D11DeviceContext::DrawIndexed()
        402: Cone
        405: ID3D11DeviceContext::DrawIndexed()
        412: Cone
        415: ID3D11DeviceContext::DrawIndexed()
        422: Cone
        425: ID3D11DeviceContext::DrawIndexed()
        432: Cone
        435: ID3D11DeviceContext::DrawIndexed()
        442: Cone
        445: ID3D11DeviceContext::DrawIndexed()
        452: Cone
        455: ID3D11DeviceContext::DrawIndexed()
        462: Sphere
        465: ID3D11DeviceContext::DrawIndexed()
        472: Sphere
        475: ID3D11DeviceContext::DrawIndexed()
        482: Sphere
        485: ID3D11DeviceContext::DrawIndexed()
        492: Sphere
        495: ID3D11DeviceContext::DrawIndexed()
        502: Sphere
        505: ID3D11DeviceContext::DrawIndexed()
        512: Sphere
        515: ID3D11DeviceContext::DrawIndexed()
        522: Sphere
        525: ID3D11DeviceContext::DrawIndexed()
        532: Sphere
        535: ID3D11DeviceContext::DrawIndexed()
        542: Sphere
        545: ID3D11DeviceContext::DrawIndexed()
        552: Sphere
        555: ID3D11DeviceContext::DrawIndexed()
        556: ID3DUserDefinedAnnotation::EndEvent()
558: ID3D11DeviceContext::ClearRenderTargetView()
559: ID3D11DeviceContext::ClearDepthStencilView()
561: Lighting
        563: ID3D11DeviceContext::ClearRenderTargetView()
        564: ID3D11DeviceContext::ClearRenderTargetView()
        566: Point light
        580: ID3D11DeviceContext::DrawIndexed()
        581: Sun light
        597: ID3D11DeviceContext::DrawIndexed()
        600: Cube light
        614: ID3D11DeviceContext::DrawIndexed()
        615: ID3DUserDefinedAnnotation::EndEvent()
617: ID3D11DeviceContext::ClearRenderTargetView()
618: ID3D11DeviceContext::ClearDepthStencilView()
620: Shading
        630: ID3D11DeviceContext::Draw()
        645: ID3D11DeviceContext::DrawIndexed()
        652: ID3DUserDefinedAnnotation::EndEvent()
653: ID3DUserDefinedAnnotation::EndEvent()
654: Present(ResourceId::47)
Pass #0 starts with 2: ID3D11DeviceContext::ClearRenderTargetView()
Pass #0 contained 23 actions
Pass #1 starts with 319: ID3D11DeviceContext::ClearDepthStencilView()
Pass #1 contained 23 actions
Pass #2 starts with 558: ID3D11DeviceContext::ClearRenderTargetView()
Pass #2 contained 3 actions
Pass #3 starts with 617: ID3D11DeviceContext::ClearRenderTargetView()
Pass #3 contained 3 actions


Fetch Shader details

In this example we will fetch the disassembly for a shader and a set of constant values.

When disassembling a shader there may be more than one possible representation available, so we first enumerate the formats that are available using GetDisassemblyTargets() before selecting a target to disassemble to. The first target is always a reasonable default, and there will be at least one. GetDisassemblyTargets() takes a parameter indicating whether the pipeline state object will be available - some disassembly targets require the full pipeline and are not available when disassembling only a shader in isolation:

print("Available disassembly formats:")

targets = controller.GetDisassemblyTargets(True)

for disasm in targets:
    print("  - " + disasm)

target = targets[0]

Next we fetch any ancillary data that might be needed to disassemble - this varies by API depending on whether it supports multiple entry points per shader, or has a concept of pipeline state objects that are used together with a shader to disassemble.

For the purposes of this example we use the API abstraction PipeState so that this code works on a capture from any API, so we fetch the state bindings that we need. Finally we fetch the disassembled shader string with DisassembleShader() and print it:

    state = controller.GetPipelineState()

    # For some APIs, it might be relevant to set the PSO id or entry point name
    pipe = state.GetGraphicsPipelineObject()
    entry = state.GetShaderEntryPoint(rd.ShaderStage.Pixel)

    # Get the pixel shader's reflection object
    ps = state.GetShaderReflection(rd.ShaderStage.Pixel)

    cb = state.GetConstantBuffer(rd.ShaderStage.Pixel, 0, 0)

print("Pixel shader:")
print(controller.DisassembleShader(pipe, ps.reflection, target))

Now we want to display the constants bound to this shader. Shader bindings is an area that diverges quite a lot between the APIs, and RenderDoc’s abstraction over this is detailed in BindPointMap. For now, we’ll simply select the first constant buffer in this shader and fetch the constants for it with GetCBufferVariableContents().

cbufferVars = controller.GetCBufferVariableContents(pipe, ps.resourceId, rd.ShaderStage.Pixel, entry, 0, cb.resourceId, 0, 0)

Since constants can contain structs of other constants, we want to define a recursive function that will iterate over a constant and print it along with its value. We want to handle both vectors and matrices so we need to iterate over both rows and columns for each variable.

def printVar(v, indent = ''):
    print(indent + v.name + ":")

    if len(v.members) == 0:
        valstr = ""
        for r in range(0, v.rows):
            valstr += indent + '  '

            for c in range(0, v.columns):
                valstr += '%.3f ' % v.value.fv[r*v.columns + c]

            if r < v.rows-1:
                valstr += "\n"

        print(valstr)

    for v in v.members:
        printVar(v, indent + '    ')

Finally, we iterate over the constants that we fetched earlier calling the function for each.

for v in cbufferVars:
    printVar(v)

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

def printVar(v, indent = ''):
    print(indent + v.name + ":")

    if len(v.members) == 0:
        valstr = ""
        for r in range(0, v.rows):
            valstr += indent + '  '

            for c in range(0, v.columns):
                valstr += '%.3f ' % v.value.fv[r*v.columns + c]

            if r < v.rows-1:
                valstr += "\n"

        print(valstr)

    for v in v.members:
        printVar(v, indent + '    ')

def sampleCode(controller):
    print("Available disassembly formats:")

    targets = controller.GetDisassemblyTargets(True)

    for disasm in targets:
        print("  - " + disasm)

    target = targets[0]

    state = controller.GetPipelineState()

    # For some APIs, it might be relevant to set the PSO id or entry point name
    pipe = state.GetGraphicsPipelineObject()
    entry = state.GetShaderEntryPoint(rd.ShaderStage.Pixel)

    # Get the pixel shader's reflection object
    ps = state.GetShaderReflection(rd.ShaderStage.Pixel)

    cb = state.GetConstantBuffer(rd.ShaderStage.Pixel, 0, 0)

    print("Pixel shader:")
    print(controller.DisassembleShader(pipe, ps, target))

    cbufferVars = controller.GetCBufferVariableContents(pipe, ps.resourceId, rd.ShaderStage.Pixel, entry, 0, cb.resourceId, 0, 0)

    for v in cbufferVars:
        printVar(v)

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return (cap, controller)

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    cap,controller = loadCapture(sys.argv[1])

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()

    rd.ShutdownReplay()

Sample output:

Available disassembly formats:
- DXBC
- AMD GCN ISA
Pixel shader:
Shader hash 9dd8337a-c75dd787-1fa0f07e-5f39f955

ps_5_0
    dcl_globalFlags refactoringAllowed
    dcl_constantbuffer cb0[8], immediateIndexed
    dcl_sampler gDepthSam (s0), mode_default
    dcl_resource_texture2d (float,float,float,float) gDepthMap (t0)
    dcl_resource_texture2d (float,float,float,float) gGBufferMap (t1)
    dcl_input_ps linear v1.xyz
    dcl_input_ps linear v2.xyw
    dcl_output o0.xyzw
    dcl_output o1.xyzw
    dcl_temps 6

0: nop
1: mov r0.xyz, v2.xywx
2: div r0.xy, r0.xyxx, r0.zzzz
3: mul r0.xy, r0.xyxx, l(0.500000, -0.500000, 0.000000, 0.000000)
4: add r0.xy, r0.xyxx, l(0.500000, 0.500000, 0.000000, 0.000000)
5: mov r0.xy, r0.xyxx
6: sample_indexable(texture2d)(float,float,float,float) r0.z, r0.xyxx, gDepthMap.yzxw, gDepthSam
7: mov r0.z, r0.z
8: nop
9: mov r0.z, r0.z
10: mov r0.z, -r0.z
11: add r0.z, r0.z, l(1.001801)
12: div r0.z, l(0.421448), r0.z
13: mov r0.z, r0.z
14: dp3 r0.w, v1.xyzx, v1.xyzx
15: rsq r0.w, r0.w
16: mul r1.xyz, r0.wwww, v1.xyzx
17: div r0.z, r0.z, r1.z
18: mul r2.xyz, r0.zzzz, r1.xyzx
19: sample_indexable(texture2d)(float,float,float,float) r0.xyzw, r0.xyxx, gGBufferMap.xyzw, gDepthSam
20: dp3 r1.w, r0.xyzx, r0.xyzx
21: rsq r1.w, r1.w
22: mul r0.xyz, r0.xyzx, r1.wwww
23: mov r3.xyz, gLightPosV.xyzx
24: mov r4.xyz, -r2.xyzx
25: add r4.xyz, r3.xyzx, r4.xyzx
26: dp3 r1.w, r4.xyzx, r4.xyzx
27: rsq r1.w, r1.w
28: mul r4.xyz, r1.wwww, r4.xyzx
29: dp3 r1.w, r0.xyzx, r4.xyzx
30: max r5.x, r1.w, l(0)
31: nop
32: mov r1.xyz, -r1.xyzx
33: add r1.xyz, r1.xyzx, r4.xyzx
34: dp3 r1.w, r1.xyzx, r1.xyzx
35: rsq r1.w, r1.w
36: mul r1.xyz, r1.wwww, r1.xyzx
37: mov r0.xyz, r0.xyzx
38: mul r0.w, r0.w, l(64.000000)
39: dp3 r0.x, r1.xyzx, r0.xyzx
40: max r0.x, r0.x, l(0)
41: log r0.x, r0.x
42: mul r0.x, r0.x, r0.w
43: exp r5.y, r0.x
44: mov r5.y, r5.y
45: nop
46: mov r3.xyz, r3.xyzx
47: mov r2.xyz, r2.xyzx
48: mov r0.xyz, gLight.att.xyzx
49: mov r1.xyz, -r2.xyzx
50: add r1.xyz, r1.xyzx, r3.xyzx
51: dp3 r0.w, r1.xyzx, r1.xyzx
52: sqrt r0.w, r0.w
53: mul r0.y, r0.y, r0.w
54: add r0.x, r0.y, r0.x
55: mul r0.y, r0.w, r0.w
56: mul r0.y, r0.z, r0.y
57: add r0.x, r0.y, r0.x
58: div r0.x, l(1.000000), r0.x
59: mov r0.x, r0.x
60: mul r0.xy, r5.xyxx, r0.xxxx
61: max r0.xy, r0.xyxx, l(0, 0, 0, 0)
62: mul o0.xyzw, r0.xxxx, gLight.diffuse.xyzw
63: mul o1.xyzw, r0.yyyy, gLight.diffuse.xyzw
64: ret

gLight:
    pos:
    -2.022 2.000 -3.694
    dir:
    0.000 0.000 0.000
    ambient:
    0.300 0.300 0.300 1.000
    diffuse:
    0.300 1.000 0.600 1.000
    spec:
    0.500 0.500 0.500 1.000
    att:
    0.000 0.200 0.100
    spotPower:
    0.000
    range:
    3.000
gLightPosV:
    -2.022 0.200 6.306 -107374176.000
gLigthDirES:
    -0.298 -0.596 -0.745
gWorldViewProj:
    1.567 0.000 0.000 0.000
    0.000 2.414 0.000 0.000
    0.000 0.000 1.002 1.000
    -3.169 0.483 5.896 6.306
gWorldView:
    1.000 0.000 0.000 0.000
    0.000 1.000 0.000 0.000
    0.000 0.000 1.000 0.000
    -2.022 0.200 6.306 1.000


Fetch GPU Counter Data

In this example we will gather GPU counter data over a capture and find any actions that completely failed the depth/stencil test.

The first thing we do is enumerate a list of counters that the implementation supports using EnumerateCounters(). A few of these counters values are statically known - see GPUCounter. If you know which counter you want ahead of time you can continue straight away by calling FetchCounters() with a list of counters to sample from, or DescribeCounter() to obtain a CounterDescription of the counter itself:

# Enumerate the available counters
counters = controller.EnumerateCounters()

if not (rd.GPUCounter.SamplesPassed in counters):
        raise RuntimeError("Implementation doesn't support Samples Passed counter")

# Now we fetch the counter data, this is a good time to batch requests of as many
# counters as possible, the implementation handles any book keeping.
results = controller.FetchCounters([rd.GPUCounter.SamplesPassed])

# Get the description for the counter we want
samplesPassedDesc = controller.DescribeCounter(rd.GPUCounter.SamplesPassed)

However we will also print all available counters. If the implementation supports vendor-specific counters they will be enumerated as well and we can print their descriptions.

# Describe each counter
for c in counters:
        desc = controller.DescribeCounter(c)

        print("Counter %d (%s):" % (c, desc.name))
        print("    %s" % desc.description)
        print("    Returns %d byte %s, representing %s" % (desc.resultByteWidth, desc.resultType, desc.unit))

Once we have the list of CounterResult from sampling the specified counters, each result returned is for one counter on one event. Since we only fetched one counter we can simply iterate over the results looking up the action for each. For actual draws (excluding clears and markers etc) we use the counter description to determine the data payload size, and get the value out. Interpreting this can either happen based on the description, or in our case we know that this counter returns a simple value we can check:

# Look in the results for any draws with 0 samples written - this is an indication
# that if a lot of draws appear then culling could be better.
for r in results:
        draw = actions[r.eventId]

        # Only care about draws, not about clears and other misc events
        if not (draw.flags & rd.ActionFlags.Drawcall):
                continue

        if samplesPassedDesc.resultByteWidth == 4:
                val = r.value.u32
        else:
                val = r.value.u64

        if val == 0:
                print("EID %d '%s' had no samples pass depth/stencil test!" % (r.eventId, draw.GetName(controller.GetStructuredFile())))

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

actions = {}

# Define a recursive function for iterating over actions
def iterDraw(d, indent = ''):
    global actions

    # save the action by eventId
    actions[d.eventId] = d

    # Iterate over the draw's children
    for d in d.children:
        iterDraw(d, indent + '    ')

def sampleCode(controller):
    # Iterate over all of the root actions, so we have names for each
    # eventId
    for d in controller.GetRootActions():
        iterDraw(d)

    # Enumerate the available counters
    counters = controller.EnumerateCounters()

    if not (rd.GPUCounter.SamplesPassed in counters):
        raise RuntimeError("Implementation doesn't support Samples Passed counter")

    # Now we fetch the counter data, this is a good time to batch requests of as many
    # counters as possible, the implementation handles any book keeping.
    results = controller.FetchCounters([rd.GPUCounter.SamplesPassed])

    # Get the description for the counter we want
    samplesPassedDesc = controller.DescribeCounter(rd.GPUCounter.SamplesPassed)

    # Describe each counter
    for c in counters:
        desc = controller.DescribeCounter(c)

        print("Counter %d (%s):" % (c, desc.name))
        print("    %s" % desc.description)
        print("    Returns %d byte %s, representing %s" % (desc.resultByteWidth, desc.resultType, desc.unit))

    # Look in the results for any draws with 0 samples written - this is an indication
    # that if a lot of draws appear then culling could be better.
    for r in results:
        draw = actions[r.eventId]

        # Only care about draws, not about clears and other misc events
        if not (draw.flags & rd.ActionFlags.Drawcall):
            continue

        if samplesPassedDesc.resultByteWidth == 4:
            val = r.value.u32
        else:
            val = r.value.u64

        if val == 0:
            print("EID %d '%s' had no samples pass depth/stencil test!" % (r.eventId, draw.GetName(controller.GetStructuredFile())))

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return cap,controller

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    cap,controller = loadCapture(sys.argv[1])

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()

    rd.ShutdownReplay()

Sample output:

Counter 1 (GPU Duration):
    Time taken for this event on the GPU, as measured by delta between two GPU timestamps.
    Returns 8 byte CompType.Float, representing CounterUnit.Seconds
Counter 2 (Input Vertices Read):
    Number of vertices read by input assembler.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 3 (Input Primitives):
    Number of primitives read by the input assembler.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 4 (GS Primitives):
    Number of primitives output by a geometry shader.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 5 (Rasterizer Invocations):
    Number of primitives that were sent to the rasterizer.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 6 (Rasterized Primitives):
    Number of primitives that were rendered.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 7 (Samples Passed):
    Number of samples that passed depth/stencil test.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
    ... which we will sample
Counter 8 (VS Invocations):
    Number of times a vertex shader was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 9 (HS Invocations):
    Number of times a hull shader was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 10 (DS Invocations):
    Number of times a domain shader (or tesselation evaluation shader in OpenGL) was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 11 (GS Invocations):
    Number of times a geometry shader was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 12 (PS Invocations):
    Number of times a pixel shader was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
Counter 13 (CS Invocations):
    Number of times a compute shader was invoked.
    Returns 8 byte CompType.UInt, representing CounterUnit.Absolute
EID 69 'DrawIndexed()' had no samples pass depth/stencil test!
EID 82 'DrawIndexed()' had no samples pass depth/stencil test!
EID 95 'DrawIndexed()' had no samples pass depth/stencil test!
EID 108 'DrawIndexed()' had no samples pass depth/stencil test!
EID 199 'DrawIndexed()' had no samples pass depth/stencil test!
EID 212 'DrawIndexed()' had no samples pass depth/stencil test!
EID 225 'DrawIndexed()' had no samples pass depth/stencil test!
EID 238 'DrawIndexed()' had no samples pass depth/stencil test!


Save a texture to disk

In this example we will find a particular action, and save the color output to disk as an image file.

To begin with, so that we have an interesting action selected we iterate over the list of actions finding the draw with the highest vertex count. For more on how to iterate through a capture’s list of actions, see Iterate Action tree.

Once we have set the draw we want as the current event, we can configure the texture save operation. To do this we create a TextureSave object. The properties of the object determine how the texture will be mapped to an image file to be saved to disk.

At minimum you need to select a file format, and we’ll try a few - JPG, HDR, PNG, and DDS.

For JPG and HDR, alpha is not supported so we choose to blend to a checkerboard pattern in RGB, so the alpha is ‘visible’. You can also choose other alpha operations. For the other formats they support alpha natively so we preserve it.

DDS is the only format that supports mip levels and array slices, so we choose to keep all of these in the output file instead of selecting only one. It is also possible to map array slices into a grid to display an array texture in a single-image format.

DDS will also support the exact format that the texture is in, rather than encoding it to a different precision.

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

# Recursively search for the drawcall with the most vertices
def biggestDraw(prevBiggest, d):
    ret = prevBiggest
    if ret == None or d.numIndices > ret.numIndices:
        ret = d

    for c in d.children:
        biggest = biggestDraw(ret, c)

        if biggest.numIndices > ret.numIndices:
            ret = biggest

    return ret

def sampleCode(controller):
    # Find the biggest drawcall in the whole capture
    draw = None
    for d in controller.GetRootActions():
        draw = biggestDraw(draw, d)

    # Move to that draw
    controller.SetFrameEvent(draw.eventId, True)

    texsave = rd.TextureSave()

    # Select the first color output
    texsave.resourceId = draw.outputs[0]

    if texsave.resourceId == rd.ResourceId.Null():
        return

    filename = str(int(texsave.resourceId))

    print("Saving images of %s at %d: %s" % (filename, draw.eventId, draw.GetName(controller.GetStructuredFile())))

    # Save different types of texture

    # Blend alpha to a checkerboard pattern for formats without alpha support
    texsave.alpha = rd.AlphaMapping.BlendToCheckerboard

    # Most formats can only display a single image per file, so we select the
    # first mip and first slice
    texsave.mip = 0
    texsave.slice.sliceIndex = 0

    texsave.destType = rd.FileType.JPG
    controller.SaveTexture(texsave, filename + ".jpg")

    texsave.destType = rd.FileType.HDR
    controller.SaveTexture(texsave, filename + ".hdr")

    # For formats with an alpha channel, preserve it
    texsave.alpha = rd.AlphaMapping.Preserve

    texsave.destType = rd.FileType.PNG
    controller.SaveTexture(texsave, filename + ".png")

    # DDS textures can save multiple mips and array slices, so instead
    # of the default behaviour of saving mip 0 and slice 0, we set -1
    # which saves *all* mips and slices
    texsave.mip = -1
    texsave.slice.sliceIndex = -1

    texsave.destType = rd.FileType.DDS
    controller.SaveTexture(texsave, filename + ".dds")

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return (cap, controller)

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    cap,controller = loadCapture(sys.argv[1])

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()

    rd.ShutdownReplay()


Decoding Mesh Data

In this example we will fetch the geometry inputs to and outputs from a vertex shader. While this sample does not handle all possible edge cases, it is more complex than most others.

First we gather the API state that describes the vertex input data. In this example we will use the API abstraction PipeState so that this code works on a capture from any API:

state = controller.GetPipelineState()

# Get the index & vertex buffers, and fixed vertex inputs
ib = state.GetIBuffer()
vbs = state.GetVBuffers()
attrs = state.GetVertexInputs()

We iterate over every attribute defined, and create an object that describes where to source it from, based on MeshFormat - since that is the format returned by GetPostVSData() this allows us to re-use code.

In the object we pass both the indices (which does not vary per attribute in our case) as well as the data for the vertex buffer the attribute comes from.

for attr in attrs:
        # We don't handle instance attributes
        if attr.perInstance:
                raise RuntimeError("Instanced properties are not supported!")

        meshInput = MeshData()
        meshInput.indexResourceId = ib.resourceId
        meshInput.indexByteOffset = ib.byteOffset
        meshInput.indexByteStride = ib.byteStride
        meshInput.baseVertex = draw.baseVertex
        meshInput.indexOffset = draw.indexOffset
        meshInput.numIndices = draw.numIndices

        # If the draw doesn't use an index buffer, don't use it even if bound
        if not (draw.flags & rd.ActionFlags.Indexed):
                meshInput.indexResourceId = rd.ResourceId.Null()

        # The total offset is the attribute offset from the base of the vertex
        meshInput.vertexByteOffset = attr.byteOffset + vbs[attr.vertexBuffer].byteOffset + draw.vertexOffset * vbs[attr.vertexBuffer].byteStride
        meshInput.format = attr.format
        meshInput.vertexResourceId = vbs[attr.vertexBuffer].resourceId
        meshInput.vertexByteStride = vbs[attr.vertexBuffer].byteStride
        meshInput.name = attr.name

        meshInputs.append(meshInput)

Next we fetch the index data using GetBufferData(), applying any offsets that might be present, and decode it using python’s struct module. If we’re not using index buffers, then we just generate a range of indices from the first vertex up to the number of indices.

def getIndices(controller, mesh):
    # Get the character for the width of index
    indexFormat = 'B'
    if mesh.indexByteStride == 2:
        indexFormat = 'H'
    elif mesh.indexByteStride == 4:
        indexFormat = 'I'

    # Duplicate the format by the number of indices
    indexFormat = str(mesh.numIndices) + indexFormat

    # If we have an index buffer
    if mesh.indexResourceId != rd.ResourceId.Null():
        # Fetch the data
        ibdata = controller.GetBufferData(mesh.indexResourceId, mesh.indexByteOffset, 0)

        # Unpack all the indices, starting from the first index to fetch
        offset = mesh.indexOffset * mesh.indexByteStride
        indices = struct.unpack_from(indexFormat, ibdata, offset)

        # Apply the baseVertex offset
        return [i + mesh.baseVertex for i in indices]
    else:
        # With no index buffer, just generate a range
        return tuple(range(mesh.numIndices))

To begin with, we define a helper that will read a given variable out of a bytes object, using a ResourceFormat do define the size and format of the data.

We only handle simple regular formatted types, rather than bit-packed types, to simplify the code. As a shortcut, we use a hash of strings, where the hash key is the component type, and then the character index in the string is the byte width. This gives us the struct.unpack character to decode one component of the variable, then we prepend the number of components to fetch.

For normalised formats - UNorm and SNorm - we also divide the resulting integer value to get the final floating point value used.

# Unpack a tuple of the given format, from the data
def unpackData(fmt, data):
    # We don't handle 'special' formats - typically bit-packed such as 10:10:10:2
    if fmt.Special():
        raise RuntimeError("Packed formats are not supported!")

    formatChars = {}
    #                                 012345678
    formatChars[rd.CompType.UInt]  = "xBHxIxxxL"
    formatChars[rd.CompType.SInt]  = "xbhxixxxl"
    formatChars[rd.CompType.Float] = "xxexfxxxd" # only 2, 4 and 8 are valid

    # These types have identical decodes, but we might post-process them
    formatChars[rd.CompType.UNorm] = formatChars[rd.CompType.UInt]
    formatChars[rd.CompType.UScaled] = formatChars[rd.CompType.UInt]
    formatChars[rd.CompType.SNorm] = formatChars[rd.CompType.SInt]
    formatChars[rd.CompType.SScaled] = formatChars[rd.CompType.SInt]

    # We need to fetch compCount components
    vertexFormat = str(fmt.compCount) + formatChars[fmt.compType][fmt.compByteWidth]

    # Unpack the data
    value = struct.unpack_from(vertexFormat, data, 0)

    # If the format needs post-processing such as normalisation, do that now
    if fmt.compType == rd.CompType.UNorm:
        divisor = float((2 ** (fmt.compByteWidth * 8)) - 1)
        value = tuple(float(i) / divisor for i in value)
    elif fmt.compType == rd.CompType.SNorm:
        maxNeg = -float(2 ** (fmt.compByteWidth * 8)) / 2
        divisor = float(-(maxNeg-1))
        value = tuple((float(i) if (i == maxNeg) else (float(i) / divisor)) for i in value)

    # If the format is BGRA, swap the two components
    if fmt.BGRAOrder():
        value = tuple(value[i] for i in [2, 1, 0, 3])

    return value

Finally with that helper defined we can iterate over each attribute for the first three indices:

indices = getIndices(controller, meshData[0])

# We'll decode the first three indices making up a triangle
for i in range(0, 3):
        idx = indices[i]

        print("Vertex %d is index %d:" % (i, idx))

for attr in meshData:

Using the index, we can fetch the right vertex data for each vertex’s attribute using GetBufferData() again. This simplified approach is very wasteful since we re-fetch the same vertex data for each vertex buffer over and over. A more realistic sample would cache the vertex data:

# This is the data we're reading from. This would be good to cache instead of
# re-fetching for every attribute for every index
offset = attr.vertexByteOffset + attr.vertexByteStride * idx
data = controller.GetBufferData(attr.vertexResourceId, offset, 0)

# Get the value from the data
value = unpackData(attr.format, data)

# We don't go into the details of semantic matching here, just print both
print("\tAttribute '%s': %s" % (attr.name, str(value)))

For the vertex outputs, we do something very similar but instead of fetching the attributes from state bindings, we look at the shader reflection data of the vertex. Similarly instead of fetching the vertex byte data from bound vertex buffers, we call GetPostVSData() to fetch it from the analysis.

In the case of vertex outputs there is no explicit offset available, so we calculate our own offsets. Note that for some APIs like Vulkan the outputs are not necessarily tightly packed, so padding calculations may be necessary.

The position output is also treated specially - it always appears first, regardless of the actual order of the outputs. We solve this by noting which output is the builtin position output, and shuffling it to the start of the array.

posidx = 0

vs = controller.GetPipelineState().GetShaderReflection(rd.ShaderStage.Vertex)

# Repeat the process, but this time sourcing the data from postvs.
# Since these are outputs, we iterate over the list of outputs from the
# vertex shader's reflection data
for attr in vs.outputSignature:
        # Copy most properties from the postvs struct
        meshOutput = MeshData()
        meshOutput.indexResourceId = postvs.indexResourceId
        meshOutput.indexByteOffset = postvs.indexByteOffset
        meshOutput.indexByteStride = postvs.indexByteStride
        meshOutput.baseVertex = postvs.baseVertex
        meshOutput.indexOffset = 0
        meshOutput.numIndices = postvs.numIndices

        # The total offset is the attribute offset from the base of the vertex,
        # as calculated by the stride per index
        meshOutput.vertexByteOffset = postvs.vertexByteOffset
        meshOutput.vertexResourceId = postvs.vertexResourceId
        meshOutput.vertexByteStride = postvs.vertexByteStride

        # Construct a resource format for this element
        meshOutput.format = rd.ResourceFormat()
        meshOutput.format.compByteWidth = rd.VarTypeByteSize(attr.varType)
        meshOutput.format.compCount = attr.compCount
        meshOutput.format.compType = rd.VarTypeCompType(attr.varType)
        meshOutput.format.type = rd.ResourceFormatType.Regular

        meshOutput.name = attr.semanticIdxName if attr.varName == '' else attr.varName

        if attr.systemValue == rd.ShaderBuiltin.Position:
                posidx = len(meshOutputs)

        meshOutputs.append(meshOutput)

# Shuffle the position element to the front
if posidx > 0:
        pos = meshOutputs[posidx]
        del meshOutputs[posidx]
        meshOutputs.insert(0, pos)

accumOffset = 0

for i in range(0, len(meshOutputs)):
        meshOutputs[i].vertexByteOffset = accumOffset

        # Note that some APIs such as Vulkan will pad the size of the attribute here
        # while others will tightly pack
        fmt = meshOutputs[i].format

        accumOffset += (8 if fmt.compByteWidth > 4 else 4) * fmt.compCount

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

# We'll need the struct data to read out of bytes objects
import struct

# We base our data on a MeshFormat, but we add some properties
class MeshData(rd.MeshFormat):
    indexOffset = 0
    name = ''

# Recursively search for the drawcall with the most vertices
def biggestDraw(prevBiggest, d):
    ret = prevBiggest
    if ret == None or d.numIndices > ret.numIndices:
        ret = d

    for c in d.children:
        biggest = biggestDraw(ret, c)

        if biggest.numIndices > ret.numIndices:
            ret = biggest

    return ret

# Unpack a tuple of the given format, from the data
def unpackData(fmt, data):
    # We don't handle 'special' formats - typically bit-packed such as 10:10:10:2
    if fmt.Special():
        raise RuntimeError("Packed formats are not supported!")

    formatChars = {}
    #                                 012345678
    formatChars[rd.CompType.UInt]  = "xBHxIxxxL"
    formatChars[rd.CompType.SInt]  = "xbhxixxxl"
    formatChars[rd.CompType.Float] = "xxexfxxxd" # only 2, 4 and 8 are valid

    # These types have identical decodes, but we might post-process them
    formatChars[rd.CompType.UNorm] = formatChars[rd.CompType.UInt]
    formatChars[rd.CompType.UScaled] = formatChars[rd.CompType.UInt]
    formatChars[rd.CompType.SNorm] = formatChars[rd.CompType.SInt]
    formatChars[rd.CompType.SScaled] = formatChars[rd.CompType.SInt]

    # We need to fetch compCount components
    vertexFormat = str(fmt.compCount) + formatChars[fmt.compType][fmt.compByteWidth]

    # Unpack the data
    value = struct.unpack_from(vertexFormat, data, 0)

    # If the format needs post-processing such as normalisation, do that now
    if fmt.compType == rd.CompType.UNorm:
        divisor = float((2 ** (fmt.compByteWidth * 8)) - 1)
        value = tuple(float(i) / divisor for i in value)
    elif fmt.compType == rd.CompType.SNorm:
        maxNeg = -float(2 ** (fmt.compByteWidth * 8)) / 2
        divisor = float(-(maxNeg-1))
        value = tuple((float(i) if (i == maxNeg) else (float(i) / divisor)) for i in value)

    # If the format is BGRA, swap the two components
    if fmt.BGRAOrder():
        value = tuple(value[i] for i in [2, 1, 0, 3])

    return value

# Get a list of MeshData objects describing the vertex inputs at this draw
def getMeshInputs(controller, draw):
    state = controller.GetPipelineState()

    # Get the index & vertex buffers, and fixed vertex inputs
    ib = state.GetIBuffer()
    vbs = state.GetVBuffers()
    attrs = state.GetVertexInputs()

    meshInputs = []

    for attr in attrs:

        # We don't handle instance attributes
        if attr.perInstance:
            raise RuntimeError("Instanced properties are not supported!")

        meshInput = MeshData()
        meshInput.indexResourceId = ib.resourceId
        meshInput.indexByteOffset = ib.byteOffset
        meshInput.indexByteStride = ib.byteStride
        meshInput.baseVertex = draw.baseVertex
        meshInput.indexOffset = draw.indexOffset
        meshInput.numIndices = draw.numIndices

        # If the draw doesn't use an index buffer, don't use it even if bound
        if not (draw.flags & rd.ActionFlags.Indexed):
            meshInput.indexResourceId = rd.ResourceId.Null()

        # The total offset is the attribute offset from the base of the vertex
        meshInput.vertexByteOffset = attr.byteOffset + vbs[attr.vertexBuffer].byteOffset + draw.vertexOffset * vbs[attr.vertexBuffer].byteStride
        meshInput.format = attr.format
        meshInput.vertexResourceId = vbs[attr.vertexBuffer].resourceId
        meshInput.vertexByteStride = vbs[attr.vertexBuffer].byteStride
        meshInput.name = attr.name

        meshInputs.append(meshInput)

    return meshInputs

# Get a list of MeshData objects describing the vertex outputs at this draw
def getMeshOutputs(controller, postvs):
    meshOutputs = []
    posidx = 0

    vs = controller.GetPipelineState().GetShaderReflection(rd.ShaderStage.Vertex)

    # Repeat the process, but this time sourcing the data from postvs.
    # Since these are outputs, we iterate over the list of outputs from the
    # vertex shader's reflection data
    for attr in vs.outputSignature:
        # Copy most properties from the postvs struct
        meshOutput = MeshData()
        meshOutput.indexResourceId = postvs.indexResourceId
        meshOutput.indexByteOffset = postvs.indexByteOffset
        meshOutput.indexByteStride = postvs.indexByteStride
        meshOutput.baseVertex = postvs.baseVertex
        meshOutput.indexOffset = 0
        meshOutput.numIndices = postvs.numIndices

        # The total offset is the attribute offset from the base of the vertex,
        # as calculated by the stride per index
        meshOutput.vertexByteOffset = postvs.vertexByteOffset
        meshOutput.vertexResourceId = postvs.vertexResourceId
        meshOutput.vertexByteStride = postvs.vertexByteStride

        # Construct a resource format for this element
        meshOutput.format = rd.ResourceFormat()
        meshOutput.format.compByteWidth = rd.VarTypeByteSize(attr.varType)
        meshOutput.format.compCount = attr.compCount
        meshOutput.format.compType = rd.VarTypeCompType(attr.varType)
        meshOutput.format.type = rd.ResourceFormatType.Regular

        meshOutput.name = attr.semanticIdxName if attr.varName == '' else attr.varName

        if attr.systemValue == rd.ShaderBuiltin.Position:
            posidx = len(meshOutputs)

        meshOutputs.append(meshOutput)

    # Shuffle the position element to the front
    if posidx > 0:
        pos = meshOutputs[posidx]
        del meshOutputs[posidx]
        meshOutputs.insert(0, pos)

    accumOffset = 0

    for i in range(0, len(meshOutputs)):
        meshOutputs[i].vertexByteOffset = accumOffset

        # Note that some APIs such as Vulkan will pad the size of the attribute here
        # while others will tightly pack
        fmt = meshOutputs[i].format

        accumOffset += (8 if fmt.compByteWidth > 4 else 4) * fmt.compCount

    return meshOutputs

def getIndices(controller, mesh):
    # Get the character for the width of index
    indexFormat = 'B'
    if mesh.indexByteStride == 2:
        indexFormat = 'H'
    elif mesh.indexByteStride == 4:
        indexFormat = 'I'

    # Duplicate the format by the number of indices
    indexFormat = str(mesh.numIndices) + indexFormat

    # If we have an index buffer
    if mesh.indexResourceId != rd.ResourceId.Null():
        # Fetch the data
        ibdata = controller.GetBufferData(mesh.indexResourceId, mesh.indexByteOffset, 0)

        # Unpack all the indices, starting from the first index to fetch
        offset = mesh.indexOffset * mesh.indexByteStride
        indices = struct.unpack_from(indexFormat, ibdata, offset)

        # Apply the baseVertex offset
        return [i + mesh.baseVertex for i in indices]
    else:
        # With no index buffer, just generate a range
        return tuple(range(mesh.numIndices))

def printMeshData(controller, meshData):
    indices = getIndices(controller, meshData[0])

    print("Mesh configuration:")
    for attr in meshData:
        print("\t%s:" % attr.name)
        print("\t\t- vertex: %s / %d stride" % (attr.vertexResourceId,  attr.vertexByteStride))
        print("\t\t- format: %s x %s @ %d" % (attr.format.compType, attr.format.compCount, attr.vertexByteOffset))

    # We'll decode the first three indices making up a triangle
    for i in range(0, 3):
        idx = indices[i]

        print("Vertex %d is index %d:" % (i, idx))

        for attr in meshData:
            # This is the data we're reading from. This would be good to cache instead of
            # re-fetching for every attribute for every index
            offset = attr.vertexByteOffset + attr.vertexByteStride * idx
            data = controller.GetBufferData(attr.vertexResourceId, offset, 0)

            # Get the value from the data
            value = unpackData(attr.format, data)

            # We don't go into the details of semantic matching here, just print both
            print("\tAttribute '%s': %s" % (attr.name, value))

def sampleCode(controller):
    # Find the biggest drawcall in the whole capture
    draw = None
    for d in controller.GetRootActions():
        draw = biggestDraw(draw, d)

    # Move to that draw
    controller.SetFrameEvent(draw.eventId, True)

    print("Decoding mesh inputs at %d: %s\n\n" % (draw.eventId, draw.GetName(controller.GetStructuredFile())))

    # Calculate the mesh input configuration
    meshInputs = getMeshInputs(controller, draw)

    # Fetch and print the data from the mesh inputs
    printMeshData(controller, meshInputs)

    print("Decoding mesh outputs\n\n")

    # Fetch the postvs data
    postvs = controller.GetPostVSData(0, 0, rd.MeshDataStage.VSOut)

    # Calcualte the mesh configuration from that
    meshOutputs = getMeshOutputs(controller, postvs)

    # Print it
    printMeshData(controller, meshOutputs)

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return (cap, controller)

if 'pyrenderdoc' in globals():
    pyrenderdoc.Replay().BlockInvoke(sampleCode)
else:
    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    cap,controller = loadCapture(sys.argv[1])

    sampleCode(controller)

    controller.Shutdown()
    cap.Shutdown()

    rd.ShutdownReplay()

Sample output:

Decoding mesh inputs at 69: DrawIndexed(5580)

Mesh configuration:
    POSITION0:
        - vertex: <ResourceId 142> / 44 stride
        - format: CompType.Float x 3 @ 0
    TANGENT0:
        - vertex: <ResourceId 142> / 44 stride
        - format: CompType.Float x 3 @ 12
    NORMAL0:
        - vertex: <ResourceId 142> / 44 stride
        - format: CompType.Float x 3 @ 24
    TEXCOORD0:
        - vertex: <ResourceId 142> / 44 stride
        - format: CompType.Float x 2 @ 36
Vertex 0 is index 0:
    Attribute 'POSITION0': (1.0, -1.5, 0.0)
    Attribute 'TANGENT0': (-0.0, 0.0, 1.0)
    Attribute 'NORMAL0': (0.9701425433158875, 0.24253533780574799, 0.0)
    Attribute 'TEXCOORD0': (0.0, 1.0)
Vertex 1 is index 31:
    Attribute 'POSITION0': (0.9750000238418579, -1.399999976158142, 0.0)
    Attribute 'TANGENT0': (-0.0, 0.0, 1.0)
    Attribute 'NORMAL0': (0.9701424241065979, 0.24253588914871216, 0.0)
    Attribute 'TEXCOORD0': (0.0, 0.9666666388511658)
Vertex 2 is index 32:
    Attribute 'POSITION0': (0.9536939859390259, -1.399999976158142, 0.20271390676498413)
    Attribute 'TANGENT0': (-0.20791170001029968, 0.0, 0.9781476259231567)
    Attribute 'NORMAL0': (0.9489423036575317, 0.24253617227077484, 0.20170393586158752)
    Attribute 'TEXCOORD0': (0.03333333507180214, 0.9666666388511658)
Decoding mesh outputs

Mesh configuration:
    SV_POSITION:
        - vertex: <ResourceId 1000000000000000237> / 68 stride
        - format: CompType.Float x 4 @ 0
    POSITION:
        - vertex: <ResourceId 1000000000000000237> / 68 stride
        - format: CompType.Float x 4 @ 16
    TEXCOORD:
        - vertex: <ResourceId 1000000000000000237> / 68 stride
        - format: CompType.Float x 2 @ 32
    TANGENT:
        - vertex: <ResourceId 1000000000000000237> / 68 stride
        - format: CompType.Float x 3 @ 40
    NORMAL:
        - vertex: <ResourceId 1000000000000000237> / 68 stride
        - format: CompType.Float x 4 @ 52
Vertex 0 is index 0:
    Attribute 'SV_POSITION': (-6.269223690032959, -4.345583915710449, -2.4250497817993164, -2.0)
    Attribute 'POSITION': (-4.0, 0.0, -12.0, 1.0)
    Attribute 'TEXCOORD': (0.0, 1.0)
    Attribute 'TANGENT': (-5.0, 1.5, -11.0)
    Attribute 'NORMAL': (0.9701425433158875, 0.24253533780574799, 0.0, 0.0)
Vertex 1 is index 31:
    Attribute 'SV_POSITION': (-6.308406352996826, -4.104162216186523, -2.4250497817993164, -2.0)
    Attribute 'POSITION': (-4.025000095367432, 0.10000002384185791, -12.0, 1.0)
    Attribute 'TEXCOORD': (0.0, 0.9666666388511658)
    Attribute 'TANGENT': (-5.0, 1.5, -11.0)
    Attribute 'NORMAL': (0.9701424241065979, 0.24253588914871216, 0.0, 0.0)
Vertex 2 is index 32:
    Attribute 'SV_POSITION': (-6.341799736022949, -4.104162216186523, -2.221970558166504, -1.797286033630371)
    Attribute 'POSITION': (-4.046306133270264, 0.10000002384185791, -11.797286033630371, 1.0)
    Attribute 'TEXCOORD': (0.03333333507180214, 0.9666666388511658)
    Attribute 'TANGENT': (-5.207911491394043, 1.5, -11.021852493286133)
    Attribute 'NORMAL': (0.9489423036575317, 0.24253617227077484, 0.20170393586158752, 0.0)


Display texture in window

In this example we will open a window and iterate through the capture on a loop, displaying the first colour output target on it.

Note

This is intended for use with the python module directly, as the UI already has a texture viewer panel to do this with much more control. The principle is the same though and it can be useful reference of how to iterate over a capture.

To create a window we use tkinter, since it is provided with the Python distribution.

# Use tkinter to create windows
import tkinter

# Create a simple window
window = tkinter.Tk()
window.geometry("1280x720")

Next we need to determine which windowing systems the RenderDoc implementation supports, and create a WindowingData object for the window we want to render to. For the purposes of this example we will look for Win32 since it’s the simplest to set up - needing only a window handle that we can get from tkinter easily. XCB/XLib require a display connection, which would be possible to get from another library such as Qt.

Once we have the WindowingData, we can create a ReplayOutput using CreateOutput().

# Create renderdoc windowing data.
winsystems = [rd.WindowingSystem(i) for i in controller.GetSupportedWindowSystems()]

# Pass window system specific data here, See:
# - renderdoc.CreateWin32WindowingData
# - renderdoc.CreateXlibWindowingData
# - renderdoc.CreateXCBWindowingData

# This example code works on windows as that's simple to integrate with tkinter
if not rd.WindowingSystem.Win32 in winsystems:
    raise RuntimeError("Example requires Win32 windowing system: " + str(winsystems))

windata = rd.CreateWin32WindowingData(int(window.frame(), 16))

# Create a texture output on the window
out = controller.CreateOutput(windata, rd.ReplayOutputType.Texture)

In order to iterate over all actions we need some global state first from GetTextures() and GetRootActions(), and we’ll also define a helper function to fetch a particular texture by resourceId, so that we can easily look up the details for a texture.

# Fetch the list of textures
textures = controller.GetTextures()

# Fetch the list of actions
actions = controller.GetRootActions()

# Function to look up the texture descriptor for a given resourceId
def getTexture(texid):
    global textures
    for tex in textures:
        if tex.resourceId == texid:
            return tex
    return None

We now define two callback functions - paint and advance. paint will be called every 33ms, it will display the output with the latest state using Display(). advance changes the current state to reflect a new action.

# Our paint function will be called ever 33ms, to display the output
def paint():
    global out, window
    out.Display()
    window.after(33, paint)

Within advance we do a few things. First we move the current event to the current action’s eventId, using SetFrameEvent(). Then we set up the texture display configuration with SetTextureDisplay(), to point to the first colour output at that action.

When we update to a new texture, we fetch its details using our earlier getTexture and calculate a scale that keeps the texture fully visible on screen.

Finally we move to the next action in the list for the next time advance is called.

# Start on the first action
curact = actions[0]

loopcount = 0

# The advance function will be called every 50ms, to move to the next action
def advance():
    global out, window, curact, actions, loopcount

    # Move to the current action
    controller.SetFrameEvent(curact.eventId, False)

    # Initialise a default TextureDisplay object
    disp = rd.TextureDisplay()

    # Set the first colour output as the texture to display
    disp.resourceId = curact.outputs[0]

    if disp.resourceId != rd.ResourceId.Null():
        # Get the details of this texture
        texDetails = getTexture(disp.resourceId)

        # Calculate the scale required in width and height
        widthScale = window.winfo_width() / texDetails.width
        heightScale = window.winfo_height() / texDetails.height

        # Use the lower scale to fit the texture on the window
        disp.scale = min(widthScale, heightScale)

        # Update the texture display
        out.SetTextureDisplay(disp)

    # Set the next action
    curact = curact.next

    # If we have no next action, start again from the first
    if curact is None:
        loopcount = loopcount + 1
        curact = actions[0]

    # after 3 loops, quit
    if loopcount == 3:
        window.quit()
    else:
        window.after(50, advance)

Once we have the callbacks defined, we call them once to initialise the display and set up the repeated callbacks, and start the tkinter main window loop.

# Start the callbacks
advance()
paint()

# Start the main window loop
window.mainloop()

Example Source

import sys

# Import renderdoc if not already imported (e.g. in the UI)
if 'renderdoc' not in sys.modules and '_renderdoc' not in sys.modules:
    import renderdoc

# Alias renderdoc for legibility
rd = renderdoc

def loadCapture(filename):
    # Open a capture file handle
    cap = rd.OpenCaptureFile()

    # Open a particular file - see also OpenBuffer to load from memory
    result = cap.OpenFile(filename, '', None)

    # Make sure the file opened successfully
    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't open file: " + str(result))

    # Make sure we can replay
    if not cap.LocalReplaySupport():
        raise RuntimeError("Capture cannot be replayed")

    # Initialise the replay
    result,controller = cap.OpenCapture(rd.ReplayOptions(), None)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError("Couldn't initialise replay: " + str(result))

    return cap,controller

if 'pyrenderdoc' in globals():
    raise RuntimeError("This sample should not be run within the RenderDoc UI")
else:
    if len(sys.argv) <= 1:
        print('Usage: python3 {} filename.rdc'.format(sys.argv[0]))
        sys.exit(0)

    rd.InitialiseReplay(rd.GlobalEnvironment(), [])

    cap,controller = loadCapture(sys.argv[1])

# Use tkinter to create windows
import tkinter

# Create a simple window
window = tkinter.Tk()
window.geometry("1280x720")

# Create renderdoc windowing data.
winsystems = [rd.WindowingSystem(i) for i in controller.GetSupportedWindowSystems()]

# Pass window system specific data here, See:
# - renderdoc.CreateWin32WindowingData
# - renderdoc.CreateXlibWindowingData
# - renderdoc.CreateXCBWindowingData

# This example code works on windows as that's simple to integrate with tkinter
if not rd.WindowingSystem.Win32 in winsystems:
    raise RuntimeError("Example requires Win32 windowing system: " + str(winsystems))

windata = rd.CreateWin32WindowingData(int(window.frame(), 16))

# Create a texture output on the window
out = controller.CreateOutput(windata, rd.ReplayOutputType.Texture)

# Fetch the list of textures
textures = controller.GetTextures()

# Fetch the list of actions
actions = controller.GetRootActions()

# Function to look up the texture descriptor for a given resourceId
def getTexture(texid):
    global textures
    for tex in textures:
        if tex.resourceId == texid:
            return tex
    return None

# Our paint function will be called ever 33ms, to display the output
def paint():
    global out, window
    out.Display()
    window.after(33, paint)

# Start on the first action
curact = actions[0]

loopcount = 0

# The advance function will be called every 50ms, to move to the next action
def advance():
    global out, window, curact, actions, loopcount

    # Move to the current action
    controller.SetFrameEvent(curact.eventId, False)

    # Initialise a default TextureDisplay object
    disp = rd.TextureDisplay()

    # Set the first colour output as the texture to display
    disp.resourceId = curact.outputs[0]

    if disp.resourceId != rd.ResourceId.Null():
        # Get the details of this texture
        texDetails = getTexture(disp.resourceId)

        # Calculate the scale required in width and height
        widthScale = window.winfo_width() / texDetails.width
        heightScale = window.winfo_height() / texDetails.height

        # Use the lower scale to fit the texture on the window
        disp.scale = min(widthScale, heightScale)

        # Update the texture display
        out.SetTextureDisplay(disp)

    # Set the next action
    curact = curact.next

    # If we have no next action, start again from the first
    if curact is None:
        loopcount = loopcount + 1
        curact = actions[0]

    # after 3 loops, quit
    if loopcount == 3:
        window.quit()
    else:
        window.after(50, advance)

# Start the callbacks
advance()
paint()

# Start the main window loop
window.mainloop()

controller.Shutdown()

cap.Shutdown()

if 'pyrenderdoc' not in globals():
    rd.ShutdownReplay()


Remote Capture and Replay

This example is a bit different since it’s not ready-to-run. It provides a template for how you can capture and replay on a remote machine, instead of the local machine. It also shows how to use device protocols to automatically manage devices.

First we can enumerate which device protocols are currently supported.

protocols = rd.GetSupportedDeviceProtocols()

Each string in the list corresponds to a protocol that can be used for managing devices. If we’re using one we can call GetDeviceProtocolController() passing the protocol name and retrieve the controller.

The controller provides a few methods for managing devices. First we can call GetDevices() to return a list of device IDs. The format of these device IDs is protocol-dependent but will be equivalent to a normal hostname. Devices may have human-readable names obtainable via GetFriendlyName().

protocol = rd.GetDeviceProtocolController(protocol_to_use)

devices = protocol.GetDevices()

if len(devices) == 0:
    raise RuntimeError(f"no {protocol_to_use} devices connected")

# Choose the first device
dev = devices[0]
name = protocol.GetFriendlyName(dev)

print(f"Running test on {dev} - named {name}")

URL = protocol.GetProtocolName() + "://" + dev

The URL will be used the same as we would use a hostname, when connecting for target control or remote servers.

Note that protocols may have additional restrictions - be sure to check IsSupported() to check if the device is expected to function at all, and SupportsMultiplePrograms() to see if it supports launching multiple programs. If multiple programs are not supported, you should ensure all running capturable programs are closed before launching a new one.

To begin with we create a remote server connection using CreateRemoteServerConnection(). The URL is as constructed above for protocol-based connections, or a simple hostname/IP if we’re connecting directly to remote machine.

If the connection fails, normally we must fail but if we have a device protocol available we can attempt to launch the remote server automatically using StartRemoteServer().

if result == rd.ResultCode.NetworkIOFailed and protocol is not None:
  # If there's just no I/O, most likely the server is not running. If we have
  # a protocol, we can try to start the remote server
  print("Couldn't connect to remote server, trying to start it")

  result = protocol.StartRemoteServer(URL)

  if result != rd.ResultCode.Succeeded:
    raise RuntimeError(f"Couldn't launch remote server, got error {str(result)}")

  # Try to connect again!
  result,remote = rd.CreateRemoteServerConnection(URL)

Note

The remote server connection has a default timeout of 5 seconds. If the connection is unused for 5 seconds, the other side will disconnect and subsequent use of the interface will fail.

Once we have a remote server connection, we can browse the remote filesystem for the executable we want to launch using GetHomeFolder() and ListFolder().

Then once we’ve selected the executable, we can launch the remote program for capturing with ExecuteAndInject(). This function is almost identical to the local ExecuteAndInject() except that it is not possible to wait for the program to exit.

In our sample, we now place the remote server connection on a background thread that will ping it each second to keep the connection alive while we use a target control connection to trigger a capture in the application.

def ping_remote(remote, kill):
  success = True
  while success and not kill.is_set():
    success = remote.Ping()
    time.sleep(1)

kill = threading.Event()
ping_thread = threading.Thread(target=ping_remote, args=(remote,kill))
ping_thread.start()

To connect to and control an application we use CreateTargetControl() with the URL as before and the ident returned from ExecuteAndInject().

target = rd.CreateTargetControl(URL, result.ident, 'remote_capture.py', True)

# Here we wait for whichever condition you want
target.TriggerCapture(1)

There are a couple of ways to trigger a capture, both TriggerCapture() and QueueCapture() depending on whether you want a time-based or frame-based trigger. The application itself can also use the in-application API to trigger a capture.

The target control connection can be intermittently polled for messages using ReceiveMessage(), which keeps the connection alive and will return any new information such as the data for a new capture that has been created. A message of type NewCapture indicates a new capture has been created, and newCapture contains the information including the path.

msg = target.ReceiveMessage(None)

# Once msg.type == rd.TargetControlMessageType.NewCapture has been retrieved

cap_path = msg.newCapture.path
cap_id = msg.newCapture.captureId

Once the capture has been found we are finished with the target control connection so we can shut it down and stop the background thread that was keeping the remote server connection alive. Using the remote server connection we can copy the capture back to the local machine with CopyCaptureFromRemote(). Similarly if we wanted to load a previously made capture that wasn’t on the remote machine CopyCaptureToRemote() would be useful to copy it ready to be opened.

Finally to open the capture we use, and that returns a ReplayController which can be used as normal and will tunnel over the remote server connection. It can be useful to intermittently ping the remote server connection to check that it’s still valid, and remote server and controller calls can be interleaved as long as they don’t overlap on multiple threads.

Example Source

import renderdoc as rd
import threading
import time

# This sample is intended as an example of how to do remote capture and replay
# as well as using device protocols to automatically enumerate remote targets.
#
# It is not complete since it requires filling in with custom logic to select
# the executable and trigger the capture at the desired time
raise RuntimeError("This sample should not be run directly, read the source")

rd.InitialiseReplay(rd.GlobalEnvironment(), [])

protocols = rd.GetSupportedDeviceProtocols()

print(f"Supported device protocols: {protocols}")

# Protocols are optional - they allow automatic detection and management of
# devices.
if protocol_to_use is not None:
    # the protocol must be supported
    if protocol_to_use not in protocols:
        raise RuntimeError(f"{protocol_to_use} protocol not supported")

    protocol = rd.GetDeviceProtocolController(protocol_to_use)

    devices = protocol.GetDevices()

    if len(devices) == 0:
        raise RuntimeError(f"no {protocol_to_use} devices connected")

    # Choose the first device
    dev = devices[0]
    name = protocol.GetFriendlyName(dev)

    print(f"Running test on {dev} - named {name}")

    URL = protocol.GetProtocolName() + "://" + dev

    # Protocols can enumerate devices which are not supported. Capture/replay
    # is not guaranteed to work on these devices
    if not protocol.IsSupported(URL):
        raise RuntimeError(f"{dev} doesn't support capture/replay - too old?")

    # Protocol devices may be single-use and not support multiple captured programs
    # If so, trying to execute a program for capture is an error
    if not protocol.SupportsMultiplePrograms(URL):
        # check to see if anything is running. Just use the URL
        ident = rd.EnumerateRemoteTargets(URL, 0)

        if ident != 0:
            raise RuntimeError(f"{name} already has a program running on {ident}")
else:
    # If you're not using a protocol then the URL can simply be a hostname.
    # The remote server must be running already - how that is done is up
    # to you. Everything else will work the same over a normal TCP connection
    protocol = None
    URL = hostname

# Let's try to connect
result,remote = rd.CreateRemoteServerConnection(URL)

if result == rd.ResultCode.NetworkIOFailed and protocol is not None:
    # If there's just no I/O, most likely the server is not running. If we have
    # a protocol, we can try to start the remote server
    print("Couldn't connect to remote server, trying to start it")

    result = protocol.StartRemoteServer(URL)

    if result != rd.ResultCode.Succeeded:
        raise RuntimeError(f"Couldn't launch remote server, got error {str(result)}")

    # Try to connect again!
    result,remote = rd.CreateRemoteServerConnection(URL)

if result != rd.ResultCode.Succeeded:
    raise RuntimeError(f"Couldn't connect to remote server, got error {str(result)}")

# We now have a remote connection. This works regardless of whether it's a device
# with a protocol or not. In fact we are done with the protocol at this point
protocol = None

print("Got connection to remote server")

# GetHomeFolder() gives you a good default path to start with.
# ListFolder() lists the contents of a folder and can recursively
# browse the remote filesystem.
home = remote.GetHomeFolder()
paths = remote.ListFolder(home)

print(f"Executables in home folder '{home}':")

for p in paths:
    print("  - " + p.filename)

# Select your executable, perhaps hardcoded or browsing using the above
# functions
exe,workingDir,cmdLine,env,opts = select_executable()

print(f"Running {exe}")

result = remote.ExecuteAndInject(exe, workingDir, cmdLine, env, opts)

if result.result != rd.ResultCode.Succeeded:
    remote.ShutdownServerAndConnection()
    raise RuntimeError(f"Couldn't launch {exe}, got error {str(result.result)}")

# Spin up a thread to keep the remote server connection alive while we make a capture,
# as it will time out after 5 seconds of inactivity
def ping_remote(remote, kill):
    success = True
    while success and not kill.is_set():
        success = remote.Ping()
        time.sleep(1)

kill = threading.Event()
ping_thread = threading.Thread(target=ping_remote, args=(remote,kill))
ping_thread.start()

# Create target control connection
target = rd.CreateTargetControl(URL, result.ident, 'remote_capture.py', True)

if target is None:
    kill.set()
    ping_thread.join()
    remote.ShutdownServerAndConnection()
    raise RuntimeError(f"Couldn't connect to target control for {exe}")

print("Connected - waiting for desired capture")

# Wait for the capture condition we want
capture_condition()

print("Triggering capture")

target.TriggerCapture(1)

# Pump messages, keep waiting until we get a capture message. Time out after 30 seconds
msg = None
start = time.clock()
while msg is None or msg.type != rd.TargetControlMessageType.NewCapture:
    msg = target.ReceiveMessage(None)

    if time.clock() - start > 30:
        break

# Close the target connection, we're done either way
target.Shutdown()
target = None

# Stop the background ping thread
kill.set()
ping_thread.join()

# If we didn't get a capture, error now
if msg.type != rd.TargetControlMessageType.NewCapture:
    remote.ShutdownServerAndConnection()
    raise RuntimeError("Didn't get new capture notification after triggering capture")

cap_path = msg.newCapture.path
cap_id = msg.newCapture.captureId

print(f"Got new capture at {cap_path} which is frame {msg.newCapture.frameNumber} with {msg.newCapture.api}")

# We could save the capture locally
# remote.CopyCaptureFromRemote(cap_path, local_path, None)

# Open a replay. It's recommended to set no proxy preference, but you could
# call remote.LocalProxies and choose an index.
#
# The path must be remote - if the capture isn't freshly created then you need
# to copy it with remote.CopyCaptureToRemote()
result,controller = remote.OpenCapture(rd.RemoteServer.NoPreference, cap_path, rd.ReplayOptions(), None)

if result != rd.ResultCode.Succeeded:
    remote.ShutdownServerAndConnection()
    raise RuntimeError(f"Couldn't open {cap_path}, got error {str(result)}")

# We can now use replay as normal.
#
# The replay is tunnelled over the remote connection, so you don't have to keep
# pinging the remote connection while using the controller. Use of the remote
# connection and controller can be interleaved though you should only access
# them from one thread at once. If they are both unused for 5 seconds though,
# the timeout will happen, so if the controller is idle it's advisable to ping
# the remote connection

sampleCode(controller)

print("Shutting down")

controller.Shutdown()

# We can still use remote here - e.g. capture again, replay something else,
# save the capture, etc

remote.ShutdownServerAndConnection()

rd.ShutdownReplay()


qrenderdoc examples

These examples are only relevant to the scripting available in the UI.

  • Display buffer with format
    • Example Source


Display buffer with format

This example shows an easy way to automate a repro case. It could be run as a command line argument when starting the UI, to avoid repetitive steps.

First the code opens a specified file, although this step could be omitted if the desired capture is already open.

filename = "test.rdc"

pyrenderdoc.LoadCapture(filename, renderdoc.ReplayOptions(), filename, False, True)

Next we iterate through the list of buffers to find the one we want. The selection criteria are up to you, in this case we look at the name provided and identify the buffer by that, however it could also be a particular size, or the buffer bound at a given event.

mybuf = renderdoc.ResourceId.Null()

for buf in pyrenderdoc.GetBuffers():
    print("buf %s is %s" % (buf.resourceId, pyrenderdoc.GetResourceName(buf.resourceId)))

    # here put your actual selection criteria - i.e. look for a particular name
    if pyrenderdoc.GetResourceName(buf.resourceId) == "dataBuffer":
        mybuf = buf.resourceId
        break

print("selected %s" % pyrenderdoc.GetResourceName(mybuf))

Once we’ve identified the buffer we want to view, we create a buffer viewer and display it on the main tool area.

# Open a new buffer viewer for this buffer, with the given format
bufview = pyrenderdoc.ViewBuffer(0, 0, mybuf, formatter)

# Show the buffer viewer on the main tool area
pyrenderdoc.AddDockWindow(bufview.Widget(), qrenderdoc.DockReference.MainToolArea, None)

Example Source

filename = "test.rdc"
formatter = "float3 pos; half norms[16]; uint flags;"

pyrenderdoc.LoadCapture(filename, renderdoc.ReplayOptions(), filename, False, True)

mybuf = renderdoc.ResourceId.Null()

for buf in pyrenderdoc.GetBuffers():
    print("buf %s is %s" % (buf.resourceId, pyrenderdoc.GetResourceName(buf.resourceId)))

    # here put your actual selection criteria - i.e. look for a particular name
    if pyrenderdoc.GetResourceName(buf.resourceId) == "dataBuffer":
        mybuf = buf.resourceId
        break

print("selected %s" % pyrenderdoc.GetResourceName(mybuf))

if mybuf != renderdoc.ResourceId.Null():
    # Open a new buffer viewer for this buffer, with the given format
    bufview = pyrenderdoc.ViewBuffer(0, 0, mybuf, formatter)

    # Show the buffer viewer on the main tool area
    pyrenderdoc.AddDockWindow(bufview.Widget(), qrenderdoc.DockReference.MainToolArea, None)


renderdoc API Reference

  • Capturing
  • Replay Control
  • Replay Outputs
  • Replay Analysis
  • Formats
  • Resources
  • Shaders
  • Pipeline State Objects
  • Structured Data
  • Performance Counters
  • Frame Statistics
  • Utilities


Capturing

Contents

  • Capturing
    • Execution & Injection
    • Global Hooking
    • Target Control

Execution & Injection

renderdoc.ExecuteAndInject(app, workingDir, cmdLine, env, capturefile, opts, waitForExit)

Launch an application and inject into it to allow capturing.

Parameters:
  • app # (str) – The path to the application to run.
  • workingDir # (str) – The working directory to use when running the application. If blank, the directory containing the application is used.
  • cmdLine # (str) – The command line to use when running the application, it will be processed in a platform specific way to generate arguments.
  • env # (List[ EnvironmentModification ]) – Any environment changes that should be made when running the program.
  • capturefile # (str) – The capture file path template, or blank to use a default location.
  • opts # (CaptureOptions) – The capture options to use when injecting into the program.
  • waitForExit # (bool) – If True this function will block until the process exits.
Returns:

The ExecuteResult indicating both the status of the operation (success or failure) and any reason for failure, or else the ident where the new application is listening for target control if everything succeeded.
Return type:

ExecuteResult
renderdoc.InjectIntoProcess(pid, env, capturefile, opts, waitForExit)

Where supported by operating system and permissions, inject into a running process.

Parameters:
  • pid # (int) – The Process ID (PID) to inject into.
  • env # (List[ EnvironmentModification ]) – Any environment changes that should be made when running the program.
  • capturefile # (str) – The capture file path template, or blank to use a default location.
  • opts # (CaptureOptions) – The capture options to use when injecting into the program.
  • waitForExit # (bool) – If True this function will block until the process exits.
Returns:

The ExecuteResult indicating both the status of the operation (success or failure) and any reason for failure, or else the ident where the new application is listening for target control if everything succeeded.
Return type:

ExecuteResult
class renderdoc.CaptureOptions

Sets up configuration and options for optional features either at capture time or at API initialisation time that the user can enable or disable at will.

DecodeFromString(encoded)

Decode the options from a string, as returned by EncodeAsString(). Updates this object in place.

Parameters: encoded # (str) – The encoded string, as returned by EncodeAsString().
EncodeAsString()

Encode the current options to a string suitable for passing around between processes.

Returns: The encoded string, suitable for passing to DecodeFromString().
Return type: str
allowFullscreen

Allow the application to enable fullscreen.

Default - enabled

True - The application can enable or disable fullscreen at will.

False - fullscreen is force disabled.

allowVSync

Allow the application to enable vsync.

Default - enabled

True - The application can enable or disable vsync at will.

False - vsync is force disabled.

apiValidation

Record API debugging events and messages

Default - disabled

True - Enable built-in API debugging features and records the results into the capture logfile, which is matched up with events on replay.

False - no API debugging is forcibly enabled.

captureAllCmdLists

In APIs that allow for the recording of command lists to be replayed later, RenderDoc may choose to not capture command lists before a frame capture is triggered, to reduce overheads. This means any command lists recorded once and replayed many times will not be available and may cause a failure to capture.

Note

This is only true for APIs where multithreading is difficult or discouraged. Newer APIs like Vulkan and D3D12 will ignore this option and always capture all command lists since the API is heavily oriented around it and the overheads have been reduced by API design.

True - All command lists are captured from the start of the application.

False - Command lists are only captured if their recording begins during the period when a frame capture is in progress.

captureCallstacks

Capture CPU callstacks for API events

Default - disabled

True - Enables capturing of callstacks.

False - no callstacks are captured.

captureCallstacksOnlyActions

When capturing CPU callstacks, only capture them from actions. This option does nothing if captureCallstacks is not enabled.

Default - disabled

True - Only captures callstacks for actions.

False - Callstacks, if enabled, are captured for every event.

debugOutputMute

Mute API debugging output when the API validation mode option is enabled.

Default - enabled

True - Mute any API debug messages from being displayed or passed through.

False - API debugging is displayed as normal.

delayForDebugger

Specify a delay in seconds to wait for a debugger to attach, after creating or injecting into a process, before continuing to allow it to run.

0 indicates no delay, and the process will run immediately after injection.

Default - 0 seconds

hookIntoChildren

Hooks any system API calls that create child processes, and injects RenderDoc into them recursively with the same options.

Default - disabled

True - Hooks into spawned child processes.

False - Child processes are not hooked by RenderDoc.

refAllResources

By default RenderDoc only includes resources in the final logfile necessary for that frame, this allows you to override that behaviour.

Default - disabled

True - all live resources at the time of capture are included in the log and available for inspection.

False - only the resources referenced by the captured frame are included.

softMemoryLimit

Define a soft memory limit which some APIs may aim to keep overhead under where possible. Anything above this limit will where possible be saved directly to disk during capture. This will cause increased disk space use (which may cause a capture to fail if disk space is exhausted) as well as slower capture times.

Not all memory allocations may be deferred like this so it is not a guarantee of a memory limit.

Units are in MBs, suggested values would range from 200MB to 1000MB.

Default - 0 Megabytes

verifyBufferAccess

Verify buffer access. This includes checking the memory returned by a Map() call to detect any out-of-bounds modification, as well as initialising buffers with undefined contents to a marker value to catch use of uninitialised memory.

Note

This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do not do the same kind of interception & checking and undefined contents are really undefined.

Default - disabled

True - Verify buffer access.

False - No verification is performed, and overwriting bounds may cause crashes or corruption in RenderDoc.

renderdoc.GetDefaultCaptureOptions()

Retrieve the default and recommended set of capture options.

Returns: The default capture options.
Return type: CaptureOptions
class renderdoc.EnvironmentModification

A modification to a single environment variable.

mod

The modification to use.

name

The name of the environment variable.

sep

The separator to use if needed.

value

The value to use with the modification specified in mod.

class renderdoc.EnvMod(value)

How to modify an environment variable.

Set

Set the variable to the given value.

Append

Add the given value to the end of the variable, using the separator.

Prepend

Add the given value to the start of the variable, using the separator.

class renderdoc.EnvSep(value)

The separator to use if needed when modifying an environment variable.

Platform

Use the character appropriate for separating items on the platform.

On Windows this means the semi-colon ; character will be used, on posix systems the colon : character will be used.

SemiColon

Use a semi-colon ; character.

Colon

Use a colon : character.

NoSep

No separator will be used.

class renderdoc.ExecuteResult

The result of executing or injecting into a program.

ident

The ident where the new application is listening for target control, or 0 if something went wrong.

result

The ResultDetails resulting from the operation, indicating success or failure.

Type: ResultDetails

Global Hooking

renderdoc.StartGlobalHook(pathmatch, logfile, opts)

Begin injecting speculatively into all new processes started on the system. Where supported by platform, configuration, and setup begin injecting speculatively into all new processes started on the system.

This function can only be called if global hooking is supported (see CanGlobalHook()) and if global hooking is not active (see IsGlobalHookActive()).

The hook must be closed with StopGlobalHook() before the application is closed.

This function must be called when the process is running with administrator/superuser permissions.

Parameters:
  • pathmatch # (str) – A string to match against each new process’s executable path to determine which corresponds to the program we actually want to capture.
  • logfile # (str) – Where to store any captures.
  • opts # (CaptureOptions) – The capture options to use when injecting into the program.
Returns:

The result of the operation, if the result succeeded the hook is now active.
Return type:

ResultDetails
renderdoc.StopGlobalHook()

Stop the global hook that was activated by StartGlobalHook().

This function can only be called if global hooking is supported (see CanGlobalHook()) and if global hooking is active (see IsGlobalHookActive()).

renderdoc.IsGlobalHookActive()

Determines if the global hook is active or not.

This function can only be called if global hooking is supported (see CanGlobalHook()).

Returns: True if the hook is active, or False if the hook is inactive.
Return type: bool
renderdoc.CanGlobalHook()

Determines if the global hook is supported on the current platform and configuration.

Returns: True if global hooking can be used on the platform, False if not.
Return type: bool

Target Control

renderdoc.EnumerateRemoteTargets(URL, nextIdent)

Repeatedly query to enumerate which targets are active on a given machine and their idents.

Initially this should be called with nextIdent being 0, to retrieve the first target active. After that it can be called again and again with the previous return value to enumerate more targets.

This function will block for a variable timeout depending on how many targets are scanned.

Parameters:
  • URL # (str) – The URL to connect to. If blank, the local machine is used. If no protocol is specified then default TCP enumeration happens.
  • nextIdent # (int) – The next ident to scan.
Returns:

The ident of the next active target, or 0 if no other targets exist.
Return type:

int
renderdoc.CreateTargetControl(URL, ident, clientName, forceConnection)

Creates a TargetControl connection to a given hostname and ident.

This function will block until the control connection is ready, or an error occurs.

Parameters:
  • URL # (str) – The URL to connect to. If blank, the local machine is used. If no protocol is specified then default TCP enumeration happens.
  • ident # (int) – The ident for the particular target to connect to on that machine.
  • clientName # (str) – The client name to use when connecting. See TargetControl.GetBusyClient().
  • forceConnection # (bool) – Force the connection and kick off any existing client that is currently connected.
Returns:

A handle to the target control connection, or None if something went wrong.
Return type:

TargetControl
class renderdoc.TargetControl

A connection to a running application with RenderDoc injected, which allows limited control over the capture process as well as querying the current status.

Connected()

Determines if the connection is still alive.

Returns: True if the connection still appears to be working, False if it has been closed.
Return type: bool
CopyCapture(captureId, localpath)

Begin copying a given capture stored on a remote machine to the local machine over the target control connection.

Parameters:
  • captureId # (int) – The identifier of the remote capture.
  • localpath # (str) – The absolute path on the local system where the file should be saved.
CycleActiveWindow()

Cycle the currently active window if there are more windows to capture.

DeleteCapture(captureId)

Delete a capture from the remote machine.

Parameters: captureId # (int) – The identifier of the remote capture.
GetAPI()

Retrieves the API currently in use by the target.

Returns: The API name, or empty if no API is initialised yet.
Return type: str
GetBusyClient()

If a busy message was received, determine the client keeping the target busy.

Returns: The name of the client currently connected to the target.
Return type: str
GetPID()

Retrieves the Process ID (PID) of the target on its local system.

Returns: The Process ID, or 0 if that’s not applicable on the target platform.
Return type: int
GetTarget()

Retrieves the target’s name or identifier - typically the name of the executable.

Returns: The target name.
Return type: str
QueueCapture(frameNumber, numFrames)

Queue up a capture to happen on a particular frame number. When this frame is about to begin a capture is begun, and it ends when this frame number ends.

Note

Frame 0 is defined as starting when the device is created, up to the first swapchain present defined frame boundary.

Parameters:
  • frameNumber # (int) – The number of the frame to capture on.
  • numFrames # (int) – How many frames to capture. These will be captured sequentially and independently to separate files.
ReceiveMessage(progress)

Query to see if a message has been received from the remote system.

The details of the types of messages that can be received are listed under TargetControlMessage.

Note

If no message has been received, this function will pump the connection. You are expected to continually call this function and process any messages to kee pthe connection alive.

This function will block but only to a limited degree. If no message is waiting after a small time it will return with a No-op message to allow further processing.

Parameters: progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value when a long blocking message is coming through, e.g. a capture copy. Can be None if no progress is desired.
Returns: The message that was received.
Return type: TargetControlMessage
Shutdown()

Closes the connection without affecting the running application.

TriggerCapture(numFrames)

Trigger a capture on the target, with the same semantics as if the capture key had been pressed - from the next presentation call after this message is processed on the target to the next after that.

Parameters: numFrames # (int) – How many frames to capture. These will be captured sequentially and independently to separate files.
class renderdoc.TargetControlMessage

A message from a target control connection.

apiUse

The API use data.

Type: APIUseData
busy

The busy signal data.

Type: BusyData
capProgress

The progress of an on-going capture.

When valid, will be in the range of 0.0 to 1.0 (0 - 100%). If not valid when a capture isn’t going or has finished, it will be -1.0

capturableWindowCount

The number of the capturable windows

newCapture

The new capture data.

Type: NewCaptureData
newChild

The new child process data.

Type: NewChildData
type

The type of message received

class renderdoc.TargetControlMessageType(value)

The type of message received from or sent to an application target control connection.

Unknown

No message or an unknown message type.

Disconnected

The other end of the connection disconnected.

Busy

The other end of the connection was busy.

Noop

Nothing happened, the connection is being kept alive.

NewCapture

A new capture was made.

CaptureCopied

A capture was successfully copied across the connection.

RegisterAPI

The target has initialised a graphics API.

NewChild

The target has created a child process.

CaptureProgress

Progress update on an on-going frame capture.

CapturableWindowCount

The number of capturable windows has changed.

RequestShow

The client has requested that the controller show itself (raise its window to the top).

class renderdoc.NewCaptureData

Information about the a new capture created by the target.

api

The API used for this capture, if available.

Note

May be empty if running with an older version of RenderDoc

byteSize

The size of the capture, in bytes.

captureId

An identifier to use to refer to this capture.

frameNumber

The frame number that this capture came from.

local

True if the target is running on the local system.

path

The local path on the target system where the capture is saved.

thumbHeight

The height of the image contained in thumbnail.

thumbWidth

The width of the image contained in thumbnail.

thumbnail

The raw bytes that contain the capture thumbnail, as RGB8 data.

timestamp

The time the capture was created, as a unix timestamp in UTC.

title

The custom title for this capture, if empty a default title can be used.

class renderdoc.APIUseData

Information about the API that the target is using.

name

The name of the API.

presenting

True if the API is presenting to a swapchain

supportMessage

A string message if the API is unsupported explaining why.

Type: str
supported

True if the API can be captured.

class renderdoc.BusyData

Information about why the target is busy.

clientName

The name of the client currently connected to the target.

class renderdoc.NewChildData

Information about a new child process spawned by the target.

ident

The ident where the new child’s target control is active.

processId

The PID (Process ID) of the new child.


Replay Control

Contents

  • Replay Control
    • Initialisation and Shutdown
    • Capture File Access
    • GPU Enumeration
    • Replay Controller
    • Device Protocols
    • Remote Servers

Initialisation and Shutdown

renderdoc.InitialiseReplay(globalEnv, args)

Initialises RenderDoc for replay. Replay API functions should not be called before this has been called. It should be called exactly once, and before shutdown you must call ShutdownReplay().

Parameters:
  • globalEnv # (GlobalEnvironment) – The path to the new log file.
  • args # (List[str]) – Any extra command-line arguments.
renderdoc.ShutdownReplay()

Shutdown RenderDoc for replay. Replay API functions should not be called after this has been called. It is not safe to re-initialise replay after this function has been called so it should only be called at program shutdown. This function must only be called if InitialiseReplay() was previously called.

class renderdoc.GlobalEnvironment

Structure used for initialising environment in a replay application.

enumerateGPUs

Whether to enumerate available GPUs. If the replay program is only being used for internal operation where enumerating GPUs would be too expensive or problematic, it can be disabled here.

waylandDisplay

The handle to the wayland display to use internally. If left NULL, wayland cannot be used.

xlibDisplay

The handle to the X display to use internally. If left NULL, one will be opened.

class renderdoc.ResultCode(value)

The result from a replay operation such as opening a capture or connecting to a remote server.

Succeeded

The operation succeeded.

UnknownError

An unknown error occurred.

InternalError

An internal error occurred indicating a bug or unexpected condition.

FileNotFound

The specified file was not found.

InjectionFailed

Injection or hooking into the target process failed.

IncompatibleProcess

An incompatible process was found, e.g. a 32-bit process with 32-bit support not available.

NetworkIOFailed

A network I/O operation failed.

NetworkRemoteBusy

The remote side of the network connection was busy.

NetworkVersionMismatch

The other side of the network connection was not at a compatible version.

FileIOFailed

A filesystem I/O operation failed.

FileIncompatibleVersion

The capture file had an incompatible version.

FileCorrupted

The capture file is corrupted or otherwise unrecognisable.

FileUnrecognised

The file was not recognised as any supported file type.

ImageUnsupported

The image file or format is unrecognised or not supported in this form.

APIUnsupported

The API used in the capture is not supported.

APIInitFailed

The API used in the capture failed to initialise.

APIIncompatibleVersion

The API data in the capture had an incompatible version.

APIHardwareUnsupported

Current replaying hardware unsupported or incompatible with captured hardware.

APIDataCorrupted

While loading the capture for replay, the driver encountered corrupted or invalid serialised data.

APIReplayFailed

The API failed to replay the capture, with some runtime error that couldn’t be determined until the replay began.

JDWPFailure

Use of JDWP to launch and inject into the application failed, this most often indicates that some other JDWP-using program such as Android Studio is interfering.

AndroidGrantPermissionsFailed

Failed to grant runtime permissions when installing Android remote server.

AndroidABINotFound

Couldn’t determine supported ABIs when installing Android remote server.

AndroidAPKFolderNotFound

Couldn’t find the folder which contains the Android remote server APK.

AndroidAPKInstallFailed

Failed to install Android remote server for unknown reasons.

AndroidAPKVerifyFailed

Failed to install Android remote server.

RemoteServerConnectionLost

While replaying on a remote server, the connection was lost.

OutOfMemory

An out of memory error was encountered.

DeviceLost

A device lost fatal error was encountered.

DataNotAvailable

Data was requested through RenderDoc’s API which is not available.

InvalidParameter

An invalid parameter was passed to RenderDoc’s API.

CompressionFailed

Compression or decompression failed.

class renderdoc.ResultDetails

A general result from an operation with optional string information for failures.

This struct can be compared directly to a ResultCode for simple checks of status, and when converted to a string it includes the formatted result code and message as appropriate.

Note

The string information is only valid until ShutdownReplay() is called. After that point, accessing the string information is invalid and may crash. Care should be taken if ShutdownReplay() is called in response to an error, that the error code is read and saved.

Copying the ResultDetails instance is not sufficient to preserve the string information. It should be copied to e.g. a Tuple[ResultCode, str] instead.

Message()

For error codes, this will contain the stringified error code as well as any optional extra information that is available about the error.

Note

It’s not necessary to also display the stringified version of code as that is automatically included in the message.

Returns: A formatted message for failure codes, including the code itself.
Return type: str
OK()

A simple helper function to check if this result is successful.

Returns: Whether or not this result is successful
Return type: bool
code

The ResultDetails resulting from the operation, indicating success or failure.

Capture File Access

renderdoc.OpenCaptureFile()

Create a handle for a capture file.

This function returns a new handle to a capture file. Once initialised by opening a file the handle can only be shut-down, it is not re-usable.

Returns: A handle to the specified path.
Return type: CaptureFile
class renderdoc.CaptureAccess

An interface for accessing a capture, possibly over a network connection. This is a subset of the functionality provided in CaptureFile which only supports import/export and construction of files.

DriverName()

Retrieves the name of the driver that was used to create this capture.

Returns: A simple string identifying the driver used to make the capture.
Return type: str
FindSectionByName(name)

Locate the index of a section by its name. Returns -1 if the section is not found.

This index should not be cached, as writing sections could re-order the indices.

Parameters: name # (str) – The name of the section to search for.
Returns: The index of the section, or -1 if not found.
Return type: int
FindSectionByType(type)

Locate the index of a section by its type. Returns -1 if the section is not found.

This index should not be cached, as writing sections could re-order the indices.

Parameters: type # (SectionType) – The type of the section to search for.
Returns: The index of the section, or -1 if not found.
Return type: int
GetAvailableGPUs()

Returns the list of available GPUs, that can be used in combination with ReplayOptions to force replay on a particular GPU.

Returns: The list of GPUs available.
Return type: List[GPUDevice]
GetResolve(callstack)

Retrieve the details of each stackframe in the provided callstack.

Must only be called after InitResolver() has returned True.

Parameters: callstack # (List[int]) – The integer addresses in the original callstack.
Returns: The list of resolved callstack entries as strings.
Return type: List[str]
GetSectionContents(index)

Get the raw byte contents of the specified section.

Parameters: index # (int) – The index of the section.
Returns: The raw contents of the section, if the index is valid.
Return type: bytes
GetSectionCount()

Retrieve the total number of available sections.

Returns: The number of sections in the capture
Return type: int
GetSectionProperties(index)

Get the describing properties of the specified section.

Parameters: index # (int) – The index of the section.
Returns: The properties of the section, if the index is valid.
Return type: SectionProperties
HasCallstacks()

Query if callstacks are available.

Returns: True if any callstacks are available, False otherwise.
Return type: bool
InitResolver(interactive, progress)

Begin initialising a callstack resolver, looking up symbol files and caching as necessary.

This function blocks while trying to initialise callstack resolving, so it should be called on a separate thread.

Parameters:
  • interactive # (bool) – True if missing symbols or other prompts should be resolved interactively. If this is False, the function will not interact or block forever on user interaction and will always assume the input is effectively ‘cancel’ or empty. This may cause the symbol resolution to fail.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the resolver process. Can be None if no progress is desired.
Returns:

The result of the operation.
Return type:

ResultDetails
WriteSection(props, contents)

Writes a new section with specified properties and contents. If an existing section already has the same type or name, it will be overwritten (two sections cannot share the same type or name).

Parameters:
  • props # (SectionProperties) – The properties of the section to be written.
  • contents # (bytes) – The raw contents of the section.
Returns:

The result of the operation.
Return type:

ResultDetails
class renderdoc.CaptureFile

A handle to a capture file. Used for simple cheap processing and meta-data fetching without opening the capture for analysis.

Convert(filename, filetype, file, progress)

Converts the currently loaded file to a given format and saves it to disk.

This allows converting a native RDC to another representation, or vice-versa converting another representation back to native RDC.

Parameters:
  • filename # (str) – The filename to save to.
  • filetype # (str) – The format to convert to.
  • file # (SDFile) – An optional SDFile with the structured data to source from. This is useful in case the format specifies that it doesn’t need buffers, and you already have a ReplayController open with the structured data. This saves the need to load the file again. If None then structured data will be fetched if not already present and used.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the conversion. Can be None if no progress is desired.
Returns:

The result of the operation.
Return type:

ResultDetails
CopyFileTo(filename)

When a capture file is opened, an exclusive lock is held on the file on disk. This makes it impossible to copy the file to another location at the user’s request. Calling this function will copy the file on disk to a new location but otherwise won’t affect the capture handle. The new file will be locked, the old file will be unlocked - to allow deleting if necessary.

It is invalid to call this function if OpenFile() has not previously been called to open the file.

Parameters: filename # (str) – The filename to copy to.
Returns: The result of the file copy operation.
Return type: ResultDetails
GetCaptureFileFormats()

Returns the list of capture file formats.

Returns: The list of capture file formats available.
Return type: List[CaptureFileFormat]
GetStructuredData()

Returns the structured data for this capture.

The lifetime of this data is scoped to the lifetime of the capture handle, so it cannot be used after the handle is destroyed.

Returns: The structured data representing the file.
Return type: SDFile
GetThumbnail(type, maxsize)

Retrieves the embedded thumbnail from the capture.

Note

The only supported values for GetThumbnail.type are FileType.JPG, FileType.PNG, FileType.TGA, and FileType.BMP.

Parameters:
  • type # (FileType) – The image format to convert the thumbnail to.
  • maxsize # (int) – The largest width or height allowed. If the thumbnail is larger, it’s resized.
Returns:

The raw contents of the thumbnail, converted to the desired type at the desired max resolution.
Return type:

Thumbnail
LocalReplaySupport()

Queries for how well a particular capture is supported on the local machine.

If the file was opened with a format other than native rdc this will always return no replay support.

Returns: How much support for replay exists locally.
Return type: ReplaySupport
OpenBuffer(buffer, filetype, progress)

Initialises the file handle from a raw memory buffer.

This may be useful if you don’t want to parse the whole file or already have the file in memory.

For the OpenBuffer.filetype parameter, see OpenFile().

Parameters:
  • buffer # (bytes) – The buffer containing the data to process.
  • filetype # (str) – The format of the given file.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value if an import step occurs. Can be None if no progress is desired.
Returns:

The result of the operation.
Return type:

ResultDetails
OpenCapture(opts, progress)

Opens a capture for replay locally and returns a handle to the capture. Only supported for handles opened with a native rdc capture, otherwise this will fail.

This function will block until the capture is fully loaded and ready.

Once the replay is created, this CaptureFile can be shut down, there is no dependency on it by the ReplayController.

Parameters:
  • opts # (ReplayOptions) – The options controlling how the capture should be replayed.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the opening. Can be None if no progress is desired.
Returns:

A tuple containing the status of opening the capture, whether success or failure, and the resulting ReplayController handle if successful.
Return type:

Tuple[ResultDetails,ReplayController]
OpenFile(filename, filetype, progress)

Initialises the capture handle from a file.

This method supports converting from non-native representations via structured data, by specifying the input format in the OpenFile.filetype parameter. The list of supported formats can be retrieved by calling GetCaptureFileFormats().

rdc is guaranteed to always be a supported filetype, and will be assumed if the filetype is empty or unrecognised.

Parameters:
  • filename # (str) – The filename of the file to open.
  • filetype # (str) – The format of the given file.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value if an import step occurs. Can be None if no progress is desired.
Returns:

The result of the operation.
Return type:

ResultDetails
RecordedMachineIdent()

Retrieves the identifying string describing what type of machine created this capture.

Returns: A string identifying the machine ident used to make the capture.
Return type: str
SetMetadata(driverName, machineIdent, thumbType, thumbWidth, thumbHeight, thumbData, timeBase, timeFreq)

Sets the matadata for this capture handle.

This function may only be called if the handle is ‘empty’ - i.e. no file has been opened with OpenFile() or OpenBuffer().

Note

The only supported values for SetMetadata.thumbType are FileType.JPG, FileType.PNG, FileType.TGA, and FileType.BMP.

Parameters:
  • driverName # (str) – The name of the driver. Must be a recognised driver name (even if replay support for that driver is not compiled in locally.
  • machineIdent # (int) – The encoded machine identity value. Optional value and can be left to 0, as the bits to set are internally defined, so only generally useful if copying a machine ident from an existing capture.
  • thumbType # (FileType) – The file type of the thumbnail. Ignored if SetMetadata.thumbData is empty.
  • thumbWidth # (int) – The width of the thumbnail. Ignored if SetMetadata.thumbData is empty.
  • thumbHeight # (int) – The height of the thumbnail. Ignored if SetMetadata.thumbData is empty.
  • thumbData # (bytes) – The raw data of the thumbnail. If empty, no thumbnail is set.
  • timeBase # (int) – The base value for timestamps in the capture. Can be set to 0 to indicate that timestamps are already capture relative.
  • timeFreq # (float) – The frequency for timestamps and durations to be divided by to convert to microseconds. Can be set to 1.0 to indicate that timestamps and durations are already in microseconds.
SetStructuredData(file)

Sets the structured data for this capture.

This allows calling code to populate a capture out of generated structured data. In combination with SetMetadata() this allows a purely in-memory creation of a file to be saved out with Convert().

The data is copied internally so it can be destroyed after calling this function.

Parameters: file # (SDFile) – The structured data representing the file.
Shutdown()

Closes the file handle.

TimestampBase()

Retrieves the timestamp basis that all timestamps in the capture are relative to. May be 0 if all timestamps are already absolute.

Returns: The timestamp base value
Return type: int
TimestampFrequency()

Retrieves frequency for timestamps and durations to be divided by to convert to microseconds. May be 1.0 if all timestamps and durations are already in microseconds.

Returns: The timestamp frequency
Return type: float
class renderdoc.ReplaySupport(value)

How supported a given API is on a particular replay instance.

Unsupported

The API is not supported.

Supported

The API is fully supported.

SuggestRemote

The API is supported locally but the capture indicates it was made on a different type of machine so remote replay might be desired.

class renderdoc.CaptureFileFormat

The format for a capture file either supported to read from, or export to

convertSupported

Indicates whether captures or structured data can be saved out in this format.

description

A human readable long-form description of the file format.

extension

The file of the format as a single minimal string, e.g. rdc.

name

A human readable short phrase naming the file format.

openSupported

Indicates whether or not files in this format can be opened and processed as structured data.

requiresBuffers

Indicates whether exporting to this format requires buffers or just structured data. If it doesn’t require buffers then it can be exported directly from an opened capture, which by default has structured data but no buffers available.

class renderdoc.SectionProperties

Properties of a section in a renderdoc capture file.

compressedSize

The number of bytes of data in this section when compressed on disk.

flags

The flags describing how this section is stored.

name

The name of this section.

type

The type of this section, if it is a known pre-defined section.

uncompressedSize

The number of bytes of data contained in this section, once uncompressed.

version

The version of this section - the meaning of which is up to the type.

class renderdoc.SectionType(value)

The types of several pre-defined and known sections. This allows consumers of the API to recognise and understand the contents of the section.

Note that sections above the highest value here may be encountered if they were written in a new version of RenderDoc that addes a new section type. They should be considered equal to Unknown by any processing.

Unknown

An unknown section - any custom or non-predefined section will have this type.

FrameCapture

This section contains the actual captured frame, in RenderDoc’s internal chunked representation. The contents can be fetched as structured data with or without replaying the frame.

The name for this section will be “renderdoc/internal/framecapture”.

ResolveDatabase

This section contains platform-specific data used to resolve callstacks.

The name for this section will be “renderdoc/internal/resolvedb”.

Bookmarks

This section contains a JSON document with bookmarks added to the capture to highlight important events.

The name for this section will be “renderdoc/ui/bookmarks”.

Notes

This section contains a JSON document with free-form information added for human consumption, e.g. details about how the capture was obtained with repro steps in the original program, or with driver and machine info.

The name for this section will be “renderdoc/ui/notes”.

ResourceRenames

This section contains a JSON document with custom names applied to resources in the UI, over and above any friendly names specified in the capture itself.

The name for this section will be “renderdoc/ui/resrenames”.

AMDRGPProfile

This section contains a .rgp profile from AMD’s RGP tool, which can be extracted and loaded.

The name for this section will be “amd/rgp/profile”.

ExtendedThumbnail

This section contains a thumbnail in format other than JPEG. For example, when it needs to be lossless.

The name for this section will be “renderdoc/internal/exthumb”.

EmbeddedLogfile

This section contains the log file at the time of capture, for debugging.

The name for this section will be “renderdoc/internal/logfile”.

EditedShaders

This section contains any edited shaders.

The name for this section will be “renderdoc/ui/edits”.

D3D12Core

This section contains an internal copy of D3D12Core for replaying.

The name for this section will be “renderdoc/internal/d3d12core”.

D3D12SDKLayers

This section contains an internal copy of D3D12SDKLayers for replaying.

The name for this section will be “renderdoc/internal/d3d12sdklayers”.

class renderdoc.SectionFlags(value)

A set of flags describing the properties of a section in a renderdoc capture.

NoFlags

No special section properties.

ASCIIStored

This section was stored as pure ASCII. This can be useful since it is possible to generate an ASCII section in a text editor by hand or with any simple printf style script, and then concatenate it to a .rdc and have a valid section.

LZ4Compressed

This section is compressed with LZ4 on disk.

ZstdCompressed

This section is compressed with Zstd on disk.

class renderdoc.Thumbnail

Contains the bytes and metadata describing a thumbnail.

data

The bytes byte array containing the raw data.

height

The height of the thumbnail image.

type

The FileType of the data in the thumbnail.

width

The width of the thumbnail image.

GPU Enumeration

class renderdoc.GPUDevice

Describes a single GPU at replay time.

apis

The APIs that this device supports.

Type: List[GraphicsAPI]
deviceID

The PCI deviceID of this GPU.

driver

The name of the driver of this GPU, if multiple drivers are available for it.

name

The human-readable name of this GPU.

vendor

The GPUVendor of this GPU.

class renderdoc.GPUVendor(value)

Identifies a GPU vendor.

Unknown

A GPU from an unknown vendor

ARM

An ARM GPU

AMD

An AMD GPU

Broadcom

A Broadcom GPU

Imagination

An Imagination GPU

Intel

An Intel GPU

nVidia

An nVidia GPU

Qualcomm

A Qualcomm GPU

Verisilicon

A Verisilicon or Vivante GPU

Software

A software-rendering emulated GPU

Samsung

A Samsung GPU

renderdoc.GPUVendorFromPCIVendor(vendorID)

Get the GPUVendor for a given PCI Vendor ID.

Parameters: vendorID # (int) – The PCI Vendor ID
Returns: The vendor identified
Return type: GPUVendor
class renderdoc.GraphicsAPI(value)

Identifies a Graphics API.

D3D11

Direct3D 11.

D3D12

Direct3D 12.

OpenGL

OpenGL.

Vulkan

Vulkan.

renderdoc.IsD3D(api)

Check if an API is D3D or not

Parameters: api # (GraphicsAPI) – The graphics API in question
Returns: True if api is a D3D-based API, False otherwise
Return type: bool
renderdoc.GetDriverInformation(api)

Retrieves the driver information (if available) for a given graphics API.

Parameters: api # (GraphicsAPI) – The API to get driver information for.
Returns: A DriverInformation containing the driver information.
Return type: DriverInformation
class renderdoc.DriverInformation

Gives information about the driver for this API.

vendor

The GPUVendor that provides this driver

version

The version string for the driver

Replay Controller

class renderdoc.ReplayController

The primary interface to access the information in a capture and the current state, as well as control the replay and analysis functionality available.

KillCallback()

Not an actual member function - the signature for any KillCallback callbacks.

Called whenever some on-going blocking process needs to determine if it should close.

Returns: Whether or not the process should be killed.
Return type: bool
ProgressCallback()

Not an actual member function - the signature for any ProgressCallback callbacks.

Called by an on-going blocking process to update a progress bar or similar user feedback.

The progress value will go from 0.0 to 1.0 as the process completes. Any other value will indicate that the process has completed

Parameters: progress (float) – The latest progress amount.
PreviewWindowCallback()

Not an actual member function - the signature for any PreviewWindowCallback callbacks.

Called when a preview window could optionally be opened to display some information. It will be called repeatedly with active set to True to allow any platform-specific message pumping.

Parameters: active (bool) – True if a preview window is active/opened, False if it has closed.
Returns: The windowing data for a preview window, or empty/default values if no window should be created.
Return type: WindowingData
NoPreference

No preference for a particular value, see ReplayController.DebugPixel().

AddFakeMarkers()

Add fake marker regions to the list of actions in the capture, based on which textures are bound as outputs. Will not do anything if the capture already contains user marker regions.

Warning

This must be called immediately after capture load, calling it at a later time will cause corruption. No other functions should be called between load and this one.

Note

The event IDs for fake marker pushes and pops will not be contiguous with the surrounding actions and will be set to values above the last real event in the capture. This also means they break the typical rules that event IDs always increase. It’s recommended that these events are not referenced directly in other calls such as SetFrameEvent, and fake markers should be used sparingly at all compared to proper application-provided markers.

BuildCustomShader(entry, sourceEncoding, source, compileFlags, type)

Builds a shader suitable for running on the local replay instance as a custom shader.

System-level include directories can be set up via SetCustomShaderIncludes.

See TextureDisplay.customShaderId.

Parameters:
  • entry # (str) – The entry point to use when compiling.
  • sourceEncoding # (ShaderEncoding) – The encoding of the source data.
  • source # (bytes) – The source data itself.
  • compileFlags # (ShaderCompileFlags) – API-specific compilation flags.
  • type # (ShaderStage) – The stage that this shader will be executed at.
Returns:

A tuple with the id of the new shader if compilation was successful, ResourceId.Null() otherwise, and a str with any warnings/errors from compilation.
Return type:

Tuple[ResourceId,str]
BuildTargetShader(entry, sourceEncoding, source, compileFlags, type)

Builds a shader suitable for running in the capture’s API as a replacement shader.

Parameters:
  • entry # (str) – The entry point to use when compiling.
  • sourceEncoding # (ShaderEncoding) – The encoding of the source data.
  • source # (bytes) – The source data itself.
  • compileFlags # (ShaderCompileFlags) – API-specific compilation flags.
  • type # (ShaderStage) – The stage that this shader will be executed at.
Returns:

A tuple with the id of the new shader if compilation was successful, ResourceId.Null() otherwise, and a str with any warnings/errors from compilation.
Return type:

Tuple[ResourceId,str]
CancelReplayLoop()

Cancels a replay loop begun in ReplayLoop(). Does nothing if no loop is active.

ContinueDebug(debugger)

Continue a shader’s debugging with a given shader debugger instance. This will run an implementation defined number of steps and then return those steps in a list. This may be a fixed number of steps or it may run for a fixed length of time and return as many steps as can be calculated in that time.

This will always perform at least one step. If the list is empty, the debugging process has completed, further calls will return an empty list.

Parameters: debugger # (ShaderDebugger) – The shader debugger to continue running.
Returns: A number of subsequent states.
Return type: List[ShaderDebugState]
CreateOutput(window, type)

Creates a replay output of the given type to the given native window

Parameters:
  • window # (WindowingData) – A WindowingData describing the native window.
  • type # (ReplayOutputType) – What type of output to create
Returns:

A handle to the created output, or None on failure
Return type:

ReplayOutput
CreateRGPProfile(window)

Uses the given output window to create an RGP Profile.

Parameters: window # (WindowingData) – A WindowingData describing the native window.
Returns: The path to the created RGP profile, or empty on failure
Return type: str
DebugPixel(x, y, inputs)

Retrieve a debugging trace from running a pixel shader.

Note

X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in bottom-left co-ordinates, care must be taken to translate them.

Parameters:
  • x # (int) – The x co-ordinate.
  • y # (int) – The y co-ordinate.
  • inputs # (DebugPixelInputs) – Specific properties to select which fragment to debug e.g. sample: The multi-sampled sample. Ignored if non-multisampled texture. primitive: Debug the pixel from this primitive if there’s ambiguity. If set to NoPreference then a random fragment writing to the given co-ordinate is debugged. view: Debug the fragment writing to this view for layered or multiview rendering, ignored if set to NoPreference.
Returns:

The resulting trace resulting from debugging. Destroy with FreeTrace().
Return type:

ShaderDebugTrace
DebugThread(groupid, threadid)

Retrieve a debugging trace from running a compute thread.

Parameters:
  • groupid # (Tuple[int,int,int]) – A list containing the 3D workgroup index.
  • threadid # (Tuple[int,int,int]) – A list containing the 3D thread index within the workgroup.
Returns:

The resulting trace resulting from debugging. Destroy with FreeTrace().
Return type:

ShaderDebugTrace
DebugVertex(vertid, instid, idx, view)

Retrieve a debugging trace from running a vertex shader.

Parameters:
  • vertid # (int) – The vertex ID as a 0-based index up to the number of vertices in the draw.
  • instid # (int) – The instance ID as a 0-based index up to the number of instances in the draw.
  • idx # (int) – The actual index used to look up vertex inputs, either from the vertex ID for non- indexed draws or drawn from the index buffer. This must have all drawcall offsets applied.
  • view # (int) – The index of the multiview viewport to use, or 0 if multiview is not in use.
Returns:

The resulting trace resulting from debugging. Destroy with FreeTrace().
Return type:

ShaderDebugTrace
DescribeCounter(counter)

Get information about what a counter actually represents, in terms of a human-readable understanding as well as the type and unit of the resulting information.

Parameters: counter # (GPUCounter) – The counter to query about.
Returns: The description of the counter.
Return type: CounterDescription
DisassembleShader(pipeline, refl, target)

Retrieve the disassembly for a given shader, for the given disassembly target.

Parameters:
  • pipeline # (ResourceId) – The pipeline state object, if applicable, that this shader is bound to.
  • refl # (ShaderReflection) – The shader reflection details of the shader to disassemble
  • target # (str) – The name of the disassembly target to generate for. Must be one of the values returned by GetDisassemblyTargets(), or empty to use the default generation.
Returns:

The disassembly text, or an error message if something went wrong.
Return type:

str
EnumerateCounters()

Retrieve a list of which counters are available in the current capture analysis implementation.

Returns: The list of counters available.
Return type: List[GPUCounter]
FetchCounters(counters)

Retrieve the values of a specified set of counters.

Parameters: counters # (List[ GPUCounter ]) – The list of counters to fetch results for.
Returns: The list of counter results generated.
Return type: List[CounterResult]
FileChanged()

Notify the interface that the file it has open has been changed on disk.

FreeCustomShader(id)

Free a previously created custom shader.

See BuildCustomShader().

Parameters: id # (ResourceId) – The id of the custom shader to free.
FreeTargetResource(id)

Free a previously created target shader.

See BuildTargetShader().

Parameters: id # (ResourceId) – The id of the target shader to free.
FreeTrace(trace)

Free a debugging trace from running a shader invocation debug.

Parameters: trace # (ShaderDebugTrace) – The shader debugging trace to free.
GetAPIProperties()

Retrieve a APIProperties object describing the current capture.

Returns: The properties of the current capture.
Return type: APIProperties
GetBufferData(buff, offset, len)

Retrieve the contents of a range of a buffer as a bytes.

Parameters:
  • buff # (ResourceId) – The id of the buffer to retrieve data from.
  • offset # (int) – The byte offset to the start of the range.
  • len # (int) – The length of the range, or 0 to retrieve the rest of the bytes in the buffer.
Returns:

The requested buffer contents.
Return type:

bytes
GetBuffers()

Retrieve the list of buffers alive in the capture.

Returns: The list of buffers in the capture.
Return type: List[BufferDescription]
GetCBufferVariableContents(pipeline, shader, stage, entryPoint, cbufslot, buffer, offset, length)

Retrieve the contents of a constant block by reading from memory or their source otherwise.

Parameters:
  • pipeline # (ResourceId) – The pipeline state object, if applicable, that this shader is bound to.
  • shader # (ResourceId) – The id of the shader to use for metadata.
  • stage # (ShaderStage) – The shader stage to fetch variables from.
  • entryPoint # (str) – The entry point of the shader being used. In some APIs, this is ignored.
  • cbufslot # (int) – The index in the ShaderReflection.constantBlocks list to look up.
  • buffer # (ResourceId) – The id of the buffer to use for data. If ConstantBlock.bufferBacked is False this is ignored.
  • offset # (int) – Retrieve buffer contents starting at this byte offset.
  • length # (int) – Retrieve this many bytes after offset. May be 0 to fetch the rest of the buffer.
Returns:

The shader variables with their contents.
Return type:

List[ShaderVariable]
GetCustomShaderEncodings()

Retrieve the list of supported ShaderEncoding which can be build using BuildCustomShader().

The list is sorted in priority order, so if the caller has a shader in a form but could compile/translate it to another, prefer to satisfy the first encoding before later encodings.

This typically means the ‘native’ encoding is listed first, and then subsequent encodings are compiled internally - so compiling externally could be preferable as it allows better customisation of the compile process or using alternate/updated tools.

Returns: The list of target shader encodings available.
Return type: List[ShaderEncoding]
GetCustomShaderSourcePrefixes()

Retrieve a list of source prefixes that should be applied to custom shaders of each ShaderEncoding before custom compilation prior to calling BuildCustomShader().

This list provides source code prefixes which should be applied to a given custom shader in a ShaderEncoding if and only if that shader is being compiled in a custom step to a different encoding, prior to being passed to BuildCustomShader(). This allows source compatibility even when doing custom compilation.

For example a shader written in ShaderEncoding.HLSL may be custom compiled to ShaderEncoding.SPIRV before being passed to BuildCustomShader(). In this case any prefix for ShaderEncoding.HLSL should be prepended to the source before custom compilation, to allow for defines and other helpers to be made available, since otherwise the shader may not compile.

If a shader encoding is not in the list, no prefix is required. This may be possible even for a high level language such as ShaderEncoding.GLSL.

Returns: A list of pairs, listing a prefix for each shader encoding referenced.
Return type: List[ShaderSourcePrefix]
GetD3D11PipelineState()

Retrieve the current D3D11State pipeline state.

The return value will be None if the capture is not using the D3D11 API. You should use GetAPIProperties() to determine the API of the capture.

See also GetPipelineState().

Returns: The current D3D11 pipeline state.
Return type: D3D11State
GetD3D12PipelineState()

Retrieve the current D3D12State pipeline state.

The return value will be None if the capture is not using the D3D12 API. You should use GetAPIProperties() to determine the API of the capture.

See also GetPipelineState().

Returns: The current D3D12 pipeline state.
Return type: D3D12State
GetDebugMessages()

Retrieve a list of any newly generated diagnostic messages.

Every time this function is called, any debug messages returned will not be returned again. Only newly generated messages will be returned after that.

Returns: The list of the DebugMessage messages.
Return type: List[DebugMessage]
GetDisassemblyTargets(withPipeline)

Retrieve the list of possible disassembly targets for DisassembleShader(). The values are implementation dependent but will always include a default target first which is the native disassembly of the shader. Further options may be available for additional diassembly views or hardware-specific ISA formats.

Parameters: withPipeline # (bool) – More disassembly may be available when a pipeline is specified.
Returns: The list of disassembly targets available.
Return type: List[str]
GetFatalErrorStatus()

Poll for the current status of the replay.

This function can be used to monitor to see if a fatal error has been encountered and react appropriately, such as by displaying a message to the user. The replay controller interface should remain stable and return null/empty data for the most part, but it’s recommended for maximum stability to stop using the controller when a fatal error is encountered.

If there has been no error, this will return ResultCode.Succeeded. If there has been an error this will return the error code every time, it will not be ‘consumed’ so it’s safe to have multiple things checking it.

Returns: The current fatal error status.
Return type: ResultDetails
GetFrameInfo()

Retrieve the information about the frame contained in the capture.

Returns: The frame information.
Return type: FrameDescription
GetGLPipelineState()

Retrieve the current GLState pipeline state.

The return value will be None if the capture is not using the OpenGL API. You should use GetAPIProperties() to determine the API of the capture.

See also GetPipelineState().

Returns: The current OpenGL pipeline state.
Return type: GLState
GetHistogram(textureId, sub, typeCast, minval, maxval, channels)

Retrieve a list of values that can be used to show a histogram of values for the specified texture.

The output list contains N buckets, and each bucket has the number of pixels that falls in each bucket when the pixel values are divided between minval and maxval.

Parameters:
  • textureId # (ResourceId) – The texture to get the histogram from.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
  • minval # (float) – The lower end of the smallest bucket. If any values are below this, they are not added to any bucket.
  • maxval # (float) – The upper end of the largest bucket. If any values are above this, they are not added to any bucket.
  • channels # (Tuple[bool,bool,bool,bool]) – A set of four flags indicating whether each of RGBA respectively should be included in the count.
Returns:

A list of the unnormalised bucket values.
Return type:

List[int]
GetMinMax(textureId, sub, typeCast)

Retrieves the minimum and maximum values in the specified texture.

Parameters:
  • textureId # (ResourceId) – The texture to get the values from.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
Returns:

A tuple with the minimum and maximum pixel values respectively.
Return type:

Tuple[PixelValue,PixelValue]
GetPipelineState()

Retrieve the current PipeState pipeline state abstraction.

This pipeline state will always be valid, and allows queries that will work regardless of the capture’s API.

Returns: The current pipeline state abstraction.
Return type: PipeState
GetPostVSData(instance, view, stage)

Retrieve the generated data from one of the geometry processing shader stages.

Parameters:
  • instance # (int) – The index of the instance to retrieve data for, or 0 for non-instanced draws.
  • view # (int) – The index of the multiview view to retrieve data for, or 0 if multiview is disabled.
  • stage # (MeshDataStage) – The stage of the geometry processing pipeline to retrieve data from.
Returns:

The information describing where the post-transform data is stored.
Return type:

MeshFormat
GetResources()

Retrieve the list of all resources in the capture.

This includes any object allocated a ResourceId, that don’t have any other state or are only used as intermediary elements.

Returns: The list of resources in the capture.
Return type: List[ResourceDescription]
GetRootActions()

Retrieve the list of root-level actions in the capture.

Returns: The list of root-level actions in the capture.
Return type: List[ActionDescription]
GetShader(pipeline, shader, entry)

Retrieve the information about the frame contained in the capture.

Parameters:
  • pipeline # (ResourceId) – The pipeline state object, if applicable, that this shader is bound to.
  • shader # (ResourceId) – The shader to get reflection data for.
  • entry # (ShaderEntryPoint) – The entry point within the shader to reflect. May be ignored on some APIs
Returns:

The frame information.
Return type:

ShaderReflection
GetShaderEntryPoints(shader)

Retrieve a list of entry points for a shader.

If the given ID doesn’t specify a shader, an empty list will be return. On some APIs, the list will only ever have one result (only one entry point per shader).

Parameters: shader # (ResourceId) – The shader to look up entry points for.
Returns: The list of the ShaderEntryPoint messages.
Return type: List[ShaderEntryPoint]
GetStructuredFile()

Fetch the structured data representation of the capture loaded.

Returns: The structured file.
Return type: SDFile
GetSupportedWindowSystems()

Retrieves the supported WindowingSystem systems by the local system.

Returns: The list of supported systems.
Return type: List[WindowingSystem]
GetTargetShaderEncodings()

Retrieve the list of supported ShaderEncoding which can be build using BuildTargetShader().

The list is sorted in priority order, so if the caller has a shader in a form but could compile/translate it to another, prefer to satisfy the first encoding before later encodings.

This typically means the ‘native’ encoding is listed first, and then subsequent encodings are compiled internally - so compiling externally could be preferable as it allows better customisation of the compile process or using alternate/updated tools.

Returns: The list of target shader encodings available.
Return type: List[ShaderEncoding]
GetTextureData(tex, sub)

Retrieve the contents of one subresource of a texture as a bytes.

Parameters:
  • tex # (ResourceId) – The id of the texture to retrieve data from.
  • sub # (Subresource) – The subresource within this texture to use.
Returns:

The requested texture contents.
Return type:

bytes
GetTextures()

Retrieve the list of textures alive in the capture.

Returns: The list of textures in the capture.
Return type: List[TextureDescription]
GetUsage(id)

Retrieve a list of ways a given resource is used.

Parameters: id # (ResourceId) – The id of the texture or buffer resource to be queried.
Returns: The list of usages of the resource.
Return type: List[EventUsage]
GetVulkanPipelineState()

Retrieve the current VKState pipeline state.

The return value will be None if the capture is not using the Vulkan API. You should use GetAPIProperties() to determine the API of the capture.

See also GetPipelineState().

Returns: The current Vulkan pipeline state.
Return type: VKState
PickPixel(textureId, x, y, sub, typeCast)

Retrieve the contents of a particular pixel in a texture.

Note

X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in bottom-left co-ordinates, care must be taken to translate them.

Parameters:
  • textureId # (ResourceId) – The texture to pick the pixel from.
  • x # (int) – The x co-ordinate to pick from.
  • y # (int) – The y co-ordinate to pick from.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
Returns:

The contents of the pixel.
Return type:

PixelValue
PixelHistory(texture, x, y, sub, typeCast)

Retrieve the history of modifications to the selected pixel on the selected texture.

Note

X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in bottom-left co-ordinates, care must be taken to translate them.

Parameters:
  • texture # (ResourceId) – The texture to search for modifications.
  • x # (int) – The x co-ordinate.
  • y # (int) – The y co-ordinate.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
Returns:

The list of pixel history events.
Return type:

List[PixelModification]
RemoveReplacement(id)

Remove any previously specified replacement for an object.

See ReplaceResource().

Parameters: id # (ResourceId) – The id of the original resource that was previously being substituted.
ReplaceResource(original, replacement)

Replace one resource with another for subsequent replay and analysis work.

This is commonly used for modifying the capture by selectively replacing resources with newly created resources.

See BuildTargetShader(), RemoveReplacement().

Parameters:
  • original # (ResourceId) – The id of the original resource that should be substituted.
  • replacement # (ResourceId) – The id of the new resource that should be used instead.
ReplayLoop(window, texid)

Goes into a blocking loop, repeatedly replaying the open capture as fast as possible, displaying the selected texture in a default unscaled manner to the given output window.

The function won’t return until CancelReplayLoop() is called. Since this function is blocking, that function must be called from another thread.

Parameters:
  • window # (WindowingData) – A WindowingData describing the native window.
  • texid # (ResourceId) – The id of the texture to display.
SaveTexture(saveData, path)

Save a texture to a file on disk, with possible transformation to map a complex texture to something compatible with the target file format.

Parameters:
  • saveData # (TextureSave) – The configuration settings of which texture to save, and how
  • path # (str) – The path to save to on disk.
Returns:

The result of the operation.
Return type:

ResultDetails
SetCustomShaderIncludes(directories)

Sets a list of directories to search for include files when compiling custom shaders with the internal shader compiler.

Note

This is currently only supported for D3D11 and D3D12. For Vulkan includes can be supported via configuring an external compiler to SPIR-V which is ingested.

Parameters: directories # (List[str]) – The absolute paths of the directories.
SetFrameEvent(eventId, force)

Move the replay to reflect the state immediately after the given eventId.

Parameters:
  • eventId # (int) – The eventId to move to.
  • force # (bool) – True if the internal replay should refresh even if the eventId is already current. This can be useful if external factors might cause the replay to vary.
Shutdown()

Shutdown and destroy the current interface and all outputs that have been created.

class renderdoc.ReplayOptions

The options controlling how replay of a capture should be performed

apiValidation

Replay with API validation enabled and use debug messages from there, ignoring any that may be contained in the capture.

The default is not to do any validation.

Note

RenderDoc does not handle invalid API use in the general case so validation should still be performed at runtime in your program for ground truth results.

forceGPUDeviceID

Force the selection of a GPU by device ID. This allows overriding which GPU is used to replay on.

When set to 0, specifies no particular device.

See forceGPUDeviceID for a full explanation of GPU selection override.

forceGPUDriverName

Force the selection of a GPU by driver name. This allows overriding which GPU is used to replay on.

When set to an empty string, specifies no particular driver.

See forceGPUDeviceID for a full explanation of GPU selection override.

forceGPUVendor

Force the selection of a GPU by vendor ID. This allows overriding which GPU is used to replay on, even if a different GPU would be the best match for the capture.

When set to GPUVendor.Unknown, specifies no particular vendor.

See also forceGPUDeviceID and forceGPUDriverName. Available GPUs can be enumerated using CaptureAccess.GetAvailableGPUs().

The default is not to do any override. The capture contains information about what GPU was used, and the closest matching GPU is used on replay.

Note

If a GPU is forced that is not available or not supported for a given capture, such as when GPUs are only available for some APIs and not others, the default GPU selection will be used. If a GPU is available for a capture but fails to open however then there is no fallback to a default GPU.

OpenGL does not support GPU selection so the default method (which effectively does nothing) will always be used.

optimisation

How much optimisation should be done, potentially at the cost of correctness.

The default is ReplayOptimisationLevel.Balanced.

class renderdoc.ReplayOptimisationLevel(value)

The level of optimisation used in

NoOptimisation

Completely disabled, no optimisation will be used at all.

Conservative

Optimisation is used when it doesn’t interfere with replay correctness.

Balanced

Optimisation is used when it has minimal impact on replay correctness. This could include e.g. resources appearing cleared instead of containing contents from prior frames where those resources are written to before being read.

Fastest

All possible optimisations are enabled as long as they do not cause invalid/incorrect replay. This could result in side-effects like data from one replay being visible early in another replay, if it’s known that the data will be overwritten before being used.

class renderdoc.APIProperties

Gives some API-specific information about the capture.

degraded

True if the capture was loaded successfully but running in a degraded mode - e.g. with software rendering, or with some functionality disabled due to lack of support.

localRenderer

The GraphicsAPI used to render the log. For remote replay this could be different to the above, and lets the UI make decisions e.g. to flip rendering of images.

pipelineType

The GraphicsAPI of the actual log/capture.

pixelHistory

(True if the API supports viewing pixel history.

remoteReplay

True if the capture is being replayed over a remote connection.

rgpCapture

True if the driver and system are configured to allow creating RGP captures.

shaderDebugging

(True if the API supports shader debugging.

shadersMutable

True if the driver mutates shader reflection structures from event to event. Currently this is only true for OpenGL where the superfluous indirect in the binding model must be worked around by re-sorting bindings.

vendor

The GPUVendor of the active GPU being used.

Device Protocols

class renderdoc.DeviceProtocolController

An interface for enumerating and controlling remote devices.

GetDevices()

Returns a list of devices currently available through the given protocol.

Until a device is enumerated through this function it may not be available for connection through other methods such as target control or remote server access, even if the device is physically connected, due to initialisation happening only when enumerated.

The returned string is the hostname of the device, which can be connected via protocol://hostname with interfaces that take a hostname.

Returns: A list of the devices currently available.
Return type: List[str]
GetFriendlyName(URL)

Retrieves the user friendly name of the given device. This may be easier for a user to correlate to a device than the hostname which may be only a programmatic identifier.

Parameters: URL # (str) – The URL of the device in the form protocol://host, with protocol as returned by GetProtocolName() and host as returned by GetDevices().
Returns: A string identifying the device.
Return type: str
GetProtocolName()

Retrieves the name of this protocol as passed to GetDeviceProtocolController().

Returns: A string identifying the protocol.
Return type: str
IsSupported(URL)

Query if the device supports RenderDoc capture and replay.

Parameters: URL # (str) – The URL of the device in the form protocol://host, with protocol as returned by GetProtocolName() and host as returned by GetDevices().
Returns: True if any the device is supported, False otherwise.
Return type: bool
StartRemoteServer(URL)

Start the remote server running on the given device.

Parameters: URL # (str) – The URL of the device in the form protocol://host, with protocol as returned by GetProtocolName() and host as returned by GetDevices().
Returns: The status of starting the server, whether success or failure.
Return type: ResultDetails
SupportsMultiplePrograms(URL)

Query if the device supports multiple programs running and being captured. If not, the user can be prompted to close an existing program before a new one is launched.

Parameters: URL # (str) – The URL of the device in the form protocol://host, with protocol as returned by GetProtocolName() and host as returned by GetDevices().
Returns: True if the device supports multiple programs, False otherwise.
Return type: bool
renderdoc.GetSupportedDeviceProtocols()

Retrieve the set of device protocols supported (see GetDeviceProtocolController()).

Returns: The supported device protocols.
Return type: List[str]
renderdoc.GetDeviceProtocolController(protocol)

Creates a DeviceProtocolController that provides device-specific controls.

This interface is intended to allow closer integration with remote devices.

Note

Note that the use of scripting with Android is explicitly not supported due to the inherent fragility and unreliability of the Android platform. This interface is designed primarily for internal use and no support will be provided for Android-specific problems encountered using this.

This function will not block, however the protocol may still be initialising when it is returned so immediate use of it may block.

Parameters: protocol # (str) – The protocol to fetch a controller for.
Returns: A handle to the protocol controller, or None if something went wrong such as an unsupported protocol being specified.
Return type: DeviceProtocolController

Remote Servers

class renderdoc.RemoteServer

A connection to a running remote RenderDoc server on another machine. This allows the transfer of captures to and from the local machine, as well as remotely replaying a capture with a local proxy renderer, so that captures that are not supported locally can still be debugged with as much work as possible happening on the local machine.

NoPreference

No preference for a particular value, see ReplayController.DebugPixel().

CloseCapture(rend)

Close a capture analysis handle previously opened by OpenCapture().

Parameters: rend # (ReplayController) – The ReplayController that is to be closed.
CopyCaptureFromRemote(remotepath, localpath, progress)

Copy a capture file that is stored on the remote system to the local system.

This function will block until the copy is fully complete, or an error has occurred.

Parameters:
  • remotepath # (str) – The remote path where the file should be copied from.
  • localpath # (str) – The local path where the file should be saved.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the copy. Can be None if no progress is desired.
CopyCaptureToRemote(filename, progress)

Copy a capture file that is stored on the local system to the remote system.

This function will block until the copy is fully complete, or an error has occurred.

This is primarily useful for when a capture is only stored locally and must be replayed remotely, as the capture must be available on the machine where the replay happens.

Parameters:
  • filename # (str) – The path to the file on the local system.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the copy. Can be None if no progress is desired.
Returns:

The path on the remote system where the capture was saved temporarily.
Return type:

str
ExecuteAndInject(app, workingDir, cmdLine, env, opts)

Launch an application and inject into it to allow capturing.

This happens on the remote system, so all paths are relative to the remote filesystem.

Parameters:
  • app # (str) – The path to the application to run.
  • workingDir # (str) – The working directory to use when running the application. If blank, the directory containing the application is used.
  • cmdLine # (str) – The command line to use when running the application, it will be processed in a platform specific way to generate arguments.
  • env # (List[ EnvironmentModification ]) – Any environment changes that should be made when running the program.
  • opts # (CaptureOptions) – The capture options to use when injecting into the program.
Returns:

The ExecuteResult indicating both the status of the operation (success or failure) and any reason for failure, or else the ident where the new application is listening for target control if everything succeeded.
Return type:

ExecuteResult
GetHomeFolder()

Retrieve the path on the remote system where browsing can begin.

Returns: The ‘home’ path where browsing for files or folders can begin.
Return type: str
ListFolder(path)

Retrieve the contents of a folder path on the remote system.

If an error occurs, a single PathEntry will be returned with appropriate error flags.

Parameters: path # (str) – The remote path to list.
Returns: The contents of the specified folder.
Return type: List[PathEntry]
LocalProxies()

Retrieve a list of renderers available for local proxying.

These will be strings like “D3D11” or “OpenGL”.

Returns: A list of names of the local proxies.
Return type: List[str]
OpenCapture(proxyid, logfile, opts, progress)

Open a capture file for remote capture and replay. The capture will be opened and replayed on the remote system, and proxied to the local system with a given renderer. As much work as possible will happen locally to save on bandwidth, processing and latency.

This function will block until the capture is fully opened on the remote system and ready for use, or an error has occurred.

Note

You must close the resulting ReplayController with the CloseCapture() function to ensure the local proxy is correctly tidied up, instead of using ReplayController.Shutdown().

Parameters:
  • proxyid # (int) – The index in the array returned by LocalProxies() to use as a local proxy, or NoPreference to indicate no preference for any proxy.
  • logfile # (str) – The path on the remote system where the file is. If the file is only available locally you can use CopyCaptureToRemote() to transfer it over the remote connection.
  • opts # (ReplayOptions) – The options controlling how the capture should be replayed.
  • progress # (ProgressCallback) – A callback that will be repeatedly called with an updated progress value for the opening. Can be None if no progress is desired.
Returns:

A tuple containing the status of opening the capture, whether success or failure, and the resulting ReplayController handle if successful.
Return type:

Tuple[ResultDetails,ReplayController]
Ping()

Pings the remote server to ensure the connection is still alive.

Returns: The result of the operation - if a failure occurred the connection is no longer alive.
Return type: ResultDetails
RemoteSupportedReplays()

Retrieve a list of renderers supported by the remote server.

These will be strings like “D3D11” or “OpenGL”.

Returns: A list of names of the remote renderers.
Return type: List[str]
ShutdownConnection()

Closes the connection without affecting the running server.

ShutdownServerAndConnection()

Closes the connection and also tells the running server to close.

TakeOwnershipCapture(filename)

Take ownership over a capture file.

Initially when a capture is made, it is owned by the injected library in the application. It passes ownership to any program that is connected via target control that is notified about the capture, which is then responsible for either saving the file or deleting it if it’s unwanted.

Passing ownership of a file to the remote server means that it will be kept around for future use until the server closes, at which point it will delete any files it owns.

Parameters: filename # (str) – The remote path to take ownership of.
renderdoc.CreateRemoteServerConnection(URL)

Create a connection to a remote server running on given hostname.

Parameters: URL # (str) – The hostname to connect to, if blank then localhost is used. If no protocol is specified then default TCP enumeration happens.
Returns: The status of opening the connection, whether success or failure, and a RemoteServer instance if it were successful
Return type: Tuple[ResultDetails,RemoteServer]
renderdoc.CheckRemoteServerConnection(URL)

Check the connection to a remote server running on given hostname.

This should be preferred to CreateRemoteServerConnection() when no connection is desired, as the status can be checked without interfering with making connections.

Parameters: URL # (str) – The hostname to connect to, if blank then localhost is used. If no protocol is specified then default TCP enumeration happens.
Returns: The status of the server.
Return type: ResultDetails
renderdoc.BecomeRemoteServer(listenhost, port, killReplay, previewWindow)

This launches a remote server which will continually run in a loop to server requests from external sources.

This function will block until a remote connection tells the server to shut down, or the killReplay callback returns True.

Parameters:
  • listenhost # (str) – The name of the interface to listen on.
  • port # (int) – The port to listen on, or 0 to listen on the default port.
  • killReplay # (KillCallback) – A callback that returns a bool indicating if the server should be shut down or not.
  • previewWindow # (PreviewWindowCallback) – A callback that returns information for a preview window when the server wants to display some preview of the ongoing replay.
class renderdoc.PathEntry

Properties of a path on a remote filesystem.

filename

The filename of this path. This contains only the filename, not the full path.

flags

The PathProperty flags for this path.

lastmod

The last modified date of this path, as a unix timestamp in UTC.

size

The size of the path in bytes.

class renderdoc.PathProperty(value)

A set of flags describing the properties of a path on a remote filesystem.

NoFlags

No special file properties.

Directory

This file is a directory or folder.

Hidden

This file is considered hidden by the filesystem.

Executable

This file has been identified as an executable program or script.

ErrorUnknown

A special flag indicating that a query for this file failed, but for unknown reasons.

ErrorAccessDenied

A special flag indicating that a query for this file failed because access to the path was denied.

ErrorInvalidPath

A special flag indicating that a query for this file failed because the path was invalid.


Replay Outputs

Contents

  • Replay Outputs
    • General
    • Window Configuration
    • Texture View
    • Mesh View

General

class renderdoc.ReplayOutput

A stateful output handle that contains the current configuration for one particular view of the capture. This allows multiple outputs to run independently without interfering with each other.

The different types are enumerated in ReplayOutputType.

NoResult

No result was found in e.g. PickVertex().

AddThumbnail(window, textureId, sub, typeCast)

Sets up a thumbnail for displaying a particular texture with sensible defaults.

The window handle specified will be filled (in an aspect-ratio preserving way) with the texture.

If the window specified has been used for a thumbnail before, then the texture will be updated but otherwise nothing will be created and the existing internal data will be reused. This means that you can call this function multiple times to just change the texture.

Should only be called for texture outputs.

Parameters:
  • window # (WindowingData) – A WindowingData describing the native window.
  • textureId # (ResourceId) – The texture ID to display in the thumbnail preview.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
Returns:

A result indicating if the thumbnail was successfully created.
Return type:

ResultDetails
ClearThumbnails()

Clear and release all thumbnails associated with this output. See AddThumbnail().

DisablePixelContext()

Disable the pixel context view from rendering.

Display()

Render to the window handle specified when the output was created.

This will also render any thumbnails and the pixel context, if enabled.

DrawThumbnail(width, height, textureId, sub, typeCast)

Draws a thumbnail for a particular texture with sensible defaults and returns an RGBA8 byte buffer for display. This does not render to a window but internally to a texture which is read back from the GPU.

Should only be called for texture outputs.

Parameters:
  • width # (int) – The width of the desired thumbnail.
  • height # (int) – The height of the desired thumbnail.
  • textureId # (ResourceId) – The texture ID to display in the thumbnail preview.
  • sub # (Subresource) – The subresource within this texture to use.
  • typeCast # (CompType) – If possible interpret the texture with this type instead of its normal type. If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
Returns:

A buffer with the thumbnail RGBA8 data if successful, or empty if something went wrong.
Return type:

bytes
GetCustomShaderTexID()

Retrieves the ResourceId containing the contents of the texture after being passed through a custom shader pass.

Should only be called for texture outputs.

Returns: The ResourceId assigned to the texture with the results of the custom shader.
Return type: ResourceId
GetDebugOverlayTexID()

Retrieves the ResourceId containing the contents of the debug overlay rendering (if enabled).

Should only be called for texture outputs.

Returns: The ResourceId assigned to the texture with the debug overlay.
Return type: ResourceId
GetDimensions()

Retrieve the current dimensions of the output.

Returns: The current width and height of the output.
Return type: Tuple[int,int]
PickVertex(x, y)

Retrieves the vertex and instance that is under the cursor location, when viewed relative to the current window with the current mesh display configuration.

Note

X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in bottom-left co-ordinates, care must be taken to translate them.

Should only be called for mesh outputs.

Parameters:
  • x # (int) – The x co-ordinate to pick from.
  • y # (int) – The y co-ordinate to pick from.
Returns:

A tuple with the first value being the vertex index in the mesh, and the second value being the instance index. The values are set to NoResult if no vertex was found,
Return type:

Tuple[int,int]
ReadbackOutputTexture()

Read the output texture back as byte data. Primarily useful for headless outputs where the output data is not displayed anywhere natively.

Returns: The output texture data as tightly packed RGB 3-byte data.
Return type: bytes
SetDimensions(width, height)

Sets the dimensions of the output, useful only for headless outputs that don’t have a backing window which don’t have any implicit dimensions. This allows configuring a virtual viewport which is useful for operations like picking vertices that depends on the output dimensions.

Note

For outputs with backing windows, this will be ignored.

Parameters:
  • width # (int) – The width to use.
  • height # (int) – The height to use.
SetMeshDisplay(config)

Sets the configuration for a mesh output.

Parameters: config # (MeshDisplay) – The configuration.
SetPixelContext(window)

Sets up a zoomed in pixel context view around a particular pixel selection.

The texture rendering uses the configuration specified in SetTextureDisplay() except with a fixed high zoom value and a fixed position, see SetPixelContextLocation().

Should only be called for texture outputs.

Parameters: window # (WindowingData) – A WindowingData describing the native window.
Returns: A result indicating if the pixel context was successfully configured.
Return type: ResultDetails
SetPixelContextLocation(x, y)

Sets the pixel that the pixel context should be centred on.

Should only be called for texture outputs.

Parameters:
  • x # (int) – The X co-ordinate to highlight.
  • y # (int) – The Y co-ordinate to highlight.
SetTextureDisplay(config)

Sets the configuration for a texture output.

Parameters: config # (TextureDisplay) – The configuration.
Shutdown()

Shutdown this output.

It’s optional to call this, as calling ReplayController.Shutdown() will shut down all of its outputs.

class renderdoc.ReplayOutputType(value)

The type of ReplayOutput to create

Headless

A headless output that does nothing to display to windows but can still be controlled and queried the same way

Texture

An output that is used for displaying textures, thumbnails and pixel context

Mesh

An output that will display mesh data previews

renderdoc.SetColors(darkChecker, lightChecker, darkTheme)

Configure the default colours used for checkerboards, this can broadly speaking help match the replay rendering to the overall theme of the replay application.

Parameters:
  • darkChecker # (FloatVector) – The color of dark squares in checkerboard patterns.
  • lightChecker # (FloatVector) – The color of light squares in checkerboard patterns.
  • darkTheme # (bool) – True if the theme is a ‘dark’ theme, used to pick different contrasting colors. False if the theme is ‘light’ and normal colors are used.

Window Configuration

class renderdoc.WindowingData

An opaque structure created to hold windowing setup data

class renderdoc.WindowingSystem(value)

Specifies a windowing system to use for creating an output window.

Unknown

Unknown window type, no windowing data is passed and no native window is described.

Headless

The windowing data doesn’t describe a real window but a virtual area, allowing all normal output rendering to happen off-screen. See CreateHeadlessWindowingData().

Win32

The windowing data refers to a Win32 window. See CreateWin32WindowingData().

Xlib

The windowing data refers to an Xlib window. See CreateXLibWindowingData().

XCB

The windowing data refers to an XCB window. See CreateXCBWindowingData().

Android

The windowing data refers to an Android window. See CreateAndroidWindowingData().

MacOS

The windowing data refers to a MacOS / OS X NSView & CALayer that is Metal/GL compatible. See CreateMacOSWindowingData().

GGP

The windowing data refers to an GGP surface. See CreateGgpWindowingData().

Wayland

The windowing data refers to an Wayland window. See CreateWaylandWindowingData().

renderdoc.CreateHeadlessWindowingData(width, height)

Create a WindowingData for no backing window, it will be headless.

Parameters:
  • width # (int) – The initial width for this virtual window.
  • height # (int) – The initial height for this virtual window.
Returns:

A WindowingData corresponding to an ‘empty’ backing window.
Return type:

WindowingData
renderdoc.CreateWin32WindowingData(window)

Create a WindowingData for a Win32 HWND handle.

Parameters: window # (HWND) – The native HWND handle for this window.
Returns: A WindowingData corresponding to the given window.
Return type: WindowingData
renderdoc.CreateXlibWindowingData(display, window)

Create a WindowingData for an Xlib Drawable handle.

Parameters:
  • display # (Display) – The Display connection used for this window.
  • window # (Drawable) – The native Drawable handle for this window.
Returns:

A WindowingData corresponding to the given window.
Return type:

WindowingData
renderdoc.CreateXCBWindowingData(connection, window)

Create a WindowingData for an XCB xcb_window_t handle.

Parameters:
  • connection # (xcb_connection_t) – The xcb_connection_t connection used for this window.
  • window # (xcb_window_t) – The native xcb_window_t handle for this window.
Returns:

A WindowingData corresponding to the given window.
Return type:

WindowingData
renderdoc.CreateWaylandWindowingData(display, window)

Create a WindowingData for an Wayland wl_surface handle.

Parameters:
  • display # (wl_display) – The wl_display connection used for this window.
  • window # (wl_surface) – The native wl_surface handle for this window.
Returns:

A WindowingData corresponding to the given window.
Return type:

WindowingData
renderdoc.CreateGgpWindowingData()

Create a WindowingData for a GGP application.

Returns: A WindowingData corresponding to the given system.
Return type: WindowingData
renderdoc.CreateAndroidWindowingData(window)

Create a WindowingData for an Android ANativeWindow handle.

Parameters: window # (ANativeWindow) – The native ANativeWindow handle for this window.
Returns: A WindowingData corresponding to the given window.
Return type: WindowingData
renderdoc.CreateMacOSWindowingData(view, layer)

Create a WindowingData for an metal/opengl-compatible macOS CALayer handle and NSView handle (as void pointers).

Parameters:
  • view # (NSView) – The native NSView handle for this window.
  • layer # (CALayer) – The native CALayer handle for this window.
Returns:

A WindowingData corresponding to the given window.
Return type:

WindowingData

Texture View

class renderdoc.TextureDisplay

Describes how to render a texture preview of an image. Describes the zoom and pan settings for the texture when rendering on a particular output, as well as the modification and selection of a particular subresource (such as array slice, mip or multi-sampled sample).

Note

X and Y co-ordinates are always considered to be top-left, even on GL, for consistency between APIs and preventing the need for API-specific code in most cases. This means if co-ordinates are fetched from e.g. viewport or scissor data or other GL pipeline state which is perhaps in bottom-left co-ordinates, care must be taken to translate them.

ResolveSamples

Value for sampleIdx if the samples should be averaged.

alpha

True if the alpha channel should be visible. If enabled with any of RGB, the texture will be blended to the background color or checkerboard.

If only one channel is selected, it will be rendered in grayscale

backgroundColor

The background color to use behind the texture display.

If set to (0, 0, 0, 0) the global checkerboard colors are used.

Type: FloatVector
blue

True if the blue channel should be visible.

If only one channel is selected, it will be rendered in grayscale

customShaderId

The ResourceId of a custom shader to use when rendering.

See ReplayController.BuildCustomShader() for creating an appropriate custom shader.

decodeYUV

True if the texture should be decoded as if it contains YUV data.

flipY

True if the texture should be flipped vertically when rendering.

green

True if the green channel should be visible.

If only one channel is selected, it will be rendered in grayscale

hdrMultiplier

If >= 0.0 the RGBA values will be viewed as HDRM with this as the multiplier.

linearDisplayAsGamma

True if the texture should be interpreted as gamma.

See the FAQ entry.

overlay

Selects a DebugOverlay to draw over the top of the texture.

rangeMax

The value in each channel to map to the white point.

rangeMin

The value in each channel to map to the black point.

rawOutput

True if the rendered image should be as close as possible in value to the input.

This is primarily useful when rendering to a floating point target for retrieving pixel data from the input texture in cases where it isn’t easy to directly fetch the input texture data.

red

True if the red channel should be visible.

If only one channel is selected, it will be rendered in grayscale

resourceId

The ResourceId of the texture to display.

scale

The scale to apply to the texture when rendering as a floating point value.

1.0 corresponds to 100%

subresource

The subresource of the texture to display.

If the Subresource.sample member is set to ResolveSamples then a default resolve will be performed that averages all samples.

Type: Subresource
typeCast

If possible interpret the texture with this type instead of its normal type.

If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.

xOffset

The offset to pan in the X axis.

yOffset

The offset to pan in the Y axis.

class renderdoc.DebugOverlay(value)

The type of overlay image to render on top of an existing texture view, for debugging purposes.

In overlays that refer to the ‘current pass’, for any API that does not have an explicit notion of a render pass, it is defined as all previous drawcalls that render to the same set of render targets. Note that this is defined independently from any marker regions.

See the documentation for this feature.

NoOverlay

No overlay should be rendered.

Drawcall

An overlay highlighting the area rasterized by the drawcall on screen, no matter what tests or processes may be discarding the pixels actually rendered.

The rest of the image should be dimmed slightly to make the draw on screen clearer.

Wireframe

Similar to the Drawcall overlay, this should render over the top of the image, but showing the wireframe of the object instead of a solid render.

Depth

This overlay shows pixels from the object that passed all depth tests in green, and pixels that failed any depth test in red.

If some pixel is overwritten more than once by the object, if any of the samples passed the result will be green (i.e. the failure overlay is conservative).

Stencil

This overlay shows pixels from the object that passed all stencil tests in green, and pixels that failed any stencil test in red.

If some pixel is overwritten more than once by the object, if any of the samples passed the result will be green (i.e. the failure overlay is conservative).

BackfaceCull

This overlay shows pixels from the object that passed backface culling in green, and pixels that were backface culled in red.

If some pixel is overwritten more than once by the object, if any of the samples passed the result will be green (i.e. the failure overlay is conservative).

ViewportScissor

This overlay shows a rectangle on screen corresponding to both the current viewport, and if enabled the current scissor as well.

NaN

This overlay renders the image in greyscale using a simple luminosity calculation, then highlights any pixels that are NaN in red, any that are positive or negative infinity in green, and any that are negative in blue.

Clipping

This overlay renders the image in greyscale using a simple luminosity calculation, then highlights any pixels that are currently above the white point in green and any pixels that are below the black point in red.

This is relative to the current black and white points used to display the texture.

ClearBeforePass

This overlay clears the bound render targets before the current pass, allowing you to see only the contribution from the current pass.

Note only color targets are cleared, depth-stencil targets are unchanged so any depth or stencil tests will still pass or fail in the same way.

ClearBeforeDraw

This is the same as the ClearBeforePass overlay, except it clears before the current drawcall, not the current pass.

QuadOverdrawPass

This overlay shows pixel overdraw using 2x2 rasterized quad granularity instead of single-pixel overdraw. This represents the number of times the pixel shader was invoked along triangle edges even if each pixel is only overdrawn once.

The overlay accounts for all draws in the current pass.

QuadOverdrawDraw

This is the same as the QuadOverdrawPass overlay, except it only shows the overdraw for the current drawcall, not the current pass.

TriangleSizePass

This overlay shows the size of each triangle, starting from triangles with area 16 (4x4) and above at the lower end to triangles with area 0.125 (1/8th pixel) at the upper end.

The overlay accounts for all draws in the current pass.

TriangleSizeDraw

This is similar to the TriangleSizePass overlay, except it only shows the triangle size for the current drawcall, not the current pass.

Mesh View

class renderdoc.MeshDisplay

Describes how to render a mesh preview of one or more meshes. Describes the camera configuration as well as what options to use when rendering both the current mesh, and any other auxilliary meshes.

NoHighlight

Value for highlightVert if no vertex should be highlighted.

aspect

The aspect ratio to use when calculating a perspective projection matrix.

axisMapping

The axis mapping to apply to the mesh.

Type: AxisMapping
cam

The camera to use when rendering all of the meshes.

Type: Camera
curInstance

The index of the currently selected instance in the drawcall.

curView

The index of the currently selected multiview view in the drawcall.

exploderScale

Scales the exploded vertex displacement.

fov

The field of view to use when calculating a perspective projection matrix.

highlightVert

The index of the vertex to highlight, or NoHighlight to select no vertex.

maxBounds

The maximum co-ordinates in each axis of the mesh bounding box.

Type: FloatVector
minBounds

The minimum co-ordinates in each axis of the mesh bounding box.

Type: FloatVector
ortho

True if the projection matrix to use when unprojecting vertex positions is orthographic.

position

The configuration for the primary mesh’s position data.

Type: MeshFormat
second

The configuration for the primary mesh’s secondary data, if used for solid shading.

Type: MeshFormat
showAllInstances

True if all instances in the drawcall should be drawn as secondary meshes.

showBBox

True if the bounding box around the mesh should be rendered.

showPrevInstances

True if all previous instances in the drawcall should be drawn as secondary meshes.

showWholePass

True if all draws in the current pass up to the current draw should be drawn as secondary meshes.

type

The MeshDataStage where this mesh data comes from.

visualisationMode

The visualisation mode to use when rendering the current mesh.

vtxExploderSliderSNorm

Displace/explode vertices to help visualise vertex reuse vs disjointedness.

wireframeDraw

True if the wireframe of the mesh should be rendered as well as solid shading.

class renderdoc.MeshDataStage(value)

Describes a particular stage in the geometry transformation pipeline.

VSIn

The inputs to the vertex shader described by the explicit API vertex input bindings.

VSOut

The outputs from the vertex shader corresponding one-to-one to the input elements.

GSOut

The final output from the last stage in the pipeline, be that tessellation or geometry shader.

This has possibly been expanded/multiplied from the inputs

TaskOut

Data from a task/amplification shader.

AmpOut

Data from an amplification shader (alias for TaskOut).

MeshOut

Data from a mesh shader.

class renderdoc.MeshletSize

The size information for a meshlet.

numIndices

The number of indices in the meshlet.

numVertices

The number of vertices in this meshlet. This may be larger or smaller than the number of indices.

class renderdoc.TaskGroupSize

The size information for a task group.

x

The size in the x dimension.

y

The size in the y dimension.

z

The size in the z dimension.

class renderdoc.MeshFormat

Contains the details of a single element of data (such as position or texture co-ordinates) within a mesh.

allowRestart

True if the primitive restart index feature should be used.

baseVertex

For indexed meshes, a value added to each index before using it to read the vertex.

dispatchSize

The size of the dispatch that launched a meshlet based draw.

Only valid for the task stage if task shaders are used.

Note

This is present because the dispatch size at the time of the mesh output fetch may not match the ActionDescription.dispatchDimension due to non-determinism in the capture. Being present here allows the replay to process the mesh output validly in itself without seeing a mismatch.

Type: Tuple[int,int,int]
farPlane

The far plane for the projection matrix.

flipY

True if there is an implicit Y-flip to account for in the projection.

format

The format description of this mesh components elements.

Type: ResourceFormat
indexByteOffset

The offset in bytes where the indices start in idxbuf.

indexByteSize

The number of bytes to use from the index buffer. Only valid on APIs that allow it.

indexByteStride

The width in bytes of each index. Valid values are 1 (depending on API), 2 or 4.

indexResourceId

The ResourceId of the index buffer that goes with this mesh element.

instStepRate

The number of instances to render with the same value. See instanced.

instanced

True if this mesh element comes from instanced data. See instStepRate.

meshColor

The color to use for rendering the wireframe of this mesh element.

Type: FloatVector
meshletIndexOffset

If showing a set of meshlets that don’t start from index 0, this is the number of vertices to consider skipped before meshletSizes - equivalent to baseVertex.

Primarily useful for keeping a consistent colouring of meshlets when filtering to a subset

See also meshletOffset.

meshletOffset

If showing a set of meshlets that don’t start from meshlet 0, this is the number of meshlet to consider skipped before meshletSizes.

Primarily useful for keeping a consistent colouring of meshlets when filtering to a subset

See also meshletIndexOffset.

meshletSizes

The size of each meshlet, for a meshlet based draw.

Each meshlet lists its individual size, but a cumulative sum can be used for defining boundaries between meshlets either by raw vertex order (using the number of indices) or by index value (using the number of vertices).

Type: List[MeshletSize]
nearPlane

The near plane for the projection matrix.

numIndices

The number of vertices in the mesh.

perPrimitiveOffset

The offset in bytes to the start of the per-primitive rate vertex data.

Only for meshlet outputs.

perPrimitiveStride

The stride in bytes of the per-primitive rate vertex data.

Only for meshlet outputs.

restartIndex

The primitive restart index to use, if possible. See allowRestart.

showAlpha

True if the alpha component of this element should be used.

status

A string with the status of this mesh format - only used when a mesh format is returned to the application detailing e.g. vertex output data.

An empty string indicates no errors/problems.

Type: str
taskSizes

The size of each task group’s dispatch, for a meshlet based draw.

Each group of a task shader within a dispatch can itself fill out a payload and dispatch a number of mesh groups. This list contains the 3-dimensional dimension that each task group emitted.

Type: List[TaskGroupSize]
topology

The Topology that describes the primitives in this mesh.

unproject

True if this mesh element contains post-projection positional data.

vertexByteOffset

The offset in bytes to the start of the vertex data.

vertexByteSize

The number of bytes to use from the vertex buffer. Only valid on APIs that allow it.

vertexByteStride

The stride in bytes between the start of one vertex and the start of another.

vertexResourceId

The ResourceId of the vertex buffer containing this mesh element.

class renderdoc.Visualisation(value)

What kind of visualisation to use when rendering a mesh.

NoSolid

No solid shading should be done.

Solid

The mesh should be rendered in a single flat unshaded color.

Lit

The mesh should be rendered with face normals generated on the primitives and used for lighting.

Secondary

The mesh should be rendered using the secondary element as color.

Explode

The mesh should be rendered with vertices displaced and coloured by vertex ID.

Meshlet

The mesh should be rendered colorising each meshlet differently.

class renderdoc.Camera

A handle to a camera controller, used for user interaction and controlling a view of a 3D scene.

GetForward()

Retrieves the forward vector of the camera, in the positive Z direction.

Returns: The forward vector of the camera. W is set to 1
Return type: FloatVector
GetPosition()

Retrieves the position of the camera

Returns: The position vector of the camera. W is set to 1
Return type: FloatVector
GetRight()

Retrieves the right vector of the camera, in the positive X direction.

Returns: The right vector of the camera. W is set to 1
Return type: FloatVector
GetUp()

Retrieves the up vector of the camera, in the positive Y direction.

Returns: The up vector of the camera. W is set to 1
Return type: FloatVector
ResetArcball()

Reset the arcball to defaults.

RotateArcball(ax, ay, bx, by)

Rotates the arcball based on relative window co-ordinates.

The co-ordinates are in pixels and represent the old/new co-ordinates of the mouse cursor over the drag.

Parameters:
  • ax # (float) – The X co-ordinate of the previous mouse position.
  • ay # (float) – The Y co-ordinate of the previous mouse position.
  • bx # (float) – The X co-ordinate of the new mouse position.
  • by # (float) – The Y co-ordinate of the new mouse position.
SetArcballDistance(dist)

Sets the distance in units the arcball camera sits away from the lookat position.

Parameters: dist # (float) – The distance of the camera from the lookat position.
SetFPSRotation(x, y, z)

Sets the rotation for an FPS camera.

It is invalid to call this function for arcball cameras.

Parameters:
  • x # (float) – The rotation around the X axis (pitch).
  • y # (float) – The rotation around the Y axis (yaw).
  • z # (float) – The rotation around the Z axis (roll).
SetPosition(x, y, z)

Sets the position for the camera, either arcball or FPS.

For arcball cameras, this sets the lookat position at the centre of the arcball.

For FPS look cameras, this sets the position of the camera in space.

Parameters:
  • x # (float) – The X co-ordinate of the position.
  • y # (float) – The Y co-ordinate of the position.
  • z # (float) – The Z co-ordinate of the position.
Shutdown()

Closes the camera handle.

class renderdoc.CameraType(value)

The type of camera controls for an Camera.

Arcball

Arcball controls that rotate and zoom around the origin point.

FPSLook

Traditional FPS style controls with movement in each axis relative to the current look direction.

class renderdoc.AxisMapping

A transform to map the x, y, and z axes to new directions.

xAxis

The mapping of the x axis.

Type: FloatVector
yAxis

The mapping of the y axis.

Type: FloatVector
zAxis

The mapping of the z axis.

Type: FloatVector
renderdoc.InitCamera(type)

Create a new camera of a given type.

Parameters: type # (CameraType) – The type of controls to use
Returns: The handle to the new camera.
Return type: Camera


Replay Analysis

Contents

  • Replay Analysis
    • Frame and Actions
    • Debug Messages
    • Resource Usage
    • Texture Saving
    • Pixel History
    • Shader Debuging

Frame and Actions

class renderdoc.FrameDescription

Contains frame-level global information

NoFrameNumber

No frame number is available.

captureTime

The time when the capture was created, as a unix timestamp in UTC.

compressedFileSize

The total file size of the whole capture in bytes, before decompression.

debugMessages

The debug messages that are not associated with any particular event.

Type: List[DebugMessage]
fileOffset

The offset into the file of the start of the frame.

Note

Similarly to APIEvent.fileOffset this should only be used as a relative measure, as it is not a literal number of bytes from the start of the file on disk.

frameNumber

Starting from frame #1 defined as the time from application startup to first present, this counts the frame number when the capture was made.

Note

This value is only accurate if the capture was triggered through the default mechanism, if it was triggered from the application API it doesn’t correspond to anything and will be set to NoFrameNumber.

initDataSize

The byte size of the section of the file that contains frame-initial contents.

persistentSize

The byte size of the section of the file that must be kept in memory persistently.

stats

The frame statistics.

Type: FrameStatistics
uncompressedFileSize

The total file size of the whole capture in bytes, after decompression.

class renderdoc.ActionDescription

Describes the properties of an action.

An action is a call such as a draw, a compute dispatch, clears, copies, resolves, etc. Any GPU event which may have deliberate visible side-effects to application-visible memory, typically resources such as textures and buffers. It also includes markers, which provide a user-generated annotation of events and actions.

GetName(structuredFile)

Returns the name for this action, either from its custom name (see customName) or from the matching chunk in the structured data passed in.

Parameters: structuredFile # (SDFile) – The structured data file for the capture this action is from.
Returns: Returns the best available name for this action.
Return type: str
IsFakeMarker()

Returns whether or not this action corresponds to a fake marker added by ReplayController.AddFakeMarkers().

Such actions may break expectations of event IDs and action IDs, so it is recommended to avoid processing them wherever possible.

Returns: Returns whether or not this action is a fake marker.
Return type: bool
actionId

A 1-based index of this action relative to other actions.

baseVertex

For indexed drawcalls, the offset added to each index after fetching.

children

The child actions below this one, if it’s a marker region or multi-action.

Type: List[ActionDescription]
copyDestination

The ResourceId identifying the destination object in a copy, resolve or blit operation.

copyDestinationSubresource

Which part of copyDestination is used.

Type: Subresource
copySource

The ResourceId identifying the source object in a copy, resolve or blit operation.

copySourceSubresource

Which part of copySource is used.

Type: Subresource
customName

The custom name of this action.

For markers this will be a user-provided string. In most other cases this will be empty, and the name can be generated using structured data. The last listed event in events will correspond to the event for the overall action, and its chunk will contain a name and any parameters.

Some actions will have a custom name generated for e.g. reading back and directly displaying indirect parameters or render pass parameters.

depthOut

The resource used for depth output - see outputs.

dispatchBase

The 3D base offset of the workgroup ID if the call allows an override, or 0 if not.

Type: Tuple[int,int,int]
dispatchDimension

The 3D number of workgroups to dispatch in a dispatch call.

Type: Tuple[int,int,int]
dispatchThreadsDimension

The 3D size of each workgroup in threads if the call allows an override, or 0 if not.

Type: Tuple[int,int,int]
drawIndex

The index of this action in an call with multiple draws, e.g. an indirect action.

0 if not part of a multi-action.

eventId

The eventId that actually produced the action.

events

The events that happened since the previous action.

Type: List[APIEvent]
flags

A set of ActionFlags properties describing what kind of action this is.

indexOffset

For indexed drawcalls, the first index to fetch from the index buffer.

instanceOffset

For instanced drawcalls, the offset applied before looking up instanced vertex inputs.

markerColor

A RGBA color specified by a debug marker call.

Type: FloatVector
next

The next action in the frame, or None if this is the last action in the frame.

Type: ActionDescription
numIndices

The number of indices or vertices as appropriate for a draw action. 0 if not used.

numInstances

The number of instances for a draw action. 0 if not used.

outputs

An 8-tuple of the ResourceId ids for the color outputs, which can be used for very coarse bucketing of actions into similar passes by their outputs.

Type: Tuple[ResourceId,…]
parent

The parent of this action, or None if there is no parent for this action.

Type: ActionDescription
previous

The previous action in the frame, or None if this is the first action in the frame.

Type: ActionDescription
vertexOffset

For non-indexed drawcalls, the offset applied before looking up each vertex input.

class renderdoc.ActionFlags(value)

A set of flags describing the properties of a particular action. An action is a call such as a draw, a compute dispatch, clears, copies, resolves, etc. Any GPU event which may have deliberate visible side-effects to application-visible memory, typically resources such as textures and buffers. It also includes markers, which provide a user-generated annotation of events and actions.

NoFlags

The action has no special properties.

Clear

The action is a clear call. See ClearColor and ClearDepthStencil.

Drawcall

The action renders primitives using the graphics pipeline.

Dispatch

The action issues a number of compute workgroups.

MeshDispatch

The action issues a number of mesh groups for a draw.

CmdList

The action calls into a previously recorded child command list.

SetMarker

The action inserts a single debugging marker.

PushMarker

The action begins a debugging marker region that has children.

PopMarker

The action ends a debugging marker region.

Present

The action is a presentation call that hands a swapchain image to the presentation engine.

MultiAction

The action is a multi-action that contains several specified child actions. Typically a MultiDraw or ExecuteIndirect on D3D12.

Copy

The action performs a resource copy operation.

Resolve

The action performs a resource resolve or blit operation.

GenMips

The action performs a resource mip-generation operation.

PassBoundary

The action marks the beginning or end of a render pass. See BeginPass and EndPass.

DispatchRay

This action issues a number of rays.

BuildAccStruct

This action builds the acceleration structure.

Indexed

The action uses an index buffer.

Instanced

The action uses instancing. This does not mean it renders more than one instanced, simply that it uses the instancing feature.

Auto

The action interacts with stream-out to render all vertices previously written. This is a Direct3D 11 specific feature.

Indirect

The action uses a buffer on the GPU to source some or all of its parameters in an indirect way.

ClearColor

The action clears a color target.

ClearDepthStencil

The action clears a depth-stencil target.

BeginPass

The action marks the beginning of a render pass.

EndPass

The action marks the end of a render pass.

CommandBufferBoundary

The action is a virtual marker added to show command buffer boundaries.

class renderdoc.APIEvent

An individual API-level event, generally corresponds one-to-one with an API call.

NoChunk

No chunk is available.

chunkIndex

The chunk index for this function call in the structured file.

If no chunk index is available this will be set to NoChunk. This will only happen for fake markers added to the capture after load.

eventId

The API event’s Event ID.

This is a 1-based count of API events in the capture. The eventId is used as a reference point in many places in the API to represent where in the capture the ‘current state’ is, and to perform analysis in reference to the state at a particular point in the frame.

eventIds are generally increasing, positive, and contiguous, with a few exceptions. These are when fake markers are added to a capture with ReplayController.AddFakeMarkers(). Thus if strong eventId guarantees are desired, this function should be avoided.

Also eventIds may not correspond directly to an actual function call - sometimes a function such as a multi action indirect will be one function call that expands to multiple events to allow inspection of results part way through the multi action.

fileOffset

A byte offset in the data stream where this event happens.

Note

This should only be used as a relative measure, it is not a literal number of bytes from the start of the file on disk.

Debug Messages

class renderdoc.DebugMessage

A debugging message from the API validation or internal analysis and error detection.

category

The category of this debug message.

description

The string contents of the message.

eventId

The eventId where this debug message was found.

messageID

An ID that identifies this particular debug message uniquely.

severity

The severity of this debug message.

source

The source of this debug message.

class renderdoc.MessageCategory(value)

The type of issue that a debug message is about.

Application_Defined

This message was generated by the application.

Miscellaneous

This message doesn’t fall into any other pre-defined category.

Initialization

This message is about initialisation or creation of objects.

Cleanup

This message is about cleanup, destruction or shutdown of objects.

Compilation

This message is about compilation of shaders.

State_Creation

This message is about creating unified state objects.

State_Setting

This message is about changing current pipeline state.

State_Getting

This message is about fetching or retrieving current pipeline state.

Resource_Manipulation

This message is about updating or changing a resource’s properties or contents.

Execution

This message is about performing work.

Shaders

This message is about the use, syntax, binding or linkage of shaders.

Deprecated

This message is about the use of deprecated functionality.

Undefined

This message is about the use of undefined behaviour.

Portability

This message is about behaviour that could be or is not portable between different environments.

Performance

This message is about performance problems or pitfalls.

class renderdoc.MessageSeverity(value)

How serious a debug message is

High

This message is very serious, indicating a guaranteed problem or major flaw.

Medium

This message is somewhat serious, indicating a problem that should be addressed or investigated.

Low

This message is not very serious. This indicates something that might indicate a problem.

Info

This message is not about a problem but is purely informational.

class renderdoc.MessageSource(value)

Where a debug message was reported from

API

This message comes from the API’s debugging or validation layers.

RedundantAPIUse

This message comes from detecting redundant API calls - calls with no side-effect or purpose, e.g. setting state that is already set.

IncorrectAPIUse

This message comes from detecting incorrect use of the API.

GeneralPerformance

This message comes from detecting general performance problems that are not hardware or platform specific.

GCNPerformance

This message comes from detecting patterns that will cause performance problems on GCN-based hardware.

RuntimeWarning

This message comes not from inspecting the log but something detected at runtime while in use, for example exceptions generated during shader debugging.

UnsupportedConfiguration

This message comes from replaying a capture in an environment with insufficient capability to accurately reproduce the API work. Either this means the replay will be wrong, or it may be that depending on the exact API work some inaccuracies might happen.

Resource Usage

class renderdoc.EventUsage

Describes a particular use of a resource at a specific eventId.

eventId

The eventId where this usage happened.

usage

The ResourceUsage in question.

view

An optional ResourceId identifying the view through which the use happened.

class renderdoc.ResourceUsage(value)

How a resource is being used in the pipeline at a particular point.

Note that a resource may be used for more than one thing in one event, see EventUsage.

Unused

The resource is not being used.

VertexBuffer

The resource is being used as a fixed-function vertex buffer input.

IndexBuffer

The resource is being used as an index buffer.

VS_Constants

The resource is being used for constants in the vertex shader.

HS_Constants

The resource is being used for constants in the tessellation control or hull shader.

DS_Constants

The resource is being used for constants in the tessellation evaluation or domain shader.

GS_Constants

The resource is being used for constants in the geometry shader.

PS_Constants

The resource is being used for constants in the pixel shader.

CS_Constants

The resource is being used for constants in the compute shader.

TS_Constants

The resource is being used as a constants in the amplification or task shader.

MS_Constants

The resource is being used as a constants in the mesh shader.

All_Constants

The resource is being used for constants in all shader stages.

StreamOut

The resource is being used for stream out/transform feedback storage after geometry processing.

VS_Resource

The resource is being used as a read-only resource in the vertex shader.

HS_Resource

The resource is being used as a read-only resource in the tessellation control or hull shader.

DS_Resource

The resource is being used as a read-only resource in the tessellation evaluation or domain shader.

GS_Resource

The resource is being used as a read-only resource in the geometry shader.

PS_Resource

The resource is being used as a read-only resource in the pixel shader.

CS_Resource

The resource is being used as a read-only resource in the compute shader.

TS_Resource

The resource is being used as a read-only resource in the amplification or task shader.

MS_Resource

The resource is being used as a read-only resource in the mesh shader.

All_Resource

The resource is being used as a read-only resource in all shader stages.

VS_RWResource

The resource is being used as a read-write resource in the vertex shader.

HS_RWResource

The resource is being used as a read-write resource in the tessellation control or hull shader.

DS_RWResource

The resource is being used as a read-write resource in the tessellation evaluation or domain shader.

GS_RWResource

The resource is being used as a read-write resource in the geometry shader.

PS_RWResource

The resource is being used as a read-write resource in the pixel shader.

CS_RWResource

The resource is being used as a read-write resource in the compute shader.

TS_RWResource

The resource is being used as a read-write resource in the amplification or task shader.

MS_RWResource

The resource is being used as a read-write resource in the mesh shader.

All_RWResource

The resource is being used as a read-write resource in all shader stages.

InputTarget

The resource is being read as an input target for reading from the target currently being written.

ColorTarget

The resource is being written to as a color output.

DepthStencilTarget

The resource is being written to and tested against as a depth-stencil output.

Indirect

The resource is being used for indirect arguments.

Clear

The resource is being cleared.

Discard

The resource contents are discarded explicitly or implicitly.

GenMips

The resource is having mips generated for it.

Resolve

The resource is being resolved or blitted, as both source and destination.

ResolveSrc

The resource is being resolved or blitted from.

ResolveDst

The resource is being resolved or blitted to.

Copy

The resource is being copied, as both source and destination.

CopySrc

The resource is being copied from.

CopyDst

The resource is being copied to.

Barrier

The resource is being specified in a barrier, as defined in Vulkan or Direct3D 12.

CPUWrite

The resource is written from the CPU, either directly as mapped memory or indirectly via a synchronous update.

renderdoc.ResUsage(stage)

Calculate the ResourceUsage value for read-only resource use at a given shader stage.

Parameters: stage # (ShaderStage) – The shader stage.
Returns: The value for read-only resource usage at a given shader stage.
Return type: ResourceUsage
renderdoc.RWResUsage(stage)

Calculate the ResourceUsage value for read-write resource use at a given shader stage.

Parameters: stage # (ShaderStage) – The shader stage.
Returns: The value for read-write resource usage at a given shader stage.
Return type: ResourceUsage
renderdoc.CBUsage(stage)

Calculate the ResourceUsage value for constant buffer use at a given shader stage.

Parameters: stage # (ShaderStage) – The shader stage.
Returns: The value for constant buffer usage at a given shader stage.
Return type: ResourceUsage

Texture Saving

class renderdoc.TextureSave

Describes a texture to save and how to map it to the destination file format.

alpha

Controls handling of alpha channel, only relevant for file formats that don’t have alpha.

It is an AlphaMapping that controls what behaviour to use.

alphaCol

The background color if alpha is set to AlphaMapping.BlendToColor.

Type: FloatVector
channelExtract

Selects a single component out of a texture to save as grayscale, or -1 to save all.

comp

Controls black/white point mapping for output formats that are normal 8-bit SRGB, values are truncated so that values below the black point and above the white point are clamped, and the values in between are evenly distributed.

Type: TextureComponentMapping
destType

The FileType to use when saving to the destination file.

jpegQuality

The quality to use when saving to a JPG file. Valid values are between 1 and 100.

mip

Selects the mip to be written out.

If set to -1 then all mips are written, where allowed by file format. If not allowed, mip 0 is written

resourceId

The ResourceId of the texture to save.

sample

Controls mapping for multisampled textures (ignored if texture is not multisampled)

Type: TextureSampleMapping
slice

Controls mapping for arrayed textures (ignored if texture is not arrayed)

Type: TextureSliceMapping
typeCast

If possible interpret the texture with this type instead of its normal type.

If set to CompType.Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.

class renderdoc.FileType(value)

The format of an image file

DDS

A DDS file

PNG

A PNG file

JPG

A JPG file

BMP

A BMP file

TGA

A TGA file

HDR

An HDR file

EXR

An EXR file

Raw

Raw data, just the bytes of the image tightly packed with no metadata or compression/encoding

class renderdoc.AlphaMapping(value)

What to do with the alpha channel from a texture while saving out to a file.

Discard

Completely discard the alpha channel and only write RGB to the file.

BlendToColor

Blend to the primary background color using alpha.

BlendToCheckerboard

Blend to a checkerboard pattern with the primary and secondary background colors.

Preserve

Preserve the alpha channel and save it to the file by itself.

This is only valid for file formats that support alpha channels.

class renderdoc.TextureComponentMapping

How to map components to normalised [0, 255] for saving to 8-bit file formats.

blackPoint

The value that should be mapped to 0

whitePoint

The value that should be mapped to 255

class renderdoc.TextureSampleMapping

How to map multisampled textures for saving to non-multisampled file formats.

ResolveSamples

Value for sampleIndex if the samples should be averaged.

mapToArray

True if the samples should be mapped to array slices. A multisampled array expands each slice in-place, so it would be slice 0: sample 0, slice 0: sample 1, slice 1: sample 0, etc.

This then follows the mapping for array slices as with any other array texture. sampleIndex is ignored.

sampleIndex

If mapToArray is False this selects which sample should be extracted to treat as a normal 2D image. If set to ResolveSamples then instead there’s a default average resolve.

class renderdoc.TextureSliceMapping

How to map array textures for saving to non-arrayed file formats.

If sliceIndex is -1, cubeCruciform == slicesAsGrid == False and the file format doesn’t support saving all slices, only slice 0 is saved.

cubeCruciform

Write out 6 slices in a cruciform pattern:

     +----+
     | +y |
     |    |
+----+----+----+----+
| -x | +z | +x | -z |
|    |    |    |    |
+----+----+----+----+
     | -y |
     |    |
     +----+

With the gaps filled in with transparent black.

sliceGridWidth

The width of a grid if slicesAsGrid is True.

sliceIndex

Selects the (depth/array) slice to save.

If this is -1, then all slices are written out as detailed below. This is only supported in formats that don’t support slices natively, and will be done in RGBA8.

slicesAsGrid

If True, write out the slices as a 2D grid with the width given in sliceGridWidth. Any empty slices in the grid are written as transparent black.

Pixel History

class renderdoc.PixelModification

An attempt to modify a pixel by a particular event.

Passed()

Determine if this fragment passed all tests and wrote to the texture.

Returns: True if it passed all tests, False if it failed any.
Return type: bool
backfaceCulled

True if the backface culling test eliminated this fragment.

depthBoundsFailed

True if depth bounds clipping eliminated this fragment.

depthClipped

True if depth near/far clipping eliminated this fragment.

depthTestFailed

True if depth testing eliminated this fragment.

directShaderWrite

True if this event came as part of an arbitrary shader write.

eventId

The eventId where the modification happened.

fragIndex

A 0-based index of which fragment this modification corresponds to, in the case that multiple fragments from a single action wrote to a pixel.

postMod

The value of the texture after this fragment ran.

Type: ModificationValue
preMod

The value of the texture before this fragment ran.

This is valid only for the first fragment if multiple fragments in the same event write to the same pixel.

Type: ModificationValue
predicationSkipped

True if predicated rendering skipped this call.

primitiveID

The primitive that generated this fragment.

sampleMasked

True if the sample mask eliminated this fragment.

scissorClipped

True if scissor clipping eliminated this fragment.

shaderDiscarded

True if the pixel shader executed a discard on this fragment.

shaderOut

The value that this fragment wrote from the pixel shader.

Type: ModificationValue
stencilTestFailed

True if stencil testing eliminated this fragment.

unboundPS

True if no pixel shader was bound at this event.

viewClipped

True if viewport clipping eliminated this fragment.

class renderdoc.ModificationValue

The value of pixel output at a particular event.

IsValid()
Returns: Returns whether or not this modification value is valid.
Return type: bool
SetInvalid()

Sets this modification value to be invalid.

col

The color value.

Type: PixelValue
depth

The depth output, as a float.

stencil

The stencil output, or -1 if not available.

class renderdoc.PixelValue

The contents of an RGBA pixel.

floatValue

The RGBA value interpreted as float.

Type: Tuple[float, float, float, float]
intValue

The RGBA value interpreted as 32-bit signed integer.

Type: Tuple[int, int, int, int]
uintValue

The RGBA value interpreted as 32-bit unsigned integer.

Type: Tuple[int, int, int, int]

Shader Debuging

class renderdoc.DebugPixelInputs

Contains the properties used to select which fragment to debug, used as an input to DebugPixel.

primitive

The primitive index.

sample

The multi-sampled sample.

view

The layered or multiview rendering view index.


Formats

Contents

  • Formats
    • Resource Format

Resource Format

class renderdoc.ResourceFormat

Description of the format of a resource or element.

BGRAOrder()
Returns: True if the components are to be read in BGRA order.

Note

The convention is that components are in RGBA order. Whether that means first byte to last byte, or in bit-packed formats red in the lowest bits.

With BGRA order this means blue is in the first byte/lowest bits, but alpha is still always expected in the last byte/uppermost bits.

Return type: bool
BlockFormat()
Returns: True if the ResourceFormat is a block-compressed type.
Return type: bool
ElementSize()

Return the size of a single element in this format, usually a pixel. For regular sized formats this is just compByteWidth times compCount, for special packed formats it’s the tightly packed size of a single element, with no padding.

Block-compressed formats define an ‘element’ as a whole block of texels.

YUV formats where texel size varies depending on subsampling will return the size of a decompressed texel.

Returns: The size of an element
Return type: int
Name()
Returns: The name of the format.
Return type: str
SRGBCorrected()

Equivalent to checking if compType is CompType.UNormSRGB

Returns: True if the components are SRGB corrected on read and write.
Return type: bool
SetBGRAOrder(flag)

Set BGRA order flag. See BGRAOrder().

Parameters: flag # (bool) – The new flag value.
SetYUVPlaneCount(planes)

Set number of YUV planes. See YUVPlaneCount().

Invalid values will result in 1 being set.

Parameters: planes # (int) – The new number of YUV planes.
SetYUVSubsampling(subsampling)

Set YUV subsampling rate. See YUVSubsampling().

The value should be e.g. 444 for 4:4:4 or 422 for 4:2:2. Invalid values will result in 0 being set.

Parameters: subsampling # (int) – The new subsampling rate.
Special()
Returns: True if the ResourceFormat is a ‘special’ non-regular type.
Return type: bool
YUVPlaneCount()

Get the number of planes for a YUV format. Only valid when type is a YUV format like ResourceFormatType.YUV8.

For other formats, 1 is returned.

Returns: The number of planes
Return type: int
YUVSubsampling()

Get the subsampling rate for a YUV format. Only valid when type is a YUV format like ResourceFormatType.YUV8.

For other formats, 0 is returned.

Returns: The subsampling rate, e.g. 444 for 4:4:4 or 420 for 4:2:0
Return type: int
compByteWidth

The width in bytes of each component.

compCount

The number of components in each element.

compType

The type of each component.

Type: CompType
type

The ResourceFormatType of this format. If the value is not ResourceFormatType.Regular then it’s a non-uniform layout like block-compressed.

Type: ResourceFormatType
class renderdoc.ResourceFormatType(value)

A resource format’s particular type. This accounts for either block-compressed textures or formats that don’t have equal byte-multiple sizes for each channel.

Regular

This format has no special layout, so its format is described by a number of components, a CompType and a byte width per component.

Undefined

This format is undefined or unknown, or does not map to any known regular format.

BC1

A block-compressed texture in BC1 format (RGB with 1-bit alpha, 0.5 bytes per pixel)

Formerly known as DXT1, commonly used for color maps.

BC2

A block-compressed texture in BC2 format (RGB with 4-bit alpha, 1 byte per pixel)

Formerly known as DXT3, rarely used.

BC3

A block-compressed texture in BC3 format (RGBA, 1 byte per pixel)

Formerly known as DXT5, commonly used for color + alpha maps, or color with attached single channel data.

BC4

A block-compressed texture in BC4 format (Single channel, 0.5 bytes per pixel)

Commonly used for single component data such as gloss or height data.

BC5

A block-compressed texture in BC5 format (Two channels, 1 byte per pixel)

Commonly used for normal maps.

BC6

A block-compressed texture in BC6 format (RGB floating point, 1 byte per pixel)

Commonly used for HDR data of all kinds.

BC7

A block-compressed texture in BC7 format (RGB or RGBA, 1 byte per pixel)

Commonly used for high quality color maps, with or without alpha.

ETC2

A block-compressed texture in ETC2 format (RGB with 1-bit alpha, 0.5 bytes per pixel)

Commonly used on mobile or embedded platforms.

Note that the mode added in EAC with 1 byte per pixel and full 8-bit alpha is grouped as EAC, with a component count of 4. See EAC.

EAC

A block-compressed texture in EAC format, expanded from ETC2.

Commonly used on mobile or embedded platforms.

The single and dual channel formats encode 11-bit data with 0.5 bytes per channel (so the single channel format is 0.5 bytes per pixel total, and the dual channel format is 1 byte per pixel total). The four channel format is encoded similarly to ETC2 for the base RGB data and similarly to the single channel format for the alpha, giving 1 byte per pixel total. See ETC2.

ASTC

A block-compressed texture in ASTC format (Representation varies a lot)

The ASTC format encodes each block as 16 bytes, but the block size can vary from 4x4 (so 1 byte per pixel) up to 12x12 (0.11 bytes per pixel).

Each block can encode between one and three channels of data, either correlated or uncorrelated, in low or high dynamic range.

Commonly used on mobile or embedded platforms.

R10G10B10A2

Each pixel is stored in 32 bits. Red, green and blue are stored in 10-bits each and alpha in 2 bits. The data can either be unsigned normalised or unsigned integer.

R11G11B10

Each pixel is stored in 32 bits. Red and green are stored as an 11-bit float with no sign bit, 5-bit exponent and 6-bit mantissa. Blue is stored with 5-bit exponent and 5-bit mantissa.

R5G6B5

Each pixel is stored in 16 bits. Red and blue are stored as 5 bits, and green is stored as six. The data is unsigned normalised.

R5G5B5A1

Each pixel is stored in 16 bits. Red, green, and blue are stored as 5 bits, with 1-bit alpha. The data is unsigned normalised.

R9G9B9E5

Each pixel is stored in 32 bits. Red, green, and blue are stored with individual 9-bit mantissas and a shared 5-bit exponent. There are no sign bits.

R4G4B4A4

Each pixel is stored in 16 bits. Red, green, blue, and alpha are stored as 4-bit unsigned normalised values.

R4G4

Each pixel is stored in 8 bits. Red and green are stored as 4-bit unsigned normalised values.

D16S8

Each pixel is considered a packed depth-stencil value with 16 bit normalised depth and 8 bit stencil.

D24S8

Each pixel is considered a packed depth-stencil value with 24 bit normalised depth and 8 bit stencil.

D32S8

Each pixel is considered a packed depth-stencil value with 32 bit floating point depth and 8 bit stencil.

S8

Each pixel is an 8 bit stencil value.

YUV8

The pixel data is 8-bit in YUV subsampled format. More information about subsampling setup is stored separately

YUV10

The pixel data is 10-bit in YUV subsampled format. More information about subsampling setup is stored separately

YUV12

The pixel data is 12-bit in YUV subsampled format. More information about subsampling setup is stored separately

YUV16

The pixel data is 16-bit in YUV subsampled format. More information about subsampling setup is stored separately

PVRTC

PowerVR properitary texture compression format.

A8

8-bit unsigned normalised alpha - equivalent to standard R8 with a pre-baked swizzle.

class renderdoc.CompType(value)

Represents the component type of a channel in a texture or element in a structure.

Typeless

A component that has no concrete type.

Float

An IEEE floating point value of 64-bit, 32-bit or 16-bit size.

UNorm

An unsigned normalised floating point value. This is converted by dividing the input value by the maximum representable unsigned integer value, to produce a value in the range [0, 1]

SNorm

A signed normalised floating point value in range. This is converted by dividing the input value by the maximum representable positive signed integer value, to produce a value in the range [-1, 1]. As a special case, the maximum negative signed integer is also mapped to -1 so there are two representations of -1. This means there is only one 0 value and that there is the same range of available values for positive and negative values.

For example, signed 16-bit integers range from -32768 to +32767. -32768 is mapped to -1, and then any other value is divided by 32767 giving an equal set of values in the range [-1, 0] as in the range [0, 1].

UInt

An unsigned integer value.

SInt

A signed integer value.

UScaled

An unsigned scaled floating point value. This is converted from the input unsigned integer without any normalisation as with UNorm, so the resulting values range from 0 to the maximum unsigned integer value 2^N - 1.

SScaled

A signed scaled floating point value. This is converted from the input unsigned integer without any normalisation as with SNorm, so the resulting values range from the minimum signed integer value -2^(N-1) to the maximum signed integer value 2^(N-1) - 1.

Depth

An opaque value storing depth information, either floating point for 32-bit depth values or else unsigned normalised for other bit sizes.

UNormSRGB

Similar to UNorm normalised between the minimum and maximum unsigned values to 0.0 - 1.0, but with an sRGB gamma curve applied.


Resources

Contents

  • Resources
    • General
    • Textures
    • Buffers

General

class renderdoc.ResourceId

This is an opaque identifier that uniquely locates a resource.

Note

These IDs do not overlap ever - textures, buffers, shaders and samplers will all have unique IDs and do not reuse the namespace. Likewise the IDs assigned for resources during capture are not re-used on replay - the corresponding resources created on replay to stand-in for capture-time resources are given unique IDs and a mapping is stored to between the capture-time resource and the replay-time one.

static Null()

A helper function that explicitly creates an empty/invalid/null ResourceId.

Returns: an empty/invalid/null ResourceId.
Return type: ResourceId
class renderdoc.ResourceDescription

A description of any type of resource.

SetCustomName(givenName)

Utility function for setting up a custom name to overwrite the auto-generated one.

Parameters: givenName # (str) – The custom name to use.
autogeneratedName

True if name was just autogenerated based on the ID, not assigned a human-readable name by the application.

derivedResources

The ResourceId of any derived resources, such as resource views or aliases.

Can be empty if there are no derived resources.

This is the inverse of parentResources in a potentially many:many relationship, but typically it is one parent to many derived.

Type: List[ResourceId]
initialisationChunks

The chunk indices in the structured file that initialised this resource.

This will at least contain the first call that created it, but may contain other auxilliary calls.

Type: List[int]
name

The name given to this resource.

parentResources

The ResourceId of parent resources, of which this is derived.

Can be empty if there are no parent resources.

This is the inverse of derivedResources in a potentially many:many relationship, but typically it is one parent to many derived.

Type: List[ResourceId]
resourceId

The unique ResourceId that identifies this resource.

type

The ResourceType of the resource.

class renderdoc.ResourceType(value)

The type of a resource referred to by binding or API usage.

In some cases there is a little overlap or fudging when mapping API concepts - this is primarily just intended for e.g. fuzzy user filtering or rough categorisation. Precise mapping would require API-specific concepts.

Unknown

An unknown type of resource.

Device

A system-level object, typically unique.

Queue

A queue representing the ability to execute commands in a single stream, possibly in parallel to other queues.

CommandBuffer

A recorded set of commands that can then be subsequently executed.

Texture

A texture - one- to three- dimensional, possibly with array layers and mip levels. See TextureDescription.

Buffer

A linear (possibly typed) view of memory. See BufferDescription.

View

A particular view into a texture or buffer, e.g. either accessing the underlying resource through a different type, or only a subset of the resource.

Sampler

The information regarding how a texture is accessed including wrapping, minification/magnification and other information. The precise details are API-specific and listed in the API state when bound.

SwapchainImage

A special class of Texture that is owned by the swapchain and is used for presentation.

Memory

An object corresponding to an actual memory allocation, which other resources can then be bound to.

Shader

A single shader object for any shader stage. May be bound directly, or used to compose into a PipelineState depending on the API.

ShaderBinding

An object that determines some manner of shader binding. Since this varies significantly by API, different concepts used for shader resource binding fall under this type.

PipelineState

A single object containing all information regarding the current GPU pipeline, containing both shader objects, potentially some shader binding information, and fixed-function state.

StateObject

A single object encapsulating some amount of related state that can be set together, instead of setting each individual state separately.

RenderPass

An object related to collecting render pass information together. This may not be an actual explicit render pass object if it doesn’t exist in the API, it may also be a collection of textures in a framebuffer that are bound together to the API for rendering.

Query

A query for retrieving some kind of feedback from the GPU, either as a fixed number or a boolean value which can be used in predicated rendering.

Sync

A synchronisation object used for either synchronisation between GPU and CPU, or GPU-to-GPU work.

Pool

An object which pools together other objects in an opaque way, either for runtime allocation and deallocation, or for caching purposes.

AccelerationStructure

A structure used to carry implementation-defined spatial partitioning data and related information, used to accelerate geometry intersection queries (e.g. for ray tracing).

Textures

class renderdoc.TextureDescription

A description of a texture resource.

arraysize

How many array elements this texture has, will be at least 1.

byteSize

How many bytes would be used to store this texture and all its mips/slices.

creationFlags

The way this texture will be used in the pipeline.

cubemap

True if this texture is used as a cubemap or cubemap array.

depth

The depth of the texture, or 1 if not applicable.

dimension

The base dimension of the texture - either 1, 2, or 3.

format

The format of each pixel in the texture.

Type: ResourceFormat
height

The height of the texture, or 1 if not applicable.

mips

How many mips this texture has, will be at least 1.

msQual

The quality setting of this texture, or 0 if not applicable.

msSamp

How many multisampled samples this texture has, will be at least 1.

resourceId

The unique ResourceId that identifies this texture.

type

The TextureType of the texture.

width

The width of the texture, or length for buffer textures.

class renderdoc.TextureType(value)

The dimensionality of a texture binding.

Unknown

An unknown type of texture.

Buffer

A texel buffer.

Texture1D

A 1D texture.

Texture1DArray

A 1D texture array.

Texture2D

A 2D texture.

TextureRect

A rectangle texture, a legacy format for non-power of two textures.

Texture2DArray

A 2D texture array.

Texture2DMS

A multi-sampled 2D texture.

Texture2DMSArray

A multi-sampled 2D texture array.

Texture3D

A 3D texture.

TextureCube

A Cubemap texture.

TextureCubeArray

A Cubemap texture array.

class renderdoc.TextureCategory(value)

A set of flags describing how this texture may be used

NoFlags

The texture will not be used for any of the uses below.

ShaderRead

The texture will be read by a shader.

ColorTarget

The texture will be written to as a color target.

DepthTarget

The texture will be written to and tested against as a depth target.

ShaderReadWrite

The texture will be read and written to by a shader.

SwapBuffer

The texture is part of a window swapchain.

class renderdoc.Subresource

Specifies a subresource within a texture.

mip

The mip level in the texture.

sample

The sample in a multisampled texture.

slice

The slice within the texture. For 3D textures this is a depth slice, for arrays it is an array slice.

Note

Cubemaps are simply 2D array textures with a special meaning, so the faces of a cubemap are the 2D array slices in the standard order: X+, X-, Y+, Y-, Z+, Z-. Cubemap arrays are 2D arrays with 6 * N faces, where each cubemap within the array takes up 6 slices in the above order.

Buffers

class renderdoc.BufferDescription

A description of a buffer resource.

creationFlags

The way this buffer will be used in the pipeline.

gpuAddress

The known base GPU Address of this buffer. 0 if not applicable or available.

length

The byte length of the buffer.

resourceId

The unique ResourceId that identifies this buffer.

class renderdoc.BufferCategory(value)

A set of flags describing how this buffer may be used

NoFlags

The buffer will not be used for any of the uses below.

Vertex

The buffer will be used for sourcing vertex input data.

Index

The buffer will be used for sourcing primitive index data.

Constants

The buffer will be used for sourcing shader constant data.

ReadWrite

The buffer will be used for read and write access from shaders.

Indirect

The buffer will be used to provide indirect parameters for launching GPU-based actions.


Shaders

Contents

  • Shaders
    • Bindpoints
    • Reflection
    • Debug Info
    • Shader Constants
    • Shader Debugging
    • Shader Variables

Bindpoints

class renderdoc.ShaderBindpointMapping

This structure goes hand in hand with ShaderReflection to determine how to map from bindpoint indices in the resource lists there to API-specific binding points. The bindPoint member in ShaderResource or ConstantBlock refers to an index in these associated lists, which then map potentially sparsely and potentially in different orders to the appropriate API registers, indices, or slots.

API specific details:

  • Direct3D11 - All Bindpoint.bindset values are 0 as D3D11 has no notion of sets, and the only namespacing that exists is by shader stage and object type. Mostly this already exists with the constant block, read only and read write resource lists.

    Bindpoint.arraySize is likewise unused as D3D11 doesn’t have arrayed resource bindings.

    Bindpoint.bind refers to the register/slot binding within the appropriate type (SRVs for read-only resources, UAV for read-write resources, samplers/constant buffers in each type).

  • OpenGL - Similarly to D3D11, Bindpoint.bindset and Bindpoint.arraySize are unused as OpenGL does not have true binding sets or array resource binds.

    For OpenGL there may be many more duplicate Bindpoint objects as the Bindpoint.bind refers to the index in the type-specific list, which is much more granular on OpenGL. E.g. 0 may refer to images, storage buffers, and atomic buffers all within the readWriteResources list. The index is the uniform value of the binding. Since no objects are namespaced by shader stage, the same value in two shaders refers to the same binding.

  • Direct3D12 - Since D3D12 doesn’t have true resource arrays (they are linearised into sequential registers) Bindpoint.arraySize is not used.

    Bindpoint.bindset corresponds to register spaces, with Bindpoint.bind then mapping to the register within that space. The root signature then maps these registers to descriptors.

  • Vulkan - For Vulkan Bindpoint.bindset corresponds to the index of the descriptor set, and Bindpoint.bind refers to the index of the descriptor within that set. Bindpoint.arraySize also is used as descriptors in Vulkan can be true arrays, bound all at once to a single binding.

constantBlocks

Provides a list of Bindpoint entries for remapping the ShaderReflection.constantBlocks list.

Type: List[Bindpoint]
inputAttributes

This maps input attributes as a simple swizzle on the ShaderReflection.inputSignature indices for APIs where this mapping is mutable at runtime.

Type: List[int]
readOnlyResources

Provides a list of Bindpoint entries for remapping the ShaderReflection.readOnlyResources list.

Type: List[Bindpoint]
readWriteResources

Provides a list of Bindpoint entries for remapping the ShaderReflection.readWriteResources list.

Type: List[Bindpoint]
samplers

Provides a list of Bindpoint entries for remapping the ShaderReflection.samplers list.

Type: List[Bindpoint]
class renderdoc.Bindpoint

Declares the binding information for a single resource binding.

See ShaderBindpointMapping for how this mapping works in detail.

arraySize

If this is an arrayed binding, the number of elements in the array.

bind

The binding index.

bindset

The binding set.

used

True if the shader actually uses this resource, otherwise it’s declared but unused.

class renderdoc.BindpointIndex

References a particular element in a Bindpoint.

arrayIndex

If this is an arrayed binding, the element in the array being referenced.

bind

The binding index.

bindset

The binding set.

Reflection

class renderdoc.ShaderReflection

The reflection and metadata fully describing a shader.

The information in this structure is API agnostic, and is matched up against a ShaderBindpointMapping instance to map the information here to the API’s binding points and resource binding scheme.

constantBlocks

The constant block bindings.

Type: List[ConstantBlock]
debugInfo

The embedded debugging information.

Type: ShaderDebugInfo
dispatchThreadsDimension

The 3D dimensions of a compute workgroup, for compute shaders.

Type: Tuple[int,int,int]
encoding

The ShaderEncoding of this shader. See rawBytes.

entryPoint

The entry point in the shader for this reflection, if multiple entry points exist.

inputSignature

The input signature.

Type: List[SigParameter]
interfaces

The list of strings with the shader’s interfaces. Largely an unused API feature.

Type: List[str]
outputSignature

The output signature.

Type: List[SigParameter]
outputTopology

The output topology for geometry, tessellation and mesh shaders.

Type: Topology
pointerTypes

The list of pointer types referred to in this shader.

Type: List[ShaderConstantType]
rawBytes

A raw bytes dump of the original shader, encoded in the form denoted by encoding.

readOnlyResources

The read-only resource bindings.

Type: List[ShaderResource]
readWriteResources

The read-write resource bindings.

Type: List[ShaderResource]
resourceId

The ResourceId of this shader.

samplers

The sampler bindings.

Type: List[ShaderSampler]
stage

The ShaderStage that this shader corresponds to, if multiple entry points exist.

taskPayload

The block layout of the task-mesh communication payload.

Only relevant for task or mesh shaders, this gives the output payload (for task shaders) or the input payload (for mesh shaders)

Type: ConstantBlock
class renderdoc.ShaderStage(value)

The stage in a pipeline where a shader runs

Vertex

The vertex shader.

Hull

The hull shader. See also Tess_Control.

Tess_Control

The tessellation control shader. See also Hull.

Domain

The domain shader. See also Tess_Eval.

Tess_Eval

The tessellation evaluation shader. See also Domain.

Geometry

The geometry shader.

Pixel

The pixel shader. See also Fragment.

Fragment

The fragment shader. See also Pixel.

Compute

The compute shader.

Amplification

The amplification shader. See also Task.

Task

The task shader. See also Amplification.

Mesh

The mesh shader.

class renderdoc.ShaderStageMask(value)

A set of flags for ShaderStage stages

Unknown

No flags set for any shader stages.

Vertex

The flag for ShaderStage.Vertex.

Hull

The flag for ShaderStage.Hull.

Tess_Control

The flag for ShaderStage.Tess_Control.

Domain

The flag for ShaderStage.Domain.

Tess_Eval

The flag for ShaderStage.Tess_Eval.

Geometry

The flag for ShaderStage.Geometry.

Pixel

The flag for ShaderStage.Pixel.

Fragment

The flag for ShaderStage.Fragment.

Compute

The flag for ShaderStage.Compute.

Task

The flag for ShaderStage.Task.

Amplification

The flag for ShaderStage.Amplification.

Mesh

The flag for ShaderStage.Mesh.

All

A shorthand version with flags set for all stages together.

renderdoc.MaskForStage(stage)

Calculate the corresponding flag for a shader stage

Parameters: stage # (ShaderStage) – The shader stage
Returns: The flag that corresponds to the input shader stage
Return type: ShaderStageMask
class renderdoc.SigParameter

The information describing an input or output signature element describing the interface between shader stages.

NoIndex

Value for an index that means it is invalid or not applicable for this parameter.

channelUsedMask

A bitmask indicating which components in the shader register are actually used by the shader itself, for APIs that pack signatures together.

compCount

The number of components used to store this element. See varType.

needSemanticIndex

A convenience flag - True if the semantic name is unique and no index is needed.

perPrimitiveRate

A flag indicating if this parameter is output at per-primitive rate rather than per-vertex.

regChannelMask

A bitmask indicating which components in the shader register are stored, for APIs that pack signatures together.

regIndex

The index of the shader register/binding used to store this signature element.

This may be NoIndex if the element is system-generated and not consumed by another shader stage. See systemValue.

semanticIdxName

The combined semantic name and index.

semanticIndex

The semantic index of this variable - see semanticName.

semanticName

The semantic name of this variable, if the API uses semantic matching for bindings.

stream

Selects a stream for APIs that provide multiple output streams for the same named output.

systemValue

The ShaderBuiltin value that this element contains.

varName

The name of this variable - may not be present in the metadata for all APIs.

varType

The variable type of data that this element stores.

class renderdoc.ShaderBuiltin(value)

Annotates a particular built-in input or output from a shader with a special meaning to the hardware or API.

Some of the built-in inputs or outputs can be declared multiple times in arrays or otherwise indexed to apply to multiple related things - see ClipDistance, CullDistance and ColorOutput.

Undefined

Undefined built-in or no built-in is attached to this shader variable.

Position

As an output from the final vertex processing shader stage, this feeds the vertex position to the rasterized. As an input to the pixel shader stage this receives the position from the rasterizer.

PointSize

An output that controls the size of point primitives.

ClipDistance

An output for the distance to a user-defined clipping plane. Any pixel with an interpolated value that is negative will not be rasterized. Typically there can be more than one such output.

CullDistance

An output for the distance to a user-defined culling plane. Any primitive with all vertices having negative values will not be rasterized. Typically there can be more than one such output.

RTIndex

An output for selecting the render target index in an array to render to. Available in geometry shaders and possibly earlier stages depending on hardware/API capability.

ViewportIndex

An output for selecting the viewport index to render to. Available in geometry shaders and possibly earlier stages depending on hardware/API capability.

VertexIndex

An input to the vertex shader listing the vertex index. The exact meaning of this index can vary by API but generally it refers to either a 0-based counter for non-indexed draws, or the index value for indexed draws. It may or may not be affected by offsets, depending on API semantics.

PrimitiveIndex

A built-in indicating which primitive is being processed. This can be read by all primitive stages after the vertex shader, and written by the geometry shader.

InstanceIndex

This built-in is defined similar to VertexIndex but for instances within an instanced drawcall. It counts from 0 and as with VertexIndex it may or may not be affected by drawcall offsets.

DispatchSize

An input in compute shaders that gives the number of workgroups executed by the dispatch call.

DispatchThreadIndex

An input in compute shaders giving a 3D shared index across all workgroups, such that the index varies across each thread in the workgroup up to its size, then the indices for workgroup (0,0,1) begin adjacent to where workgroup (0,0,0) ended.

This is related to GroupThreadIndex and GroupIndex.

GroupIndex

An input in compute shaders giving a 3D index of this current workgroup amongst all workgroups, up to the dispatch size.

The index is constant across all threads in the workgroup.

This is related to GroupThreadIndex and DispatchThreadIndex.

GroupSize

The size of a workgroup, giving the number of threads in each dimension.

GroupFlatIndex

An input in compute shaders giving a flat 1D index of the thread within the current workgroup. This index increments first in the X dimension, then in the Y dimension, then in the Z dimension.

GroupThreadIndex

An input in compute shaders giving a 3D index of this thread within its workgroup, up to the workgroup size.

The input does not vary between one thread in a workgroup and the same thread in another workgroup.

This is related to GroupIndex and DispatchThreadIndex.

GSInstanceIndex

An input to the geometry shader giving the instance being run, if the geometry shader was setup to be invoked multiple times for each input primitive.

OutputControlPointIndex

An input to the tessellation control or hull shader giving the output control point index or patch vertex being operated on.

DomainLocation

An input to the tessellation evaluation or domain shader, giving the normalised location on the output patch where evaluation is occuring. E.g. for triangle output this is the barycentric co-ordinates of the output vertex.

IsFrontFace

An input to the pixel shader indicating whether or not the contributing triangle was considered front-facing or not according to the API setup for winding order and backface orientation.

MSAACoverage

An input or an output from the pixel shader. As an input, it specifies a bitmask of which samples in a pixel were covered by the rasterizer. As an output, it specifies which samples in the destination target should be updated.

MSAASamplePosition

An input to the pixel shader that contains the location of the current sample relative to the pixel, when running the pixel shader at sample frequency.

MSAASampleIndex

An input to the pixel shader that indicates which sample in the range 0 .. N-1 is currently being processed.

PatchNumVertices

An input to the tessellation stages, this gives the number of vertices in each patch.

OuterTessFactor

An output from the tessellation control or hull shader, this determines the level to which the outer edge of each primitive is tessellated by the fixed-function tessellator.

It is also available for reading in the tessellation evaluation or domain shader.

InsideTessFactor

Related to OuterTessFactor this functions in the same way to determine the tessellation level inside the primitive.

ColorOutput

An output from the pixel shader, this determines the color value written to the corresponding target. There will be as many color output built-ins as there are targets bound.

DepthOutput

An output from the pixel shader, writes the depth of this pixel with no restrictions.

Related to DepthOutputGreaterEqual and DepthOutputLessEqual.

DepthOutputGreaterEqual

An output from the pixel shader, writes the depth of this pixel with the restriction that it will be greater than or equal to the original depth produced by the rasterizer.

Related to DepthOutput and DepthOutputLessEqual.

DepthOutputLessEqual

An output from the pixel shader, writes the depth of this pixel with the restriction that it will be less than or equal to the original depth produced by the rasterizer.

Related to DepthOutputGreaterEqual and DepthOutput.

BaseVertex

The first vertex processed in this draw, as specified by the firstVertex / baseVertex parameter to the draw call.

BaseInstance

The first instance processed in this draw call, as specified by the firstInstance parameter.

DrawIndex

For indirect or multi-draw commands, the index of this draw call within the overall draw command.

StencilReference

The stencil reference to be used for stenciling operations on this fragment.

PointCoord

The fragments co-ordinates within a point primitive being rasterized.

IsHelper

Indicates if the current invocation is a helper invocation.

SubgroupSize

The number of invocations in a subgroup.

NumSubgroups

The number of subgroups in the local workgroup.

SubgroupIndexInWorkgroup

The index of the current subgroup within all subgroups in the workgroup, up to NumSubgroups - 1.

IndexInSubgroup

The index of the current thread in the current subgroup, up to SubgroupSize - 1.

SubgroupEqualMask

A bitmask where the bit corresponding to IndexInSubgroup is set.

SubgroupGreaterEqualMask

A bitmask where all bits greater or equal to the one corresponding to IndexInSubgroup are set.

SubgroupGreaterMask

A bitmask where all bits greater than the one corresponding to IndexInSubgroup are set.

SubgroupLessEqualMask

A bitmask where all bits less or equal to the one corresponding to IndexInSubgroup are set.

SubgroupLessMask

A bitmask where all bits less than the one corresponding to IndexInSubgroup are set.

DeviceIndex

The device index executing the shader, relative to the current device group.

IsFullyCovered

Indicates if the current fragment area is fully covered by the generating primitive.

FragAreaSize

Gives the dimensions of the area that the fragment covers.

FragInvocationCount

Gives the maximum number of invocations for the fragment being covered.

PackedFragRate

Contains the packed shading rate, with an API specific packing of X and Y. For example:

1x being 0, 2x being 1, 4x being 2. Then the lower two bits being the Y rate and the next 2 bits being the X rate.

Barycentrics

Contains the barycentric co-ordinates.

CullPrimitive

An output to indicate whether or not a primitive should be culled.

OutputIndices

An output containing the indices for a meshlet.

MultiViewIndex

An input specifying the view being rendered to in multiview rendering. Only valid when multiview rendering is enabled.

class renderdoc.ConstantBlock

Contains the information for a block of constant values. The values are not present, only the metadata about how the variables are stored in memory itself and their type/name information.

bindPoint

The bindpoint for this block. This is an index in the ShaderBindpointMapping.constantBlocks list.

bufferBacked

True if the contents are stored in a buffer of memory. If not then they are set by some other API-specific method, such as direct function calls or they may be compile-time specialisation constants.

byteSize

The total number of bytes consumed by all of the constants contained in this block.

compileConstants

True if this is a virtual buffer listing compile-time specialisation constants.

inlineDataBytes

True if this is backed by in-line data bytes rather than a specific buffer.

name

The name of this constant block, may be empty on some APIs.

variables

The constants contained within this block.

Type: List[ShaderConstant]
class renderdoc.ShaderSampler

Contains the information for a separate sampler in a shader. If the API doesn’t have the concept of separate samplers, this struct will be unused and only ShaderResource is relevant.

Note

that constant blocks will not have a shader resource entry, see ConstantBlock.

bindPoint

The bindpoint for this block. This is an index in either the ShaderBindpointMapping.samplers list.

name

The name of this sampler.

class renderdoc.ShaderResource

Contains the information for a shader resource that is made accessible to shaders directly by means of the API resource binding system.

Note

that constant blocks and samplers will not have a shader resource entry, see ConstantBlock and ShaderSampler.

bindPoint

The bindpoint for this block. This is an index in either the ShaderBindpointMapping.readOnlyResources list or ShaderBindpointMapping.readWriteResources list as appropriate (see isReadOnly).

isReadOnly

True if this resource is available to the shader for reading only, otherwise it is able to be read from and written to arbitrarily.

isTexture

True if this resource is a texture, otherwise it is a buffer.

name

The name of this resource.

resType

The TextureType that describes the type of this resource.

variableType

The type of each element of this resource.

Type: ShaderConstantType

Debug Info

class renderdoc.ShaderDebugInfo

Contains the information about a shader contained within API-specific debugging information attached to the shader.

Primarily this means the embedded original source files.

compileFlags

The flags used to compile this shader.

Type: ShaderCompileFlags
compiler

The KnownShaderTool of the compiling tool.

Type: KnownShaderTool
debugStatus

If debuggable is false then this contains a simple explanation of why the shader is not supported for debugging

debuggable

Indicates whether this particular shader can be debugged. In some cases even if the API can debug shaders in general, specific shaders cannot be debugged because they use unsupported functionality

editBaseFile

The index of the file which should be used for re-editing this shader’s entry point.

This is an optional value, and if set to -1 you should fall back to using the file specified in entryLocation, and if no file is specified there then use the first file listed.

encoding

The ShaderEncoding of the source. See files.

Type: ShaderEncoding
entryLocation

The source location of the first executable line or the entry point.

Note

The information is not guaranteed to be available depending on the underlying shader format, so all of the elements are optional.

Type: LineColumnInfo
entrySourceName

The name of the entry point in the source code, not necessarily the same as the entry point name exported to the API.

Type: str
files

The shader files encoded in the form denoted by encoding.

The first entry in the list is always the file where the entry point is.

Type: List[ShaderSourceFile]
sourceDebugInformation

Indicates whether this shader has debug information to allow source-level debugging.

class renderdoc.ShaderEncoding(value)

Identifies a shader encoding used to pass shader code to an API.

Unknown

Unknown or unprocessable format.

DXBC

DXBC binary shader, used by D3D11 and D3D12.

GLSL

GLSL in string format, used by OpenGL.

SPIRV

SPIR-V binary shader, as used by Vulkan. This format is technically not distinct from OpenGLSPIRV but is considered unique here since it really should have been a different format, and introducing a separation allows better selection of tools automatically.

SPIRVAsm

Canonical SPIR-V assembly form, used (indirectly via SPIRV) by Vulkan. See SPIRV.

OpenGLSPIRV

SPIR-V binary shader, as used by OpenGL. This format is technically not distinct from VulkanSPIRV but is considered unique here since it really should have been a different format, and introducing a separation allows better selection of tools automatically.

OpenGLSPIRVAsm

Canonical SPIR-V assembly form, used (indirectly via OpenGLSPIRV) by OpenGL. See OpenGLSPIRV and note that it’s artificially differentiated from SPIRVAsm.

HLSL

HLSL in string format, used by D3D11, D3D12, and Vulkan/GL via compilation to SPIR-V.

DXIL

DXIL binary shader, used by D3D12. Note that although the container is still DXBC format this is used to distinguish from DXBC for compiler I/O matching.

Slang

Slang in string format, used by the slang compiler for compilation to multiple backend formats.

class renderdoc.KnownShaderTool(value)

Identifies a particular known tool used for shader processing.

Unknown

Corresponds to no known tool.

SPIRV_Cross
SPIRV-Cross
targetting normal Vulkan flavoured SPIR-V.
SPIRV_Cross_OpenGL
SPIRV-Cross
targetting OpenGL extension flavoured SPIR-V.
spirv_dis
spirv-dis from SPIRV-Tools
targetting normal Vulkan flavoured SPIR-V.
spirv_dis_OpenGL
spirv-dis from SPIRV-Tools
targetting OpenGL extension flavoured SPIR-V.
glslangValidatorGLSL
glslang compiler (GLSL)
targetting normal Vulkan flavoured SPIR-V.
glslangValidatorGLSL_OpenGL
glslang compiler (GLSL)
targetting OpenGL extension flavoured SPIR-V.
glslangValidatorHLSL

glslang compiler (HLSL).

spirv_as
spirv-as from SPIRV-Tools
targetting normal Vulkan flavoured SPIR-V.
spirv_as_OpenGL
spirv-as from SPIRV-Tools
targetting OpenGL extension flavoured SPIR-V.
dxcSPIRV
DirectX Shader Compiler with Vulkan SPIR-V
output.
dxcDXIL

DirectX Shader Compiler with DXIL output.

fxc

fxc Shader Compiler with DXBC output.

slangSPIRV

Slang Shader Compiler with Vulkan SPIR-V output.

slangDXIL

Slang Shader Compiler with DXIL output.

renderdoc.ToolExecutable(tool)

Returns the default executable name with no suffix for a given KnownShaderTool.

Note

The executable name is returned with no suffix, e.g. foobar which may need a platform specific suffix like .exe appended.

Parameters: tool # (KnownShaderTool) – The tool to get the executable name for.
Returns: The default executable name for this tool, or an empty string if the tool is unrecognised.
Return type: str
renderdoc.ToolInput(tool)

Returns the expected default input ShaderEncoding that a KnownShaderTool expects. This may not be accurate and may be configurable depending on the tool.

Parameters: tool # (KnownShaderTool) – The tool to get the input encoding for.
Returns: The encoding that this tool expects as an input by default.
Return type: renderdoc.ShaderEncoding
renderdoc.ToolOutput(tool)

Returns the expected default output ShaderEncoding that a KnownShaderTool produces. This may not be accurate and may be configurable depending on the tool.

Parameters: tool # (KnownShaderTool) – The tool to get the output encoding for.
Returns: The encoding that this tool produces as an output by default.
Return type: renderdoc.ShaderEncoding
renderdoc.IsTextRepresentation(encoding)

Check whether or not this is a human readable text representation.

Parameters: encoding # (ShaderEncoding) – The encoding to check.
Returns: True if it describes a text representation, False for a bytecode representation.
Return type: bool
class renderdoc.ShaderEntryPoint

Describes an entry point in a shader.

name

The name of the entry point.

stage

The ShaderStage for this entry point .

class renderdoc.ShaderSourceFile

Contains a source file available in a debug-compiled shader.

contents

The actual contents of the file.

filename

The filename of this source file.

class renderdoc.ShaderCompileFlags

Contains the information about the compilation environment of a shader

flags

The API or compiler specific flags used to compile this shader originally.

Type: List[ShaderCompileFlag]
class renderdoc.ShaderCompileFlag

Contains a single flag used at compile-time on a shader.

name

The name of the compile flag.

value

The value of the compile flag.

class renderdoc.ShaderSourcePrefix

Contains the source prefix to add to a given type of shader source

encoding

The encoding of the language this prefix applies to.

prefix

The source prefix to add.

Shader Constants

class renderdoc.ShaderConstant

Contains the detail of a constant within a struct, such as a ConstantBlock, with its type and relative location in memory.

bitFieldOffset

If the variable is bitfield packed, the bit offset from byteOffset above where this variable starts.

If the variable is not a bitfield, this value will be 0. Only integer scalars will have bitfield packing.

Note

Although the offset specified in byteOffset is in bytes, this bitfield offset may be larger than 0 depending on the surrounding values and their types and packing. However it is guaranteed that the offset and the size (from bitFieldSize) will be contained within the normal bit size for the variable type. For example if the variable type is a 32-bit integer, the offsets may range from 0 to 31 and the sum of offset and size will be no more than 32. If the variable is an 8-bit integer, similarly the offset will be 0 to 7 and the sum will be no more than 8.

bitFieldSize

If the variable is bitfield packed, the number of bits this variable spans starting from bitFieldOffset into memory.

If the variable is not a bitfield, this value will be 0. Only integer scalars will have bitfield packing.

byteOffset

The byte offset of this constant relative to the parent structure

defaultValue

If this constant is no larger than a 64-bit constant, gives a default value for it.

name

The name of this constant

type

The type information for this constant.

Type: ShaderConstantType
class renderdoc.ShaderConstantType

Describes the type and members of a ShaderConstant.

ColMajor()

Helper function for checking if flags does not have ShaderVariableFlags.RowMajorMatrix set. This is entirely equivalent to checking that flag manually, but since it is common this helper is provided.

Note

Vectors and scalars will be marked as row-major by convention for convenience.

Returns: If the storage is column-major order in memory
Return type: bool
RowMajor()

Helper function for checking if flags has ShaderVariableFlags.RowMajorMatrix set. This is entirely equivalent to checking that flag manually, but since it is common this helper is provided.

Note

Vectors and scalars will be marked as row-major by convention for convenience.

Returns: If the storage is row-major order in memory
Return type: bool
arrayByteStride

The number of bytes between the start of one element in the array and the next.

baseType

The base VarType of this constant.

columns

The number of columns in this matrix.

elements

The number of elements in the array, or 1 if it’s not an array.

flags

The flags controlling how this constant is interpreted and displayed.

Type: ShaderVariableFlags
matrixByteStride

The number of bytes between the start of one column/row in a matrix and the next.

members

Any members that this constant may contain.

Type: List[ShaderConstant]
name

The name of the type of this constant, e.g. a struct name.

pointerTypeID

The index in ShaderReflection.pointerTypes of the pointee type.

rows

The number of rows in this matrix.

class renderdoc.ShaderVariableFlags(value)

A set of flags for events that control how a shader/buffer value is interpreted and displayed

NoFlags

No flags are specified.

RowMajorMatrix

This matrix is stored in row-major order in memory, instead of column-major. In RenderDoc values are always provided row-major regardless, for consistency of access, but if this flag is not present then the original values were in column order in memory, so the data has been transposed.

HexDisplay

This value should be displayed using hexadecimal where possible.

BinaryDisplay

This value should be displayed using binary where possible.

RGBDisplay

This value should be interpreted as an RGB colour for display where possible.

R11G11B10

This value should be decoded from a 32-bit integer in R11G11B10 packing format.

R10G10B10A2

This value should be decoded from a 32-bit integer in R10G10B10A2 packing format.

UNorm

This value should be treated as unsigned normalised floating point values when interpreting.

SNorm

This value should be treated as signed normalised floating point values when interpreting.

Truncated

This value was truncated when reading - the available range was exhausted.

class renderdoc.VarType(value)

Represents the base type of a shader variable in debugging or constant blocks.

Float

A single-precision (32-bit) floating point value.

Double

A double-precision (64-bit) floating point value.

Half

A half-precision (16-bit) floating point value.

SInt

A signed 32-bit integer value.

UInt

An unsigned 32-bit integer value.

SShort

A signed 16-bit integer value.

UShort

An unsigned 16-bit integer value.

SLong

A signed 64-bit integer value.

ULong

An unsigned 64-bit integer value.

SByte

A signed 8-bit integer value.

UByte

An unsigned 8-bit integer value.

Bool

A boolean value.

Enum

An enum - each member gives a named value, and the type itself is stored as an integer.

Struct

A structure with some number of members.

GPUPointer

A 64-bit pointer into GPU-addressable memory. Variables with this type are stored with opaque contents and should be decoded with ShaderVariable.GetPointer().

ConstantBlock

A reference to a constant block bound to the shader. Variables with this type are stored with opaque contents and should be decoded with ShaderVariable.GetBinding().

ReadOnlyResource

A reference to a read only resource bound to the shader. Variables with this type are stored with opaque contents and should be decoded with ShaderVariable.GetBinding().

ReadWriteResource

A reference to a read/write resource bound to the shader. Variables with this type are stored with opaque contents and should be decoded with ShaderVariable.GetBinding().

Sampler

A reference to a sampler bound to the shader. Variables with this type are stored with opaque contents and should be decoded with ShaderVariable.GetBinding().

Unknown

An unknown type.

renderdoc.VarTypeByteSize(type)

Get the byte size of a variable type.

Parameters: type # (VarType) – The variable type
Returns: The size in bytes of this type
Return type: int
renderdoc.VarTypeCompType(type)

Get the component type of a variable type.

Parameters: type # (VarType) – The variable type
Returns: The base component type of this variable type
Return type: CompType

Shader Debugging

class renderdoc.ShaderDebugTrace

This stores the whole state of a shader’s execution from start to finish, with each individual debugging step along the way, as well as the immutable global constant values that do not change with shader execution.

constantBlocks

Constant buffer backed variables for this shader.

Each entry in this list corresponds to a constant block with the same index in the ShaderBindpointMapping.constantBlocks list, which can be used to look up the metadata.

Depending on the underlying shader representation, the constant block may retain any structure or it may have been vectorised and flattened.

Type: List[ShaderVariable]
debugger

An opaque handle identifying by the underlying debugger, which is used to simulate the shader and generate new debug states.

If this is None then the trace is invalid.

Type: ShaderDebugger
inputs

The input variables for this shader.

Type: List[ShaderVariable]
instInfo

An array of the same size as the number of instructions in the shader, with per-instruction information such as source line mapping, and source variables.

Warning

This array is not indexed by instruction. Since it is common for adjacent instructions to have effectively identical source information, this array only stores unique information ordered by instruction. On some internal representations this may be one entry per instruction, and on others it may be sparse and require a binary lookup to locate the corresponding information for an instruction. If no direct match is found, the lower bound match is valid (i.e. the data for instruction A before the data for instruction B is valid for all instructions in range [A, B).

Type: List[InstructionSourceInfo]
readOnlyResources

The read-only resource variables for this shader.

The ‘value’ of the variable is always a single unsigned integer, which is the bindpoint - an index into the ShaderBindpointMapping.readOnlyResources list, which can be used to look up the other metadata as well as find the binding from the pipeline state.

Type: List[ShaderVariable]
readWriteResources

The read-write resource variables for this shader.

The ‘value’ of the variable is always a single unsigned integer, which is the bindpoint - an index into the ShaderBindpointMapping.readWriteResources list, which can be used to look up the other metadata as well as find the binding from the pipeline state.

Type: List[ShaderVariable]
samplers

The sampler variables for this shader.

The ‘value’ of the variable is always a single unsigned integer, which is the bindpoint - an index into the ShaderBindpointMapping.samplers list, which can be used to look up the other metadata as well as find the binding from the pipeline state.

Type: List[ShaderVariable]
sourceVars

An optional mapping from high-level source variables to which debug variables and includes extra type information.

This list contains source variable mapping that is valid for the lifetime of a debug trace. It may be empty if there is no source variable mapping that extends to the life of the debug trace.

Type: List[SourceVariableMapping]
stage

The shader stage being debugged in this trace

class renderdoc.ShaderDebugger

An opaque structure that has internal state for shader debugging

class renderdoc.SourceVariableMapping

Maps the contents of a high-level source variable to one or more shader variables in a ShaderDebugState, with type information.

A single high-level variable may be represented by multiple mappings but only along regular boundaries, typically whole vectors. For example an array may have each element in a different mapping, or a matrix may have a mapping per row. The properties such as rows and elements reflect the parent object.

Note

There is not necessarily a 1:1 mapping from source variable to debug variable, so this can change over time.

columns

The number of columns in this variable.

name

The name and member of this source variable that’s being mapped from.

offset

The offset in the parent source variable, for struct members. Useful for sorting.

rows

The number of rows in this variable - 1 for vectors, >1 for matrices.

signatureIndex

The index in the input or output signature of the shader that this variable represents.

The type of signature can be disambiguated by the debug variables referenced - inputs are stored separately.

This will be set to -1 if the variable is not part of either signature.

type

The variable type of the source being mapped from, if the debug variable is untyped.

variables

The debug variables that the components of this high level variable map to. Multiple ranges could refer to the same variable if a contiguous range is mapped to - the mapping is component-by-component to greatly simplify algorithms at the expense of a small amount of storage space.

Type: List[DebugVariableReference]
class renderdoc.DebugVariableReference

A particular component of a debugging variable that a high-level variable component maps to

component

The component within the variable.

name

The name of the base debug variable.

type

The type of variable this is referring to.

class renderdoc.DebugVariableType(value)

Represents the category of debugging variable that a source variable maps to.

Undefined

Undefined type.

Input

A constant input value, stored globally.

Constant

A constant buffer value, stored globally.

Sampler

A sampler, stored globally.

ReadOnlyResource

A read-only resource, stored globally.

ReadWriteResource

A read-write resource, stored globally.

Variable

A mutable variable, stored per state.

class renderdoc.LineColumnInfo

Details the current region of code that an instruction maps to

SourceEqual(o)
Parameters: o # (LineColumnInfo) – The object to compare against.
Returns: True if this object is equal to the parameter, disregarding disassemblyLine.
Return type: bool
colEnd

The column number (starting from 1) of the end of the code on the line specified by lineEnd. If set to 0, no column information is available and the whole lines should be treated as covering the code.

colStart

The column number (starting from 1) of the start of the code on the line specified by lineStart. If set to 0, no column information is available and the whole lines should be treated as covering the code.

disassemblyLine

The line (starting from 1) in the disassembly where this instruction is located.

fileIndex

The current file, as an index into the list of files for this shader.

If this is negative, no source mapping is available and only disassemblyLine is valid.

lineEnd

The ending line-number (starting from 1) of the source code.

lineStart

The starting line-number (starting from 1) of the source code.

class renderdoc.InstructionSourceInfo

Gives per-instruction source code mapping information, including what line(s) correspond to this instruction and which source variables exist

instruction

The instruction that this information is for.

lineInfo

The source location that this instruction corresponds to

Type: LineColumnInfo
sourceVars

An optional mapping of which high-level source variables map to which debug variables and including extra type information.

This list contains source variable mapping that is only valid at this instruction, and is fully complete & redundant including all previous source variables that are still valid at this instruction.

Type: List[SourceVariableMapping]
class renderdoc.ShaderDebugState

This stores the current state of shader debugging at one particular step in the shader, with all mutable variable contents.

callstack

The function names in the current callstack at this instruction.

The oldest/outer function is first in the list, the newest/inner function is last.

Type: List[str]
changes

The changes in mutable variables for this shader. The change documents the bidirectional change of variables, so that a single state can be updated either forwards or backwards using the information.

Type: List[ShaderVariableChange]
flags

A set of ShaderEvents flags that indicate what events happened on this step.

nextInstruction

The next instruction to be executed after this state. The initial state before any shader execution happened will have nextInstruction == 0.

stepIndex

The program counter within the debug trace. The initial state will be index 0, and it will increment linearly after that regardless of loops or branching.

class renderdoc.ShaderEvents(value)

A set of flags for events that may occur while debugging a shader

NoEvent

No event has occurred.

SampleLoadGather

A texture was sampled, loaded or gathered.

GeneratedNanOrInf

A floating point operation generated a NaN or infinity result.

class renderdoc.ShaderVariableChange

This stores the before and after state of a ShaderVariable.

after

The value of the variable after the change. If this variable is uninitialised that means the variable stopped existing on this step.

Type: ShaderVariable
before

The value of the variable before the change. If this variable is uninitialised that means the variable came into existance on this step.

Type: ShaderVariable

Shader Variables

class renderdoc.ShaderVariable

Holds a single named shader variable. It contains either a primitive type (up to a 4x4 matrix of a basic type) or a list of members, which can either be struct or array members of this parent variable.

Matrices are always stored row-major. If necessary they are transposed when retrieving from the raw data bytes when they are specified to be column-major in the API/shader metadata.

ColMajor()

Helper function for checking if flags does not have ShaderVariableFlags.RowMajorMatrix set. This is entirely equivalent to checking that flag manually, but since it is common this helper is provided.

Note

Vectors and scalars will be marked as row-major by convention for convenience.

Returns: If the storage is column-major order in memory
Return type: bool
GetBinding()

Utility function for getting the bindpoint referenced by this variable.

Note

The return value is undefined if this variable is not a binding reference.

Returns: A BindpointIndex with the binding referenced.
Return type: BindpointIndex
GetPointer()

Utility function for getting a pointer value, with optional type information.

Note

The return value is undefined if this variable is not a pointer.

Returns: A PointerVal with the pointer value.
Return type: PointerVal
RowMajor()

Helper function for checking if flags has ShaderVariableFlags.RowMajorMatrix set. This is entirely equivalent to checking that flag manually, but since it is common this helper is provided.

Note

Vectors and scalars will be marked as row-major by convention for convenience.

Returns: If the storage is row-major order in memory
Return type: bool
SetBinding(bindset, bind, arrayIndex)

Utility function for setting a bindpoint reference.

See ShaderBindpointMapping for the details of how bindpoints are interpreted. The type of binding is given by the type member.

Parameters:
  • bindset # (int) – The bind set.
  • bind # (int) – The bind itself.
  • arrayIndex # (int) – The array index, if the bind is an array. If it isn’t an array this should be set to 0.
SetTypedPointer(pointer, shader, pointerTypeID)

Utility function for setting a pointer value with type information.

Parameters:
  • pointer # (int) – The actual pointer value.
  • shader # (ResourceId) – The shader containing the type information.
  • pointerTypeID # (int) – The type’s index in the shader’s ShaderReflection.pointerTypes list.
SetTypelessPointer(pointer)

Utility function for setting a pointer value with no type information.

Parameters: pointer # (int) – The actual pointer value.
columns

The number of columns in this matrix.

flags

The flags controlling how this constant is interpreted and displayed.

Type: ShaderVariableFlags
members

The members of this variable.

Type: List[ShaderVariable]
name

The name of this variable.

rows

The number of rows in this matrix.

type

The basic type of this variable.

value

The contents of this variable if it has no members.

Type: ShaderValue
class renderdoc.ShaderValue

A C union that holds 16 values, with each different basic variable type.

f16v

16-tuple of 16-bit half-precision float values.

Type: Tuple[int,…]
f32v

16-tuple of float values.

Type: Tuple[float,…]
f64v

16-tuple of double values.

Type: Tuple[float,…]
s16v

16-tuple of 16-bit signed integer values.

Type: Tuple[int,…]
s32v

16-tuple of 32-bit signed integer values.

Type: Tuple[int,…]
s64v

16-tuple of 64-bit signed integer values.

Type: Tuple[int,…]
s8v

16-tuple of 8-bit signed integer values.

Type: Tuple[int,…]
u16v

16-tuple of 16-bit unsigned integer values.

Type: Tuple[int,…]
u32v

16-tuple of 32-bit unsigned integer values.

Type: Tuple[int,…]
u64v

16-tuple of 64-bit unsigned integer values.

Type: Tuple[int,…]
u8v

16-tuple of 8-bit unsigned integer values.

Type: Tuple[int,…]
class renderdoc.PointerVal

A 64-bit pointer value with optional type information.

pointer

The actual pointer value itself.

pointerTypeID

The index into ShaderReflection.pointerTypes of the pointed type.

shader

An optional ResourceId identifying the shader containing the type info.


Pipeline State Objects

  • D3D11 Pipeline State
  • D3D12 Pipeline State
  • OpenGL Pipeline State
  • Vulkan Pipeline State
  • Common Pipeline State Abstraction


D3D11 Pipeline State

Contents

  • D3D11 Pipeline State
    • Vertex Input
    • Shaders and Bindings
    • Stream-out
    • Rasterizer
    • Output Merger
    • Predication
class renderdoc.D3D11State

The full current D3D11 pipeline state.

computeShader

The compute shader stage.

Type: D3D11Shader
domainShader

The domain shader stage.

Type: D3D11Shader
geometryShader

The geometry shader stage.

Type: D3D11Shader
hullShader

The hull shader stage.

Type: D3D11Shader
inputAssembly

The input assembly pipeline stage.

Type: D3D11InputAssembly
outputMerger

The output merger pipeline stage.

Type: D3D11OutputMerger
pixelShader

The pixel shader stage.

Type: D3D11Shader
predication

The predicated rendering state.

Type: D3D11Predication
rasterizer

The rasterizer pipeline stage.

Type: D3D11Rasterizer
streamOut

The stream-out pipeline stage.

Type: D3D11StreamOut
vertexShader

The vertex shader stage.

Type: D3D11Shader

Vertex Input

class renderdoc.D3D11InputAssembly

Describes the input assembler data.

bytecode

The shader reflection for the bytecode used to create the input layout.

Type: ShaderReflection
indexBuffer

The bound index buffer.

Type: D3D11IndexBuffer
layouts

The input layout elements in this layout.

Type: List[D3D11Layout]
resourceId

The ResourceId of the layout object.

topology

The current primitive topology.

Type: Topology
vertexBuffers

The bound vertex buffers

Type: List[D3D11VertexBuffer]
class renderdoc.D3D11IndexBuffer

Describes the D3D11 index buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the index data.

byteStride

The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but it can be 0 if no index buffer is bound.

resourceId

The ResourceId of the index buffer.

class renderdoc.D3D11VertexBuffer

Describes a single D3D11 vertex buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the vertex data.

byteStride

The byte stride between the start of one set of vertex data and the next.

resourceId

The ResourceId of the buffer bound to this slot.

class renderdoc.D3D11Layout

Describes a single D3D11 input layout element for one vertex input.

TightlyPacked

Value for byteOffset that indicates this element is tightly packed.

byteOffset

The byte offset from the start of the vertex data in the vertex buffer from inputSlot.

If the value is TightlyPacked then the element is packed tightly after the previous element, or 0 if this is the first element.

format

The format describing how the input data is interpreted.

Type: ResourceFormat
inputSlot

The vertex buffer input slot where the data is sourced from.

instanceDataStepRate

If perInstance is True then this is how many times each instance data is used before advancing to the next instance.

E.g. if this value is two, then two instances will be drawn with the first instance data, then two with the next instance data.

perInstance

True if the vertex data is instance-rate.

semanticIndex

The semantic index for this input.

semanticName

The semantic name for this input.

Shaders and Bindings

class renderdoc.D3D11Shader

Describes a D3D11 shader stage.

bindpointMapping

The bindpoint mapping data to match reflection.

Type: ShaderBindpointMapping
classInstances

The bound class instance names.

Type: List[str]
constantBuffers

The bound constant buffers.

Type: List[D3D11ConstantBuffer]
reflection

The reflection data for this shader.

Type: ShaderReflection
resourceId

The ResourceId of the shader itself.

samplers

The bound samplers.

Type: List[D3D11Sampler]
srvs

The bound SRVs.

Type: List[D3D11View]
stage

A ShaderStage identifying which stage this shader is bound to.

uavs

The bound UAVs - only valid for the compute stage, other stages pull the UAVs from the D3D11OutputMerger.

Type: List[D3D11View]
class renderdoc.D3D11ConstantBuffer

Describes a constant buffer binding.

resourceId

The ResourceId of the buffer.

vecCount

The size of the buffer binding, in units of float4 (16 bytes).

If the capture isn’t using the D3D11.1 binding methods, this offset will be 4096 (64 kiB).

vecOffset

The offset of the buffer binding, in units of float4 (16 bytes).

If the capture isn’t using the D3D11.1 binding methods, this offset will be 0.

class renderdoc.D3D11Sampler

Describes a sampler state object.

UseBorder()

Check if the border color is used in this D3D11 sampler.

Returns: True if the border color is used, False otherwise.
Return type: bool
addressU

The AddressMode in the U direction.

addressV

The AddressMode in the V direction.

addressW

The AddressMode in the W direction.

borderColor

The RGBA border color.

Type: Tuple[float,float,float,float]
compareFunction

The CompareFunction for comparison samplers.

filter

The filtering mode.

Type: TextureFilter
maxAnisotropy

The maximum anisotropic filtering level to use.

maxLOD

The maximum mip level that can be used.

minLOD

The minimum mip level that can be used.

mipLODBias

A bias to apply to the calculated mip level before sampling.

resourceId

The ResourceId of the sampler state object.

class renderdoc.D3D11View

Describes the details of a D3D11 resource view - any one of UAV, SRV, RTV or DSV.

bufferFlags

Valid for buffers - the flags for additional view properties.

bufferStructCount

If the view has a hidden counter, this stores the current value of the counter.

counterResourceId

The ResourceId of the resource where the hidden buffer counter is stored.

elementByteSize

The byte size of a single element in the view. Either the byte size of viewFormat, or the structured buffer element size, as appropriate.

firstElement

Valid for buffers - the first element to be used in the view.

firstMip

Valid for textures - the first mip that is available through the view.

firstSlice

Valid for texture arrays or 3D textures - the first slice available through the view.

numElements

Valid for buffers - the number of elements to be used in the view.

numMips

Valid for textures - the number of mip levels in the view.

numSlices

Valid for texture arrays or 3D textures - the number of slices in the view.

resourceResourceId

The ResourceId of the underlying resource the view refers to.

structured

True if this view describes a structured buffer.

type

The TextureType of the view type.

viewFormat

The format cast that the view uses.

Type: ResourceFormat
viewResourceId

The ResourceId of the view itself.

Stream-out

class renderdoc.D3D11StreamOut

Describes the stream-out stage bindings.

NoRasterization

Value for rasterizedStream that indicates no stream is being rasterized.

outputs

The bound stream-out buffer bindings.

Type: List[D3D11StreamOutBind]
rasterizedStream

Which stream-out stream is being used for rasterization.

If the value is NoRasterization then no stream has been selected for rasterization.

Type: int
class renderdoc.D3D11StreamOutBind

Describes a binding on the D3D11 stream-out stage.

byteOffset

The byte offset of the stream-output binding.

resourceId

The ResourceId of the buffer.

Rasterizer

class renderdoc.D3D11Rasterizer

Describes the rasterization state of the D3D11 pipeline.

scissors

The bound scissor regions.

Type: List[Scissor]
state

The details of the rasterization state.

Type: D3D11RasterizerState
viewports

The bound viewports.

Type: List[Viewport]
class renderdoc.D3D11RasterizerState

Describes a rasterizer state object.

antialiasedLines

True if lines should be anti-aliased. Ignored if multisampleEnable is False.

conservativeRasterization

The current ConservativeRaster mode.

cullMode

The polygon CullMode.

depthBias

The fixed depth bias value to apply to z-values.

depthBiasClamp

The clamp value for calculated depth bias from depthBias and slopeScaledDepthBias

depthClip

True if pixels outside of the near and far depth planes should be clipped.

fillMode

The polygon FillMode.

forcedSampleCount

A sample count to force rasterization to when UAV rendering or rasterizing, or 0 to not force any sample count.

frontCCW

True if counter-clockwise polygons are front-facing. False if clockwise polygons are front-facing.

multisampleEnable

True if the quadrilateral MSAA algorithm should be used on MSAA targets.

resourceId

The ResourceId of the rasterizer state object.

scissorEnable

True if the scissor test should be applied.

slopeScaledDepthBias

The slope-scaled depth bias value to apply to z-values.

Output Merger

class renderdoc.D3D11OutputMerger

Describes the current state of the output-merger stage of the D3D11 pipeline.

blendState

The current blend state details.

Type: D3D11BlendState
depthReadOnly

True if depth access to the depth-stencil target is read-only.

depthStencilState

The current depth-stencil state details.

Type: D3D11DepthStencilState
depthTarget

The currently bound depth-stencil target.

Type: D3D11View
renderTargets

The bound render targets.

Type: List[D3D11View]
stencilReadOnly

True if stencil access to the depth-stencil target is read-only.

uavStartSlot

Which slot in the output targets is the first UAV.

uavs

The bound UAVs.

Type: List[D3D11View]
class renderdoc.D3D11DepthStencilState

Describes a depth-stencil state object.

backFace

The stencil state for back-facing polygons.

Type: StencilFace
depthEnable

True if depth testing should be performed.

depthFunction

The CompareFunction to use for testing depth values.

depthWrites

True if depth values should be written to the depth target.

frontFace

The stencil state for front-facing polygons.

Type: StencilFace
resourceId

The ResourceId of the depth-stencil state object.

stencilEnable

True if stencil operations should be performed.

class renderdoc.D3D11BlendState

Describes a blend state object.

alphaToCoverage

True if alpha-to-coverage should be used when blending to an MSAA target.

blendFactor

The constant blend factor to use in blend equations.

Type: Tuple[float,float,float,float]
blends

The blend operations for each target.

Type: List[ColorBlend]
independentBlend

True if independent blending for each target should be used.

False if the first blend should be applied to all targets.

resourceId

The ResourceId of the blend state object.

sampleMask

The mask determining which samples are written to.

Predication

class renderdoc.D3D11Predication

Describes the current state of predicated rendering.

isPassing

True if the current predicate would render.

resourceId

The ResourceId of the active predicate.

value

The value to go along with the predicate.


D3D12 Pipeline State

Contents

  • D3D12 Pipeline State
    • Root Signature and Bindings
    • Vertex Input
    • Shader
    • Stream-out
    • Rasterizer
    • Output Merger
    • Resource States
class renderdoc.D3D12State

The full current D3D12 pipeline state.

ampShader

The amplification shader stage.

Type: D3D12Shader
computeShader

The compute shader stage.

Type: D3D12Shader
domainShader

The domain shader stage.

Type: D3D12Shader
geometryShader

The geometry shader stage.

Type: D3D12Shader
hullShader

The hull shader stage.

Type: D3D12Shader
inputAssembly

The input assembly pipeline stage.

Type: D3D12InputAssembly
meshShader

The mesh shader stage.

Type: D3D12Shader
outputMerger

The output merger pipeline stage.

Type: D3D12OM
pipelineResourceId

The ResourceId of the pipeline state object.

pixelShader

The pixel shader stage.

Type: D3D12Shader
rasterizer

The rasterizer pipeline stage.

Type: D3D12Rasterizer
resourceStates

The resource states for the currently live resources.

Type: List[D3D12ResourceData]
rootElements

The root signature, as a range per element.

Type: List[D3D12RootSignatureRange]
rootSignatureResourceId

The ResourceId of the root signature object.

streamOut

The stream-out pipeline stage.

Type: D3D12StreamOut
vertexShader

The vertex shader stage.

Type: D3D12Shader

Root Signature and Bindings

class renderdoc.D3D12RootSignatureRange

Contains information for a single root signature element range

constantBuffers

The constant buffers in this range.

Type: List[D3D12ConstantBuffer]
dynamicallyUsedCount

Lists how many bindings in views are dynamically used. Useful to avoid redundant iteration to determine whether any bindings are present.

For more information see D3D12View.dynamicallyUsed.

firstUsedIndex

Gives the index of the first binding in views that is dynamically used. Useful to avoid redundant iteration in very large descriptor arrays with a small subset that are used.

For more information see D3D12View.dynamicallyUsed.

immediate

True if this root element is a root constant (i.e. not in a table).

lastUsedIndex

Gives the index of the first binding in views that is dynamically used. Useful to avoid redundant iteration in very large descriptor arrays with a small subset that are used.

Note

This may be set to a higher value than the number of bindings, if no dynamic use information is available. Ensure that this is an additional check on the bind and the count is still respected.

For more information see D3D12View.dynamicallyUsed.

registerSpace

The register space of this element.

rootSignatureIndex

The index in the original root signature that this descriptor came from.

samplers

The samplers in this range.

Type: List[D3D12Sampler]
type

The BindType contained by this element.

views

The SRVs or UAVs in this range.

Type: List[D3D12View]
visibility

The ShaderStageMask of this element.

class renderdoc.D3D12ConstantBuffer

Describes the details of a constant buffer view descriptor.

bind

The shader register that this constant buffer is bound to.

byteOffset

The byte offset where the buffer view starts in the underlying buffer.

byteSize

How many bytes are in this constant buffer view.

resourceId

The ResourceId of the underlying buffer resource.

rootValues

If immediate is True and this is a root constant, this contains the root values set as interpreted as a series of DWORD values.

Type: List[int]
tableIndex

The index in the the parent descriptor table where this descriptor came from.

class renderdoc.D3D12Sampler

Describes the details of a sampler descriptor.

UseBorder()

Check if the border color is used in this D3D12 sampler.

Returns: True if the border color is used, False otherwise.
Return type: bool
addressU

The AddressMode in the U direction.

addressV

The AddressMode in the V direction.

addressW

The AddressMode in the W direction.

bind

The shader register that this sampler is bound to.

borderColorType

For samplers - the RGBA border color type. This determines how the data in borderColorValue will be interpreted.

Type: CompType
borderColorValue

For samplers - the RGBA border color value. Typically the float tuple inside will be used, but the exact component type can be checked with borderColorType.

Type: PixelValue
compareFunction

The CompareFunction for comparison samplers.

filter

The filtering mode.

Type: TextureFilter
maxAnisotropy

The maximum anisotropic filtering level to use.

maxLOD

The maximum mip level that can be used.

minLOD

The minimum mip level that can be used.

mipLODBias

A bias to apply to the calculated mip level before sampling.

tableIndex

The index in the the parent descriptor table where this descriptor came from.

unnormalized

True if unnormalized co-ordinates are used in this sampler.

class renderdoc.D3D12View

Describes the details of a D3D12 resource view - any one of UAV, SRV, RTV or DSV.

bind

The shader register that this view is bound to.

bufferFlags

The D3DBufferViewFlags set for the buffer.

bufferStructCount

If the view has a hidden counter, this stores the current value of the counter.

counterByteOffset

The byte offset in counterResourceId where the counter is stored.

counterResourceId

The ResourceId of the resource where the hidden buffer counter is stored.

dynamicallyUsed

True if this binding element is dynamically used.

If set to False this means that the binding was available to the shader but during execution it was not referenced. The data gathered for setting this variable is conservative, meaning that only accesses through arrays will have this calculated to reduce the required feedback bandwidth - single non-arrayed descriptors may have this value set to True even if the shader did not use them, since single descriptors may only be dynamically skipped by control flow.

elementByteSize

The byte size of a single element in the view. Either the byte size of viewFormat, or the structured buffer element size, as appropriate.

firstElement

Valid for buffers - the first element to be used in the view.

firstMip

Valid for textures - the highest mip that is available through the view.

firstSlice

Valid for texture arrays or 3D textures - the first slice available through the view.

minLODClamp

The minimum mip-level clamp applied when sampling this texture.

numElements

Valid for buffers - the number of elements to be used in the view.

numMips

Valid for textures - the number of mip levels in the view.

numSlices

Valid for texture arrays or 3D textures - the number of slices in the view.

resourceId

The ResourceId of the underlying resource the view refers to.

swizzle

The swizzle applied to a texture by the view.

Type: TextureSwizzle4
tableIndex

The index in the the parent descriptor table where this descriptor came from.

type

The TextureType of the view type.

viewFormat

The format cast that the view uses.

Type: ResourceFormat

Vertex Input

class renderdoc.D3D12InputAssembly

Describes the input assembler state in the PSO.

indexBuffer

The bound index buffer.

Type: D3D12IndexBuffer
indexStripCutValue

The index value to use for cutting strips. Either 0, 0xffff or 0xffffffff. If the value is 0, strip cutting is disabled.

layouts

The input layout elements in this layout.

Type: List[D3D12Layout]
topology

The current primitive topology.

Type: Topology
vertexBuffers

The bound vertex buffers

Type: List[D3D12VertexBuffer]
class renderdoc.D3D12Layout

Describes a single D3D12 input layout element for one vertex input.

TightlyPacked

Value for byteOffset that indicates this element is tightly packed.

byteOffset

The byte offset from the start of the vertex data in the vertex buffer from inputSlot.

If the value is TightlyPacked then the element is packed tightly after the previous element, or 0 if this is the first element.

format

The format describing how the input data is interpreted.

Type: ResourceFormat
inputSlot

The vertex buffer input slot where the data is sourced from.

instanceDataStepRate

If perInstance is True then this is how many times each instance data is used before advancing to the next instance.

E.g. if this value is two, then two instances will be drawn with the first instance data, then two with the next instance data.

perInstance

True if the vertex data is instance-rate.

semanticIndex

The semantic index for this input.

semanticName

The semantic name for this input.

class renderdoc.D3D12VertexBuffer

Describes a single D3D12 vertex buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the vertex data.

byteSize

The number of bytes available in this vertex buffer.

byteStride

The byte stride between the start of one set of vertex data and the next.

resourceId

The ResourceId of the buffer bound to this slot.

class renderdoc.D3D12IndexBuffer

Describes the D3D12 index buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the index data.

byteSize

The number of bytes available in this index buffer.

byteStride

The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but it can be 0 if no index buffer is bound.

resourceId

The ResourceId of the index buffer.

Shader

class renderdoc.D3D12Shader

Describes a D3D12 shader stage.

bindpointMapping

The bindpoint mapping data to match reflection.

Type: ShaderBindpointMapping
reflection

The reflection data for this shader.

Type: ShaderReflection
resourceId

The ResourceId of the shader object itself.

stage

A ShaderStage identifying which stage this shader is bound to.

Stream-out

class renderdoc.D3D12StreamOut

Describes the stream-out state in the PSO.

NoRasterization

Value for rasterizedStream that indicates no stream is being rasterized.

outputs

The bound stream-out buffer bindings.

Type: List[D3D12StreamOutBind]
rasterizedStream

Which stream-out stream is being used for rasterization.

If the value is NoRasterization then no stream has been selected for rasterization.

Type: int
class renderdoc.D3D12StreamOutBind

Describes a binding on the D3D12 stream-out stage.

byteOffset

The byte offset in resourceId where the buffer view starts in the underlying buffer.

byteSize

How many bytes are in this stream-out buffer view.

resourceId

The ResourceId of the buffer.

writtenCountByteOffset

The byte offset in writtenCountResourceId where the stream-out count will be written.

writtenCountResourceId

The ResourceId of the buffer where the written count will be stored.

Rasterizer

class renderdoc.D3D12Rasterizer

Describes the rasterization state of the D3D12 pipeline.

sampleMask

The mask determining which samples are written to.

scissors

The bound scissor regions.

Type: List[Scissor]
state

The details of the rasterization state.

Type: D3D12RasterizerState
viewports

The bound viewports.

Type: List[Viewport]
class renderdoc.D3D12RasterizerState

Describes the rasterizer state in the PSO.

baseShadingRate

The current base variable shading rate. This will always be 1x1 when variable shading is disabled.

Type: Tuple[int,int]
conservativeRasterization

The current ConservativeRaster mode.

cullMode

The polygon CullMode.

depthBias

The fixed depth bias value to apply to z-values.

depthBiasClamp

The clamp value for calculated depth bias from depthBias and slopeScaledDepthBias

depthClip

True if pixels outside of the near and far depth planes should be clipped.

fillMode

The polygon FillMode.

forcedSampleCount

A sample count to force rasterization to when UAV rendering or rasterizing, or 0 to not force any sample count.

frontCCW

True if counter-clockwise polygons are front-facing. False if clockwise polygons are front-facing.

lineRasterMode

The line rasterization mode.

shadingRateCombiners

The shading rate combiners.

The combiners are applied as follows, according to the D3D spec:

intermediateRate = combiner[0] ( baseShadingRate,  shaderExportedShadingRate ) finalRate        = combiner[1] ( intermediateRate, imageBasedShadingRate     )

Where the first input is from baseShadingRate and the second is the exported shading rate from a vertex or geometry shader, which defaults to 1x1 if not exported.

The intermediate result is then used as the first input to the second combiner, together with the shading rate sampled from the shading rate image.

Type: Tuple[ShadingRateCombiner,ShadingRateCombiner]
shadingRateImage

The image bound as a shading rate image.

Type: ResourceId
slopeScaledDepthBias

The slope-scaled depth bias value to apply to z-values.

Output Merger

class renderdoc.D3D12OM

Describes the current state of the output-merger stage of the D3D12 pipeline.

blendState

The current blend state details.

Type: D3D12BlendState
depthReadOnly

True if depth access to the depth-stencil target is read-only.

depthStencilState

The current depth-stencil state details.

Type: D3D12DepthStencilState
depthTarget

The currently bound depth-stencil target.

Type: D3D12View
multiSampleCount

The sample count used for rendering.

multiSampleQuality

The MSAA quality level used for rendering.

renderTargets

The bound render targets.

Type: List[D3D12View]
stencilReadOnly

True if stenncil access to the depth-stencil target is read-only.

class renderdoc.D3D12DepthStencilState

Describes the state of the depth-stencil state in the PSO.

backFace

The stencil state for back-facing polygons.

Type: StencilFace
depthBoundsEnable

True if depth bounds tests should be applied.

depthEnable

True if depth testing should be performed.

depthFunction

The CompareFunction to use for testing depth values.

depthWrites

True if depth values should be written to the depth target.

frontFace

The stencil state for front-facing polygons.

Type: StencilFace
maxDepthBounds

The far plane bounding value.

minDepthBounds

The near plane bounding value.

stencilEnable

True if stencil operations should be performed.

class renderdoc.D3D12BlendState

Describes the blend state in the PSO.

alphaToCoverage

True if alpha-to-coverage should be used when blending to an MSAA target.

blendFactor

The constant blend factor to use in blend equations.

Type: Tuple[float,float,float,float]
blends

The blend operations for each target.

Type: List[ColorBlend]
independentBlend

True if independent blending for each target should be used.

False if the first blend should be applied to all targets.

Resource States

class renderdoc.D3D12ResourceData

Contains the current state of a given resource.

resourceId

The ResourceId of the resource.

states

The subresource states in this resource.

Type: List[D3D12ResourceState]
class renderdoc.D3D12ResourceState

Describes the current state that a sub-resource is in.

name

A human-readable name for the current state.


OpenGL Pipeline State

Contents

  • OpenGL Pipeline State
    • Vertex Input
    • Shader
    • Fixed Vertex Processing
    • Shader Bindings
    • Transform Feedback
    • Rasterizer
    • Depth/Stencil State
    • Framebuffer
    • Blending
    • Hints
class renderdoc.GLState

The full current OpenGL pipeline state.

atomicBuffers

The currently bound atomic buffers.

Type: List[GLBuffer]
computeShader

The compute shader stage.

Type: GLShader
depthState

The depth state.

Type: GLDepthState
fragmentShader

The fragment shader stage.

Type: GLShader
framebuffer

The bound framebuffer.

Type: GLFrameBuffer
geometryShader

The geometry shader stage.

Type: GLShader
hints

The hint state.

Type: GLHints
images

The currently bound load/store images.

Type: List[GLImageLoadStore]
pipelineResourceId

The ResourceId of the program pipeline (if active).

rasterizer

The rasterization configuration.

Type: GLRasterizer
samplers

The currently bound samplers.

type: List[GLSampler]
shaderStorageBuffers

The currently bound shader storage buffers.

Type: List[GLBuffer]
stencilState

The stencil state.

Type: GLStencilState
tessControlShader

The tessellation control shader stage.

Type: GLShader
tessEvalShader

The tessellation evaluation shader stage.

Type: GLShader
textures

The currently bound textures.

Type: List[GLTexture]
transformFeedback

The transform feedback stage.

Type: GLFeedback
uniformBuffers

The currently bound uniform buffers.

Type: List[GLBuffer]
vertexInput

The vertex input stage.

Type: GLVertexInput
vertexProcessing

The fixed-function vertex processing stage.

Type: GLFixedVertexProcessing
vertexShader

The vertex shader stage.

Type: GLShader

Vertex Input

class renderdoc.GLVertexInput

Describes the setup for fixed-function vertex input fetch.

attributes

The vertex attributes.

Type: List[GLVertexAttribute]
indexBuffer

The ResourceId of the index buffer.

indexByteStride

The byte width of the index buffer - typically 1, 2 or 4 bytes. It can be 0 for non-indexed draws.

Note

This does not correspond to a real GL state since the index type is specified per-action in the call itself. This is an implicit state derived from the last (or current) action at any given event.

primitiveRestart

True if primitive restart is enabled for strip primitives.

provokingVertexLast

True if the provoking vertex is the last one in the primitive.

False if the provoking vertex is the first one.

restartIndex

The index value to use to indicate a strip restart.

topology

The byte width of the index buffer - typically 1, 2 or 4 bytes.

Note

This does not correspond to a real GL state since the topology is specified per-action in the call itself. This is an implicit state derived from the last (or current) action at any given event.

vertexArrayObject

The ResourceId of the vertex array object that’s bound.

vertexBuffers

The vertex buffers.

Type: List[GLVertexBuffer]
class renderdoc.GLVertexAttribute

Describes the configuration for a single vertex attribute.

Note

If old-style vertex attrib pointer setup was used for the vertex attributes then it will be decomposed into 1:1 attributes and buffers.

byteOffset

The byte offset from the start of the vertex data in the vertex buffer from vertexBufferSlot.

enabled

True if this vertex attribute is enabled.

floatCast

Only valid for integer formatted attributes, True if they are cast to float.

This is because they were specified with an integer format but glVertexAttribFormat (not glVertexAttribIFormat) so they will be cast.

format

The format describing how the vertex attribute is interpreted.

Type: ResourceFormat
genericValue

The generic value of the vertex attribute if no buffer is bound.

Type: PixelValue
vertexBufferSlot

The vertex buffer input slot where the data is sourced from.

class renderdoc.GLVertexBuffer

Describes a single OpenGL vertex buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the vertex data.

byteStride

The byte stride between the start of one set of vertex data and the next.

instanceDivisor

The instance rate divisor.

If this is 0 then the vertex buffer is read at vertex rate.

If it’s 1 then one element is read for each instance, and for N greater than 1 then N instances read the same element before advancing.

resourceId

The ResourceId of the buffer bound to this slot.

Shader

class renderdoc.GLShader

Describes an OpenGL shader stage.

bindpointMapping

The bindpoint mapping data to match reflection.

Type: ShaderBindpointMapping
programResourceId

The ResourceId of the program bound to this stage.

reflection

The reflection data for this shader.

Type: ShaderReflection
shaderResourceId

The ResourceId of the shader object itself.

stage

A ShaderStage identifying which stage this shader is bound to.

subroutines

A list of integers with the subroutine values.

Type: List[int]

Fixed Vertex Processing

class renderdoc.GLFixedVertexProcessing

Describes the setup for fixed vertex processing operations.

clipNegativeOneToOne

True if the clip-space Z goes from -1 to 1.

False if the clip-space Z goes from 0 to 1.

clipOriginLowerLeft

True if the clipping origin should be in the lower left.

False if it’s in the upper left.

clipPlanes

An 8-tuple of bool determining which user clipping planes are enabled.

Type: Tuple[bool,…]
defaultInnerLevel

A tuple of float giving the default inner level of tessellation.

Type: Tuple[float,float]
defaultOuterLevel

A tuple of float giving the default outer level of tessellation.

Type: Tuple[float,float,float,float]
discard

True if primitives should be discarded during rasterization.

Shader Bindings

class renderdoc.GLTexture

Describes the details of a texture.

completeStatus

The details of the texture’s (in)completeness. If this string is empty, the texture is complete. Otherwise it contains an explanation of why the texture is believed to be incomplete.

depthReadChannel

The channel to read from in a depth-stencil texture.

-1 for non depth-stencil textures.

0 if depth should be read.

1 if stencil should be read.

firstMip

Valid for textures - the first mip that is available.

numMips

Valid for textures - the number of mips that are available.

resourceId

The ResourceId of the underlying resource the view refers to.

swizzle

The swizzle applied to a texture.

Type: TextureSwizzle4
type

The TextureType of the texture.

typeConflict

The details of any type conflict on this binding. This can happen if multiple uniforms are pointing to the same binding but with different types. In this case it is impossible to disambiguate which binding was used.

If this string is empty, no conflict is present. Otherwise it contains the bindings which are in conflict and their types.

class renderdoc.GLSampler

Describes the sampler properties of a texture.

UseBorder()

Check if the border color is used in this OpenGL sampler.

Returns: True if the border color is used, False otherwise.
Return type: bool
addressR

The AddressMode in the R direction.

addressS

The AddressMode in the S direction.

addressT

The AddressMode in the T direction.

borderColor

The RGBA border color.

Type: Tuple[float,float,float,float]
compareFunction

The CompareFunction for comparison samplers.

filter

The filtering mode.

Type: TextureFilter
maxAnisotropy

The maximum anisotropic filtering level to use.

maxLOD

The maximum mip level that can be used.

minLOD

The minimum mip level that can be used.

mipLODBias

A bias to apply to the calculated mip level before sampling.

resourceId

The ResourceId of the sampler object, if a separate one is set.

seamlessCubeMap

True if seamless cubemap filtering is enabled for this texture.

class renderdoc.GLBuffer

Describes the properties of a buffer.

byteOffset

The byte offset from the start of the buffer.

byteSize

The byte size of the buffer.

resourceId

The ResourceId of the buffer object.

class renderdoc.GLImageLoadStore

Describes the properties of a load/store image.

imageFormat

The format that the image is bound as.

Type: ResourceFormat
layered

True if multiple layers are bound together to the image. False if only one layer is bound.

mipLevel

The mip of the texture that’s used in the attachment.

readAllowed

True if loading from the image is allowed.

resourceId

The ResourceId of the texture object.

slice

The slice of the texture that’s used in the attachment.

type

The TextureType of the texture.

writeAllowed

True if storing to the image is allowed.

Transform Feedback

class renderdoc.GLFeedback

Describes the current feedback state.

active

True if the transform feedback object is currently active.

bufferResourceId

The buffer bindings.

Type: Tuple[ResourceId,ResourceId,ResourceId,ResourceId]
byteOffset

The buffer byte offsets.

Type: Tuple[int,int,int,int]
byteSize

The buffer byte sizes.

Type: Tuple[int,int,int,int]
feedbackResourceId

The ResourceId of the transform feedback binding.

paused

True if the transform feedback object is currently paused.

Rasterizer

class renderdoc.GLRasterizer

Describes the rasterization state of the OpenGL pipeline.

scissors

The bound scissor regions.

Type: List[Scissor]
state

The details of the rasterization state.

Type: GLRasterizerState
viewports

The bound viewports.

Type: List[Viewport]
class renderdoc.GLRasterizerState

Describes the rasterizer state toggles.

alphaToCoverage

True if alpha-to-coverage should be used when blending to an MSAA target.

alphaToOne

True if alpha-to-one should be used when blending to an MSAA target.

cullMode

The polygon CullMode.

depthBias

The fixed depth bias value to apply to z-values.

depthClamp

True if pixels outside of the near and far depth planes should be clamped and to 0.0 to 1.0 and not clipped.

fillMode

The polygon FillMode.

frontCCW

True if counter-clockwise polygons are front-facing. False if clockwise polygons are front-facing.

lineWidth

The fixed line width in pixels.

minSampleShadingRate

The minimum sample shading rate.

multisampleEnable

True if multisampling should be used during rendering.

offsetClamp

The clamp value for calculated depth bias from depthBias and slopeScaledDepthBias

pointFadeThreshold

The threshold value at which points are clipped if they exceed this size.

pointOriginUpperLeft

True if the point sprite texture origin is upper-left. False if lower-left.

pointSize

The fixed point size in pixels.

programmablePointSize

True if the point size can be programmably exported from a shader.

sampleCoverage

True if a temporary mask using sampleCoverageValue should be used to resolve the final output color.

sampleCoverageInvert

True if the temporary sample coverage mask should be inverted.

sampleCoverageValue

The sample coverage value used if sampleCoverage is True.

sampleMask

True if the generated samples should be bitwise AND masked with sampleMaskValue.

sampleMaskValue

The sample mask value that should be masked against the generated coverage.

sampleShading

True if rendering should happen at sample-rate frequency.

slopeScaledDepthBias

The slope-scaled depth bias value to apply to z-values.

Depth/Stencil State

class renderdoc.GLDepthState

Describes the depth state.

depthBounds

True if depth bounds tests should be applied.

depthEnable

True if depth testing should be performed.

depthFunction

The CompareFunction to use for testing depth values.

depthWrites

True if depth values should be written to the depth target.

farBound

The far plane bounding value.

nearBound

The near plane bounding value.

class renderdoc.GLStencilState

Describes the stencil state.

backFace

The stencil state for back-facing polygons.

Type: StencilFace
frontFace

The stencil state for front-facing polygons.

Type: StencilFace
stencilEnable

True if stencil operations should be performed.

Framebuffer

class renderdoc.GLFrameBuffer

Describes the current state of the framebuffer stage of the pipeline.

blendState

The details of the blending state.

Type: GLBlendState
dither

True if dithering should be used when writing to color buffers.

drawFBO

The draw framebuffer.

Type: GLFBO
framebufferSRGB

True if sRGB correction should be applied when writing to an sRGB-formatted texture.

readFBO

The read framebuffer.

Type: GLFBO
class renderdoc.GLFBO

Describes the contents of a framebuffer object.

colorAttachments

The framebuffer color attachments.

Type: List[GLAttachment]
depthAttachment

The framebuffer depth attachment.

Type: GLAttachment
drawBuffers

The draw buffer indices into the colorAttachments attachment list.

Type: List[int]
readBuffer

The read buffer index in the colorAttachments attachment list.

resourceId

The ResourceId of the framebuffer.

stencilAttachment

The framebuffer stencil attachment.

Type: GLAttachment
class renderdoc.GLAttachment

Describes the state of a framebuffer attachment.

mipLevel

The mip of the texture that’s used in the attachment.

numSlices

The number of slices of the texture that are used in the attachment.

resourceId

The ResourceId of the texture bound to this attachment.

slice

The slice of the texture that’s used in the attachment.

swizzle

The swizzle applied to the texture.

Type: TextureSwizzle4

Blending

class renderdoc.GLBlendState

Describes the blend pipeline state.

blendFactor

The constant blend factor to use in blend equations.

Type: Tuple[float,float,float,float]
blends

The blend operations for each target.

Type: List[ColorBlend]

Hints

class renderdoc.GLHints

Describes the current state of GL hints and smoothing.

derivatives

A QualityHint with the derivatives hint.

lineSmoothing

A QualityHint with the line smoothing hint.

lineSmoothingEnabled

True if line smoothing is enabled.

polySmoothing

A QualityHint with the polygon smoothing hint.

polySmoothingEnabled

True if polygon smoothing is enabled.

textureCompression

A QualityHint with the texture compression hint.

class renderdoc.QualityHint(value)

An API specific hint for a certain behaviour. A legacy concept in OpenGL that controls hints to the implementation where there is room for interpretation within the range of valid behaviour.

DontCare

The hinted behaviour can follow any valid path as the implementation decides.

Nicest

The hinted behaviour should follow the most correct or highest quality path.

Fastest

The hinted behaviour should follow the most efficient path.


Vulkan Pipeline State

Contents

  • Vulkan Pipeline State
    • Pipeline and Bindings
    • Vertex Input
    • Shader
    • Tessellation
    • Transform Feedback
    • Rasterizer
    • Multisampling
    • Blending
    • Depth/Stencil State
    • Renderpass and Framebuffer
    • Image States
    • Conditional Rendering
class renderdoc.VKState

The full current Vulkan pipeline state.

colorBlend

The color blending configuration.

Type: VKColorBlendState
compute

The currently bound compute pipeline, if any.

Type: VKPipeline
computeShader

The compute shader stage.

Type: VKShader
conditionalRendering

The current conditional rendering state.

Type: VKConditionalRendering
currentPass

The current renderpass, subpass and framebuffer.

Type: VKCurrentPass
depthStencil

The depth-stencil state.

Type: VKDepthStencil
fragmentShader

The fragment shader stage.

Type: VKShader
geometryShader

The geometry shader stage.

Type: VKShader
graphics

The currently bound graphics pipeline, if any.

Type: VKPipeline
images

The resource states for the currently live resources.

Type: List[VKImageData]
inputAssembly

The input assembly stage.

Type: VKInputAssembly
meshShader

The mesh shader stage.

Type: VKShader
multisample

The multisampling configuration.

Type: VKMultiSample
pushconsts

The raw push constant data.

Type: bytes
rasterizer

The rasterization configuration.

Type: VKRasterizer
shaderMessages

The shader messages retrieved for this action.

Type: List[ShaderMessage]
taskShader

The task shader stage.

Type: VKShader
tessControlShader

The tessellation control shader stage.

Type: VKShader
tessEvalShader

The tessellation evaluation shader stage.

Type: VKShader
tessellation

The tessellation stage.

Type: VKTessellation
transformFeedback

The transform feedback stage.

Type: VKTransformFeedback
vertexInput

The vertex input stage.

Type: VKVertexInput
vertexShader

The vertex shader stage.

Type: VKShader
viewportScissor

The viewport setup.

Type: VKViewState

Pipeline and Bindings

class renderdoc.VKPipeline

Describes the object and descriptor set bindings of a Vulkan pipeline object.

descriptorSets

The bound descriptor sets.

Type: List[VKDescriptorSet]
flags

The flags used to create the pipeline object.

pipelineComputeLayoutResourceId

The ResourceId of the compute pipeline layout object.

pipelineFragmentLayoutResourceId

The ResourceId of the fragment pipeline layout object.

When not using pipeline libraries, this will be identical to pipelinePreRastLayoutResourceId.

pipelinePreRastLayoutResourceId

The ResourceId of the pre-rasterization pipeline layout object.

When not using pipeline libraries, this will be identical to pipelineFragmentLayoutResourceId.

pipelineResourceId

The ResourceId of the pipeline object.

class renderdoc.VKDescriptorSet

The contents of a descriptor set.

bindings

The bindings within this set. This list is indexed by the binding, so it may be sparse (some entries do not contain any elements).

Type: List[VKDescriptorBinding]
descriptorSetResourceId

The ResourceId of the descriptor set object.

inlineData

The inline byte data within this descriptor set. Individual bindings will have an offset and size into this buffer.

Type: bytes
layoutResourceId

The ResourceId of the descriptor set layout that matches this set.

pushDescriptor

Indicates if this is a virtual ‘push’ descriptor set.

class renderdoc.VKDescriptorBinding

The contents of a single binding within a descriptor set, either arrayed or not.

binds

The binding elements. If descriptorCount is 1 then this list has only one element and the binding is not arrayed.

Type: List[VKBindingElement]
descriptorCount

How many descriptors are in this binding array. If this binding is empty/non-existant this value will be 0.

dynamicallyUsedCount

Lists how many bindings in binds are dynamically used. Useful to avoid redundant iteration to determine whether any bindings are present.

For more information see VKBindingElement.dynamicallyUsed.

firstUsedIndex

Gives the index of the first binding in binds that is dynamically used. Useful to avoid redundant iteration in very large descriptor arrays with a small subset that are used.

For more information see VKBindingElement.dynamicallyUsed.

lastUsedIndex

Gives the index of the first binding in binds that is dynamically used. Useful to avoid redundant iteration in very large descriptor arrays with a small subset that are used.

Note

This may be set to a higher value than the number of bindings, if no dynamic use information is available. Ensure that this is an additional check on the bind and the count is still respected.

For more information see VKBindingElement.dynamicallyUsed.

stageFlags

The ShaderStageMask where this binding is visible.

class renderdoc.VKBindingElement

The contents of a single binding element within a descriptor set, possibly in an array.

UseBorder()

For samplers - check if the border color is used in this Vulkan sampler.

Returns: True if the border color is used, False otherwise.
Return type: bool
addressU

For samplers - the AddressMode in the U direction.

addressV

For samplers - the AddressMode in the V direction.

addressW

For samplers - the AddressMode in the W direction.

borderColorType

For samplers - the RGBA border color type. This determines how the data in borderColorValue will be interpreted.

Type: CompType
borderColorValue

For samplers - the RGBA border color value. Typically the float tuple inside will be used, but the exact component type can be checked with borderColorType.

Type: PixelValue
byteOffset

For buffers - the byte offset where the buffer view starts in the underlying buffer.

For inline block uniforms (see inlineBlock) this is the byte offset into the descriptor set’s inline block data.

byteSize

For buffers - how many bytes are in this buffer view.

chromaFilter

For ycbcr samplers - the FilterMode describing the chroma filtering mode.

compareFunction

For samplers - the CompareFunction for comparison samplers.

dynamicallyUsed

True if this binding element is dynamically used.

If set to False this means that the binding was available to the shader but during execution it was not referenced. The data gathered for setting this variable is conservative, meaning that only accesses through arrays will have this calculated to reduce the required feedback bandwidth - single non-arrayed descriptors may have this value set to True even if the shader did not use them, since single descriptors may only be dynamically skipped by control flow.

filter

The filtering mode.

Type: TextureFilter
firstMip

For textures - the first mip level used in the view.

firstSlice

For 3D textures and texture arrays - the first slice used in the view.

forceExplicitReconstruction

For ycbcr samplers - True if explicit reconstruction is force enabled.

immutableSampler

True if this is an immutable sampler binding.

inlineBlock

True if this is an inline uniform block binding.

maxAnisotropy

For samplers - the maximum anisotropic filtering level to use.

maxLOD

For samplers - the maximum mip level that can be used.

minLOD

For samplers and image views - the minimum mip level that can be used.

mipBias

For samplers - a bias to apply to the calculated mip level before sampling.

numMips

For textures - the number of mip levels in the view.

numSlices

For 3D textures and texture arrays - the number of array slices in the view.

resourceResourceId

The ResourceId of the current underlying buffer or image object.

samplerResourceId

The ResourceId of the current sampler object.

samplerSwizzle

The swizzle applied to samplers. Primarily for ycbcr samplers applied before conversion but for non-ycbcr samplers can be used for implementations that require sampler swizzle information for border colors.

Type: TextureSwizzle4
seamless

True if this sampler is seamless across cubemap boundaries (the default).

srgbBorder

For samplers - True if the border colour is swizzled with an sRGB formatted image.

swizzle

The swizzle applied to a texture by the view.

Type: TextureSwizzle4
type

The BindType of this binding element.

unnormalized

For samplers - True if unnormalized co-ordinates are used in this sampler.

viewFormat

The format cast that the view uses.

Type: ResourceFormat
viewResourceId

The ResourceId of the current view object, if one is in use.

xChromaOffset

For ycbcr samplers - the ChromaSampleLocation X-axis chroma offset.

yChromaOffset

For ycbcr samplers - the ChromaSampleLocation Y-axis chroma offset.

ycbcrModel

For ycbcr samplers - the YcbcrConversion used for conversion.

ycbcrRange

For ycbcr samplers - the YcbcrRange used for conversion.

ycbcrSampler

For samplers - the ResourceId of the ycbcr conversion object associated with this sampler.

Vertex Input

class renderdoc.VKInputAssembly

Describes the vulkan input assembly configuration.

indexBuffer

The index buffer binding.

Type: VKIndexBuffer
primitiveRestartEnable

True if primitive restart is enabled for strip primitives.

topology

The current primitive topology.

Type: Topology
class renderdoc.VKIndexBuffer

Describes the Vulkan index buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the index data.

byteStride

The number of bytes for each index in the index buffer. Typically 2 or 4 bytes but it can be 0 if no index buffer is bound.

resourceId

The ResourceId of the index buffer.

class renderdoc.VKVertexInput

Describes the fixed-function vertex input fetch setup.

attributes

The vertex attributes.

Type: List[VKVertexAttribute]
bindings

The vertex bindings.

Type: List[VKVertexBinding]
vertexBuffers

The vertex buffers.

Type: List[VKVertexBuffer]
class renderdoc.VKVertexAttribute

Describes the configuration of a single vertex attribute.

binding

The vertex binding where data will be sourced from.

byteOffset

The byte offset from the start of each vertex data in the binding to this attribute.

format

The format describing how the input element is interpreted.

Type: ResourceFormat
location

The location in the shader that is bound to this attribute.

class renderdoc.VKVertexBinding

Describes a vertex binding.

instanceDivisor

The instance rate divisor.

If this is 0 then every vertex gets the same value.

If it’s 1 then one element is read for each instance, and for N greater than 1 then N instances read the same element before advancing.

perInstance

True if the vertex data is instance-rate.

vertexBufferBinding

The vertex binding where data will be sourced from.

class renderdoc.VKVertexBuffer

Describes a single Vulkan vertex buffer binding.

byteOffset

The byte offset from the start of the buffer to the beginning of the vertex data.

byteSize

The size of the vertex buffer.

byteStride

The byte stride between the start of one set of vertex data and the next.

resourceId

The ResourceId of the buffer bound to this slot.

Shader

class renderdoc.VKShader

Describes a Vulkan shader stage.

bindpointMapping

The bindpoint mapping data to match reflection.

Type: ShaderBindpointMapping
entryPoint

The name of the entry point in the shader module that is used.

pushConstantRangeByteOffset

The byte offset into the push constant data that is visible to this shader.

pushConstantRangeByteSize

The number of bytes in the push constant data that is visible to this shader.

reflection

The reflection data for this shader.

Type: ShaderReflection
requiredSubgroupSize

The required subgroup size specified for this shader at pipeline creation time.

resourceId

The ResourceId of the shader module object.

specializationData

The provided specialization constant data. Shader constants store the byte offset into this buffer as their byteOffset. This data includes the applied specialization constants over the top of the default values, so it is safe to read any constant from here and get the correct current value.

Type: bytes
specializationIds

The specialization constant ID for each entry in the specialization constant block of reflection info. This corresponds to the constantID in VkSpecializationMapEntry, while the offset and size into specializationData can be obtained from the reflection info.

Type: List[int]
stage

A ShaderStage identifying which stage this shader is bound to.

Tessellation

class renderdoc.VKTessellation

Describes the state of the fixed-function tessellator.

domainOriginUpperLeft

True if the tessellation domain origin is upper-left, False if lower-left.

numControlPoints

The number of control points in each input patch.

Transform Feedback

class renderdoc.VKTransformFeedback

Describes the state of the fixed-function transform feedback.

buffers

The bound transform feedback buffers.

Type: List[VKXFBBuffer]
rasterizedStream

Which stream-out stream is being used for rasterization.

Type: int
class renderdoc.VKXFBBuffer

Describes a single transform feedback binding.

active

A flag indicating if this buffer is active or not.

bufferResourceId

The ResourceId of the bound data buffer.

byteOffset

The offset in bytes to the start of the data in the bufferResourceId.

byteSize

The size in bytes of the data buffer.

counterBufferOffset

The offset in bytes to the counter in the counterBufferResourceId.

counterBufferResourceId

The ResourceId of the buffer storing the counter value (if set).

Rasterizer

class renderdoc.VKViewportScissor

Describes a combined viewport and scissor region.

scissor

The scissor.

Type: Scissor
vp

The viewport.

Type: Viewport
class renderdoc.VKViewState

Describes the view state in the pipeline.

depthNegativeOneToOne

Whether depth clip range is set to [-1, 1] through VK_EXT_depth_clip_control.

discardRectangles

The discard rectangles, if enabled.

Type: List[VKRenderArea]
discardRectanglesExclusive

True if a fragment in any one of the discard rectangles fails the discard test, and a fragment in none of them passes.

False if a fragment in any one of the discard rectangles passes the discard test, and a fragment in none of them is discarded.

Note

A True value and an empty list of discardRectangles means the test is effectively disabled, since with no rectangles no fragment can be inside one.

viewportScissors

The bound viewports and scissors.

Type: List[VKViewportScissor]
class renderdoc.VKRasterizer

Describes the rasterizer state in the pipeline.

conservativeRasterization

The active conservative rasterization mode.

cullMode

The polygon CullMode.

depthBias

The fixed depth bias value to apply to z-values.

depthBiasClamp

The clamp value for calculated depth bias from depthBias and slopeScaledDepthBias

depthBiasEnable

Whether depth biasing is enabled.

depthClampEnable

True if pixels outside of the near and far depth planes should be clamped and to 0.0 to 1.0.

depthClipEnable

True if pixels outside of the near and far depth planes should be clipped.

Note

In Vulkan 1.0 this value was implicitly set to the opposite of depthClampEnable, but with later extensions & versions it can be set independently.

extraPrimitiveOverestimationSize

The extra size in pixels to increase primitives by during conservative rasterization, in the x and y directions in screen space.

See conservativeRasterizationMode

fillMode

The polygon FillMode.

frontCCW

True if counter-clockwise polygons are front-facing. False if clockwise polygons are front-facing.

lineRasterMode

The line rasterization mode.

lineStippleFactor

The line stipple factor, or 0 if line stipple is disabled.

lineStipplePattern

The line stipple bit-pattern.

lineWidth

The fixed line width in pixels.

pipelineShadingRate

The current pipeline fragment shading rate. This will always be 1x1 when a fragment shading rate has not been specified.

Type: Tuple[int,int]
provokingVertexFirst

Whether the provoking vertex is the first one (default behaviour).

rasterizerDiscardEnable

True if primitives should be discarded during rasterization.

shadingRateCombiners

The fragment shading rate combiners.

The combiners are applied as follows, according to the Vulkan spec:

intermediateRate = combiner[0] ( pipelineShadingRate,  shaderExportedShadingRate ) finalRate        = combiner[1] ( intermediateRate,     imageBasedShadingRate     )

Where the first input is from pipelineShadingRate and the second is the exported shading rate from the last pre-rasterization shader stage, which defaults to 1x1 if not exported.

The intermediate result is then used as the first input to the second combiner, together with the shading rate sampled from the fragment shading rate attachment.

Type: Tuple[ShadingRateCombiner,ShadingRateCombiner]
slopeScaledDepthBias

The slope-scaled depth bias value to apply to z-values.

Multisampling

class renderdoc.VKMultiSample

Describes the multisampling state in the pipeline.

minSampleShading

The minimum sample shading rate.

rasterSamples

How many samples to use when rasterizing.

sampleLocations

The custom sample locations configuration.

Type: VKSampleLocations
sampleMask

A mask that generated samples should be masked with using bitwise AND.

sampleShadingEnable

True if rendering should happen at sample-rate frequency.

class renderdoc.VKSampleLocations

Describes state of custom sample locations in the pipeline.

customLocations

The custom sample locations. Only x and y are valid, z and w are set to 0.0.

If the list is empty then the standard sample pattern is in use.

Type: List[FloatVector]
gridHeight

The height in pixels of the region configured.

gridWidth

The width in pixels of the region configured.

Blending

class renderdoc.VKColorBlendState

Describes the pipeline blending state.

alphaToCoverageEnable

True if alpha-to-coverage should be used when blending to an MSAA target.

alphaToOneEnable

True if alpha-to-one should be used when blending to an MSAA target.

blendFactor

The constant blend factor to use in blend equations.

Type: Tuple[float,float,float,float]
blends

The blend operations for each target.

Type: List[ColorBlend]

Depth/Stencil State

class renderdoc.VKDepthStencil

Describes the pipeline depth-stencil state.

backFace

The stencil state for back-facing polygons.

Type: StencilFace
depthBoundsEnable

True if depth bounds tests should be applied.

depthFunction

The CompareFunction to use for testing depth values.

depthTestEnable

True if depth testing should be performed.

depthWriteEnable

True if depth values should be written to the depth target.

frontFace

The stencil state for front-facing polygons.

Type: StencilFace
maxDepthBounds

The far plane bounding value.

minDepthBounds

The near plane bounding value.

stencilTestEnable

True if stencil operations should be performed.

Renderpass and Framebuffer

class renderdoc.VKCurrentPass

Describes the current pass instance at the current time.

colorFeedbackAllowed

If feedback loops are allowed on color attachments

depthFeedbackAllowed

If feedback loops are allowed on depth attachments

framebuffer

The framebuffer that is currently being used.

Type: VKFramebuffer
renderArea

The render area that is currently being rendered to.

Type: VKRenderArea
renderpass

The renderpass and subpass that is currently active.

Type: VKRenderPass
stencilFeedbackAllowed

If feedback loops are allowed on stencil attachments

class renderdoc.VKRenderPass

Describes the setup of a renderpass and subpasses.

colorAttachments

The color attachments for the current subpass, as indices into the framebuffer attachments.

Type: List[int]
depthstencilAttachment

An index into the framebuffer attachments for the depth-stencil attachment.

If there is no depth-stencil attachment, this index is -1.

depthstencilResolveAttachment

An index into the framebuffer attachments for the depth-stencil resolve attachment.

If there is no depth-stencil resolve attachment, this index is -1.

dynamic

Whether or not dynamic rendering is in use (no render pass or framebuffer objects).

feedbackLoop

Whether or not there is a potential feedback loop.

fragmentDensityAttachment

An index into the framebuffer attachments for the fragment density attachment.

If there is no fragment density attachment, this index is -1.

Note

Only one at most of fragmentDensityAttachment and shadingRateAttachment will be set.

fragmentDensityOffsets

If VK_QCOM_fragment_density_map_offset is enabled, contains a list of offsets applied to the fragment density map during rendering.

If the list is empty, fdm_offset is disabled and rendering is as normal.

Type: List[Offset]
inputAttachments

The input attachments for the current subpass, as indices into the framebuffer attachments.

Type: List[int]
multiviews

If multiview is enabled, contains a list of view indices to be broadcast to during rendering.

If the list is empty, multiview is disabled and rendering is as normal.

Type: List[int]
resolveAttachments

The resolve attachments for the current subpass, as indices into the framebuffer attachments.

Type: List[int]
resourceId

The ResourceId of the render pass.

shadingRateAttachment

An index into the framebuffer attachments for the fragment shading rate attachment.

If there is no fragment shading rate attachment, this index is -1.

Note

Only one at most of fragmentDensityAttachment and shadingRateAttachment will be set.

shadingRateTexelSize

The size of the framebuffer region represented by each texel in shadingRateAttachment.

For example if this is (2,2) then every texel in the attachment gives the shading rate of a 2x2 block in the framebuffer so the shading rate attachment is half the size of the other attachments in each dimension.

If no attachment is set in shadingRateAttachment this will be (1,1).

Type: Tuple[int,int]
subpass

The index of the current active subpass.

suspended

Whether or not dynamic rendering is currently suspended.

tileOnlyMSAASampleCount

If VK_EXT_multisampled_render_to_single_sampled is enabled, contains the number of samples used to render this subpass.

If the subpass is not internally multisampled, tileOnlyMSAASampleCount is set to 0.

class renderdoc.VKFramebuffer

Describes a framebuffer object and its attachments.

attachments

The attachments of this framebuffer.

Type: List[VKAttachment]
height

The height of this framebuffer in pixels.

layers

The number of layers in this framebuffer.

resourceId

The ResourceId of the framebuffer object.

width

The width of this framebuffer in pixels.

class renderdoc.VKAttachment

Describes a single attachment in a framebuffer object.

firstMip

The first mip level used in the attachment.

firstSlice

For 3D textures and texture arrays, the first slice used in the attachment.

imageResourceId

The ResourceId of the underlying image that the view refers to.

numMips

The number of mip levels in the attachment.

numSlices

For 3D textures and texture arrays, the number of array slices in the attachment.

swizzle

The swizzle applied to the texture by the view.

Type: TextureSwizzle4
viewFormat

The format cast that the view uses.

Type: ResourceFormat
viewResourceId

The ResourceId of the image view itself.

class renderdoc.VKRenderArea

Describes a render area in the current framebuffer.

height

The height of the render area.

width

The width of the render area.

x

The X co-ordinate of the render area.

y

The Y co-ordinate of the render area.

Image States

class renderdoc.VKImageData

Contains the current layout of all subresources in the image.

layouts

The subresource regions in this resource.

Type: List[VKImageLayout]
resourceId

The ResourceId of the image.

class renderdoc.VKImageLayout

Contains the layout of a range of subresources in an image.

baseLayer

For 3D textures and texture arrays, the first slice used in the range.

baseMip

The first mip level used in the range.

name

The name of the current image state.

numLayer

For 3D textures and texture arrays, the number of array slices in the range.

numMip

The number of mip levels in the range.

Conditional Rendering

class renderdoc.VKConditionalRendering

Contains the current conditional rendering state.

bufferId

The ResourceId of the buffer containing the predicate for conditional rendering.

byteOffset

The byte offset into buffer where the predicate is located.

isInverted

True if predicate result is inverted.

isPassing

True if the current predicate would render.


Common Pipeline State Abstraction

Contents

  • Common Pipeline State Abstraction
    • General
    • Vertex Inputs
    • Shader Resource Bindings
    • Samplers
    • Viewport and Scissor
    • Rasterizer
    • Stencil
    • Blending
    • Shader Messages
class renderdoc.PipeState

An API-agnostic view of the common aspects of the pipeline state. This allows simple access to e.g. find out the bound resources or vertex buffers, or certain pipeline state which is available on all APIs.

For more detailed or precise information without abstraction, access the specific pipeline state for the capture that’s open.

Abbrev(stage)

Retrieves a suitable two or three letter abbreviation of the given shader stage.

Parameters: stage # (ShaderStage) – The shader stage to abbreviate.
Returns: The abbreviation of the stage.
Return type: str
GetBindpointMapping(stage)

Retrieves the current bindpoint mapping for a shader stage.

This returns an empty bindpoint mapping if no shader is bound.

Parameters: stage # (ShaderStage) – The shader stage to fetch.
Returns: The bindpoint mapping for the given shader.
Return type: ShaderBindpointMapping
GetColorBlends()

Retrieves the current color blending states, per target.

Returns: The currently color blend states.
Return type: List[ColorBlend]
GetComputePipelineObject()

Retrieves the the compute pipeline state object, if applicable.

Returns: The object ID for the given pipeline object.
Return type: ResourceId
GetConstantBuffer(stage, BufIdx, ArrayIdx)

Retrieves the constant buffer at a given binding.

Parameters:
  • stage # (ShaderStage) – The shader stage to fetch from.
  • BufIdx # (int) – The index in the shader’s ConstantBlocks array to look up.
  • ArrayIdx # (int) – For APIs that support arrays of constant buffers in a single binding, the index in that array to look up.
Returns:

The constant buffer at the specified binding.
Return type:

BoundCBuffer
GetDepthResolveTarget()

Retrieves the read/write resources bound to the depth-stencil resolve output.

Returns: The currently bound depth-stencil resolve resource.
Return type: BoundResource
GetDepthTarget()

Retrieves the read/write resources bound to the depth-stencil output.

Returns: The currently bound depth-stencil resource.
Return type: BoundResource
GetGraphicsPipelineObject()

Retrieves the the graphics pipeline state object, if applicable.

Returns: The object ID for the given pipeline object.
Return type: ResourceId
GetIBuffer()

Retrieves the current index buffer binding.

Note

On OpenGL the index stride/width is not part of any state, but is specified in each action. In this case the current stride is whichever was last specified to a action, as if there was implicit state set by a action.

Returns: A BoundVBuffer with the index buffer details
Return type: BoundVBuffer
GetOutputTargets()

Retrieves the resources bound to the color outputs.

Returns: The currently bound output targets.
Return type: List[BoundResource]
GetPrimitiveTopology()

Returns the current primitive topology.

Note

On OpenGL the primitive topology is not part of any state, but is specified in each action. In this case the current topology is whichever was last specified to a action, as if there was implicit state set by a action.

Returns: The current primitive topology.
Return type: Topology
GetRasterizedStream()

Retrieves the rasterized stream, if multiple streams are being generated in the GS.

Returns: The rasterized stream, or -1 of no stream is being rasterized.
Return type: int
GetReadOnlyResources(stage, onlyUsed=False)
GetReadOnlyResources(stage) → None

Retrieves the read-only resources bound to a particular shader stage.

Parameters:
  • stage # (ShaderStage) – The shader stage to fetch from.
  • onlyUsed # (bool) – Return only a subset of resources containing those actually used by the shader.
Returns:

The currently bound read-only resources.
Return type:

List[BoundResourceArray]
GetReadWriteResources(stage, onlyUsed=False)
GetReadWriteResources(stage) → None

Retrieves the read/write resources bound to a particular shader stage.

Parameters:
  • stage # (ShaderStage) – The shader stage to fetch from.
  • onlyUsed # (bool) – Return only a subset of resources containing those actually used by the shader.
Returns:

The currently bound read/write resources.
Return type:

List[BoundResourceArray]
GetResourceLayout(id)

For APIs that have explicit barriers, retrieves the current layout of a resource.

Parameters: id # (ResourceId) – The ID of the resource to query for
Returns: The name of the current layout of the first subresource in the resource.
Return type: str
GetRestartIndex()

Retrieves the primitive restart index.

Returns: The index value that represents a primitive restart not a real index.
Return type: int
GetSamplers(stage)

Retrieves the samplers bound to a particular shader stage.

Parameters: stage # (ShaderStage) – The shader stage to fetch from.
Returns: The currently bound sampler resources.
Return type: List[BoundResourceArray]
GetScissor(index)

Retrieves the scissor region for a given index.

Parameters: index # (int) – The index to retrieve.
Returns: The scissor region for the given index.
Return type: Scissor
GetShader(stage)

Retrieves the object ID of the shader bound at a shader stage.

Parameters: stage # (ShaderStage) – The shader stage to fetch.
Returns: The object ID for the given shader.
Return type: ResourceId
GetShaderEntryPoint(stage)

Retrieves the name of the entry point function for a shader stage.

For some APIs that don’t distinguish by entry point, this may be empty.

Parameters: stage # (ShaderStage) – The shader stage to fetch.
Returns: The entry point name for the given shader.
Return type: str
GetShaderMessages()

Retrieves the shader messages obtained for the current action.

Returns: The shader messages obtained for the current action.
Return type: List[ShaderMessage]
GetShaderReflection(stage)

Retrieves the shader reflection information for a shader stage.

This returns None if no shader is bound.

Parameters: stage # (ShaderStage) – The shader stage to fetch.
Returns: The reflection data for the given shader.
Return type: ShaderReflection
GetStencilFaces()

Retrieves the current stencil states.

Returns: The currently stencil states. Front facing first, back facing second.
Return type: Tuple[StencilFace, StencilFace]
GetVBuffers()

Retrieves the currently bound vertex buffers.

Returns: The list of bound vertex buffers.
Return type: List[BoundVBuffer]
GetVertexInputs()

Retrieves the currently specified vertex attributes.

Returns: The list of current vertex attributes.
Return type: List[VertexInputAttribute]
GetViewport(index)

Retrieves the viewport for a given index.

Parameters: index # (int) – The index to retrieve.
Returns: The viewport for the given index.
Return type: Viewport
HasAlignedPostVSData(stage)

Determines whether or not the PostVS data is aligned in the typical fashion (ie. vectors not crossing float4 boundaries). APIs that use stream-out or transform feedback have tightly packed data, but APIs that rewrite shaders to dump data might have these alignment requirements.

Parameters: stage # (MeshDataStage) – The mesh data stage for the output data.
Returns: A boolean indicating if post-VS data is aligned.
Return type: bool
IsCaptureD3D11()

Determines whether or not a D3D11 capture is currently loaded.

Returns: A boolean indicating if a D3D11 capture is currently loaded.
Return type: bool
IsCaptureD3D12()

Determines whether or not a D3D12 capture is currently loaded.

Returns: A boolean indicating if a D3D12 capture is currently loaded.
Return type: bool
IsCaptureGL()

Determines whether or not an OpenGL capture is currently loaded.

Returns: A boolean indicating if an OpenGL capture is currently loaded.
Return type: bool
IsCaptureLoaded()

Determines whether or not a capture is currently loaded.

Returns: A boolean indicating if a capture is currently loaded.
Return type: bool
IsCaptureVK()

Determines whether or not a Vulkan capture is currently loaded.

Returns: A boolean indicating if a Vulkan capture is currently loaded.
Return type: bool
IsIndependentBlendingEnabled()

Determines whether or not independent blending is enabled.

Returns: A boolean indicating if independent blending is enabled.
Return type: bool
IsRestartEnabled()

Determines whether or not primitive restart is enabled.

Returns: A boolean indicating if primitive restart is enabled.
Return type: bool
IsTessellationEnabled()

Determines whether or not tessellation is currently enabled.

Returns: A boolean indicating if tessellation is currently enabled.
Return type: bool
MultiviewBroadcastCount()
Returns: The number of views being broadcast to simultaneously during rendering.
Return type: int
OutputAbbrev()

Retrieves a suitable two or three letter abbreviation of the output stage. Typically ‘OM’ or ‘FBO’.

Returns: The abbreviation of the output stage.
Return type: str
SupportsBarriers()

Determines whether or not the current capture uses explicit barriers.

Returns: A boolean indicating if explicit barriers are used.
Return type: bool
SupportsResourceArrays()

Determines whether or not the current capture supports binding arrays of resources.

Returns: A boolean indicating if binding arrays of resources is supported.
Return type: bool

General

class renderdoc.Offset

Describes a 2-dimensional int offset

x

The X offset value.

Type: int
y

The Y offset value.

Type: int

Vertex Inputs

class renderdoc.BoundVBuffer

Information about a single vertex or index buffer binding.

byteOffset

The offset in bytes from the start of the buffer to the data.

byteSize

The size of the buffer binding, or 0xFFFFFFFF if the whole buffer is bound.

byteStride

The stride in bytes between the start of one element and the start of the next.

resourceId

A ResourceId identifying the buffer.

class renderdoc.VertexInputAttribute

Information about a vertex input attribute feeding the vertex shader.

byteOffset

The byte offset from the start of the vertex data for this VB to this attribute.

floatCastWrong

Only valid for attributes on OpenGL. If the attribute has been set up for integers to be converted to floats (glVertexAttribFormat with GL_INT) we store the format as integers. This is fine if the application has a float input in the shader it just means we display the raw integer instead of the casted float. However if the shader has an integer input this is invalid and it will read something undefined - possibly the int bits of the casted float.

This property is set to True if the cast happens to an integer input and that bad cast needs to be emulated.

format

The interpreted format of this attribute.

Type: ResourceFormat
genericEnabled

True if this attribute is using genericValue for its data.

genericValue

The generic value for this attribute if it has no vertex buffer bound.

Type: PixelValue
instanceRate

If perInstance is True, the number of instances that source the same value from the vertex buffer before advancing to the next value.

name

The name of this input. This may be a variable name or a semantic name.

perInstance

True if this attribute runs at instance rate.

used

True if this attribute is enabled and used by the vertex shader.

vertexBuffer

The index of the vertex buffer used to provide this attribute.

class renderdoc.Topology(value)

A primitive topology used for processing vertex data.

Unknown

An unknown or undefined topology.

PointList

A point list.

LineList

A line list.

LineStrip

A line strip.

LineLoop

A line loop.

TriangleList

A triangle list.

TriangleStrip

A triangle strip.

TriangleFan

A triangle fan.

LineList_Adj

A line list with adjacency information.

LineStrip_Adj

A line strip with adjacency information.

TriangleList_Adj

A triangle list with adjacency information.

TriangleStrip_Adj

A triangle strip with adjacency information.

PatchList

An alias for PatchList_1CPs.

PatchList_1CPs

A patch list with 1 control points.

PatchList_2CPs

A patch list with 2 control points.

PatchList_3CPs

A patch list with 3 control points.

PatchList_4CPs

A patch list with 4 control points.

PatchList_5CPs

A patch list with 5 control points.

PatchList_6CPs

A patch list with 6 control points.

PatchList_7CPs

A patch list with 7 control points.

PatchList_8CPs

A patch list with 8 control points.

PatchList_9CPs

A patch list with 9 control points.

PatchList_10CPs

A patch list with 10 control points.

PatchList_11CPs

A patch list with 11 control points.

PatchList_12CPs

A patch list with 12 control points.

PatchList_13CPs

A patch list with 13 control points.

PatchList_14CPs

A patch list with 14 control points.

PatchList_15CPs

A patch list with 15 control points.

PatchList_16CPs

A patch list with 16 control points.

PatchList_17CPs

A patch list with 17 control points.

PatchList_18CPs

A patch list with 18 control points.

PatchList_19CPs

A patch list with 19 control points.

PatchList_20CPs

A patch list with 20 control points.

PatchList_21CPs

A patch list with 21 control points.

PatchList_22CPs

A patch list with 22 control points.

PatchList_23CPs

A patch list with 23 control points.

PatchList_24CPs

A patch list with 24 control points.

PatchList_25CPs

A patch list with 25 control points.

PatchList_26CPs

A patch list with 26 control points.

PatchList_27CPs

A patch list with 27 control points.

PatchList_28CPs

A patch list with 28 control points.

PatchList_29CPs

A patch list with 29 control points.

PatchList_30CPs

A patch list with 30 control points.

PatchList_31CPs

A patch list with 31 control points.

PatchList_32CPs

A patch list with 32 control points.

renderdoc.NumVerticesPerPrimitive(topology)

A utility function that returns the number of vertices in a primitive of a given topology.

Note

In strip topologies vertices are re-used.

Parameters: topology # (Topology) – The topology to query about.
Returns: The number of vertices in a single primitive.
Return type: int
renderdoc.VertexOffset(topology, primitive)

A utility function that returns the offset in the list of vertices of the first vertex in a particular primitive of a given topology. This calculation is simple but not trivial for the case of strip topologies.

Parameters:
  • topology # (Topology) – The topology to query about.
  • primitive # (int) – The primitive to query about.
Returns:

The vertex offset where the primitive starts.
Return type:

int
renderdoc.PatchList_Count(topology)

Return the number of control points in a patch list Topology

t must be a patch list topology, the return value will be between 1 and 32 inclusive

Parameters: topology # (Topology) – The patch list topology
Returns: The number of control points in the specified topology
Return type: int
renderdoc.PatchList_Topology(N)

Return the patch list Topology with N control points

N must be between 1 and 32 inclusive.

Parameters: N # (int) – The number of control points in the patch list
Returns: The patchlist topology with that number of control points
Return type: Topology
renderdoc.IsStrip(topology)

Check whether or not this is a strip-type topology.

Parameters: topology # (Topology) – The topology to check.
Returns: True if it describes a strip topology, False for a list.
Return type: bool

Shader Resource Bindings

class renderdoc.BoundResourceArray

Contains all of the bound resources at a particular bindpoint. In APIs that don’t support resource arrays, there will only be one bound resource.

bindPoint

The bind point for this array of bound resources.

Type: Bindpoint
dynamicallyUsedCount

Lists how many bindings in resources are dynamically used.

Some APIs provide fine-grained usage based on dynamic shader feedback, to support ‘bindless’ scenarios where only a small sparse subset of bound resources are actually used.

If this information isn’t present this will be set to a large number.

firstIndex

Gives the array index of the first binding in resource. If only a small subset of the resources are used by the shader then the array may be rebased such that the first element is not array index 0.

For more information see VKBindingElement.dynamicallyUsed.

resources

The resources at this bind point.

Type: List[BoundResource]
class renderdoc.BoundResource

Information about a single resource bound to a slot in an API-specific way.

dynamicallyUsed

True if this binding element is dynamically used.

Some APIs provide fine-grained usage based on dynamic shader feedback, to support ‘bindless’ scenarios where only a small sparse subset of bound resources are actually used.

firstMip

For textures, the highest mip level available on this binding, or -1 for all mips

firstSlice

For textures, the first array slice available on this binding. or -1 for all slices.

resourceId

A ResourceId identifying the bound resource.

typeCast

For textures, a CompType hint for how to interpret typeless textures.

class renderdoc.BoundCBuffer

Information about a single constant buffer binding.

byteOffset

The offset in bytes from the start of the buffer to the constant data.

byteSize

The size in bytes for the constant buffer. Access outside this size returns 0.

inlineData

The inline byte data for this constant buffer, if this binding is not backed by a typical buffer.

Type: bytes
resourceId

A ResourceId identifying the buffer.

class renderdoc.BindType(value)

The type of a shader resource bind.

Unknown

An unknown type of binding.

ConstantBuffer

A constant or uniform buffer.

Sampler

A separate sampler object.

ImageSampler

A combined image and sampler object.

ReadOnlyImage

An image that can only be sampled from.

ReadWriteImage

An image that can be read from and written to arbitrarily.

ReadOnlyTBuffer

A texture buffer that can only be read from.

ReadWriteTBuffer

A texture buffer that can be read from and written to arbitrarily.

ReadOnlyBuffer

A buffer that can only be read from, distinct from ConstantBuffer.

ReadWriteBuffer

A buffer that can be read from and written to arbitrarily.

ReadOnlyResource

A resource that can only be read from

ReadWriteResource

A resource that can be read from and written to arbitrarily.

InputAttachment

An input attachment for reading from the target currently being written.

class renderdoc.TextureSwizzle(value)

A single source component for a destination texture swizzle.

Red

The Red component.

Green

The Green component.

Blue

The Blue component.

Alpha

The Alpha component.

Zero

The fixed value 0.

One

The fixed value 1.

class renderdoc.TextureSwizzle4

The four components of a texture swizzle.

alpha

The alpha channel’s TextureSwizzle.

blue

The blue channel’s TextureSwizzle.

green

The green channel’s TextureSwizzle.

red

The red channel’s TextureSwizzle.

class renderdoc.D3DBufferViewFlags(value)

A set of flags for D3D buffer view properties.

NoFlags

The buffer will not be used for any of the uses below.

Raw

The buffer is used as a raw (byte-addressed) buffer.

Append

The buffer is used as a append/consume view.

Counter

The buffer is used with a structured buffer with associated hidden counter.

Samplers

class renderdoc.AddressMode(value)

A texture addressing mode in a single direction (U,V or W).

Wrap

The texture is tiled at every multiple of 1.0.

Repeat

Alias of Wrap.

Mirror

The texture is tiled as with Wrap, but with the absolute value of the texture co-ordinate.

MirrorRepeat

Alias of Mirror.

MirrorOnce

The texture is mirrored with Mirror, but the texture does not tile as with ClampEdge.

MirrorClamp

Alias of MirrorOnce.

ClampEdge

The texture is clamped to the range of [0.0, 1.0] and the texture value at each end used.

ClampBorder

The texture is clamped such that texture co-ordinates outside the range of [0.0, 1.0] are set to the border color specified in the sampler.

class renderdoc.TextureFilter

The details of a texture filter in a sampler.

filter

The FilterFunction to apply after interpolating values.

magnify

The FilterMode to use when magnifying the texture.

minify

The FilterMode to use when minifying the texture.

mip

The FilterMode to use when interpolating between mips.

class renderdoc.FilterMode(value)

The texture filtering mode for a given direction (minification, magnification, or between mips).

NoFilter

No filtering - this direction is disabled or there is no sampler.

Point

Point or nearest filtering - the closest pixel or mip level to the sample location is used.

Linear

Linear filtering - a linear interpolation happens between the pixels or mips on either side of the sample location in each direction.

Cubic

Similar to linear filtering but with a cubic curve used for interpolation instead of linear.

Anisotropic

This sampler is using anisotropic filtering.

class renderdoc.FilterFunction(value)

The function used to process the returned value after interpolation.

Normal

No special processing is used, the value is returned directly to the shader.

Comparison

The value from interpolation is compared to a reference value and the comparison result is returned to the shader.

Minimum

Instead of interpolating between sample points to retrieve an interpolated value, a min filter is used instead to find the minimum sample value.

Texels that were weight to 0 during interpolation are not included in the min function.

Maximum

Instead of interpolating between sample points to retrieve an interpolated value, a max filter is used instead to find the maximum sample value.

Texels that were weight to 0 during interpolation are not included in the max function.

class renderdoc.ChromaSampleLocation(value)

Determines where in the pixel downsampled chrome samples are positioned.

CositedEven

The chroma samples are positioned exactly in the same place as the even luma co-ordinates.

Midpoint

The chrome samples are positioned half way between each even luma sample and the next highest odd luma sample.

class renderdoc.YcbcrConversion(value)

The color model conversion that a YCbCr sampler uses to convert from YCbCr to RGB.

Raw

The input values are not converted at all.

RangeOnly

There is no model conversion but the inputs are range expanded as for YCbCr.

BT709

The conversion uses the BT.709 color model conversion.

BT601

The conversion uses the BT.601 color model conversion.

BT2020

The conversion uses the BT.2020 color model conversion.

class renderdoc.YcbcrRange(value)

Specifies the range of encoded values and their interpretation.

ITUFull

The full range of input values are valid and interpreted according to ITU “full range” rules.

ITUNarrow

A head and foot are reserved in the encoded values, and the remaining values are expanded according to “narrow range” rules.

Viewport and Scissor

class renderdoc.Viewport

Information about a viewport.

enabled

Is this viewport enabled.

height

The height of the viewport.

maxDepth

The maximum depth of the viewport.

minDepth

The minimum depth of the viewport.

width

The width of the viewport.

x

The X co-ordinate of the viewport.

y

The Y co-ordinate of the viewport.

class renderdoc.Scissor

Describes a single scissor region.

enabled

True if this scissor region is enabled.

height

Height of the scissor region.

width

Width of the scissor region.

x

X co-ordinate of the scissor region.

y

Y co-ordinate of the scissor region.

Rasterizer

class renderdoc.CullMode(value)

The culling mode for polygons.

NoCull

No polygon culling is performed.

Front

Front-facing polygons are culled.

Back

Back-facing polygons are culled.

FrontAndBack

Both front-facing and back-facing polygons are culled.

class renderdoc.FillMode(value)

The fill mode for polygons.

Solid

Polygons are filled in and rasterized solidly.

Wireframe

Polygons are rendered only with lines along their edges, forming a wireframe.

Point

Only the points at the polygons vertices are rendered.

class renderdoc.ConservativeRaster(value)

The conservative rasterization mode.

Disabled

No conservative rasterization, the default rasterization coverage algorithm is used.

Underestimate

Fragments will only be generated if the primitive full covers all parts of the pixel, including edges and corners.

Overestimate

Fragments will be generated if the primitive covers any part of the pixel, including edges and corners.

class renderdoc.LineRaster(value)

The line rasterization mode.

Default

Default line rasterization mode as defined by the API specification.

Rectangular

Lines are rasterized as rectangles extruded from the line.

Bresenham

Lines are rasterized according to the bresenham line algorithm.

RectangularSmooth

Lines are rasterized as rectangles extruded from the line with coverage falloff being implementation independent.

RectangularD3D

Lines are rasterized as rectangles extruded from the line, but with a width of 1.4 according to legacy D3D behaviour

class renderdoc.ShadingRateCombiner(value)

A combiner to apply when determining a pixel shading rate.

Keep

Keep the first input to the combiner.

Passthrough

Keep the first input to the combiner. Alias for Keep, for D3D terminology.

Replace

Replace with the second input to the combiner.

Override

Replace with the second input to the combiner. Alias for Replace, for D3D terminology.

Min

Use the minimum (finest rate) of the two inputs.

Max

Use the maximum (coarsest rate) of the two inputs.

Multiply

Multiply the two rates together (e.g. 1x1 and 1x2 = 1x2, 2x2 and 2x2 = 4x4). Note that D3D names this ‘sum’ misleadingly.

Stencil

class renderdoc.StencilFace

Describes the details of a stencil operation.

compareMask

The mask for testing stencil values.

depthFailOperation

the StencilOperation to apply if the depth-test fails.

failOperation

The StencilOperation to apply if the stencil-test fails.

function

the CompareFunction to use for testing stencil values.

passOperation

the StencilOperation to apply if the stencil-test passes.

reference

The current stencil reference value.

writeMask

The mask for writing stencil values.

class renderdoc.StencilOperation(value)

A stencil operation to apply in stencil processing.

Keep

Keep the existing value unmodified.

Zero

Set the value to 0.

Replace

Replace the value with the stencil reference value.

IncSat

Increment the value but saturate at the maximum representable value (typically 255).

DecSat

Decrement the value but saturate at 0.

IncWrap

Increment the value and wrap at the maximum representable value (typically 255) to 0.

DecWrap

Decrement the value and wrap at 0 to the maximum representable value (typically 255).

Invert

Invert the bits in the stencil value (bitwise NOT).

class renderdoc.CompareFunction(value)

A comparison function to return a bool result from two inputs A and B.

Never

False

AlwaysTrue

True

Less

A < B

LessEqual

A <= B

Greater

A > B

GreaterEqual

A >= B

Equal

A == B

NotEqual

A != B

Blending

class renderdoc.ColorBlend

Describes the blend configuration for a given output target.

alphaBlend

The blending equation for alpha values.

Type: BlendEquation
colorBlend

The blending equation for color values.

Type: BlendEquation
enabled

True if blending is enabled for this target.

logicOperation

The LogicOperation to use for logic operations, if logicOperationEnabled is True.

logicOperationEnabled

True if the logic operation in logicOperation should be used.

writeMask

The mask for writes to the render target.

class renderdoc.BlendEquation

Describes the details of a blend operation.

destination

The BlendMultiplier for the destination blend value.

operation

The BlendOperation to use in the blend calculation.

source

The BlendMultiplier for the source blend value.

class renderdoc.BlendMultiplier(value)

A multiplier on one component in the blend equation.

Note

The “source” value is the value written out by the shader.

The “second source” value is provided when dual source blending is used.

The “destination” value is the value in the target being blended to.

These values are combined using a given blend operation, see BlendOperation.

Where a color is referenced, the value depends on where the multiplier appears in the blend equation. If it is a multiplier on the color component then it refers to the color component. If it is a multiplier on the alpha component then it refers to the alpha component.

If alpha is referenced explicitly it always refers to alpha, in both color and alpha equations.

Zero

The literal value 0.0.

One

The literal value 1.0.

SrcCol

The source value’s color.

InvSrcCol

1.0 minus the source value’s color.

DstCol

The destination value’s color.

InvDstCol

1.0 minus the destination value’s color.

SrcAlpha

The source value’s alpha.

InvSrcAlpha

1.0 minus the source value’s alpha.

DstAlpha

The destination value’s alpha.

InvDstAlpha

1.0 minus the destination value’s alpha.

SrcAlphaSat

The lowest value of SrcAlpha and InvDstAlpha. If used in the alpha equation, it takes the value One.

FactorRGB

The color components of the fixed blend factor constant.

InvFactorRGB

1.0 minus the color components of the fixed blend factor constant.

FactorAlpha

The alpha component of the fixed blend factor constant.

InvFactorAlpha

1.0 minus the alpha components of the fixed blend factor constant.

Src1Col

The second source value’s color.

InvSrc1Col

1.0 minus the second source value’s color.

Src1Alpha

The second source value’s alpha.

InvSrc1Alpha

1.0 minus the second source value’s alpha.

class renderdoc.BlendOperation(value)

A blending operation to apply in color blending.

Note

The “source” value is the value written out by the shader.

The “destination” value is the value in the target being blended to.

These values are multiplied by a given blend factor, see BlendMultiplier.

Add

Add the two values being processed together.

Subtract

Subtract the destination value from the source value.

ReversedSubtract

Subtract the source value from the destination value.

Minimum

The minimum of the source and destination value.

Maximum

The maximum of the source and destination value.

class renderdoc.LogicOperation(value)

A logical operation to apply when writing texture values to an output.

Note

The “source” value is the value written out by the shader.

The “destination” value is the value in the target being written to.

NoOp

No operation is performed, the destination is unmodified.

Clear

A 0 in every bit.

Set

A 1 in every bit.

Copy

The contents of the source value.

CopyInverted

The contents of the source value are bitwise inverted.

Invert

The contents of the destination value are bitwise inverted, then written.

And

The source and destination values are combined with the bitwise AND operator.

Nand

The source and destination values are combined with the bitwise NAND operator.

Or

The source and destination values are combined with the bitwise OR operator.

Xor

The source and destination values are combined with the bitwise XOR operator.

Nor

The source and destination values are combined with the bitwise NOR operator.

Equivalent

The source and destination values are combined with the logical equivalence operator, defined as NOT (s XOR d).

AndReverse

The source and inverted destination values are combined with the bitwise AND operator - i.e. s AND (NOT d).

AndInverted

The inverted source and destination values are combined with the bitwise AND operator - i.e. (NOT s) AND d.

OrReverse

The source and inverted destination values are combined with the bitwise OR operator - i.e. s OR (NOT d).

OrInverted

The inverted source and destination values are combined with the bitwise OR operator - i.e. (NOT s) OR d.

Shader Messages

class renderdoc.ShaderMessage

A shader printed message.

disassemblyLine

The line (starting from 1) of the disassembly where this message came from, or -1 if it is not associated with any line.

Type: int
location

The location (thread/invocation) of the shader that this message comes from.

Type: ShaderMessageLocation
message

The formatted message.

Type: str
stage

The shader stage this message comes from.

Type: ShaderStage
class renderdoc.ShaderMessageLocation

A shader message’s location.

compute

The location if the shader is a compute shader.

Type: ShaderComputeMessageLocation
geometry

The location if the shader is a geometry shader.

Type: ShaderGeometryMessageLocation
mesh

The location if the shader is a task or mesh shader.

Type: ShaderMeshMessageLocation
pixel

The location if the shader is a pixel shader.

Type: ShaderPixelMessageLocation
vertex

The location if the shader is a vertex shader.

Type: ShaderVertexMessageLocation
class renderdoc.ShaderMeshMessageLocation

A task or mesh message’s location.

NotUsed

Set for values of task group/thread index when no task shaders were run.

Also set for values of a mesh group or thread index when that dimensionality is unused. For example if the shader declares a group dimension of (128,1,1) then the y and z values for thread index will be indicated as not used.

meshGroup

The mesh workgroup index within the dispatch or launching task workgroup.

Type: Tuple[int,int,int]
taskGroup

The task workgroup index between the task dispatch.

Note

If no task shader is in use, this will be NotUsed, NotUsed, NotUsed.

Type: Tuple[int,int,int]
thread

The thread index within the workgroup, either for a task shader or mesh shader.

Note

Since task shaders can only emit one set of meshes per group, the task thread is not relevant for mesh shader messages, so this is the thread either for a task or a mesh shader message.

Type: Tuple[int,int,int]
class renderdoc.ShaderVertexMessageLocation

A vertex shader message’s location.

instance

The instance for this vertex.

Type: int
vertexIndex

The vertex or index for this vertex.

Type: int
view

The multiview view for this vertex, or 0 if multiview is disabled.

Type: int
class renderdoc.ShaderPixelMessageLocation

A pixel shader message’s location.

NoLocation

No frame number is available.

primitive

The generating primitive, or NoLocation if the primitive ID is unavailable.

Type: int
sample

The sample, or NoLocation if sample shading is disabled.

Type: int
view

The multiview view for this fragment, or 0 if multiview is disabled.

Type: int
x

The x co-ordinate of the pixel.

Type: int
y

The y co-ordinate of the pixel.

Type: int
class renderdoc.ShaderGeometryMessageLocation

A geometry shader message’s location.

NoLocation

No frame number is available.

primitive

The primitive index

Type: int
view

The multiview view for this primitive, or 0 if multiview is disabled.

Type: int
class renderdoc.ShaderComputeMessageLocation

A compute shader message’s location.

thread

The thread index within the workgroup.

Type: Tuple[int,int,int]
workgroup

The workgroup index within the dispatch.

Type: Tuple[int,int,int]
  • qrenderdoc.ShaderMessageViewer


Structured Data

Contents

  • Structured Data
    • Type information
    • Objects
    • Chunks
    • Structured File
    • Creation Helper Functions

Type information

class renderdoc.SDType

Details the name and properties of a structured type

basetype

The SDBasic category that this type belongs to.

byteSize

The size in bytes that an instance of this type takes up.

This is only valid for whole chunks (where it contains the whole chunk size), for buffers that have an arbitrary size, or for basic types such as integers and floating point values where it gives the size/precision of the type.

For variable size types like structs, arrays, etc it will be set to 0.

flags

The SDTypeFlags flags for this type.

name

The name of this type.

class renderdoc.SDBasic(value)

The basic irreducible type of an object. Every other more complex type is built on these.

Chunk

A ‘special’ type indicating that the object is a chunk. A chunk can be treated like a Struct otherwise. See SDChunk.

Struct

A composite type with some number of children of different types, each child with its own name. May in some cases be empty, so the presence of children should not be assumed.

Array

A composite type with some number of children with an identical type and referred to purely by their index in the array. May be empty.

Null

An indicator that an object could be here, but is optional and is currently not present. See SDTypeFlags.Nullable.

Buffer

An opaque byte buffer.

String

A string, encoded as UTF-8.

Enum

An enum value - stored as an integer but with a distinct set of possible named values.

UnsignedInteger

An unsigned integer.

SignedInteger

An signed integer.

Float

A floating point value.

Boolean

A boolean true/false value.

Character

A single byte character. Wide/multi-byte characters are not supported (these would be stored as a string with 1 character and multiple bytes in UTF-8).

Resource

A ResourceId. Equivalent to (and stored as) an 8-byte unsigned integer, but specifically contains the unique Id of a resource in a capture.

class renderdoc.SDTypeFlags(value)

Bitfield flags that could be applied to a type.

NoFlags

This type has no special properties.

HasCustomString

This type has a custom string. This could be used for example for enums, to display the string value of the enum as well as the integer storage, or perhaps for opaque types that should be displayed to the user as a string even if the underlying representation is not a string.

Hidden

This type is considered an implementation detail and should not typically be displayed to the user.

Nullable

This type is nullable and can sometimes be removed and replaced simply with a Null type. See SDBasic.Null.

NullString

Special flag to indicate that this is a C-string which was NULL, not just empty.

FixedArray

Special flag to indicate that this is array was a fixed-size real array, rather than a complex container type or a pointer & length.

Union

Special flag to indicate that this is structure is stored as a union, meaning all children share the same memory and some external flag indicates which element is valid.

Important

Indicates that this object is important or significant, to aid in generating a summary/one-line view of a particular chunk by only including important children.

This property can be recursive - so an important child which is a structure can have only some members which are important.

ImportantChildren

Indicates that only important children should be processed, as noted in Important. This may appear on an object which has no important children - which indicates explicitly that there are no important children so when summarising no parameters should be shown.

HiddenChildren

Indicates that some children are marked as hidden. This can be important for cases where the number of children is important.

OffsetOrSize

Special flag to indicate that this type will be used as a byte offset or byte size, which is used to control the formatting mode when the value is displayed in the UI.

Objects

class renderdoc.SDObject

Defines a single structured object. Structured objects are defined recursively and one object can either be a basic type (integer, float, etc), an array, or a struct. Arrays and structs are defined similarly.

Each object owns its children and they will be deleted when it is deleted. You can use Duplicate() to make a deep copy of an object.

AddChild(child)

Add a new child object.

Parameters: child # (SDObject) – The new child to add
AsBool()

Interprets the object as a bool and returns its value. Invalid if the object is not actually a bool.

Returns: The interpreted bool value.
Return type: bool
AsFloat()

Interprets the object as a floating point number and returns its value. Invalid if the object is not actually a floating point number.

Returns: The interpreted float.
Return type: float
AsInt()

Interprets the object as an integer and returns its value. Invalid if the object is not actually an integer.

Returns: The interpreted integer.
Return type: int
AsResourceId()

Interprets the object as a ResourceId and returns its value. Invalid if the object is not actually a ResourceId.

Returns: The interpreted ID.
Return type: ResourceId
AsString()

Interprets the object as a string and returns its value. Invalid if the object is not actually a string.

Returns: The interpreted string.
Return type: str
DeleteChildren()

Delete all child objects.

Duplicate()
Returns: A new deep copy of this object, which the caller owns.
Return type: SDObject
FindChild(childName)

Find a child object by a given name. If no matching child is found, None is returned.

Parameters: childName # (str) – The name to search for.
Returns: A reference to the child object if found, or None if not.
Return type: SDObject
FindChildRecursively(childName)

Find a child object by a given name recursively. If no matching child is found, None is returned.

The order of the search is not guaranteed, so care should be taken when the name may not be unique.

Parameters: childName # (str) – The name to search for.
Returns: A reference to the child object if found, or None if not.
Return type: SDObject
GetChild(index)

Find a child object by a given index. If the index is out of bounds, None is returned.

Parameters: index # (int) – The index to look up.
Returns: A reference to the child object if valid, or None if not.
Return type: SDObject
GetParent()

Get the parent of this object. If this object has no parent, None is returned.

Returns: A reference to the parent object if valid, or None if not.
Return type: SDObject
HasEqualValue(obj)

Checks if the given object has the same value as this one. This equality is defined recursively through children.

Parameters: obj # (SDObject) – The object to compare against
Returns: A boolean indicating if the object is equal to this one.
Return type: bool
NumChildren()

Get the number of child objects.

Returns: The number of children this object contains.
Return type: int
RemoveChild(index)

Delete the child object at an index. If the index is out of bounds, nothing happens.

Parameters: index # (int) – The index to remove.
data

The SDObjectData with the contents of this object.

name

The name of this object.

type

The SDType of this object.

class renderdoc.SDObjectData

The data inside an SDObject whether it’s plain old data or complex children.

basic

The plain-old data contents of the object, in a SDObjectPODData.

string

The string contents of the object.

class renderdoc.SDObjectPODData

The plain-old-data contents of an SDObject.

Only one member is valid, as defined by the type of the SDObject.

b

The value as a boolean.

c

The value as a single byte character.

d

The value as a floating point number.

i

The value as a signed integer.

id

The value as a ResourceId.

u

The value as an unsigned integer.

Chunks

class renderdoc.SDChunk

Defines a single structured chunk, which is a SDObject.

Duplicate()
Returns: A new deep copy of this chunk, which the caller owns.
Return type: SDChunk
metadata

The SDChunkMetaData with the metadata for this chunk.

class renderdoc.SDChunkMetaData

The metadata that goes along with a SDChunk to detail how it was recorded.

callstack

The frames of the CPU-side callstack leading up to the chunk.

chunkID

The internal chunk ID - unique given a particular driver in use.

durationMicro

The duration in microseconds that this chunk took. This is the time for the actual work, not the serialising. Since 0 is a possible value for this (for extremely fast calls), -1 is the invalid/not present value.

flags

The SDChunkFlags for this chunk.

length

The length in bytes of this chunk - may be longer than the actual sum of the data if a conservative size estimate was used on creation to avoid seeking to fix-up the stored length.

threadID

The ID of the thread where this chunk was recorded.

timestampMicro

The point in time when this chunk was recorded, in microseconds since program start.

class renderdoc.SDChunkFlags(value)

Bitfield flags that could be applied to an SDChunk.

NoFlags

This chunk has no special properties.

OpaqueChunk

This chunk wasn’t supported for decoding or was skipped for another reason and was detailed as an opaque byte stream. It should be preserved as-is and will remain in native RDC format.

HasCallstack

This chunk has a callstack. Used to indicate the presence of a callstack even if it’s empty (perhaps due to failure to collect the stack frames).

Structured File

class renderdoc.SDFile

Contains the structured information in a file. Owns the buffers and chunks.

Swap(other)

Swaps the contents of this file with another.

Parameters: other # (SDFile) – The other file to swap with.
buffers

The buffers in the file, as referenced by the chunks in chunks.

Type: List[bytes]
chunks

The chunks in the file in order.

Type: List[SDChunk]
version

The version of this structured stream, typically only used internally.

Creation Helper Functions

renderdoc.makeSDArray(name)

Make a structured object which is an array.

The array will be created empty, and new members can be added using methods on SDObject.

Parameters: name # (str) – The name of the object.
Returns: The new object, owner by the caller.
Return type: SDObject
renderdoc.makeSDBool(name, val)

Make a structured object as a boolean value.

Parameters:
  • name # (str) – The name of the object.
  • val # (bool) – The bool which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDEnum(name, val)

Make a structured object as an enum value.

Note

The enum will be stored just as an integer value, but the string name of the enumeration value can be set with SDObject.SetCustomString() if desired.

Parameters:
  • name # (str) – The name of the object.
  • val # (int) – The integer value of the enum itself.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDFloat(name, val)

Make a structured object as a 32-bit float.

Note

You should ensure that the value you pass in has already been truncated to the appropriate range for the storage, as the resulting object will be undefined if the value is out of the valid range.

Parameters:
  • name # (str) – The name of the object.
  • val # (float) – The float which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDInt32(name, val)

Make a structured object as a signed 32-bit integer.

Note

You should ensure that the value you pass in has already been truncated to the appropriate range for the storage, as the resulting object will be undefined if the value is out of the valid range.

Parameters:
  • name # (str) – The name of the object.
  • val # (int) – The integer which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDInt64(name, val)

Make a structured object as a signed 64-bit integer.

Note

You should ensure that the value you pass in has already been truncated to the appropriate range for the storage, as the resulting object will be undefined if the value is out of the valid range.

Parameters:
  • name # (str) – The name of the object.
  • val # (int) – The integer which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDResourceId(name, val)

Make a structured object as a ResourceId value.

Parameters:
  • name # (str) – The name of the object.
  • val # (ResourceId) – The ID which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDString(name, val)

Make a structured object as a string value.

Parameters:
  • name # (str) – The name of the object.
  • val # (str) – The string which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDStruct(name, structtype)

Make a structured object which is a struct.

The struct will be created empty, and new members can be added using methods on SDObject.

Parameters:
  • name # (str) – The name of the object.
  • structtype # (str) – The typename of the struct.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDUInt32(name, val)

Make a structured object as an unsigned 32-bit integer.

Note

You should ensure that the value you pass in has already been truncated to the appropriate range for the storage, as the resulting object will be undefined if the value is out of the valid range.

Parameters:
  • name # (str) – The name of the object.
  • val # (int) – The integer which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject
renderdoc.makeSDUInt64(name, val)

Make a structured object as an unsigned 64-bit integer.

Note

You should ensure that the value you pass in has already been truncated to the appropriate range for the storage, as the resulting object will be undefined if the value is out of the valid range.

Parameters:
  • name # (str) – The name of the object.
  • val # (int) – The integer which will be stored in the returned object.
Returns:

The new object, owner by the caller.
Return type:

SDObject


Performance Counters

Contents

  • Performance Counters
    • Counters
    • Counter Types
    • Results

Counters

class renderdoc.CounterDescription

Describes a GPU counter’s purpose and result value.

category

The counter category. Can be empty for uncategorized counters.

counter

The GPUCounter this counter represents.

Note

This is stored as an int not a GPUCounter to allow for values that may not correspond to any of the predefined values if it’s a hardware-specific counter value.

description

If available, a longer human-readable description of the value this counter measures.

name

A short human-readable name for the counter.

resultByteWidth

The number of bytes in the resulting value.

resultType

The type of value returned by this counter.

unit

The CounterUnit for the result value.

uuid

The unique identifier for this counter that will not change across drivers or replays.

Type: Uuid
class renderdoc.CounterUnit(value)

The unit that GPU counter data is returned in.

Absolute

The value is an absolute value and should be interpreted as unitless.

Seconds

The value is a duration in seconds.

Percentage

The value is a floating point percentage value between 0.0 and 1.0.

Ratio

The value describes a ratio between two separate GPU units or counters.

Bytes

The value is in bytes.

Cycles

The value is a duration in clock cycles.

Hertz

The value is a value in Hertz (cycles per second).

Volt

The value is a value in Volts.

Celsius

The value is a value in Celsius.

class renderdoc.Uuid

A 128-bit Uuid.

words

The Uuid bytes as a tuple of four 32-bit integers.

Type: Tuple[int,int,int,int]

Counter Types

class renderdoc.GPUCounter(value)

Pre-defined GPU counters that can be supported by a given implementation.

GPU counters actually available can be queried by ReplayController.EnumerateCounters(). If any in this list are supported they will be returned with these counter IDs. More counters may be enumerated with IDs in the appropriate ranges.

EventGPUDuration

Time taken for this event on the GPU, as measured by delta between two GPU timestamps.

InputVerticesRead

Number of vertices read by input assembler.

IAPrimitives

Number of primitives read by the input assembler.

GSPrimitives

Number of primitives output by a geometry shader.

RasterizerInvocations

Number of primitives that were sent to the rasterizer.

RasterizedPrimitives

Number of primitives that were rendered.

SamplesPassed

Number of samples that passed depth/stencil test.

VSInvocations

Number of times a vertex shader was invoked.

HSInvocations

Number of times a hull shader was invoked.

TCSInvocations

Number of times a tessellation control shader was invoked.

DSInvocations

Number of times a domain shader was invoked.

TESInvocations

Number of times a tessellation evaluation shader was invoked.

GSInvocations

Number of times a domain shader was invoked.

PSInvocations

Number of times a pixel shader was invoked.

FSInvocations

Number of times a fragment shader was invoked.

CSInvocations

Number of times a compute shader was invoked.

TSInvocations

Number of times a task shader was invoked.

ASInvocations

Number of times a amplification shader was invoked.

MSInvocations

Number of times a mesh shader was invoked.

FirstAMD

The AMD-specific counter IDs start from this value.

LastAMD

The AMD-specific counter IDs end with this value.

FirstIntel

The Intel-specific counter IDs start from this value.

LastIntel

The Intel-specific counter IDs end with this value.

FirstNvidia

The nVidia-specific counter IDs start from this value.

LastNvidia

The nVidia-specific counter IDs end with this value.

FirstVulkanExtended

The Vulkan extended counter IDs start from this value.

LastVulkanExtended

The Vulkan extended counter IDs end with this value.

FirstARM

The ARM-specific counter IDs start from this value.

LastARM

The ARM-specific counter IDs end with this value.

renderdoc.IsAMDCounter(c)

Check whether or not this is an AMD private counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is an AMD private counter, False if it’s not.
Return type: bool
renderdoc.IsARMCounter(c)

Check whether or not this is an ARM private counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is an ARM private counter, False if it’s not.
Return type: bool
renderdoc.IsGenericCounter(c)

Check whether or not this is a Generic counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is a generic counter, False if it’s not.
Return type: bool
renderdoc.IsIntelCounter(c)

Check whether or not this is an Intel private counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is an Intel private counter, False if it’s not.
Return type: bool
renderdoc.IsNvidiaCounter(c)

Check whether or not this is an Nvidia private counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is an Nvidia private counter, False if it’s not.
Return type: bool
renderdoc.IsVulkanExtendedCounter(c)

Check whether or not this is a KHR counter.

Parameters: c # (GPUCounter) – The counter.
Returns: True if it is a Vulkan counter reported through the VK_KHR_performance_query extension, False if it’s not.
Return type: bool

Results

class renderdoc.CounterResult

The resulting value from a counter at an event.

counter

The counter that produced this value, stored as an int.

Note

This is stored as an int not a GPUCounter to allow for values that may not correspond to any of the predefined values if it’s a hardware-specific counter value.

eventId

The eventId that produced this value.

value

The value itself.

Type: CounterValue
class renderdoc.CounterValue

A resulting value from a GPU counter. Only one member is valid, see CounterDescription.

d

A double value.

f

A float value.

u32

A 32-bit unsigned integer.

u64

A 64-bit unsigned integer.


Frame Statistics

Contents

  • Frame Statistics
    • Resource Statistics
    • Drawcall Statistics
    • Shader Statistics
    • Fixed Function Statistics
class renderdoc.FrameStatistics

Contains all the available statistics about the captured frame.

Currently this information is only available on D3D11 and is fairly API-centric.

blends

Information about blend state binds.

Type: BlendStats
constants

A list of constant buffer bind statistics, one per each stage.

Type: List[ConstantBindStats]
depths

Information about depth-stencil state binds.

Type: DepthStencilStats
dispatches

Information about compute dispatches.

Type: DispatchStats
draws

Information about drawcalls.

Type: DrawcallStats
indices

Information about index buffer binds.

Type: IndexBindStats
layouts

Information about vertex layout binds.

Type: LayoutBindStats
outputs

Information about output merger and UAV binds.

Type: OutputTargetStats
rasters

Information about rasterizer state binds.

Type: RasterizationStats
recorded

True if the statistics in this structure are valid.

resources

A list of resource bind statistics, one per each stage.

Type: List[ResourceBindStats]
samplers

A list of sampler bind statistics, one per each stage.

Type: List[SamplerBindStats]
shaders

A list of shader bind statistics, one per each stage.

Type: List[ShaderChangeStats]
updates

Information about resource contents updates.

Type: ResourceUpdateStats
vertices

Information about vertex buffer binds.

Type: VertexBindStats

Resource Statistics

class renderdoc.ResourceUpdateStats

Contains the statistics for resource updates in a frame.

BucketType

The type of buckets being used. See BucketRecordType.

BucketCount

How many buckets there are in the arrays.

calls

How many function calls were made.

clients

How many of calls were mapped pointers written by the CPU.

servers

How many of calls were batched updates written in the command queue.

sizes

A bucketed list over the number of bytes in the update.

Type: List[int]
types

A list with one element for each type in TextureType.

The Nth element contains the number of times a resource of that type was updated.

Type: List[int]
class renderdoc.BucketRecordType(value)

The type of bucketing method for recording statistics.

Linear

Each bucket contains a fixed number of elements. The highest bucket also accumulates any values too high for any of the buckets.

Pow2

Each bucket holds twice as many elements as the previous one, with the first bucket containing just 1 (bucket index is log2(value)).

Drawcall Statistics

class renderdoc.DrawcallStats

Contains the statistics for draws in a frame.

BucketType

The type of buckets being used. See BucketRecordType.

BucketSize

How many elements each bucket contains.

BucketCount

How many buckets there are in the arrays.

calls

How many draw calls were made.

counts

A bucketed list over the number of instances in the draw.

Type: List[int]
indirect

How many of calls were indirect.

instanced

How many of calls were instanced.

class renderdoc.DispatchStats

Contains the statistics for compute dispatches in a frame.

calls

How many dispatch calls were made.

indirect

How many of calls were indirect.

Shader Statistics

class renderdoc.ConstantBindStats

Contains the statistics for constant binds in a frame.

BucketType

The type of buckets being used. See BucketRecordType.

BucketCount

How many buckets there are in the arrays.

bindslots

A list where the Nth element contains the number of calls that bound N buffers.

Type: List[int]
calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

sizes

A bucketed list over the sizes of buffers bound.

Type: List[int]
class renderdoc.SamplerBindStats

Contains the statistics for sampler binds in a frame.

bindslots

A list where the Nth element contains the number of calls that bound N samplers.

Type: List[int]
calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

class renderdoc.ResourceBindStats

Contains the statistics for resource binds in a frame.

bindslots

A list where the Nth element contains the number of calls that bound N resources.

Type: List[int]
calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

types

A list with one element for each type in TextureType.

The Nth element contains the number of times a resource of that type was bound.

Type: List[int]
class renderdoc.ShaderChangeStats

Contains the statistics for shader binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

redundants

How many calls made no change due to the existing bind being identical.

sets

How many objects were bound.

Fixed Function Statistics

class renderdoc.IndexBindStats

Contains the statistics for index buffer binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

class renderdoc.VertexBindStats

Contains the statistics for vertex buffer binds in a frame.

bindslots

A list where the Nth element contains the number of calls that bound N vertex buffers.

Type: List[int]
calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

class renderdoc.LayoutBindStats

Contains the statistics for vertex layout binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.

class renderdoc.BlendStats

Contains the statistics for blend state binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

redundants

How many calls made no change due to the existing bind being identical.

sets

How many objects were bound.

class renderdoc.DepthStencilStats

Contains the statistics for depth stencil state binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

redundants

How many calls made no change due to the existing bind being identical.

sets

How many objects were bound.

class renderdoc.RasterizationStats

Contains the statistics for rasterizer state binds in a frame.

calls

How many function calls were made.

nulls

How many objects were unbound.

rects

A list where the Nth element contains the number of calls that bound N scissor rects.

Type: List[int]
redundants

How many calls made no change due to the existing bind being identical.

sets

How many objects were bound.

viewports

A list where the Nth element contains the number of calls that bound N viewports.

Type: List[int]
class renderdoc.OutputTargetStats

Contains the statistics for output merger or UAV binds in a frame.

bindslots

A list where the Nth element contains the number of calls that bound N targets.

Type: List[int]
calls

How many function calls were made.

nulls

How many objects were unbound.

sets

How many objects were bound.


Utilities

Contents

  • Utilities
    • Maths
    • Logging & Versioning
    • Versioning
    • Settings
    • Self-hosted captures

Maths

class renderdoc.FloatVector

A floating point four-component vector

w

The w component.

x

The x component.

y

The y component.

z

The z component.

renderdoc.HalfToFloat(half)

A utility function that converts a half (stored in a 16-bit unsigned integer) to a float.

Parameters: half # (int) – The half stored as an int.
Returns: The floating point equivalent.
Return type: float
renderdoc.FloatToHalf(flt)

A utility function that converts a float to a half (stored in a 16-bit unsigned integer).

Parameters: flt # (float) – The floating point value.
Returns: The nearest half-float equivalent stored as an int.
Return type: int

Logging & Versioning

renderdoc.LogMessage(type, project, file, line, text)

Add a message to RenderDoc’s logfile.

Parameters:
  • type # (LogType) – The type of the log message. Error messages will trigger a debugger breakpoint if a debugger is attached, and fatal errors will kill the process after logging.
  • project # (str) – A short project tag, which should be uppercase and either 3 or 4 characters.
  • file # (str) – The file where this log message came from.
  • line # (int) – The line number in file where this log message came from.
  • text # (str) – The text of the message.
renderdoc.SetDebugLogFile(filename)

Sets the location for the diagnostic log output, shared by captured programs and the analysis program.

Parameters: filename # (str) – The path to the new log file.
renderdoc.GetLogFile()

Gets the location for the diagnostic log output, shared by captured programs and the analysis program.

Returns: The path to the current log file.
Return type: str
renderdoc.GetCurrentProcessMemoryUsage()

Returns the current process’s memory usage in bytes

Returns: The current memory usage in bytes.
Return type: int
renderdoc.DumpObject(obj)

Returns a string representation of an object. This is quite similar to the built-in repr() function but it iterates over struct members and prints them out, where normally repr() would stop and say something like ‘Swig Object of type …’.

Parameters: obj # (Any) – The object to dump
Returns: The string representation of the object.
Return type: str
class renderdoc.LogType(value)

The type of a log message

Debug

The log message is a verbose debug-only message that can be discarded in release builds.

Comment

The log message is informational.

Warning

The log message describes a warning that could indicate a problem or be useful in diagnostics.

Error

The log message indicates an error was encountered.

Fatal

The log message indicates a fatal error occurred which is impossible to recover from.

Versioning

renderdoc.GetVersionString()

Retrieves the version string.

This will be in the form “MAJOR.MINOR”

Returns: The version string.
Return type: str
renderdoc.GetCommitHash()

Retrieves the commit hash used to build.

This will be in the form “0123456789abcdef0123456789abcdef01234567”

Returns: The commit hash.
Return type: str
renderdoc.IsReleaseBuild()

Determines if this is a release build of RenderDoc or not.

Returns: True if the replay is running on a release build.
Return type: bool

Settings

renderdoc.GetConfigSetting(name)

Return a read-only handle to the SDObject corresponding to a given setting’s value object.

If an empty string is passed, the root object is returned containing all settings and setting categories. Categories contain other categories and settings, settings contain children that include the setting’s value, description, etc.

If no such setting exists, None is returned.

Parameters: name # (str) – The name of the setting.
Returns: The specified setting.
Return type: SDObject
renderdoc.SetConfigSetting(name)

Return a mutable handle to the SDObject corresponding to a given setting’s value object.

If no such setting exists, None is returned.

Parameters: name # (str) – The name of the setting.
Returns: The specified setting.
Return type: SDObject
renderdoc.SaveConfigSettings()

Flush the current config settings as they are in memory to the config file on disk.

Without calling this function, settings changes will only be temporary. The settings are not saved to disk on exit implicitly.

Self-hosted captures

renderdoc.CanSelfHostedCapture(dllname)

When debugging RenderDoc it can be useful to capture itself by doing a side-build with a temporary name. This function checks to see if a given self-hosted DLL is available.

Parameters: dllname # (str) – The name of the self-hosted capture module.
Returns: Whether the specified dll is loaded, ready for self-hosted capture.
Return type: bool
renderdoc.StartSelfHostCapture(dllname)

When debugging RenderDoc it can be useful to capture itself by doing a side-build with a temporary name. This function wraps up the use of the in-application API to start a capture.

Parameters: dllname # (str) – The name of the self-hosted capture module.
renderdoc.EndSelfHostCapture(dllname)

When debugging RenderDoc it can be useful to capture itself by doing a side-build with a temporary name. This function wraps up the use of the in-application API to end a capture.

Parameters: dllname # (str) – The name of the self-hosted capture module.


qrenderdoc API Reference

  • Main Interfaces
  • UI Extensions
  • Windows
  • Persistant Config


Main Interfaces

Contents

  • Main Interfaces
    • Context
    • Replay Manager
    • RGP Interop Control
    • CaptureViewer Interface
    • Utilities

Context

class qrenderdoc.CaptureContext

The capture context that the python script is running in.

APIProps()

Retrieve the APIProperties for the currently loaded capture.

Returns: The API properties.
Return type: renderdoc.APIProperties
AddCaptureViewer(viewer)

Register a new instance of CaptureViewer to receive capture event notifications.

Parameters: viewer # (CaptureViewer) – The viewer to register.
AddDockWindow(newWindow, ref, refWindow, percentage=0.5)
AddDockWindow(newWindow, ref, refWindow) → None

Adds a new window within the docking system.

Parameters:
  • newWindow # (QWidget) – The new window to add.
  • ref # (DockReference) – The location to add the new window, possibly relative to refWindow.
  • refWindow # (QWidget) – The window to refer to if the new window is being added relative, or can be None if the new location is absolute.
  • percentage # (float) – Optionally the percentage to split the area. If omitted, a 50% split is used.
AddMessages(msgs)

Add messages into the list returned by DebugMessages(). Initially set to unread.

Parameters: msgs # (List[ renderdoc.DebugMessage ]) – A list of debug messages to add.
BuiltinWindowClosed(window)

Marks a built-in window as closed.

This function is intended for internal use by the built-in windows for singleton management, and should not be called by user code.

Parameters: window # (QWidget) – The built-in window that closed.
CloseCapture()

Close the currently open capture file.

Config()

Retrieve the current persistant config.

Returns: The current persistant config manager.
Return type: PersistantConfig
ConnectToRemoteServer(host)

Connect to a remote server.

Parameters: host # (RemoteHost) – The host to connect to.
CreateBuiltinWindow(objectName)

Creates and returns a built-in window.

This function is intended for internal use for restoring layouts, and generally should not be used by user code.

Parameters: objectName # (str) – The built-in name of a singleton window.
Returns: The handle to the existing or newly created window of this type.
Return type: QWidget
CreateWindowingData(window)

Create an opaque pointer suitable for passing to CreateOutput() or other functions that expect windowing data.

Note

This function must be called on the main UI thread.

Parameters: window # (QWidget) – The window to create windowing data for.
Returns: The windowing data.
Return type: renderdoc.WindowingData
CurAction()

Retrieve the current action.

Returns: The current action, or None if no action is selected.
Return type: renderdoc.ActionDescription
CurD3D11PipelineState()

Retrieve the current D3D11State pipeline state.

The return value will be None if the capture is not using the D3D11 API. You should determine the API of the capture first before fetching it.

Returns: The current D3D11 pipeline state.
Return type: renderdoc.D3D11State
CurD3D12PipelineState()

Retrieve the current D3D12State pipeline state.

The return value will be None if the capture is not using the D3D12 API. You should determine the API of the capture first before fetching it.

Returns: The current D3D12 pipeline state.
Return type: renderdoc.D3D12State
CurEvent()

Retrieve the current eventId.

Returns: The current event.
Return type: int
CurGLPipelineState()

Retrieve the current GLState pipeline state.

The return value will be None if the capture is not using the OpenGL API. You should determine the API of the capture first before fetching it.

Returns: The current OpenGL pipeline state.
Return type: renderdoc.GLState
CurPipelineState()

Retrieve the current PipeState abstracted pipeline state.

This pipeline state will always be valid, and allows queries that will work regardless of the capture’s API.

Returns: The current API-agnostic abstracted pipeline state.
Return type: renderdoc.PipeState
CurRootActions()

Retrieve the root list of actions in the current capture.

Returns: The root actions.
Return type: List[renderdoc.ActionDescription]
CurSelectedAction()

Retrieve the currently selected action.

In most cases, prefer using CurAction(). See CaptureViewer.OnSelectedEventChanged() for more information for how this differs.

Returns: The currently selected action.
Return type: renderdoc.ActionDescription
CurSelectedEvent()

Retrieve the currently selected eventId.

In most cases, prefer using CurEvent(). See CaptureViewer.OnSelectedEventChanged() for more information for how this differs.

Returns: The current selected event.
Return type: int
CurVulkanPipelineState()

Retrieve the current VKState pipeline state.

The return value will be None if the capture is not using the Vulkan API. You should determine the API of the capture first before fetching it.

Returns: The current Vulkan pipeline state.
Return type: renderdoc.VKState
CurWindowingSystem()

Retrieve the current windowing system in use.

Returns: The active windowing system.
Return type: renderdoc.WindowingSystem
CustomShaderEncodings()

Retrieve the list of ShaderEncoding that are available for building custom shaders for the currently loaded capture. See BuildCustomShader().

Returns: The available encodings.
Return type: List[renderdoc.ShaderEncoding]
CustomShaderSourcePrefixes()

Retrieve the list of prefixes for each ShaderEncoding that should be added to custom compiled shaders. See GetCustomShaderSourcePrefixes().

Returns: A list of pairs, listing a prefix for each shader encoding referenced.
Return type: List[renderdoc.ShaderSourcePrefix]
DebugMessages()

Retrieve the current list of debug messages. This includes messages from the capture as well as messages generated during replay and analysis.

Returns: The debug messages generated to date.
Return type: List[renderdoc.DebugMessage]
DebugShader(bind, shader, pipeline, trace, debugContext)

Show a new ShaderViewer window, showing a read-only view of a debug trace through the execution of a given shader.

Parameters:
  • bind # (renderdoc.ShaderBindpointMapping) – The bindpoint mapping for the shader to view.
  • shader # (renderdoc.ShaderReflection) – The reflection data for the shader to view.
  • pipeline # (renderdoc.ResourceId) – The pipeline state object, if applicable, that this shader is bound to.
  • trace # (renderdoc.ShaderDebugTrace) – The execution trace of the debugged shader.
  • debugContext # (str) – A human-readable context string describing which invocation of this shader was debugged. For example ‘Pixel 12,34 at eventId 678’.
Returns:

The new ShaderViewer window opened, but not shown.
Return type:

ShaderViewer
EditShader(id, stage, entryPoint, files, knownTool, shaderEncoding, flags, saveCallback, revertCallback)

Show a new ShaderViewer window, showing an editable view of a given shader.

Parameters:
  • id # (renderdoc.ResourceId) – The shader object, if applicable, that’s being edited. If this edit corresponds to no shader object (such as if it’s a custom shader) this can be a null ID.
  • stage # (renderdoc.ShaderStage) – The shader stage for this shader.
  • entryPoint # (str) – The entry point to be used when compiling the edited shader.
  • files # (List[Tuple[str,str]]) – The source files, with each tuple being a pair of the filename and the file contents.
  • knownTool # (renderdoc.KnownShaderTool) – The preferred tool to use to compile, if known.
  • shaderEncoding # (renderdoc.ShaderEncoding) – The encoding of the input files.
  • flags # (renderdoc.ShaderCompileFlags) – The flags originally used to compile the shader.
  • saveCallback # (ShaderViewer.SaveCallback) – The callback function to call when a save/update is triggered.
  • revertCallback # (ShaderViewer.RevertCallback) – The callback function to call when the shader is to be reverted - either by user request or because the shader viewer was closed.
Returns:

The new ShaderViewer window opened but not shown for editing.
Return type:

ShaderViewer
ExportCapture(fmt, exportfile)

Exports the current capture file to a given path with a specified capture file format.

The capture must be available locally, if it’s not this function will fail.

Parameters:
  • fmt # (renderdoc.CaptureFileFormat) – The capture file format to export to.
  • exportfile # (str) – The path to export the capture file to.
Extensions()

Retrieve the manager for extensions.

Returns: The current extension manager.
Return type: ExtensionManager
FrameInfo()

Retrieve the FrameDescription for the currently loaded capture.

Returns: The frame information.
Return type: renderdoc.FrameDescription
GetAPIInspector()

Retrieve the current singleton APIInspector.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: APIInspector
GetAction(eventId)

Retrieve the information about an action at a given eventId.

Parameters: eventId # (int) – The eventId to query for.
Returns: The information about the action, or None if the eventId doesn’t correspond to an action.
Return type: renderdoc.ActionDescription
GetBookmarks()

Get the current list of bookmarks in the capture. Each bookmark is associated with an eventId and has some text attached. There will only be at most one bookmark for any given eventId.

The list of bookmarks is not necessarily sorted by eventId. Thus, bookmark 1 is always bookmark 1 until it is removed, the indices do not shift as new bookmarks are added or removed.

Returns: The currently set bookmarks.
Return type: List[EventBookmark]
GetBuffer(id)

Retrieve the information about a particular buffer.

Parameters: id # (renderdoc.ResourceId) – The ID of the buffer to query about.
Returns: The information about a buffer, or None if the ID does not correspond to a buffer.
Return type: renderdoc.BufferDescription
GetBuffers()

Retrieve the list of buffers in the current capture.

Returns: The list of buffers.
Return type: List[renderdoc.BufferDescription]
GetCaptureDialog()

Retrieve the current singleton CaptureDialog.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: CaptureDialog
GetCaptureFilename()

Retrieve the filename for the currently loaded capture.

Returns: The filename of the current capture.
Return type: str
GetCaptureModifications()

Get a bitmask indicating which modifications (if any) have been made to the capture in the UI which aren’t reflected in the capture file on disk.

Returns: The modifications (if any) that have been made to the capture.
Return type: CaptureModifications
GetCommentView()

Retrieve the current singleton CommentView.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: CommentView
GetDebugMessageView()

Retrieve the current singleton DebugMessageView.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: DebugMessageView
GetDiagnosticLogView()

Retrieve the current singleton LogView.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: DiagnosticLogView
GetEventBrowser()

Retrieve the current singleton EventBrowser.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: EventBrowser
GetFatalError()

If a capture is loaded, return the current fatal error status.

Returns: If a capture is currently loaded, return the fatal error status.
Return type: renderdoc.ResultDetails
GetFirstAction()

Retrieve the first action in the capture.

Returns: The first action.
Return type: renderdoc.ActionDescription
GetLastAction()

Retrieve the last action in the capture.

Returns: The last action.
Return type: renderdoc.ActionDescription
GetMainWindow()

Retrieve the current singleton MainWindow.

Returns: The current window.
Return type: MainWindow
GetMeshPreview()

Retrieve the current singleton BufferViewer configured for mesh viewing.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: BufferViewer
GetNotes(key)

Retrieve the contents for a given notes field.

Examples of fields are:

  • ‘comments’ for generic comments to be displayed in a text field
  • ‘hwinfo’ for a plaintext summary of the hardware and driver configuration of the system.
Parameters: key # (str) – The name of the notes field to retrieve.
Returns: The contents, or an empty string if the field doesn’t exist.
Return type: str
GetPerformanceCounterViewer()

Retrieve the current singleton PerformanceCounterViewer.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: PerformanceCounterViewer
GetPipelineViewer()

Retrieve the current singleton PipelineStateViewer.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: PipelineStateViewer
GetPythonShell()

Retrieve the current singleton PythonShell.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: PythonShell
GetRGPInterop()

Returns the current interop handle for RGP.

This may return None in several cases:

  • if there is no capture loaded
  • if no RGP profile has been associated with the current capture yet (See OpenRGPProfile())
  • if RGP failed to launch or connect.

The handle returned is invalidated when the capture is closed, or if OpenRGPProfile() is called.

Returns: The RGP interop connection handle.
Return type: RGPInterop
GetResource(id)

Retrieve the information about a particular resource.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to query about.
Returns: The information about a resource, or None if the ID does not correspond to a resource.
Return type: renderdoc.ResourceDescription
GetResourceInspector()

Retrieve the current singleton ResourceInspector.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: ResourceInspector
GetResourceName(id)

Retrieve the human-readable name for the resource to display.

This will first check to see if a custom name has been set for the resource, and if so use that. See SetResourceCustomName(). If no custom name has been set, it will use the resource name found in the capture, either a name set via API-specific debug methods, or an auto-generated name based on the resource type.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to query.
Returns: The current name of the resource.
Return type: str
GetResourceNameUnsuffixed(id)

Returns the same name as GetResourceName() but without any added suffix, e.g. to indicate the resource’s status such as (Edited).

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to query.
Returns: The unsuffixed resource name.
Return type: str
GetResourceReplacement(id)

Return the id of a replacement for the given resource. See RegisterReplacement() and IsResourceReplaced().

Parameters: id # (renderdoc.ResourceId) – The id of the resource to check.
Returns: The replacement id, or a null id if the resource hasn’t been replaced
Return type: renderdoc.ResourceId
GetResources()

Retrieve the list of resources in the current capture.

Returns: The list of resources.
Return type: List[renderdoc.ResourceDescription]
GetStatisticsViewer()

Retrieve the current singleton StatisticsViewer.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: StatisticsViewer
GetStructuredFile()

Retrieve the SDFile for the currently open capture.

Returns: The structured file.
Return type: renderdoc.SDFile
GetTexture(id)

Retrieve the information about a particular texture.

Parameters: id # (renderdoc.ResourceId) – The ID of the texture to query about.
Returns: The information about a texture, or None if the ID does not correspond to a texture.
Return type: renderdoc.TextureDescription
GetTextureViewer()

Retrieve the current singleton TextureViewer.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: TextureViewer
GetTextures()

Retrieve the list of textures in the current capture.

Returns: The list of textures.
Return type: List[renderdoc.TextureDescription]
GetTimelineBar()

Retrieve the current singleton TimelineBar.

Returns: The current window, which is created (but not shown) it there wasn’t one open.
Return type: TimelineBar
HasAPIInspector()

Check if there is a current APIInspector open.

Returns: True if there is a window open.
Return type: bool
HasCaptureDialog()

Check if there is a current CaptureDialog open.

Returns: True if there is a window open.
Return type: bool
HasCommentView()

Check if there is a current CommentView open.

Returns: True if there is a window open.
Return type: bool
HasDebugMessageView()

Check if there is a current DebugMessageView open.

Returns: True if there is a window open.
Return type: bool
HasDiagnosticLogView()

Check if there is a current DiagnosticLogView open.

Returns: True if there is a window open.
Return type: bool
HasEventBrowser()

Check if there is a current EventBrowser open.

Returns: True if there is a window open.
Return type: bool
HasMeshPreview()

Check if there is a current mesh previewing BufferViewer open.

Returns: True if there is a window open.
Return type: bool
HasPerformanceCounterViewer()

Check if there is a current PerformanceCounterViewer open.

Returns: True if there is a window open.
Return type: bool
HasPipelineViewer()

Check if there is a current PipelineStateViewer open.

Returns: True if there is a window open.
Return type: bool
HasPythonShell()

Check if there is a current PythonShell open.

Returns: True if there is a window open.
Return type: bool
HasResourceCustomName(id)

Checks whether a runtime custom name has been set with SetResourceCustomName().

In general, IsAutogeneratedName() should be preferred to check if the resource name is default generated just from the ID, or if it has been set to some human readable name. This function will only check if a name has been set in the UI itself, a resource could still have a custom name that was set programmatically during capture time.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to query.
Returns: Whether the name for the resource has been customised with SetResourceCustomName().
Return type: bool
HasResourceInspector()

Check if there is a current ResourceInspector open.

Returns: True if there is a window open.
Return type: bool
HasStatisticsViewer()

Check if there is a current StatisticsViewer open.

Returns: True if there is a window open.
Return type: bool
HasTextureViewer()

Check if there is a current TextureViewer open.

Returns: True if there is a window open.
Return type: bool
HasTimelineBar()

Check if there is a current TimelineBar open.

Returns: True if there is a window open.
Return type: bool
ImportCapture(fmt, importfile, rdcfile)

Imports a capture file from a non-native format, via conversion to temporary rdc.

This converts the file to a specified temporary .rdc and loads it, closing any existing capture.

The capture must be available locally, if it’s not this function will fail.

Parameters:
  • fmt # (renderdoc.CaptureFileFormat) – The capture file format to import from.
  • importfile # (str) – The path to import from.
  • rdcfile # (str) – The temporary path to save the rdc file to.
Returns:

True if the import operation was successful and the capture was loaded.
Return type:

bool
IsAutogeneratedName(id)

Determines whether the name for the given resource has been customised at all, either during capture time or with SetResourceCustomName().

If not, the name is just auto-generated based on the ID and resource type, so depending on circumstance it may be preferable to omit the name.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to query.
Returns: Whether the name for the resource has just been auto-generated.
Return type: bool
IsCaptureLoaded()

Check whether or not a capture is currently loaded.

Returns: True if a capture is loaded.
Return type: bool
IsCaptureLoading()

Check whether or not a capture is currently loading in-progress.

Returns: True if a capture is currently loading.
Return type: bool
IsCaptureLocal()

Check whether or not the current capture is stored locally, or on a remote host.

Returns: True if a capture is local.
Return type: bool
IsCaptureTemporary()

Check whether or not the current capture is considered temporary. Captures that were made by an application and then have not been explicitly saved anywhere are temporary and will be cleaned up on close (with a final prompt to save). Once they are save to disk, they are no longer temporary and treated like any other capture.

Returns: True if a capture is temporary.
Return type: bool
IsResourceReplaced(id)

Determine if a resource has been replaced. See RegisterReplacement().

Parameters: id # (renderdoc.ResourceId) – The id of the resource to check.
Returns: True if the resource has been replaced.
Return type: bool
LoadCapture(captureFile, opts, origFilename, temporary, local)

Open a capture file for replay.

Parameters:
  • captureFile # (str) – The actual path to the capture file.
  • opts # (renderdoc.ReplayOptions) – The options controlling how the capture should be replayed.
  • origFilename # (str) – The original filename, if the capture was copied remotely for replay.
  • temporary # (bool) – True if this is a temporary capture which should prompt the user for either save or delete on close.
  • local # (bool) – True if captureFile refers to a file on the local machine.
MarkMessagesRead()

Mark all messages as read, resets UnreadMessageCount() to 0.

OpenRGPProfile(filename)

Sets the path to the RGP profile to use with GetRGPInterop(), launches RGP and opens an interop connection. This function will block (with a progress dialog) until either an error is encountered or else the connection is successfully established.

This could be newly created, or extracted from an embedded section in the RDC.

The connection is automatically closed when the capture is closed. If OpenRGPProfile is called again, any previous connection will be closed.

Parameters: filename # (str) – The filename of the extracted temporary RGP capture on disk.
Returns: Whether RGP launched successfully.
Return type: bool
RaiseDockWindow(dockWindow)

Raises a window within its docking manager so it becomes the focus of wherever it is currently docked.

Parameters: dockWindow # (QWidget) – The window to raise.
RecompressCapture()

Recompress the current capture as much as possible.

RefreshStatus()

Replay the capture to the current event again, to pick up any changes that might have been made.

RegisterReplacement(arg2, to)

Register that a resource has replaced, so that the UI can be updated to reflect the change.

This should be called at the same time as ReplayController.ReplaceResource().

Parameters:
  • from # (renderdoc.ResourceId) – The id of the resource being replaced.
  • to # (renderdoc.ResourceId) – The id of the resource replacing it.
RemoveBookmark(eventId)

Remove a bookmark at a given eventId.

If no bookmark exists, this function will do nothing.

Parameters: eventId # (int) – The eventId of the bookmark to remove.
RemoveCaptureViewer(viewer)

Unregister an instance of CaptureViewer from receiving notifications.

Parameters: viewer # (CaptureViewer) – The viewer to unregister.
Replay()

Retrieve the replay manager for access to the internal RenderDoc replay controller.

Returns: The current replay manager.
Return type: ReplayManager
ResourceNameCacheID()

Returns an index that can be used to cache the results of resource naming.

In some cases (e.g. formatting in widgets) there might be high frequency fetches to names without an easy way to force a refresh on a rename. Instead, the index here can be cached and compared each time to see if any names have changed.

The index starts at 1, so initialising an internal cache to 0 will cause the first check to be considered out of date

Returns: An incrementing index that can be used as a quick check if any names have changed.
Return type: int
SaveCaptureTo(captureFile)

Saves the current capture file to a given path.

If the capture was temporary, this save action means it is no longer temporary and will be treated like any other capture.

Any modifications to the capture (see GetCaptureModifications()) will be applied at the same time.

Parameters: captureFile # (str) – The path to save the capture file to.
Returns: True if the save operation was successful.
Return type: bool
SetBookmark(mark)

Set or update a bookmark.

A bookmark will be added at the specified eventId, or if one already exists then the attached text will be replaced.

Parameters: mark # (EventBookmark) – The bookmark to add.
SetEventID(exclude, selectedEventId, eventId, force=False)
SetEventID(exclude, selectedEventId, eventId) → None

Move the current replay to a new event in the capture.

Parameters:
  • exclude # (List[ CaptureViewer ]) – A list of viewers to exclude from being notified of this change, to stop infinite recursion.
  • selectedEventId # (int) – The selected eventId. See CaptureViewer.OnSelectedEventChanged() for more information.
  • eventId # (int) – The new current eventId. See CaptureViewer.OnEventChanged() for more information.
  • force # (bool) – Optional parameter, if True then the replay will ‘move’ even if it is moving to the same eventId as it’s currently on.
SetNotes(key, contents)

Set the contents for a given notes field.

See GetNotes() for a list of possible common field keys.

Parameters:
  • key # (str) – The name of the notes field to set.
  • contents # (str) – The new contents to assign to that field.
SetResourceCustomName(id, name)

Set a custom name for a resource.

This allows an override to the name returned by GetResourceName(), most useful when there are no pre-existing debug names specified in the capture.

To remove a custom name that has been set previously, specify the empty string as the name. Then the custom name will be removed, and instead GetResourceName() will fall back to returning any name fetched from the capture.

Parameters:
  • id # (renderdoc.ResourceId) – The ID of the resource to name.
  • name # (str) – The name to provide, or an empty string to remove any previous custom name.
ShowAPIInspector()

Raise the current APIInspector, showing it in the default place if needed.

ShowCaptureDialog()

Raise the current CaptureDialog, showing it in the default place if needed.

ShowCommentView()

Raise the current CommentView, showing it in the default place if needed.

ShowDebugMessageView()

Raise the current DebugMessageView, showing it in the default place if needed.

ShowDiagnosticLogView()

Raise the current DiagnosticLogView, showing it in the default place if needed.

ShowEventBrowser()

Raise the current EventBrowser, showing it in the default place if needed.

ShowMeshPreview()

Raise the current mesh previewing BufferViewer, showing it in the default place if needed.

ShowPerformanceCounterViewer()

Raise the current PerformanceCounterViewer, showing it in the default place if needed.

ShowPipelineViewer()

Raise the current PipelineStateViewer, showing it in the default place if needed.

ShowPythonShell()

Raise the current PythonShell, showing it in the default place if needed.

ShowResourceInspector()

Raise the current ResourceInspector, showing it in the default place if needed.

ShowStatisticsViewer()

Raise the current StatisticsViewer, showing it in the default place if needed.

ShowTextureViewer()

Raise the current TextureViewer, showing it in the default place if needed.

ShowTimelineBar()

Raise the current TimelineBar, showing it in the default place if needed.

TargetShaderEncodings()

Retrieve the list of ShaderEncoding that are available for building target shaders for the currently loaded capture. See BuildTargetShader().

Returns: The available encodings.
Return type: List[renderdoc.ShaderEncoding]
TempCaptureFilename(appname)

Retrieve the absolute path where a given temporary capture should be stored. data.

Parameters: appname # (str) – The name of the application to use as part of the template.
Returns: The absolute path.
Return type: str
UnreadMessageCount()

Retrieve how many messages in DebugMessages() are currently unread.

Returns: The number of unread messages.
Return type: int
UnregisterReplacement(id)

Register that a replacement has been removed, so that the UI can be updated to reflect the change.

This should be called at the same time as ReplayController.RemoveReplacement().

See ReplaceResource().

Parameters: id # (renderdoc.ResourceId) – The id of the original resource that was previously replaced.
ViewBuffer(byteOffset, byteSize, id, format)
ViewBuffer(byteOffset, byteSize, id) → None

Show a new BufferViewer window, showing a read-only view of buffer data.

Parameters:
  • byteOffset # (int) – The offset in bytes to the start of the buffer data to show.
  • byteSize # (int) – The number of bytes in the buffer to show.
  • id # (renderdoc.ResourceId) – The ID of the buffer to fetch data from.
  • format # (str) – Optionally a HLSL/GLSL style formatting string.
Returns:

The new BufferViewer window opened, but not shown.
Return type:

BufferViewer
ViewConstantBuffer(stage, slot, idx)

Show a new BufferViewer window, showing a read-only view of a the variables in a constant buffer with their values.

Parameters:
  • stage # (renderdoc.ShaderStage) – The stage that the constant buffer is bound to.
  • slot # (int) – The index in the shader’s constant buffer list to look up.
  • idx # (int) – For APIs that support arrayed resource binds, the index in the constant buffer array.
Returns:

The new BufferViewer window opened, but not shown.
Return type:

BufferViewer
ViewPixelHistory(id, x, y, view, display)

Show a new PixelHistoryView window, showing the results from a pixel history operation.

Parameters:
  • id # (renderdoc.ResourceId) – The ID of the texture to show the history of.
  • x # (int) – The x co-ordinate of the pixel to search for.
  • y # (int) – The y co-ordinate of the pixel to search for.
  • view # (int) – The layered or multiview rendering view index of the pixel to search for.
  • display # (renderdoc.TextureDisplay) – The texture display configuration to use when looking up the history.
Returns:

The new PixelHistoryView window opened, but not shown.
Return type:

PixelHistoryView
ViewShader(shader, pipeline)

Show a new ShaderViewer window, showing a read-only view of a given shader.

Parameters:
  • shader # (renderdoc.ShaderReflection) – The reflection data for the shader to view.
  • pipeline # (renderdoc.ResourceId) – The pipeline state object, if applicable, that this shader is bound to.
Returns:

The new ShaderViewer window opened, but not shown.
Return type:

ShaderViewer
ViewShaderMessages(stages)

Show a new ShaderMessageViewer window, showing the current event’s messages.

Parameters: stages # (renderdoc.ShaderStageMask) – The initial stages being viewed.
Returns: The new ShaderMessageViewer window opened, but not shown.
Return type: ShaderMessageViewer
ViewTextureAsBuffer(id, sub, format)
ViewTextureAsBuffer(id, sub) → None

Show a new BufferViewer window, showing a read-only view of a texture’s raw bytes.

Parameters:
  • id # (renderdoc.ResourceId) – The ID of the texture itself.
  • sub # (renderdoc.Subresource) – The subresource within this texture to use.
  • format # (str) – Optionally a HLSL/GLSL style formatting string.
Returns:

The new BufferViewer window opened, but not shown.
Return type:

BufferViewer

Replay Manager

class qrenderdoc.ReplayManager

A manager for accessing the underlying replay information that isn’t already abstracted in UI side structures. This manager controls and serialises access to the underlying ReplayController, as well as handling remote server connections.

InvokeCallback(controller)

Not a member function - the signature for any InvokeCallback callbacks.

Parameters: controller (renderdoc.ReplayController) – The controller to access. Must not be cached or used after the callback returns.
DirectoryBrowseCallback(path, entries)

Not a member function - the signature for any DirectoryBrowseCallback callbacks.

Parameters:
  • path (str) – The path that was queried for.
  • entries (List[ renderdoc.PathEntry ]) – The entries underneath the path, as relevant.
AsyncInvoke(tag, method)
AsyncInvoke(method) → None

Make a tagged non-blocking invoke call onto the replay thread.

This tagged function is for cases when we might send a request - e.g. to pick a vertex or pixel - and want to pre-empt it with a new request before the first has returned. Either because some other work is taking a while or because we’re sending requests faster than they can be processed.

The manager processes only the request on the top of the queue, so when a new tagged invoke comes in, we remove any other requests in the queue before it that have the same tag.

Parameters:
  • tag # (str) – The tag to identify this callback.
  • method # (InvokeCallback) – The function to callback on the replay thread.
BlockInvoke(m)

Make a blocking invoke call onto the replay thread.

Parameters: method # (InvokeCallback) – The function to callback on the replay thread.
CancelReplayLoop()

Cancels the active replay loop. See ReplayLoop().

ConnectToRemoteServer(host)

Connect to a remote server.

Parameters: host # (RemoteHost) – The host to connect to.
Returns: Whether or not the connection was successful.
Return type: renderdoc.ResultDetails
CopyCaptureFromRemote(remotepath, localpath, window)

Copy a capture from the remote host to the local machine.

Parameters:
  • remotepath # (str) – The path on the remote server to copy from.
  • localpath # (str) – The path on the local machine to copy to.
  • window # (QWidget) – A handle to the window to use when showing a progress bar.
CopyCaptureToRemote(localpath, window)

Copy a capture from the local machine to the remote host.

Parameters:
  • localpath # (str) – The path on the local machine to copy from.
  • window # (QWidget) – A handle to the window to use when showing a progress bar.
Returns:

The path on the local machine where the file was saved, or empty if something went wrong.
Return type:

str
CurrentRemote()

Retrieves the host that the manager is currently connected to.

Returns: The host connected to, or an invalid RemoteHost if no connection is active.
Return type: RemoteHost
DeleteCapture(capturefile, local)

Delete a capture file, whether local or remote.

Parameters:
  • capturefile # (str) – The path to the file.
  • local # (bool) – True if the file is on the local machine.
DisconnectFromRemoteServer()

Disconnect from the server the manager is currently connected to.

ExecuteAndInject(exe, workingDir, cmdLine, env, capturefile, opts)

Launch an application and inject into it to allow capturing.

This happens either locally, or on the remote server, depending on whether a connection is active.

Parameters:
  • exe # (str) – The path to the executable to run.
  • workingDir # (str) – The working directory to use when running the application. If blank, the directory containing the executable is used.
  • cmdLine # (str) – The command line to use when running the executable, it will be processed in a platform specific way to generate arguments.
  • env # (List[ renderdoc.EnvironmentModification ]) – Any environment changes that should be made when running the program.
  • capturefile # (str) – The location to save any captures, if running locally.
  • opts # (renderdoc.CaptureOptions) – The capture options to use when injecting into the program.
Returns:

The ExecuteResult indicating both the status of the operation (success or failure) and any reason for failure, or else the ident where the new application is listening for target control if everything succeeded.
Return type:

renderdoc.ExecuteResult
GetCaptureAccess()

Retrieves the capture access handle for the currently open file.

Returns: The file handle active, or None if no capture is open.
Return type: renderdoc.CaptureAccess
GetCaptureFile()

Retrieves the capture file handle for the currently open file, if it is available.

If the capture is not open locally this will not be available, and only GetCaptureAccess() will be usable.

Returns: The file handle active, or None if no capture is open or the capture is only available remotely.
Return type: renderdoc.CaptureFile
GetCurrentProcessingTime()

Return the amount of time that the currently active command on the replay thread has been executing for.

This can be used to identify if a command is long-running to display a progress bar or notification.

Returns: The time in seconds that the current command has been executing for, or 0.0 if no command is executing.
Return type: float
GetHomeFolder(synchronous, callback)

Query the remote host for its home directory.

If a capture is open, the callback will happen on the replay thread, otherwise it will happen in a blocking fashion on the current thread.

Parameters:
  • synchronous # (bool) – If a capture is open, then True will use BlockInvoke() to call the callback. Otherwise if False then AsyncInvoke() will be used.
  • callback # (DirectoryBrowseCallback) – The function to callback on the replay thread.
GetRemoteSupport()

Retrieve a list of drivers that the current remote server supports.

Returns: The list of supported replay drivers.
Return type: List[str]
ListFolder(path, synchronous, callback)

Query the remote host for the contents of a path.

If a capture is open, the callback will happen on the replay thread, otherwise it will happen in a blocking fashion on the current thread.

Parameters:
  • path # (str) – The path to query the contents of.
  • synchronous # (bool) – If a capture is open, then True will use BlockInvoke() to call the callback. Otherwise if False then AsyncInvoke() will be used.
  • callback # (DirectoryBrowseCallback) – The function to callback on the replay thread.
PingRemote()

Ping the remote server to ensure the connection is still alive.

ShutdownServer()

Shutdown the server the manager is currently connected to.

RGP Interop Control

class qrenderdoc.RGPInterop

Controlling interface for interop with RGP tool.

HasRGPEvent(eventId)

Return true if the given eventId has and equivalent in RGP.

Parameters: eventId # (int) – The eventId to query for.
Returns: True if there is an equivalent. This only confirms the equivalent exists, not that it will be selectable in all cases.
Return type: bool
SelectRGPEvent(eventId)

Select the given eventId equivalent in RGP.

Parameters: eventId # (int) – The eventId to query for.
Returns: True if the selection request succeeded. This only confirms the request was sent, not that the event was selected in RGP.
Return type: bool

CaptureViewer Interface

class qrenderdoc.CaptureViewer

An interface implemented by any object wanting to be notified of capture events.

OnCaptureClosed()

Called whenever a capture is closed.

OnCaptureLoaded()

Called whenever a capture is opened.

OnEventChanged(eventId)

Called whenever the effective current event changes.

Parameters: eventId # (int) – The new eventId.
OnSelectedEventChanged(eventId)

Called whenever the current selected event changes. This is distinct from the actual effective current event, since for example selecting a marker region will change the current event to be the last event inside that region, to be consistent with selecting an item reflecting the current state after that item.

The selected event shows the eventId that was actually selected, which will usually but not always be the same as the current effective eventId.

The distinction for this callback is not normally desired, instead use OnEventChanged() to be notified whenever the current event changes. The API inspector uses this to display API events up to a marker region.

Parameters: eventId # (int) – The new eventId.

Utilities

class qrenderdoc.DockReference(value)

Specifies the relationship between the existing dock window and the new one when adding a new dock window or moving an existing dock window.

LastUsedArea

The existing dock window is not used, the new dock window is placed wherever the last dock window was placed.

NewFloatingArea

The existing dock window is not used, the new dock window is placed in a new floating area.

EmptySpace

The existing dock window is not used, the new dock window is placed in empty area in the dockarea.

NoArea

The existing dock window is not used, the new window is hidden.

AddTo

The new dock window is placed in a tab set with the existing dock window.

LeftOf

The new dock window is placed to the left of the existing dock window, at a specified proportion.

RightOf

The new dock window is placed to the right of the existing dock window, at a specified proportion.

TopOf

The new dock window is placed above the existing dock window, at a specified proportion.

BottomOf

The new dock window is placed below the existing dock window, at a specified proportion.

LeftWindowSide

The new dock window is placed left of all docks in the window, at a specified proportion.

RightWindowSide

The new dock window is placed right of all docks in the window, at a specified proportion.

TopWindowSide

The new dock window is placed above all docks in the window, at a specified proportion.

BottomWindowSide

The new dock window is placed below all docks in the window, at a specified proportion.

MainToolArea

The new dock window is placed in the ‘main’ tool area as defined by finding an existing known window and using that as the main area. In the default layout this is where most windows are placed.

LeftToolArea

The new dock window is placed in the ‘left’ tool area as defined by finding an existing known window and using that as the main area, then adding to the left of that. In the default layout this is where the event browser is placed.

TransientPopupArea

The new dock window is docked with other similar transient views like constant buffer or pixel history windows, if they exist, or else docked to the right of the main window.

class qrenderdoc.CaptureModifications(value)

Details any changes that have been made to a capture in the UI which can be saved to disk but currently aren’t. Note that detection is conservative - e.g. if a change is made, then cancelled out by reversing the change, this will still count as ‘modified’ even if the end result is the same data. In that sense it’s analogous to adding and then deleting some characters in a text editor, since there is no actual undo system.

This is a bitmask, so several values can be present at once.

NoModifications

Fixed value of 0 indicating no modifications have been made.

Renames

One or more resources have been given a custom name which hasn’t been saved.

Bookmarks

Event bookmarks have been added or removed.

Notes

The general notes field has been changed.

EditedShaders

There are shader editing changes (new edits or reverts).

All

Fixed value with all bits set, indication all modifications have been made.

class qrenderdoc.CaptureSettings

Contains all of the settings that control how to capture an executable.

autoStart

True if this capture settings object should be immediately executed upon load.

commandLine

The command line to pass when running executable.

environment

The environment changes to apply.

Type: List[renderdoc.EnvironmentModification]
executable

The path to the executable to run.

inject

True if the described capture is an inject-into-process instead of a launched executable.

numQueuedFrames

The number of queued frames to capture, or 0 if no frames are queued to be captured.

options

The settings for the capture.

Type: renderdoc.CaptureOptions
queuedFrameCap

The first queued frame to capture. Ignored if numQueuedFrames is 0.

workingDir

The path to the working directory to run in, or blank for the executable’s directory.

class qrenderdoc.EventBookmark

A description of a bookmark on an event

eventId

The eventId at which this bookmark is placed.

text

The text associated with this bookmark - could be empty


UI Extensions

Contents

  • UI Extensions
    • Extension Manager
    • Mini-Qt Helper
    • Helpers

Extension Manager

class qrenderdoc.ExtensionManager

A manager for listing available and active extensions, as well as the interface for extensions to register hooks and additional functionality.

ExtensionCallback(context, data)

Not a member function - the signature for any ExtensionCallback callbacks.

Callback for extensions to register entry points with, used in many situations depending on how it was registered.

Parameters:
  • context (CaptureContext) – The current capture context.
  • data (dict) – Additional data for the call, as a dictionary with string keys. Context-dependent based on what generated the callback
ErrorDialog(text, title)
ErrorDialog(text) → None

Display an error message dialog.

Parameters:
  • text # (str) – The text of the dialog itself, required.
  • title # (str) – The dialog title, optional.
GetInstalledExtensions()

Retrieve a list of installed extensions.

Returns: The list of installed extensions.
Return type: List[ExtensionMetadata]
GetMiniQtHelper()

Returns a handle to the mini Qt helper. See MiniQtHelper.

Returns: The helper interface.
Return type: MiniQtHelper
IsExtensionLoaded(name)

Check if an installed extension is enabled.

Parameters: name # (str) – The qualified name of the extension, e.g. foo.bar
Returns: If the extension is enabled or not.
Return type: bool
LoadExtension(name)

Enable an extension by name. If the extension is already enabled, this will reload it.

Parameters: name # (str) – The qualified name of the extension, e.g. foo.bar
Returns: If the extension loaded successfully, an empty string, otherwise the errors encountered while loading it.
Return type: str
MessageDialog(text, title)
MessageDialog(text) → None

Display a simple informational message dialog.

Parameters:
  • text # (str) – The text of the dialog itself, required.
  • title # (str) – The dialog title, optional.
OpenDirectoryName(caption, dir)
OpenDirectoryName(caption) → None
OpenDirectoryName() → None

Browse for a directory to open.

Parameters:
  • caption # (str) – The dialog title, optional.
  • dir # (str) – The starting directory for browsing, optional.
Returns:

The directory selected, or an empty string if nothing was selected.
Return type:

str
OpenFileName(caption, dir, filter)
OpenFileName(caption, dir) → None
OpenFileName(caption) → None
OpenFileName() → None

Browse for a filename to open.

Parameters:
  • caption # (str) – The dialog title, optional.
  • dir # (str) – The starting directory for browsing, optional.
  • filter # (str) – The filter to apply for filenames, optional.
Returns:

The filename selected, or an empty string if nothing was selected.
Return type:

str
QuestionDialog(text, options, title)
QuestionDialog(text, options) → None

Display an error message dialog.

Parameters:
  • text # (str) – The text of the dialog itself, required.
  • options # (List[ DialogButton ]) – The buttons to display on the dialog.
  • title # (str) – The dialog title, optional.
Returns:

The button that was clicked on.
Return type:

DialogButton
RegisterContextMenu(base, submenus, callback)

Register a context menu item in a panel for an extension.

Parameters:
  • base # (ContextMenu) – The panel to add the item to.
  • submenus # (List[str]) – A list of strings containing the submenus to add before the item. The last string will be the name of the menu item itself. Must contain at least one entry.
  • callback # (ExtensionCallback) – The function to callback when the menu item is selected.
RegisterPanelMenu(base, submenus, callback)

Register a menu item in a panel for an extension.

Parameters:
  • base # (PanelMenu) – The panel to add the item to.
  • submenus # (List[str]) – A list of strings containing the submenus to add before the item. The last string will be the name of the menu item itself. Must contain at least one entry.
  • callback # (ExtensionCallback) – The function to callback when the menu item is selected.
RegisterWindowMenu(base, submenus, callback)

Register a new menu item in the main window’s menus for an extension.

Parameters:
  • base # (WindowMenu) – The base menu to add the item to.
  • submenus # (List[str]) – A list of strings containing the submenus to add before the item. The last string will be the name of the menu item itself. Must contain at least one entry, or two entries if base is WindowMenu.NewMenu.
  • callback # (ExtensionCallback) – The function to callback when the menu item is selected.
SaveFileName(caption, dir, filter)
SaveFileName(caption, dir) → None
SaveFileName(caption) → None
SaveFileName() → None

Browse for a filename to save to.

Parameters:
  • caption # (str) – The dialog title, optional.
  • dir # (str) – The starting directory for browsing, optional.
  • filter # (str) – The filter to apply for filenames, optional.
Returns:

The filename selected, or an empty string if nothing was selected.
Return type:

str

Mini-Qt Helper

class qrenderdoc.MiniQtHelper

Python can have direct access to Qt via PySide2, but this is not always available in all RenderDoc builds. To aid extensions to manipulate widgets in a simple but portable fashion this helper exposes a small subset of Qt via RenderDoc’s python bindings.

The intention is not to allow fully flexible building of Qt panels, but to allow access to some basic UI building tools for simple data input and display which can be used on any RenderDoc build.

Note

The widget handles returned are PySide2 widgets where that is available, so this can be used to make a basic UI and optionally customise it further with PySide2 when possible.

WidgetCallback(context, widget, text)

Not a member function - the signature for any WidgetCallback callbacks.

Callback for widgets can be registered at creation time, the text field is optional and may be blank depending on the event, but the context and widget are always valid.

Parameters:
  • context (CaptureContext) – The current capture context.
  • widget (QWidget) – The widget sending the callback.
  • text (str) – Additional data for the call, such as the current or selected text.
InvokeCallback(context, widget, text)

Not a member function - the signature for any InvokeCallback callbacks.

Callback for invoking onto the UI thread from another thread (in particular the replay thread). Takes no parameters as the callback is expected to store its own state.

AddGridWidget(parent, row, column, child, rowSpan, columnSpan)

Adds a child widget to a grid layout. If the parent is not a grid layout nothing will happen and the widget will not be added anywhere.

Parameters:
  • parent # (QWidget) – The parent grid layout widget.
  • row # (int) – The row at which to add the child widget.
  • column # (int) – The column at which to add the child widget.
  • child # (QWidget) – The child widget to add.
  • rowSpan # (int) – How many rows should this child span over.
  • columnSpan # (int) – How many columns should this child span over.
AddWidget(parent, child)

Adds a child widget to the end of an ordered layout (either horizontal or vertical). If the parent is not an ordered layout nothing will happen and the widget will not be added anywhere.

Parameters:
  • parent # (QWidget) – The parent grid layout widget.
  • child # (QWidget) – The child widget to add.
ClearContainedWidgets(parent)

Removes all child widgets from a parent and makes them invisible.

These widgets remain valid and can be re-added to another parent or the same parent.

Parameters: parent # (QWidget) – The parent widget to clear of children.
CloseCurrentDialog(success)

Close the active modal dialog. This does nothing if no dialog is being shown.

Note

Closing a dialog ‘sucessfully’ does nothing except modify the return value of CloseCurrentDialog(). It allows quick distinguishing between OK and Cancel actions without having to carry that information separately in a global or other state.

Parameters: success # (bool) – True if the dialog was successful (the user clicked an OK/Accept type button).
CloseToplevelWidget(widget)

Closes a top-level widget as if the user had clicked to close.

This function is undefined if used on a non top-level widget. It will invoke the closed widget callback.

Parameters: widget # (QWidget) – The top-level widget to close.
CreateButton(pressed)

Create a normal button widget.

Parameters: pressed # (WidgetCallback) – Callback to be called when the button is pressed.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateCheckbox(changed)

Create a checkbox widget which can be toggled between unchecked and checked. When created the checkbox is unchecked.

Parameters: changed # (WidgetCallback) – Callback to be called when the widget is toggled.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateComboBox(editable, changed)

Create a drop-down combo box widget.

When created there are no pre-defined entries in the drop-down section. This can be changed with SetComboOptions().

Parameters:
  • editable # (bool) – True if the widget should allow the user to enter any text they wish as well as being able to select a pre-defined entry.
  • changed # (WidgetCallback) – Callback to be called when the text in the combobox is changed. This will be called both when a new option is selected or when the user edits the text.
Returns:

The handle to the newly created widget.
Return type:

QWidget
CreateGridContainer()

Creates and returns a grid layout widget.

The widget needs to be added to a parent to become part of a panel or window.

Children added to this layout widget are arranged in a grid. Widget sizing follows default logic, which typically has some widgets be only large enough for their content and others which are ‘greedy’ evenly divide any remaining free space. This will not violate the grid constraint though.

Returns: The handle to the newly created widget.
Return type: QWidget
CreateGroupBox(collapsible)

Create a groupbox widget which can optionally allow collapsing.

This widget can have children added, but it is recommended to immediately add only one child which is a layout type widget, to allow customising how children are added. By default the children are added in a vertical layout.

The widget needs to be added to a parent to become part of a panel or window.

Parameters: collapsible # (bool) – True if the groupbox should have a toggle in its header to allow collapsing its contents down vertically.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateHorizontalContainer()

Creates and returns a horizontal layout widget.

The widget needs to be added to a parent to become part of a panel or window.

Children added to this layout widget are listed horizontally. Widget sizing follows default logic, which typically has some widgets be only large enough for their content and others which are ‘greedy’ evenly divide any remaining free space.

Returns: The handle to the newly created widget.
Return type: QWidget
CreateLabel()

Create a read-only label widget.

Note

This widget will be blank by default, you can set the text with SetWidgetText().

Returns: The handle to the newly created widget.
Return type: QWidget
CreateOutputRenderingWidget()

Create a widget suitable for rendering to with a renderdoc.ReplayOutput. This widget takes care of painting on demand and recreating the internal display widget when necessary, however this means you must use GetWidgetWindowingData() to retrieve the windowing data for creating the output as well as call SetWidgetReplayOutput() to notify the widget of the current output.

Returns: The handle to the newly created widget.
Return type: QWidget
CreateProgressBar(horizontal)

Create a progress bar widget.

By default the progress bar has minimum and maximum values of 0 and 100. These can be changed with SetProgressBarRange().

Parameters: horizontal # (bool) – the progress bar orientation, true for horizontal otherwise vertical.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateRadiobox(changed)

Create a radio box widget which can be toggled between unchecked and checked but with at most one radio box in any group of sibling radio boxes being checked.

Upon creation the radio box is unchecked, even in a group of other radio boxes that are unchecked. If you want a default radio box to be checked, you should use SetWidgetChecked().

Parameters: changed # (WidgetCallback) – Callback to be called when the widget is toggled.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateSpacer(horizontal)

Creates and returns a spacer widget.

This widget is completely empty but consumes empty space, meaning all other non-greedy widgets in the same container will be minimally sized. This can be useful for simple layouts.

Parameters: horizontal # (bool) – True if this spacer should consume horizontal space, False if this spacer should consume vertical space. Typically this matches the direction of the layout it is in.
Returns: The handle to the newly created widget.
Return type: QWidget
CreateSpinbox(decimalPlaces, step)

Create a spinbox widget with a numerical value and up/down buttons to change it.

The number of decimal places can be set to 0 for an integer spinbox, and in that case the step should be set to 1.0.

By default the spinbox has minimum and maximum values of 0.0 and 100.0, these can be changed with SetSpinboxBounds().

Parameters:
  • decimalPlaces # (int) – The number of decimal places to display when showing the number.
  • step # (float) – The step value to apply in each direction when clicking up or down.
Returns:

The handle to the newly created widget.
Return type:

QWidget
CreateTextBox(singleLine, changed)

Create a text box widget for the user to enter text into.

Parameters:
  • singleLine # (bool) – True if the widget should be a single-line entry, otherwise it is a multi-line text box.
  • changed # (WidgetCallback) – Callback to be called when the text in the textbox is changed.
Returns:

The handle to the newly created widget.
Return type:

QWidget
CreateToplevelWidget(windowTitle, closed)

Creates and returns a top-level widget for creating layouts.

The widget is not immediately visible. It should be shown either with ShowWidgetAsDialog() or with CaptureContext.AddDockWindow() once it’s ready.

This widget can have children added, but it is recommended to immediately add only one child which is a layout type widget, to allow customising how children are added. By default the children are added in a vertical layout.

Parameters:
  • windowTitle # (str) – The title of any window with this widget as its root.
  • closed # (WidgetCallback) – A callback that will be called when the widget is closed by the user. This implicitly deletes the widget and all its children, which will no longer be valid even if a handle to them exists.
Returns:

The handle to the newly created widget.
Return type:

QWidget
CreateVerticalContainer()

Creates and returns a vertical layout widget.

The widget needs to be added to a parent to become part of a panel or window.

Children added to this layout widget are listed vertically. Widget sizing follows default logic, which typically has some widgets be only large enough for their content and others which are ‘greedy’ evenly divide any remaining free space.

Returns: The handle to the newly created widget.
Return type: QWidget
DestroyWidget(widget)

Destroy a widget. Widgets stay alive unless explicitly destroyed here, OR in one other case when they are in a widget hiearchy under a top-level window which the user closes, which can be detected with the callback parameter in CreateToplevelWidget().

If the widget being destroyed is a top-level window, it will be closed. Otherwise if it is part of a widget hierarchy it will be removed from its parent automatically. You can remove a widget and then destroy it if you wish, but you must not destroy a widget then attempt to remove it from its parent, as after the call to this function the widget is no longer valid to use.

All children under this widget will be destroyed recursively as well, which will be made invalid even if a handle to them exists.

Parameters: widget # (QWidget) – The widget to destroy.
FindChildByName(parent, name)

Find a child widget of a parent by internal name.

Parameters:
  • parent # (QWidget) – The widget to start the search from.
  • name # (str) – The internal name to search for.
Returns:

The handle to the first widget with a matching name, or None if no widget is found.
Return type:

QWidget
GetChild(parent, index)

Return a child widget for a parent.

Parameters:
  • parent # (QWidget) – The parent widget to look up.
  • index # (int) – The child index to return.
Returns:

The specified child of the parent, or None if the index is out of bounds.
Return type:

QWidget
GetComboCount(combo)

Get the number of options in a drop-down combo box. If another type of widget is passed 0 will be returned.

Parameters: combo # (QWidget) – The combo box.
Returns: The current number of options.
Return type: int
GetNumChildren(widget)

Return the number of children this widget has. This is generally only useful for layout type widgets.

Parameters: widget # (QWidget) – The widget to query.
Returns: The number of child widgets this widget has.
Return type: int
GetParent(widget)

Return the parent of a widget in the widget hierarchy.

Note

The widget returned may not be a widget created through this helper interface if the specified widget has been docked somewhere. Beware making changes to any widgets returned as you may modify the RenderDoc UI itself.

Parameters: widget # (QWidget) – The widget to query.
Returns: The handle to the parent widget with a matching name, or None if this widget is either not yet parented or is a top-level window.
Return type: QWidget
GetProgressBarMaximum(pbar)

Get the maximum value of the progress bar’s range.

Parameters: pbar # (QWidget) – the progress bar.
Returns: The maximum value of the range.
Return type: int
GetProgressBarMinimum(pbar)

Get the minimum value of the progress bar’s range.

Parameters: pbar # (QWidget) – the progress bar.
Returns: The minimum value of the range.
Return type: int
GetProgressBarValue(pbar)

Get the progress bar’s current value.

Parameters: pbar # (QWidget) – the progress bar.
Returns: The current value of the progress bar.
Return type: int
GetSpinboxValue(spinbox)

Return the current value of a spinbox widget. If another type of widget is passed 0.0 will be returned.

Parameters: spinbox # (QWidget) – The widget to query.
Returns: The current value of the spinbox.
Return type: float
GetWidgetName(widget)

Return the internal name of a widget, as set my SetWidgetName().

Parameters: widget # (QWidget) – The widget to query.
Returns: The widget’s internal name, which may be an empty string if no name has been set.
Return type: str
GetWidgetText(widget)

Return the current text of a widget. See SetWidgetText().

Parameters: widget # (QWidget) – The widget to query.
Returns: The widget’s current text, which may be an empty string if no valid text is available.
Return type: str
GetWidgetType(widget)

Return the type of the widget as a string. This type is the Qt type name so this should only be used for debugging as the name may change even if for the same type of widget.

Parameters: widget # (QWidget) – The widget to query.
Returns: The widget’s type name.
Return type: str
GetWidgetWindowingData(widget)

Return the opaque pointer of windowing data suitable for passing to CreateOutput() or other functions that expect windowing data.

If the widget is not a output rendering widget created with CreateOutputRenderingWidget() this function will fail and return an invalid set of windowing data.

It’s important to note that the windowing data is not valid forever, so this function should be called as close to where you call CreateOutput() as possible. Also don’t fetch windowing data unless you are going to create an output, because this function will cause the widget to go into an undefined state unless an output is created to render onto it.

Note

This function must be called on the main UI thread.

Parameters: widget # (QWidget) – The widget to create windowing data for.
Returns: The windowing data.
Return type: renderdoc.WindowingData
InsertWidget(parent, index, child)

Insert a child widget at the specified index in an ordered layout (either horizontal or vertical). If the parent is not an ordered layout nothing will happen and the widget will not be added anywhere.

Parameters:
  • parent # (QWidget) – The parent grid layout widget.
  • index # (int) – The index to insert the widget at. If this index is out of bounds it will be clamped, so that negative indices will be equivalent to index 0 and all indices above the number of children will append the widget
  • child # (QWidget) – The child widget to add.
InvokeOntoUIThread(callback)

Invoke a callback on the UI thread. All widget accesses must come from the UI thread, so if work has been done on the render thread then this function can be used to asynchronously and safely go back to the UI thread.

This function is safe to call on the UI thread, but it will synchronously call the callback immediately before returning.

Note

No parameters are provided to the callback, it is assumed that the callback will maintain its own context as needed.

Parameters: callback # (InvokeCallback) – The callback to invoke on the UI thread.
IsWidgetChecked(checkableWidget)

Return the current checked-state of a widget. See SetWidgetChecked(). If another type of widget is passed other than a checkbox or radio box or group box False will be returned.

Parameters: checkableWidget # (QWidget) – The widget to query.
Returns: True if the widget is currently checked.
Return type: bool
IsWidgetEnabled(widget)

Return the current enabled-state of a widget. See SetWidgetEnabled().

Parameters: widget # (QWidget) – The widget to query.
Returns: True if the widget is currently enabled.
Return type: bool
IsWidgetVisible(widget)

Return the current visibility of a widget. See SetWidgetVisible().

This query is recursive - a widget could be individually visible, but if it is under a parent which is invisible then this widget will be returned as invisible.

Parameters: widget # (QWidget) – The widget to query.
Returns: True if the widget is currently visible.
Return type: bool
ResetProgressBar(pbar)

Reset a progress bar widget.

Rewinds the progress bar’s indicator and hides the indicator’s label (theme dependent). If you want to keep the label visible, call SetProgressBarValue(0)() instead. The minimum and maximum values are not changed.

Parameters: pbar # (QWidget) – the progress bar.
SelectComboOption(combo, option)

Select the current option in a drop-down combo box. If another type of widget or an unknown option is passed, nothing will happen.

Parameters:
  • combo # (QWidget) – The combo box.
  • option # (str) – The option to select.
SetComboOptions(combo, options)

Set the pre-defined options in a drop-down combo box. If another type of widget is passed nothing will happen.

Parameters:
  • combo # (QWidget) – The combo box.
  • options # (List[str]) – The new options for the combo box.
SetLabelImage(widget, data, width, height, alpha)

Set an image for a label widget. If the widget isn’t a label, this call has no effect.

The label will be resized to a fixed size to display the image at 100% scale. Any text in the label will not be displayed, but passing an empty image will revert the label back to being text-based.

The data must be in RGB(A) format with the first byte of each texel being R.

Parameters:
  • widget # (QWidget) – The widget to set the picture for.
  • data # (bytes) – The image data itself, tightly packed.
  • width # (int) – The width of the image in pixels.
  • height # (int) – The height of the image in pixels.
  • alpha # (bool) – True if the image data contains an alpha channel.
SetProgressBarRange(pbar, minimum, maximum)

Set a progress bar’s minimum and maximum values.

If maximum is smaller than minimum, minimum is set as the maximum, too. If the current value falls outside the new range, the progress bar is reset. Use range (0, 0) to set the progress bar to indeterminated state (the progress cannot be estimated or is not being calculated).

Parameters:
  • pbar # (QWidget) – the progress bar.
  • minimum # (int) – the minimum value.
  • maximum # (int) – the maximum value.
SetProgressBarValue(pbar, value)

Set the progress bar’s current value.

Attempting to change the current value outside the minimum and maximum range does not affect the current value.

Parameters:
  • pbar # (QWidget) – the progress bar.
  • value # (int) – the new current value.
SetSpinboxBounds(spinbox, minVal, maxVal)

Set the minimum and maximum values allowed in the spinbox. If another type of widget is passed nothing will happen.

Parameters:
  • spinbox # (QWidget) – The spinbox.
  • minVal # (float) – The minimum value allowed for the spinbox to reach. Lower values entered will be clamped to this.
  • maxVal # (float) – The maximum value allowed for the spinbox to reach. Higher values entered will be clamped to this.
SetSpinboxValue(spinbox, value)

Set the value contained in a spinbox. If another type of widget is passed nothing will happen.

Parameters:
  • spinbox # (QWidget) – The spinbox.
  • value # (float) – The value for the spinbox, which will be clamped by the current bounds.
SetWidgetBackgroundColor(widget, red, green, blue)

Set the default backkground color for a rendering widget. This background color is used when no output is currently configured, e.g. when a capture is closed.

For all other widget types this has no effect.

To disable the background color pass negative values for the components, this will cause a default checkerboard to be rendered instead. This is the default behaviour when a widget is created.

Parameters:
  • widget # (QWidget) – The widget to set the background color of.
  • red # (float) – The red component of the color, in the range 0.0 - 1.0.
  • green # (float) – The green component of the color, in the range 0.0 - 1.0.
  • blue # (float) – The blue component of the color, in the range 0.0 - 1.0.
SetWidgetChecked(checkableWidget, checked)

Set whether the widget is checked or not. This only affects checkboxes and radio boxes and group box. If another type of widget is passed nothing will happen.

Parameters:
  • checkableWidget # (QWidget) – The widget to check or uncheck.
  • checked # (bool) – True if the widget should be checked.
SetWidgetEnabled(widget, enabled)

Set whether the widget is enabled or not. This generally only affects interactive widgets and not fixed widgets, interactive widgets become read-only while still displaying the same data.

Note

Disabled widgets can still be modified programmatically, they are only disabled for the user.

Parameters:
  • widget # (QWidget) – The widget to enable or disable.
  • enabled # (bool) – True if the widget should be enabled.
SetWidgetFont(widget, font, fontSize, bold, italic)

Change the font properties of a widget.

Parameters:
  • widget # (QWidget) – The widget to change font of.
  • font # (str) – The new font family to use, or an empty string to leave the font family the same.
  • fontSize # (int) – The new font point size to use, or 0 to leave the size the same.
  • bold # (bool) – True if the font should be bold.
  • italic # (bool) – True if the font should be italic.
SetWidgetName(widget, name)

Set the internal name of a widget. This is not displayed anywhere but can be used by FindChildByName() to locate a widget within a hierarchy.

Note

Names are optional and only for your use. Nothing prevents from you from setting duplicate names, but this makes searches by name ambiguous.

Parameters:
  • widget # (QWidget) – The widget to set an internal name for.
  • name # (str) – The internal name to set for the widget.
SetWidgetReplayOutput(widget, output)

Set the current output for a widget. This only affects output rendering widgets. If another type of widget is passed nothing will happen.

Passing None as the output will reset the widget and make it display the default background until another output is set.

When a capture is closed and all outputs are destroyed, the widget will automatically unset the output so there is no need to do that manually.

Parameters:
  • widget # (QWidget) – The widget to set the output for.
  • output # (renderdoc.ReplayOutput) – The new output to set, or None to unset any previous output.
SetWidgetText(widget, text)

Set the ‘text’ of a widget. How this manifests depends on the type of the widget, for example a text-box or label will set the text directly. For a checkbox or radio button this will add text next to it.

Parameters:
  • widget # (QWidget) – The widget to set text for.
  • text # (str) – The text to set for the widget.
SetWidgetVisible(widget, visible)

Set whether the widget is visible or not. An invisible widget maintains its position in the hierarchy but is not visible and cannot be interacted with in any way.

Parameters:
  • widget # (QWidget) – The widget to show or hide.
  • visible # (bool) – True if the widget should be made visible (shown).
ShowWidgetAsDialog(widget)

Show a top-level widget as a blocking modal dialog. This is most useful to prompt the user for some specific information.

The dialog is only closed when the user closes the window explicitly or if you call CloseCurrentDialog() in a widget callback, e.g. upon a button press.

Parameters: widget # (QWidget) – The top-level widget to show as a dialog.
Returns: Whether the dialog was closed successfully, via CloseCurrentDialog().
Return type: bool
UpdateProgressBarValue(pbar, delta)

Set the progress bar’s current value relative to the existing value.

Parameters:
  • pbar # (QWidget) – the progress bar.
  • delta # (int) – the relative value to update the current value.

Helpers

class qrenderdoc.ExtensionMetadata

The metadata for an extension.

author

The author of the extension, optionally with an email contact

description

A longer description of what the extension does

extensionAPI

The version of the extension API that this extension is written against

extensionURL

The URL for where the extension is fetched from

filePath

The location of this package on disk

name

The short friendly name for the extension

package

The python package for this extension, e.g. foo.bar

version

The version of the extension

class qrenderdoc.WindowMenu(value)

Specifies the base menu to add a menu item into.

Unknown

Unknown/invalid window.

File

The menu item will be in a section between Open/Save/Close captures and Import/Export.

Window

The menu item will be in a new section at the end of the menu.

Tools

The menu item will be added to a new section above Settings.

NewMenu

The menu item will be a root menu, placed between Tools and Help.

Help

The menu item will be added after the error reporting item.

class qrenderdoc.PanelMenu(value)

Specifies the panel to add a menu item into.

Unknown

Unknown/invalid panel.

EventBrowser

The EventBrowser.

PipelineStateViewer

The PipelineStateViewer.

MeshPreview

The mesh previewing BufferViewer.

TextureViewer

The TextureViewer.

BufferViewer

Any non-mesh previewing BufferViewer.

class qrenderdoc.ContextMenu(value)

Specifies the panel to add a menu item into.

Unknown

Unknown/invalid context menu.

EventBrowser_Event

Adds the item to the context menu for events in the EventBrowser.

MeshPreview_Vertex

Adds the item to the context menu for all vertices in the mesh previewing BufferViewer.

MeshPreview_VSInVertex

Adds the item to the context menu for vertex inputs in the mesh previewing BufferViewer.

MeshPreview_VSOutVertex

Adds the item to the context menu for VS output in the mesh previewing BufferViewer.

MeshPreview_GSOutVertex

Adds the item to the context menu for GS/Tess output in the mesh previewing BufferViewer.

MeshPreview_TaskOutVertex

Adds the item to the context menu for task shader output in the mesh previewing BufferViewer.

MeshPreview_MeshOutVertex

Adds the item to the context menu for mesh shader output in the mesh previewing BufferViewer.

TextureViewer_Thumbnail

Adds the item to the context menu for all thumbnails in the TextureViewer.

TextureViewer_InputThumbnail

Adds the item to the context menu for input thumbnails in the TextureViewer.

TextureViewer_OutputThumbnail

Adds the item to the context menu for output thumbnails in the TextureViewer.

class qrenderdoc.DialogButton(value)

A button for a dialog prompt.

OK

An OK button

Save

A Save button

SaveAll

A Save All button

Open

An Open button

Yes

A Yes button

YesToAll

A Yes To All button

No

A No button

NoToAll

A No To All button

Abort

An Abort button

Retry

A Retry button

Ignore

An Ignore button

Close

A Close button

Cancel

A Cancel button

Discard

A Discard button

Help

A Help button

Apply

An Apply button

Reset

A Reset button

RestoreDefaults

A Restore Defaults button


Windows

Contents

  • Windows
    • Main Window
    • Event Browser
    • API Inspector
    • Pipeline State
    • Texture Viewer
    • Buffer Viewer
    • Resource Inspector
    • Capture Dialog
    • Debug Messages
    • Diagnostic Log
    • Comment View
    • Statistics Viewer
    • Timeline Bar
    • Performance Counter Viewer
    • Python Shell
    • Shader Viewer
    • Pixel History
    • Shader Message Viewer

Main Window

class qrenderdoc.MainWindow

The main parent window of the application.

ShortcutCallback(QWidget focusWidget)

Not a member function - the signature for any ShortcutCallback callbacks.

Parameters: focusWidget (QWidget) – The widget with focus at the time this shortcut was detected. May be None.
BringToFront()

Attempts to bring the main window to the front to the user’s focus.

This may not be possible on all OSs, so the function is not guaranteed to succeed.

RegisterShortcut(shortcut, widget, callback)

Register a callback for a particular key shortcut.

This creates a managed shortcut. Qt’s shortcut system doesn’t allow specialisation/duplication, so you can’t use Ctrl+S for a shortcut in a window to update some changes if there’s also a global Ctrl+S shortcut on the window. In the end, neither shortcut will be called.

Instead this function allows the main window to manage shortcuts internally, and it will pick the closest shortcut to a given action. The search goes from the widget with the focus currently up the chain of parents, with the first match being used. If no matches are found, then a ‘global’ default will be invoked, if it exists.

Parameters:
  • shortcut # (str) – The text string representing the shortcut, e.g. ‘Ctrl+S’.
  • widget # (QWidget) – A handle to the widget to use as the context for this shortcut, or None for a global shortcut. Note that if an existing global shortcut exists the new one will not be registered.
  • callback # (ShortcutCallback) – The function to callback when the shortcut is hit.
UnregisterShortcut(shortcut, widget)

Unregister a callback for a particular key shortcut, made in a previous call to RegisterShortcut().

See the documentation for RegisterShortcut() for what these shortcuts are for.

Parameters:
  • shortcut # (str) – The text string representing the shortcut, e.g. ‘Ctrl+S’. To unregister all shortcuts for a particular widget, you can pass an empty string here. In this case, UnregisterShortcut.widget must not be None.
  • widget # (QWidget) – A handle to the widget used as the context for the shortcut, or None if referring to a global shortcut.
Widget()

Retrieves the PySide2 QWidget for this MainWindow if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Event Browser

class qrenderdoc.EventBrowser

The event browser window.

EventFilterCallback(context, filter, params, eventId, chunk, action, name)

Not a member function - the signature for any EventFilterCallback callbacks.

Called for each event in a capture when performing filtering in the Event Browser. The associated FilterParseCallback will be called first to parse the parameters, and is available for caching or syntax checking. The same filter name and params string will be passed to this function.

Parameters:
  • context (CaptureContext) – The current capture context.
  • filter (str) – The name of the filter function.
  • params (str) – The parameters to the filter function.
  • eventId (int) – The event’s eventId.
  • chunk (renderdoc.SDChunk) – The structured data chunk for this event.
  • action (renderdoc.ActionDescription) – The action that contains this event. If the event is the action itself then the event ID will be equal.
  • name (str) – The name of the event as shown in the event browser, for string-based filtering.
Returns:

Whether or not this event matches the filter
Return type:

bool
FilterParseCallback(context, filter, params)

Not a member function - the signature for any FilterParseCallback callbacks.

Called once when the filter changes, to allow parsing any any data caching, as well as reporting of errors in the filter usage.

Parameters:
  • context (CaptureContext) – The current capture context.
  • filter (str) – The name of the filter function.
  • params (str) – The parameters to the filter function.
Returns:

An empty string if the parse succeeded, otherwise any error messages to be displayed to the user, such as syntax or other errors.
Return type:

str
AutoCompleteCallback(context, filter, params)

Not a member function - the signature for any AutoCompleteCallback callbacks.

Called when autocompletion is triggered inside a filter. The params passed are any previous text inside the filter’s parameter list up to where the cursor is. The callback should return a list of identifiers used for auto-completion.

The list does not have to be pre-filtered for matches to the params, that is provided to allow different autocompletion at different stages (e.g. if there are no parameters, you can autocomplete a property, if a property is already present you can autocomplete valid values for it)

Parameters:
  • context (CaptureContext) – The current capture context.
  • filter (str) – The name of the filter function.
  • params (str) – The previous parameter text to the filter function.
Returns:

A list of strings giving identifiers to autocomplete, or an empty list of there are no such identifiers to prompt.
Return type:

List[str]
GetAPIEventForEID(eventId)

Uses the existing caching in the event browser to return a APIEvent for a specified EID.

If no capture is loaded or the EID doesn’t correspond to a known event, an empty struct will be returned.

Parameters: eventId # (int) – The EID to look up.
Returns: The event corresponding to the EID, or an empty struct if no such EID exists.
Return type: renderdoc.APIEvent
GetActionForEID(eventId)

Uses the existing caching in the event browser to return a ActionDescription for a specified EID. This action may not be the exact EID specified, but it will be the action that the EID is associated with. I.e. if you specify the EID for a state setting event the next action will be returned.

If no capture is loaded or the EID doesn’t correspond to a known event, None will be returned.

Parameters: eventId # (int) – The EID to look up.
Returns: The action containing the EID, or None if no such EID exists.
Return type: renderdoc.ActionDescription
GetCurrentFilterText()

Returns the current filter text, whether temporary or a saved filter.

Returns: The current filter text.
Return type: str
GetEventName(eventId)

Returns the formatted name of an event according to the current settings, whether that be a custom name or an auto-generated name with/without parameter names.

If no capture is loaded or the EID doesn’t correspond to a known event, an empty string will be returned.

Parameters: eventId # (int) – The EID to look up.
Returns: The formatted name of the specified event, or None if no such EID exists.
Return type: str
IsAPIEventVisible(eventId)

Determines if a given EID is visible with the current filters applied to the event browser.

If no capture is loaded or the EID doesn’t correspond to a known event, False will be returned.

Parameters: eventId # (int) – The EID to look up.
Returns: Whether or not the event is currently visible (passing the filters).
Return type: bool
RegisterEventFilterFunction(name, description, filter, parser, completer)

Registers a new event browser filter function.

Filter functions are available as $name() so long as they don’t shadow an existing function. The filter callback will be called for each event to filter.

The parser callback will be called once when a filter is first specified or the parameters change. Note that a filter can be used multiple times in a filter expression! For this reason the parser may be called multiple times and the filter callback takes the parameters string. If any expensive work is done then the parameters can be used as a cache key to cache any data once per filter expression.

Parameters:
  • name # (str) – The name of the filter function.
  • description # (str) – The description of the filter function. This should explain the available parameters (if applicable) and what the filter does. It will be used for documenting to users what each filter means.
  • filter # (EventFilterCallback) – The callback to call for each candidate event to perform filtering.
  • parser # (FilterParseCallback) – The callback to call when the parsing the parameters and checking for any errors. This can be None if no pre-parsing is required.
  • completer # (AutoCompleteCallback) – The callback to call when trying to provide autocomplete suggestions. This can be None if no completion is desired/applicable.
Returns:

Whether or not the registration was successful.
Return type:

bool
SetCurrentFilterText(text)

Sets the current filter text. This will not modify any saved filter but will modify the scratch filter. The filter is applied immediately.

Parameters: text # (str) – The filter text.
SetEmptyRegionsVisible(show)

Sets whether or not marker regions which have no visible actions.

Parameters: show # (bool) – Whether or not empty regions after filtering will be shown.
SetShowAllParameters(show)

Sets whether or not all parameters are shown in the events. By default only the most significant parameters are shown.

Note

If custom action names are used this will not have an effect for any such actions. See SetUseCustomActionNames().

Parameters: show # (bool) – Whether or not parameter names will be shown.
SetShowParameterNames(show)

Sets whether or not parameter names are shown in the events. If disabled, only the value is shown and the parameter is implicit.

Note

If custom action names are used this will not have an effect for any such actions. See SetUseCustomActionNames().

Parameters: show # (bool) – Whether or not parameter names will be shown.
SetUseCustomActionNames(use)

Sets whether or not custom action names are used. Certain actions such as indirect actions it is useful to show a custom action name which contains the actual indirect parameters instead of the ‘raw’ parameters.

Parameters: use # (bool) – Whether or not custom action names will be used.
UnregisterEventFilterFunction(name)

Unregisters an event browser filter function that was previously registered.

Parameters: name # (str) – The name of the filter function.
Returns: Whether or not the unregistration was successful.
Return type: bool
UpdateDurationColumn()

Updates the duration column if the selected time unit changes.

Widget()

Retrieves the PySide2 QWidget for this EventBrowser if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

API Inspector

class qrenderdoc.APIInspector

The API inspector window.

Refresh()

Refresh the current API view - useful if callstacks are now available.

RevealParameter(param)

Expand the API view to reveal a given parameter and select it.

Parameters: param # (renderdoc.SDObject) – The parameter to reveal and select.
Widget()

Retrieves the PySide2 QWidget for this APIInspector if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Pipeline State

class qrenderdoc.PipelineStage(value)

Specifies a pipeline stage for the PipelineStateViewer.

VertexInput

The fixed function vertex input stage.

VertexShader

The vertex shader.

HullShader

The vertex shader.

TessControlShader

The tessellation control shader.

DomainShader

The domain shader.

TessEvalShader

The tessellation evaluation shader.

GeometryShader

The geometry shader, including stream-out/transform feedback.

Rasterizer

The fixed function rasterizer stage.

ViewportsScissors

The viewports and scissors. Helper alias for Rasterizer.

PixelShader

The pixel shader.

FragmentShader

The fragment shader.

ColorDepthOutput

The fixed function color and depth output stage, including color blending and depth/stencil testing state.

Blending

The color blending state. Helper alias for ColorDepthOutput.

DepthTest

The depth test state. Helper alias for ColorDepthOutput.

StencilTest

The stencil test state. Helper alias for ColorDepthOutput.

ComputeShader

The compute shader.

SampleMask

The sample mask.

class qrenderdoc.PipelineStateViewer

The pipeline state viewer window.

SaveShaderFile(shader)

Prompt the user to save the binary form of the given shader to disk.

Parameters: shader # (renderdoc.ShaderReflection) – The shader reflection data to save.
Returns: True if the shader was saved successfully, False if an error occurred.
Return type: bool
SelectPipelineStage(stage)

Select a given pipeline stage in the viewer.

Parameters: stage # (PipelineStage) – The stage to select.
Widget()

Retrieves the PySide2 QWidget for this PipelineStateViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Texture Viewer

class qrenderdoc.FollowType(value)

Specifies a type of followed resource for the TextureViewer.

OutputColor

The index specifies which output color target to select. Shader stage and array index are ignored.

OutputDepth

The resource followed is the depth/stencil output target. All other parameters are ignored.

ReadWrite

The index specifies a resource within the given shader’s read-write resources. The array element then specifies the index within that resource’s array, if applicable.

ReadOnly

The index specifies a resource within the given shader’s read-only resources. The array element then specifies the index within that resource’s array, if applicable.

OutputDepthResolve

The resource followed is the depth/stencil resolve output target. All other parameters are ignored.

class qrenderdoc.TextureViewer

The texture viewer window.

GetChannelVisibilityBits()

Return which channels are currently displayed, as a bitmask.

If red is visible 0x1 will be set in the returned value, if blue is visible 0x2 will be set, etc.

Returns: The current bitmask showing channel visibility.
Return type: int
GetCurrentResource()

Return which resource is currently being displayed in the active tab.

Returns: The ID of the resource being displayed.
Return type: renderdoc.ResourceId
GetHistogramRange()

Return the current histogram blackpoint to whitepoint range.

Returns: The current histogram range.
Return type: Tuple[float,float]
GetPickedLocation()

Returns the currently selected texel location in the current texture.

If no location is currently selected or there is no current texture, this will return (-1, -1).

Returns: The currently picked pixel location.
Return type: Tuple[int,int]
GetSelectedSubresource()

Return which subresource is currently selected for viewing.

Returns: The subresource currently selected.
Return type: renderdoc.Subresource
GetTextureOverlay()

Return the currently selected texture overlay.

Returns: The currently selected texture overlay.
Return type: renderdoc.DebugOverlay
GetZoomLevel()

Return the current zoom level, whether manually set or auto-calculated.

Returns: The current zoom level, with 100% being represented as 1.0.
Return type: float
GotoLocation(x, y)

Highlights the given pixel location in the current texture.

Parameters:
  • x # (int) – The X co-ordinate.
  • y # (int) – The Y co-ordinate.
IsZoomAutoFit()

Return whether or not the texture viewer is currently auto-fitting the zoom level.

Returns: True if the zoom level is currently auto-fitting.
Return type: bool
SetChannelVisibility(red, green, blue, alpha)

Set the visibility of each channel.

Parameters:
  • red # (bool) – Whether the red channel should be visible.
  • green # (bool) – Whether the green channel should be visible.
  • blue # (bool) – Whether the blue channel should be visible.
  • alpha # (bool) – Whether the alpha channel should be visible.
SetHistogramRange(blackpoint, whitepoint)

Set the current histogram blackpoint to whitepoint range.

Parameters:
  • blackpoint # (float) – The value that should be mapped to black, component-wise.
  • whitepoint # (float) – The value that should be mapped to white, component-wise.
SetSelectedSubresource(sub)

Select a particular subresource within the currently selected texture. Any out of bounds parameters will be clamped to the available subresources.

Parameters: sub # (renderdoc.Subresource) – The subresource to select.
SetTextureOverlay(overlay)

Changes the currently selected overlay the given pixel location in the current texture.

Parameters: overlay # (renderdoc.DebugOverlay) – The overlay to enable.
SetZoomLevel(autofit, zoom)

Set the zoom level for displaying textures.

Parameters:
  • autofit # (bool) – True if the zoom level should be auto-calculated continuously to automatically fit the texture completely in view.
  • zoom # (float) – The zoom level as a percentage, with 100% being 1.0. Ignored if autofit is True.
ViewFollowedResource(followType, stage, index, arrayElement)

Select the ‘following’ view and choose which resource slot to follow.

Parameters:
  • followType # (FollowType) – The type of followed resource.
  • stage # (renderdoc.ShaderStage) – The shader stage of the shader reflection data to look up.
  • index # (int) – The index within the given resource list (if applicable) to follow.
  • arrayElement # (int) – The index within the given resource array (if applicable) to follow.
ViewTexture(resourceId, typeCast, focus)

Open a texture view, optionally raising this window to the foreground.

Parameters:
  • resourceId # (renderdoc.ResourceId) – The ID of the texture to view.
  • typeCast # (renderdoc.CompType) – If possible interpret the texture with this type instead of its normal type. If set to Typeless then no cast is applied, otherwise where allowed the texture data will be reinterpreted - e.g. from unsigned integers to floats, or to unsigned normalised values.
  • focus # (bool) – True if the TextureViewer should be raised.
Widget()

Retrieves the PySide2 QWidget for this TextureViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Buffer Viewer

class qrenderdoc.BufferViewer

The buffer viewer window, either a raw buffer or the geometry pipeline.

ScrollToColumn(column, stage)
ScrollToColumn(column) → None

Scroll to the given column in the given stage’s data.

Parameters:
  • column # (int) – the column to scroll to.
  • stage # (renderdoc.MeshDataStage) – The stage of the geometry pipeline to scroll within.
ScrollToRow(row, stage)
ScrollToRow(row) → None

Scroll to the given row in the given stage’s data.

Parameters:
  • row # (int) – the row to scroll to.
  • stage # (renderdoc.MeshDataStage) – The stage of the geometry pipeline to scroll within.
SetCurrentInstance(instance)

For a mesh view, set the current instance. This is ignored when called on a raw buffer view.

Parameters: instance # (int) – The instance to select, will be clamped to the range [0, numInstances-1]
SetCurrentView(view)

For a mesh view, set the current multiview view. This is ignored when called on a raw buffer view.

Parameters: view # (int) – The view to select, will be clamped to the range [0, numViews-1]
SetPreviewStage(stage)

For a mesh view, set the current preview stage. This is ignored when called on a raw buffer view.

Parameters: stage # (renderdoc.MeshDataStage) – The stage to show
ShowMeshData(stage)

Ensure the given stage’s data is visible and raised, if it wasn’t before.

Parameters: stage # (renderdoc.MeshDataStage) – The stage of the geometry pipeline to show data for.
Widget()

Retrieves the PySide2 QWidget for this BufferViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Resource Inspector

class qrenderdoc.ResourceInspector

The Resource inspector window.

CurrentResource()

Return which resource is currently being inspected.

Returns: The ID of the resource being inspected.
Return type: renderdoc.ResourceId
Inspect(id)

Change the current resource being inspected.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to inspect.
RevealParameter(param)

Expand the resource initialisation chunks to reveal and select a given parameter.

Parameters: param # (renderdoc.SDObject) – The parameter to reveal and select.
Widget()

Retrieves the PySide2 QWidget for this ResourceInspector if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Capture Dialog

class qrenderdoc.CaptureDialog

The executable capture window.

IsInjectMode()

Determines if the window is in inject or launch mode.

Returns: True if the window is set up for injecting.
Return type: bool
LoadSettings(filename)

Loads settings from a file and applies them. See SetSettings().

Parameters: filename # (str) – The filename to load the settings from.
SaveSettings(filename)

Saves the current settings to a file. See Settings().

Parameters: filename # (str) – The filename to save the settings to.
SetCommandLine(cmd)

Sets the command line string to use when launching an executable.

Parameters: cmd # (str) – The command line to use.
SetEnvironmentModifications(modifications)

Sets the list of environment modifications to apply when launching.

Parameters: modifications # (List[ renderdoc.EnvironmentModification ]) – The list of modifications to apply.
SetExecutableFilename(filename)

Sets the executable filename to capture.

Parameters: filename # (str) – The filename to execute.
SetInjectMode(inject)

Switches the window to or from inject mode.

Parameters: inject # (bool) – True if the window should configure for injecting into processes.
SetSettings(settings)

Configures the window based on a bulk structure of settings.

Parameters: settings # (CaptureSettings) – The settings to apply.
SetWorkingDirectory(dir)

Sets the working directory for capture.

Parameters: dir # (str) – The directory to use.
Settings()

Retrieves the current state of the window as a structure of settings.

Returns: The settings describing the current window state.
Return type: CaptureSettings
TriggerCapture()

Launches a capture of the current executable.

UpdateGlobalHook()

Update the current state of the global hook, e.g. if it has been enabled.

UpdateRemoteHost()

Update the current state based on the current remote host, when that changes.

Widget()

Retrieves the PySide2 QWidget for this CaptureDialog if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Debug Messages

class qrenderdoc.DebugMessageView

The debug warnings and errors window.

Widget()

Retrieves the PySide2 QWidget for this DebugMessageView if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Diagnostic Log

class qrenderdoc.DiagnosticLogView

The diagnostic log viewing window.

Widget()

Retrieves the PySide2 QWidget for this DiagnosticLogView if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Comment View

class qrenderdoc.CommentView

The capture comments window.

GetComments()

Gets the current comments text.

Returns: The current comments text.
Return type: str
SetComments(text)

Sets the current comments text.

Parameters: text # (str) – The new comments text.
Widget()

Retrieves the PySide2 QWidget for this CommentView if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Statistics Viewer

class qrenderdoc.StatisticsViewer

The statistics window.

Widget()

Retrieves the PySide2 QWidget for this StatisticsViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Timeline Bar

class qrenderdoc.TimelineBar

The timeline bar.

HighlightHistory(id, history)

Highlights the modifications in a frame of a given resource.

Parameters:
  • id # (renderdoc.ResourceId) – The ID of the resource that is being modified.
  • history # (List[ renderdoc.PixelModification ]) – A list of pixel events to display.
HighlightResourceUsage(id)

Highlights the frame usage of the specified resource.

Parameters: id # (renderdoc.ResourceId) – The ID of the resource to highlight.
Widget()

Retrieves the PySide2 QWidget for this TimelineBar if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Performance Counter Viewer

class qrenderdoc.PerformanceCounterViewer

The performance counter view window.

UpdateDurationColumn()

Updates duration columns if the selected time unit changes.

Widget()

Retrieves the PySide2 QWidget for this PerformanceCounterViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Python Shell

class qrenderdoc.PythonShell

The interactive python shell.

GetScriptText()

Returns the current script text.

Returns: The current script text.
Return type: str
LoadScriptFromFilename(filename)

Sets the current script in the python shell to the contents of the given file.

Parameters: filename # (str) – The filename of the script to load.
Returns: Whether or not the script was successfully loaded.
Return type: bool
RunScript()

Runs the current script in the python shell.

SetScriptText(script)

Sets the current script in the python shell to the given string.

Parameters: script # (str) – The text of the script to set.
Widget()

Retrieves the PySide2 QWidget for this PythonShell if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Shader Viewer

class qrenderdoc.ShaderViewer

A shader window used for viewing, editing, or debugging.

SaveCallback(context, viewer, encoding, flags, entry, compiled)

Not a member function - the signature for any SaveCallback callbacks.

Called whenever a shader viewer that was open for editing triggers a save/update.

Parameters:
  • context (CaptureContext) – The current capture context.
  • viewer (ShaderViewer) – The open shader viewer.
  • id (renderdoc.ResourceId) – The id of the shader being replaced.
  • stage (renderdoc.ShaderStage) – The shader stage of the shader being replaced.
  • encoding (renderdoc.ShaderEncoding) – The encoding of the files being passed.
  • flags (renderdoc.ShaderCompileFlags) – The flags to use during compilation.
  • entryFunc (str) – The name of the entry point.
  • source (bytes) – The byte buffer containing the source - may just be text depending on the encoding.
RevertCallback(context)

Not a member function - the signature for any RevertCallback callbacks.

Called whenever a shader viewer that was open for editing is closed.

Parameters:
  • context (CaptureContext) – The current capture context.
  • viewer (ShaderViewer) – The open shader viewer.
  • id (renderdoc.ResourceId) – The id of the shader being replaced.
AddWatch(expression)

Add an expression to the watch panel.

Parameters: expression # (str) – The name of the expression to watch.
CurrentStep()

Retrieves the current step in the debugging.

Returns: The current step.
Return type: int
GetCurrentFileContents()

Return the current text of source files within the viewer. Primarily useful for returning any edits applied when editing a shader.

Returns: The current file contents as a list of (filename, contents) pairs.
Return type: List[Tuple[str,str]]
RunForward()

Runs execution forward to the next breakpoint, or the end of the trace.

SetCurrentStep(step)

Sets the current step in the debugging.

Parameters: step # (int) – The current step to jump to.
ShowErrors(errors)

Show a list of shader compilation errors or warnings.

Parameters: errors # (str) – The string of errors or warnings to display.
ToggleBreakpointOnDisassemblyLine(disassemblyLine)

Toggles a breakpoint at a given disassembly line (starting from 1).

Parameters: disassemblyLine # (int) – The line of the disassembly to toggle a breakpoint on.
ToggleBreakpointOnInstruction(instruction=-1)
ToggleBreakpointOnInstruction() → None

Toggles a breakpoint at a given instruction.

Parameters: instruction # (int) – The instruction to toggle breakpoint at. If this is -1 the nearest instruction after the current caret position is used.
Widget()

Retrieves the PySide2 QWidget for this ShaderViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Pixel History

class qrenderdoc.PixelHistoryView

A pixel history window.

SetHistory(history)

Set the history displayed in this window.

Parameters: history # (List[ renderdoc.PixelModification ]) – A list of pixel events to display.
Widget()

Retrieves the PySide2 QWidget for this PixelHistoryView if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget

Shader Message Viewer

class qrenderdoc.ShaderMessageViewer

A shader message list window.

GetEvent()

Return the EID that this viewer is displaying messages from.

Returns: The EID.
Return type: int
GetShaderMessages()

Return the shader messages displayed in this viewer.

Returns: The shader messages.
Return type: List[renderdoc.ShaderMessage]
IsOutOfDate()

Returns whether or not this viewer is out of date - if the shaders have been edited since the messages were fetched.

Returns: True if the viewer is out of date.
Return type: bool
Widget()

Retrieves the PySide2 QWidget for this ShaderMessageViewer if PySide2 is available, or otherwise returns a unique opaque pointer that can be passed back to any RenderDoc functions expecting a QWidget.

Returns: Return the widget handle, either a PySide2 handle or an opaque handle.
Return type: QWidget


Persistant Config

Contents

  • Persistant Config
    • Config
    • Shader Processing
    • Bug Reports
    • Remote Host

Config

class qrenderdoc.PersistantConfig

A persistant config file that is automatically loaded and saved, which contains any settings and information that needs to be preserved from one run to the next.

For more information about some of these settings that are user-facing see the documentation for the settings window.

AddRemoteHost(host)

Adds a new remote host.

Parameters: host # (RemoteHost) – The remote host to add.
AllowGlobalHook

True if global hooking is enabled. Since it has potentially problematic side-effects and is dangerous, it requires explicit opt-in.

Defaults to False.

AllowProcessInject

True if process injection is enabled. Since it can often break and is almost always not want users want to do. New users can get confused by it being there and go to it first.

Defaults to False.

AlwaysLoad_Extensions

A list of strings with extension packages to always load on startup, without needing manual enabling.

Type: List[str]
AlwaysReplayLocally

True if when loading a capture that was originally captured on a remote device but uses an API that can be supported locally, should be loaded locally without prompting to switch to a remote context.

Defaults to False.

Analytics_ManualCheck

True if the user has remained with analytics turned on, but has chosen to manually check each report that is sent out. collection and reporting.

Defaults to False.

Analytics_TotalOptOut

True if the user has selected to completely opt-out from and disable all analytics collection and reporting.

Defaults to False.

BufferFormatter_SavedFormats

A list of strings with saved formats for the buffer formatter. The first line is the name and the rest of the contents are the formats.

Type: List[str]
CheckUpdate_AllowChecks

True if the UI should be allowed to make update checks remotely to see if a new version is available.

Defaults to True.

CheckUpdate_CurrentVersion

The current version at the time of update checks. Used to determine if a cached pending update is no longer valid because we got updated through some other method.

CheckUpdate_LastUpdate

A date containing the last time that update checks happened.

CheckUpdate_UpdateAvailable

True if an update to a newer version is currently available.

Defaults to False.

CheckUpdate_UpdateResponse

Contains the response from the update server from the last update check, with any release notes for the new version.

Close()

Closes the config file so that subsequent calls to Save() will not write to disk at the file the config was loaded from.

This function is rarely directly used, except in the case where RenderDoc is relaunching itself and wants to avoid file locking conflicts between the closing instance saving, and the loading instance loading. It can explicitly save and close before relaunching.

Comments_ShowOnLoad

True if when loading a new capture that contains a comments section, the comment viewer will be opened and focussed.

Defaults to False.

CrashReport_EmailAddress

The saved email address for pre-filling out in crash reports.

CrashReport_EmailNagged

True if the user has been prompted to enter their email address on a crash report. This really helps find fixes for bugs, so we prompt the user once only if they didn’t enter an email. Once the prompt has happened, regardless of the answer this is set to true and remains there forever.

Defaults to False.

CrashReport_LastOpenedCapture

The last opened capture, to send if any crash is encountered. This is different to the most recent opened file, because it’s set before any processing happens (recent files are only added to the list when they successfully open), and it’s cleared again when the capture is closed.

CrashReport_ReportedBugs

A list of BugReport detailing previously submitted bugs that we’re watching for updates.

Type: List[BugReport]
CrashReport_ShouldRememberEmail

True if the email address entered in the crash reporter should be remembered for next time. If no email is entered then nothing happens (any previous saved email is kept).

Defaults to True.

DefaultCaptureSaveDirectory

The default path to save captures in, when browsing to save a temporary capture somewhere.

DefaultReplayOptions

A ReplayOptions containing the configured default replay options to use in most scenarios when no specific options are given.

Type: renderdoc.ReplayOptions
DegradedCapture_LastUpdate

A date containing the last time that the user was warned about captures being loaded in degraded support. This prevents the user being spammed if their hardware is low spec.

EventBrowser_AddFake

True if fake action marker regions should be added to captures that don’t have any markers, for easier browsing. The regions are identified by grouping actions that write to the same targets together.

Defaults to True.

EventBrowser_ApplyColors

True if the EventBrowser should apply any colors specified with API marker regions.

Defaults to True.

EventBrowser_ColorEventRow

True if when coloring marker regions in the EventBrowser, the whole row should be colored instead of just a side-bar.

Defaults to True.

EventBrowser_TimeUnit

The TimeUnit to use to display the duration column in the EventBrowser.

Defaults to microseconds.

ExternalTool_RadeonGPUProfiler

The path to the executable of the external Radeon GPU Profiler tool.

Font_Family

The font family to use in the UI.

Defaults to an empty string which means to use the system default.

Font_GlobalScale

The global scale to apply to fonts in the application, expressed as a float.

Defaults to 1.0 which means 100%.

Font_MonoFamily

The monospaced font family to use in the UI.

Defaults to an empty string which means to use the system default.

Font_PreferMonospaced

True if a monospaced font should be used in all places where data is displayed, even if the data is not tabular such as names.

Defaults to False.

Formatter_MaxFigures

The maximum number of decimal places to show in formatted floating point values.

Note

The naming of ‘MaxFigures’ is a historical artifact - this controls the number of decimal places only, not the number of significant figures.

Defaults to 5.

Formatter_MinFigures

The minimum number of decimal places to show in formatted floating point values.

Note

The naming of ‘MinFigures’ is a historical artifact - this controls the number of decimal places only, not the number of significant figures.

Defaults to 2.

Formatter_NegExp

The cut-off on negative exponents of a normalised values to display using scientific notation.

E.g. for a value of 5, anything below 1.0e-5 will be displayed using scientific notation.

Defaults to 5.

Formatter_OffsetSizeDisplayMode

The formatting mode to use for values marked as Offsets or Sizes.

E.g. Auto: decimal by default and hexadecimal if above a certain threshold, Decimal: always use decimal, Hexadecimal: always use hexadecimal. Defaults to Auto.

Formatter_PosExp

The cut-off on positive exponents of a normalised values to display using scientific notation.

E.g. for a value of 7, anything below 1.0e+7 will be displayed using scientific notation.

Defaults to 7.

GetRemoteHost(hostname)

Look up a remote host by hostname.

Parameters: hostname # (str) – The hostname to look up
Returns: The remote host for the given hostname, or an invalid RemoteHost if no such exists.
Return type: RemoteHost
GetRemoteHosts()

Returns a list of all remote hosts.

Returns: The remote host list
Return type: List[RemoteHost]
LastCaptureExe

The filename of the last executable that was captured, inside LastCapturePath.

LastCaptureFilePath

The path to the last capture to be opened, which is useful as a default location for browsing.

LastCapturePath

The path containing the last executable that was captured, which is useful as a default location for browsing.

LastFileBrowsePath

The path to the last file browsed to in any dialog. Used as a default location for all file browsers without another explicit default directory (such as opening capture files - see LastCaptureFilePath).

Load(filename)

Loads the config from a given filename. This happens automatically on startup, so it’s not recommended that you call this function manually.

Parameters: filename # (str) – The filename to load from
Returns: A boolean status if the load was successful.
Return type: bool
LocalProxyAPI

The index of the local proxy API to use when using remote context replay. -1 if the default proxy should be used.

Defaults to -1.

RecentCaptureFiles

The recently opened capture files.

Type: List[str]
RecentCaptureSettings

The recently opened capture settings files.

Type: List[str]
RemoveRemoteHost(host)

Removes an existing remote host.

Parameters: host # (RemoteHost) – The remote host to remove.
Save()

Saves the config to disk. This can happen if you want to be sure a setting has been propagated and will not be forgotten in the case of crash or otherwise unexpected exit.

Returns: A boolean status if the save was successful.
Return type: bool
SetStyle()

Sets the UI style to the value in UIStyle.

Changing the style after the application has started may not properly update everything, so to be sure the new style is applied, the application should be restarted.

Returns: True if the style was set successfully, False if there was a problem e.g. the value of UIStyle was unrecognised or empty.
Return type: bool
SetupFormatting()

Configures the Formatter class with the settings from this config.

ShaderProcessors

A list of ShaderProcessingTool detailing shader processing programs. The list comes in priority order, with earlier processors preferred over later ones.

Type: List[ShaderProcessingTool]
TemporaryCaptureDirectory

The path to where temporary capture files should be stored until they’re saved permanently.

TextureViewer_PerTexSettings

True if the TextureViewer should store most visualisation settings on a per-texture basis instead of keeping it persistent across different textures.

:Defaults to True.

TextureViewer_PerTexYFlip

True if the TextureViewer should treat y-flipping as a per-texture state rather than a global toggle.

Does nothing if per-texture settings are disabled in general.

Defaults to False.

TextureViewer_ResetRange

True if the TextureViewer should reset the visible range when a new texture is selected.

:Defaults to False.

TextureViewer_ShaderDirs

List of the directories containing custom shader files for the Texture Viewer.

Type: List[str]
Tips_HasSeenFirst

True if the user has seen the first tip, which should always be shown first before randomising.

Defaults to False.

UIStyle

The style to load for the UI. Possible values include ‘Native’, ‘RDLight’, ‘RDDark’. If empty, the closest of RDLight and RDDark will be chosen, based on the overall light-on-dark or dark-on-light theme of the application native style.

UnsupportedAndroid_LastUpdate

A date containing the last time that the user was warned about an Android device being older than is generally supported. This prevents the user being spammed if they consistently use an old Android device. If it has been more than 3 weeks since the last time an old device was seen, we re-warn the user, but if it’s less than 3 weeks we silently update this date so continuous use doesn’t nag.

UpdateEnumeratedProtocolDevices()

If configured, queries available device protocols to update auto-configured hosts.

class qrenderdoc.TimeUnit(value)

The unit that GPU durations are displayed in.

Seconds

The durations are displayed as seconds (s).

Milliseconds

The durations are displayed as milliseconds (ms).

Microseconds

The durations are displayed as microseconds (µs).

Nanoseconds

The durations are displayed as nanoseconds (ns).

class qrenderdoc.OffsetSizeDisplayMode(value)

The formatting mode used when displaying fields marked as Offsets or Sizes.

Auto

The data is displayed as decimal values by default and hexadecimal if above a certain threshold.

Decimal

The data is displayed as decimal values.

Hexadecimal

The data is displayed as hexadecimal values.

qrenderdoc.ConfigFilePath(filename)

Retrieve the absolute path where a given file can be stored with other application data.

Parameters: filename # (str) – The base filename.
Returns: The absolute path.
Return type: str
qrenderdoc.UnitSuffix(unit)

Gets the suffix for a time unit.

Parameters: unit # (TimeUnit) – The unit to get a suffix for.
Returns: The one or two character suffix.
Return type: str
qrenderdoc.AddRecentFile(recentList, file)

Checks if a given file is in a list. If it is, then it’s shuffled to the end. If it’s not then it’s added to the end

As the name suggests, this is used for tracking a ‘recent file’ list.

Parameters:
  • recentList # (List[str]) – The list that is mutated by the function.
  • file # (str) – The file to add to the list.
qrenderdoc.RemoveRecentFile(recentList, file)

Removes a given file from the list, after normalising the path. If the path isn’t present then the list is not modified.

As the name suggests, this is used for tracking a ‘recent file’ list.

Parameters:
  • recentList # (List[str]) – The list that is mutated by the function.
  • file # (str) – The file to remove from the list.

Shader Processing

class qrenderdoc.ShaderProcessingTool

Describes an external program that can be used to process shaders, typically either compiling from a high-level language to a binary format, or decompiling from the binary format to a high-level language or textual representation.

Commonly used with SPIR-V.

CompileShader(window, source, entryPoint, stage, spirvVer, args)

Runs this program to disassemble a given shader source.

Parameters:
  • window # (QWidget) – A handle to the window to use when showing a progress bar or error messages.
  • source # (str) – The source code, preprocessed into a single file.
  • entryPoint # (str) – The name of the entry point in the shader to compile.
  • stage # (renderdoc.ShaderStage) – The pipeline stage that this shader represents.
  • spirvVer # (str) – The version of SPIR-V in use for this shader, or an empty string for defaults. The current version can be obtained from reflection data via the @spirver compile flag.
  • args # (str) – arguments to pass to the tool. The default arguments can be obtained using DefaultArguments() which can then be customised as desired. Passing an empty string uses the default arguments.
Returns:

The result of running the tool.
Return type:

ShaderToolOutput
DefaultArguments()

Return the default arguments used when invoking this tool

Returns: The arguments specified for this tool.
Return type: str
DisassembleShader(window, shader, args)

Runs this program to disassemble a given shader reflection.

Parameters:
  • window # (QWidget) – A handle to the window to use when showing a progress bar or error messages.
  • shader # (renderdoc.ShaderReflection) – The shader to disassemble.
  • args # (str) – arguments to pass to the tool. The default arguments can be obtained using DefaultArguments() which can then be customised as desired. Passing an empty string uses the default arguments.
Returns:

The result of running the tool.
Return type:

ShaderToolOutput
args

The command line argmuents to pass to the program.

executable

The path to the executable to run for this program.

input

The input that this program expects.

name

The human-readable name of the program.

output

The output that this program provides.

tool

The KnownShaderTool identifying which known tool this program is.

class qrenderdoc.ShaderToolOutput

Contains the output from invoking a ShaderProcessingTool, including both the actual output data desired as well as any stdout/stderr messages.

log

The output log - containing the information about the tool run and any errors.

result

The actual output data from the tool

Bug Reports

class qrenderdoc.BugReport

Describes a submitted bug report.

URL()

Gets the URL for this report.

Returns: The URL to the report.
Return type: str
checkDate

The last date that we checked for updates.

reportId

The private ID of the bug report.

submitDate

The original date when this bug was submitted.

unreadUpdates

Unread updates to the bug exist

Remote Host

class qrenderdoc.RemoteHost

A handle for interacting with a remote server on a given host.

CheckStatus()

Ping the host to check current status - if the server is running, connection status, etc.

Connect(server)

Create a connection to the remote server.

Returns: The status of opening the capture, whether success or failure, and a RemoteServer instance if it were successful
Return type: Tuple[renderdoc.ResultDetails, renderdoc.RemoteServer]
FriendlyName()
Returns: The friendly name for this host, if available (if empty, the Hostname is used).
Return type: str
Hostname()
Returns: The hostname of this host.
Return type: str
IsBusy()
Returns: True if someone else is currently connected to this server.
Return type: bool
IsConnected()
Returns: True if an active connection exists to this remote server.
Return type: bool
IsLocalhost()
Returns: Returns True if this host represents the special localhost device.
Return type: bool
IsServerRunning()
Returns: True if a remote server is currently running on this host.
Return type: bool
IsValid()

Returns True if this host represents a valid remote host. :rtype: bool

IsVersionMismatch()
Returns: True if there is a code version mismatch with this server.
Return type: bool
LastCapturePath()
Returns: The last folder browsed to on this host, to provide a reasonable default path.
Return type: str
Launch()

Runs the command specified in runCommand. Returns ResultDetails which indicates success or the type of failure.

Returns: The result from launching the remote server.
Return type: renderdoc.ResultDetails
Name()
Returns: The name to display for this host in the UI, either FriendlyName() if it is valid, or Hostname() if not.
Return type: str
Protocol()
Returns: The DeviceProtocolController for this host, or None if no protocol is in use
Return type: renderdoc.DeviceProtocolController
RunCommand()
Returns: The command to run locally to try to launch the server remotely.
Return type: str
SetLastCapturePath(path)

Sets the last folder browsed to. See LastCapturePath().

Parameters: path # (str) – The new path to set.
SetRunCommand(cmd)

Sets the run command. See RunCommand().

Parameters: cmd # (str) – The new command to set.
VersionMismatchError()
Returns: The version mismatch error.
Return type: str


How do I …?

  • How do I capture a frame?
    • Capturing frames
    • Injecting into a Process
    • Capture settings
    • See Also
  • How do I use RenderDoc on Android?
    • Quick start
    • Avoiding timeouts on certain packages
    • Troubleshooting
  • How do I filter visible events?
    • Filter Expressions
    • Filter functions
    • Example
    • Filter settings
  • How do I debug a shader?
    • Including debug info in shaders
    • Debugging a vertex
    • Debugging a Pixel
    • Debugging a Compute thread
    • Debugging Controls
    • HLSL Debugging
    • Debugging Displays
  • How do I use shader debug information?
    • Specifying debug shader blobs
    • See Also
  • How do I inspect a pixel value?
    • Selecting appropriate subresource
    • Picking a Pixel Value
    • Pixel Context Display
    • Pixel History
    • See Also
  • How do I specify a buffer format?
    • Basic types
    • Structs
    • Enums
    • Bitfields
    • Pointers
    • Packing and layout rules
    • Annotations
    • Array of Structs (AoS) vs Struct of Arrays (SoA)
    • Saving and loading formats
    • See Also
  • How do I view a specific texture?
    • Texture list in Texture Viewer
    • Locked tab of a Texture
    • See Also
  • How do I view details of an object?
    • Viewing Shaders
    • Viewing Textures
    • Viewing Buffers
    • Viewing Constant Buffers
  • How do I capture callstacks?
    • Overview
    • Launching Capture
    • Replaying the capture
  • How do I use a custom visualisation shader?
    • Introduction
    • Predefined inputs
      • UV co-ordinates
      • Constant Parameters
      • Texture dimensions
      • Selected Mip level
      • Selected Slice/Face
      • Selected Multisample sample
      • Selected RangeMin, RangeMax
      • Current texture type
        • D3D11 or D3D12
        • OpenGL
        • Vulkan
      • Samplers
      • Resources
        • HLSL
        • GLSL
    • See Also
  • How do I edit a shader?
    • How to edit a custom shader
    • How to edit a scene shader
    • Shader processing tools
    • Using the built-in shader editor
  • How do I capture and replay over a network?
    • Overview
    • Configuring Remote Hosts
    • Switching to a Replay Context
    • Working in a remote replay context
    • Configuring the Remote Server
    • See Also
  • How do I annotate a capture?
    • Application provided marker regions
    • Application provided object names
    • Bookmarks
    • Resource Renaming
    • Capture Comments
  • How do I import or export a capture?
    • In-capture access
    • Import/Export to file
  • How do I generate an RGP profile?
    • Enabling RGP integration
    • Generating a profile
    • Opening a previously created profile
    • Correlating information between RenderDoc and RGP
  • How do I register a python extension?
    • Creating extensions
    • Enabling extensions
    • Writing extensions
  • How do I control the replay?
    • Opening a capture with options
    • Replay options
    • Changing the default options


How do I capture a frame?

Capturing frames is the starting point to using RenderDoc. Although the basic use is very simple, there are various customisations and more advanced uses. More information on these can be found in the details of the Capture Dialog window.

Capturing frames

The basic process of capturing frames is fairly straightforward.

Opening the launch application window from the menus via File → Launch Application, the typical capture setup simply requires you to enter the executable location.

By default the working directory remains empty and defaults to the directory that contains the executable location.

Capturing: Launching an executable specifying its path and command line.

Likewise, the default options generally work well for most situations, however you can look at the details of each option in Capture Dialog.

Injecting into a Process

Warning

The important thing to note about injecting is that RenderDoc can only inject to processes that have not initialised or used the target API. If this is the case RenderDoc can insert its hooks before any use of the API and work as normal. If the API has already been used or initialised the results are undefined and likely RenderDoc will simply not function as it’s too late to hook in.

Warning

Injecting into processes is generally unreliable and even if it’s done early there are cases where it can break. It is strongly recommended that this is only used as a last resort when you know there are constraints that cannot be satisfied any other way. Injection must be enabled via the settings menu and is not available by default, before enabling it consider if you can instead launch your program through RenderDoc as above which is much more reliable.

It is possible to inject to an already running process as long as it hasn’t yet initialised a graphics API. By selecting File → Inject to Process, the capture dialog will modify to list the running processes rather than asking for an executable and command line parameters.

This can be useful if launching your application from a single exe is non-trivial and it’s easier to inject into the process after it has been launched.

Injecting to a selected existing process.

Note

If RenderDoc is not running as administrator, it cannot inject into processes that are running with elevated permissions. In this case you can either run RenderDoc as administrator (not recommended unless necessary), or re-run the process as the normal user running RenderDoc.

Capture settings

Commonly in development, the capture parameters don’t change. In fact most likely the same application or couple of applications are launched in exactly the same way repeatedly as development iterates.

To make this process easier RenderDoc supports saving and loading configuration sets to a file. While on the capture dialog, click ‘Save’ to save to a .cap file which contains both the executable path, working directory and command line - as well as the options that are selected.

This .cap file can be executed when RenderDoc’s file associations are set up, and RenderDoc will load this file and present you with the capture dialog on startup.

You can also use the “Auto start” option - when this option is enabled then a .cap file will immediately launch the program when it is loaded. This can allow you to configure a .cap which will open RenderDoc and launch the target application with the pre-configured settings in one click. If you wish to disable this, just uncheck the option and re-save to the same .cap file.

See Also

  • Capture Dialog
  • How do I capture and replay over a network?


How do I use RenderDoc on Android?

RenderDoc contains support for Android for both Vulkan and OpenGL ES. It requires a couple of extra steps more than capturing on a desktop computer, but generally the workflow is very similar.

The Android device must be running at least Android 6.0.

RenderDoc requires some tools from the Android SDK to function. On windows these usually ship with the RenderDoc package, but if you are on Linux or you have trouble please see below in the Troubleshooting section about configuring your Android SDK.

Caution

For RenderDoc’s android support, your package must be installed and it must be debuggable.

Quick start

Android is supported by using Remote Contexts to debug applications on your device from a host computer. To begin, look at the bottom left of the normal RenderDoc UI to see the remote context selection dropdown:

By default when you start up, this is set to “Local” which means all capture and replay happens on the host computer. To switch to a connected android device, click the drop-down and select your device from the options:

Note

If you don’t see your android device listed, try waiting a few seconds as available devices are scanned every so often.

If it still doesn’t appear after 10 seconds, check that you have your SDK configured correctly - see below in the Troubleshooting section.

Each device listed will likely have a cross next to it, indicating that RenderDoc’s capture & replay app is not yet running on the device. Select a device, and RenderDoc will check that RenderDoc’s app is installed and run it.

Note

After the app is installed once, it will not need to be reinstalled until you update your version of RenderDoc.

Once RenderDoc’s app is running, you are ready to capture and replay on android, and the drop-down will indicate the new active connection.

You can now use the RenderDoc UI as normal, and the entire workflow is exactly the same as you are used to on desktop, except that the capture and replay will happen on the selected android device. For example, when you click browse for an executable to run, it will list the installed packages.

If your package is not debuggable, you will not generally be able to capture it with RenderDoc. Instead build a development copy of your package that has the debuggable flag. In UE4 this is done by unchecking “For Distribution” and in Unity this is done by building a “Development Mode” build.

Then once connected, you can trigger captures and open them as normal.

Avoiding timeouts on certain packages

If your package can take a long time to startup, you can go to the settings window under the Android section and increase the Max Connection Timeout.

Troubleshooting

RenderDoc assumes your device is already configured for debugging. Check that it appears in adb devices. See here for instructions on how to configure that.

If you have Android Studio open, it will interfere with RenderDoc’s debugging by attaching to the package itself. Either close it or disable adb integration in “Tools → Android → Enable ADB integration”.

RenderDoc does its best to locate or provide necessary Android tools from the Android SDK. On Windows, these tools are shipped with the distributions and all that’s required is java - either in your PATH or via the JAVA_HOME environment variable. If these tools aren’t present then RenderDoc searches through PATH and other variables like ANDROID_HOME or ANDROID_SDK_ROOT to find the SDK. If you don’t have those environment variables set, you can browse to the SDK and JDK folders in the settings window under the Android section.

If something goes wrong with these steps, please open an issue on GitHub! The process should be as smooth as possible given Android’s platform limitations, so if you encounter problems then it may well be fixable.


How do I filter visible events?

The Event Browser window allows you to browse through the frame by changing the current event, and seeing a list of events in the capture organised into a user-defined hierarchy of markers (for more information on how to provide these markers, see How do I annotate a capture?).

By default the events which are listed are those known as actions. Draws and dispatches are examples of actions, but also events that modify resources like clears and copies. State setting and other CPU-update calls like Maps are not included and are listed in the API Inspector.

With event filters you can control which events are displayed, to include or exclude them based on substrings or more complex filters.

Filter Expressions

At the most basic level filters act like a search query across all the events in a capture. If several terms are given together:

Draw Clear Copy

This will include any event that matches any one of these terms. For example DrawIndexed() and Draw() would both match Draw and so would be displayed even if they don’t match Clear or Copy. Dispatch() would be filtered out because it doesn’t match any of these terms.

You can also exclude specific terms by prefixing them with a -:

Draw Clear Copy -Depth

Which will still display DrawIndexed() and Draw() as before, as well as for example ClearColor(). However ClearDepth() would be filtered out because it matches the -Depth term.

If you don’t want to have all terms be optional, you can instead require specific terms:

+Draw +Indexed -Instanced

This requires that events must match Draw and Indexed and must not match Instanced. This means DrawIndexed() would be displayed because it satisfies all terms, but Draw() would now be filtered out because although it matches Draw it does not match Indexed. Similarly DrawIndexedInstanced() would be filtered out because while it matches both required terms, it also matches the excluded term.

Warning

If you have some required terms like this then any optional terms are completely ignored. +Draw -Instanced would match the same events as +Draw Dispatch -Instanced. This is because an event will be included only if it matches the required term and excluded if it doesn’t, there’s no room for an optional match.

This is unlike a more flexible search which can use optional terms to weight some results higher than others, since events are always listed in their explicit order.

Filters can also be nested with parentheses, for example if you wanted to require at least one of several matches:

+Draw +(Indexed Instanced) -Indirect

Which requires that events must match Draw, and must match at least one of Indexed or Instanced.

Filter functions

The examples above all used simple string matching, which can be enough for many cases but sometimes a more complex query is desired. For this reason there are filter functions, which can query properties with more flexibility.

The default filter is an example of this, the $action() filter function will match any action - draws, dispatches, copies, clears, etc.

Default Display: The Event browser with the default event filter applied.

The $action() filter function can also take parameters, for example here we will filter for only actions which are draws with over 1000 indices or vertices:

Filtered Display: The Event browser with only draws containing more than 1000 indices.

Other filter functions are available, for example $parent(...) will match events that have a given marker as a parent, so we could filter to only the draws in the scene and not in the off-screen pass:

Filtered Display: The Event browser with only draws containing more than 1000 indices underneath the ‘Render Scene’ marker.

Notice how we changed the filter to require both $action(numIndices > 1000) as well as $parent(render scene). If we didn’t, we would include all draws with 1000 vertices as well as all events under Render Scene - which isn’t what we wanted in this case.

Note

As seen above, any marker regions which don’t have any included child events (recursively) will be hidden entirely.

There are many other filter functions and it is also possible to register custom filter functions as a python extension, you can explore the available functions and their documentation in the filter settings menu.

Example

We’ll give another real world example of how to selectively include or exclude events. Starting with the same case as above:

Default Display: The Event browser with the default event filter applied.

We want to see when bindings are changed in addition to the draws. To do this we’ll add Bind as an optional term:

Actions and binds: The filter including binding calls as well as actions.

Now we can see the pipeline and vertex/index buffer binds that happened before the first drawcall. In this case there aren’t other binding changes between the later drawcalls visible.

Let’s say that we only care about buffer bindings and want to exclude the pipeline bind. We could do this by adding a -Pipeline term, but we might then have to exclude other types of bindings and that could get tedious. Instead we’ll change the bind term to (+Bind +Buffer) which will only match events that contain Bind and Buffer. Since the term itself is optional, this still means actions are included.

Note

This could be accomplished another way such as usuing a regular expression, but for the sake of example we’ll do it like this.

Actions and binds: The filter narrows to include only buffer binding calls.

Now we can see the buffer binding calls as well as the actions that we wanted. At this point we might find that the markers setting object names are a little too noisy, so we want to exclude them. Since there isn’t necessarily a common substring with these object names we can instead exclude all markers by type. Markers are a type of action, so we can match against the action flags containing the flag indicating a set marker.

Actions and binds: The final filter, excluding set markers from the previous filters.

Finally we have the filter expression matching only the events we want. We can further include/exclude events as we wish in a similar way, or we could save this filter for later in the settings window if this is a filter we will want to have available regularly.

Filter settings

The filter settings window contains an explanation of the current filter and what it matches against, as well as ways to save/load filters, and documentation for the available filter functions.

Filter settings: The filter settings window, showing the example query above explained.

At the top the filter is editable in the same way as in the main Event Browser, and once parsed it will be highlighted showing each term corresponding to the explanation in the panel below.

The filter can be saved by pressing the save Save button. By giving the filter a name you can then re-select this filter in future. Changes to filters are only applied when explicitly saving them here, if you select a filter and edit it then those changes will not be saved.

You can also export or import the whole set of filters here with the save drop-down menu. This will overwrite your current set of filters.

At the bottom there is documentation similar to here about how the filter syntax works and in particular for each of the available filter functions how they work and what parameters they support.


How do I debug a shader?

This page goes into detail about how to set up your captures for debugging shaders, as well as how to debug a shader and what controls are available.

Warning

Shader debugging is currently only supported on D3D11, D3D12, and Vulkan. On other APIs the debug options listed below will either be hidden or disabled. In addition not all shaders on those APIs can be debugged, e.g. on D3D12 only DXBC shaders can be debugged and on Vulkan only some shader extensions and capabilities are supported. If the shader cannot be debugged the options below will also be disabled.

Including debug info in shaders

For the most part at least some reflection information is included with shaders unless it is being explicitly stripped out at some point, but usually information for debugging shaders such as the original source code is not included by default.

The option to include this additional debug information varies by API.

  • For D3D11 and D3D12 the flag /Zi to fxc or the D3DCOMPILE_DEBUG flag to D3DCompile() will include additional debugging information. /Qstrip_debug and /Qstrip_reflection will remove reflection information that can be useful - such as the names of variables in constant buffers - so it’s recommended against using these. RenderDoc does fully support the new split pdb information using /Fd.

    For shader debugging it’s recommended that you build with /Od or D3DCOMPILE_SKIP_OPTIMIZATION for the best experience, as this will also enable HLSL debugging by default.

  • On Vulkan RenderDoc supports source-level debugging via the NonSemantic.Shader.DebugInfo.100 extended instruction set. This information can be generated by glslang using -gVS to specify debug information, and by dxc using -fspv-debug=vulkan-with-source. In both cases this will embed the necessary debug information in the SPIR-V blob to debug at source level.

If you are manually splitting out debug information you can see more information on how to get this information to renderdoc, see How do I use shader debug information?.

Debugging a vertex

Vertex debugging is invoked from the mesh viewer. With the mesh viewer open you can select the input vertex you wish to debug.

When a vertex is selected in the mesh data for the vertex input it will be highlighted along with the primitive it is part of in the mesh display, provided the display is in vertex input mode.

Right click and choose debug vertex from the context menu.

Vertex Debugging: Launching vertex debugging from the mesh viewer.

From here the debugger will open with the vertex shader in the shader debugger. The inputs are automatically filled in from the mesh data.

Note

Geometry and tessellation shaders are not yet debuggable.

Debugging a Pixel

Pixel debugging is launched from the texture viewer. For more details on selecting the pixel to debug see How do I inspect a pixel value?.

When a given pixel is selected you can click the history button underneath the pixel context. This will launch the Pixel History window with the selected pixel showing every modification. You can then choose to debug any of the triangles that generated a change.

If you already have the current draw selected that you want to debug, you can click the debug button to skip the pixel history and jump straight to the debugger. The inputs to the pixel will be automatically filled in.

There are a couple of things to note while pixel debugging:

  • If the draw selected doesn’t write to the pixel you have highlighted, the pixel history window will open to let you choose which draw call to debug.
  • If a draw overdraws the same pixel several times then the results of debugging will come from the last fragment that passed the depth test. If you wish to choose a particular fragment from the list then first launch the pixel history and choose which fragment to debug from the list there.

Debugging a Compute thread

To debug a compute thread simply go to the compute shader section of the pipeline state viewer and enter the group and thread ID of the thread you would like to debug. This thread will be debugged in isolation with no other threads in the group running.

This means there can be no synchronisation with any other compute thread running and the debugging will run from start to finish as if no other thread had run.

Warning

This feature is highly experimental and is provided with no guarantees yet! It may work on simple shaders which is why it is available.

Debugging Controls

When debugging, at the moment the controls are fairly basic.

Shader controls: Controls for stepping through shaders.

The toolbar at the top gives controls for the program flow through the shader.

runfwd Run and runback Run Backward simply run from the current position all the way through to the end or start of the program respectively. The keyboard shortcuts for these controls are F5 and Shift-F5 respectively.

You can set a breakpoint by pressing F9 (this will also remove a breakpoint that is already there). When running in each direction or to cursor (see below) if execution hits a breakpoint it will stop.

runsample will run to the next texture load, gather or sample operation, and stop as if a breakpoint had been placed on that instruction.

runnaninf will run to the next operation that generates either a NaN or infinity value instead of a floating point value. This will not apply to operations that produce integer results which may be NaN/infinity when interpreted as float.

stepnext Step forward will execute the current instruction and continue to the next - this includes following any flow control statements such as jumps, loops, etc.

stepprev Step backwards will jump back to whichever instruction lead to the current instruction. This does not necessarily mean the previous instruction in the program as it could be the destination of a jump. Stepping forwards and stepping backwards will always reverse each other.

The shortcuts for these commands are F10 and Shift-F10

runcursor will run to the cursor. This will perform in a similar fashion to the “Run” command, but when it reaches the line that the cursor highlights it will stop and pause execution. It will also stop if it reaches the end of the shader. The shortcut for this is Ctrl-F10

Note

The highlighted instruction at any given point indicates the next instruction to be executed - not the instruction that was just executed.

Hovering over a register in either the disassembly or in the view windows will open a tooltip showing the value in different interpretations.

There is also a toggle available to control the ‘default’ interpretation of temporary register values - float or int. D3D registers are typeless but typically they are interpreted as float values. With this toggle you can toggle them to be interpreted as integers by default instead.

HLSL Debugging

When debug information is available in the shader, RenderDoc allows debugging at the HLSL level. This is activated by default if the shader was built with optimisation disabled, but as long as debug information is available you can toggle between assembly and HLSL debugging at any time.

In the toolbar there will be a ‘Debug in HLSL’ button when HLSL debugging is available, and similarly in reverse a ‘Debug in Assembly’ button. You can also right-click and select ‘Go to Disassembly’ or ‘Go to Source’.

While source debugging, the same controls are available to set breakpoints, run forwards and backwards, etc. Note that stepping and running in HLSL may skip over several assembly instructions at once.

Debug information also includes HLSL callstack and locals mapping, which allows RenderDoc to display the function callstack at the current instruction and the name and values of any local variables that are in scope. They are displayed in the callstack and locals windows respectively.

Callstack and Locals windows.

Note

Callstack and local mapping information is only available with windows 8.0 and later versions of fxc. That corresponds to D3DCompiler_47.dll.

Debugging Displays

There are two windows that display different types of registers. The constants window will display input and constant buffer registers that are immutable throughout execution. This will also list registers for resources and samplers (with basic format information).

Constants window: Constant, input and resource registers.

The other window will contain variable/mutable registers. These contain temporaries that are typically allocated up front and will update as you step through the execution of the shader. This window also contains the output registers.

Registers window: Variable registers - temporaries and outputs.

The final window is initially empty but can be filled out as needed. This shows custom watch expressions and their values. Here you can write any expression involving an input, temporary or output register along with a swizzle and typecast. When debug information is present you can also include locals here.

Swizzles follow the standard hlsl & glsl rules - .[xyzw] or .[rgba] in any permutation or repetition will show those channels.

The custom typecast can be any of ,u ,i ,f ,x ,o ,b to display the register as unsigned integer, signed integer, float, hex, octal, or binary respectively. You can also specify ,c to specify a color value, and show a small RGB swatch next to the floating point value with the effective color.

Watch window: Watch window - custom register expressions evaluated.


How do I use shader debug information?

RenderDoc makes extensive use of shader reflection and debug information to provide a smoother debugging experience. This kind of information gives names to anything in the shader interface such as constants, resource bindings, interpolated inputs and outputs. It includes better type information that in many cases is not available, and it can also even include embedded copies of the shader source which is used for source-level debugging.

On most APIs this debug information adds up to a large amount of information which is not necessary for functionality, and so it can be optionally stripped out. Many shader compilation pipelines will do this automatically, so the information is lost by the time RenderDoc can intercept it at the API level. For this reason there are several ways to save either the unstripped shader blob or just the debug information separately at compile time and provide ways for RenderDoc to correlate the stripped blob it sees passed to the API with the debug information on disk.

If you did not deliberately strip out debug information and left it embedded in the blob, you do not need to do anything else and RenderDoc will find and use the information. If you used a compiler-based method of generating separate debug information you will at most need to specify search paths in the RenderDoc options but you do not need to follow any of these steps.

Note

OpenGL is effectively excluded from this consideration because it has no separate debug information, everything is generated from the source uploaded to the API. If the source has been stripped of information or obfuscated, this will have to be handled by your application.

Warning

Since this debug information is stored separately, it is not part of the capture and so if the debug information is moved or deleted RenderDoc will not be able to find it and the capture will show only what is possible with no debug information.

Specifying debug shader blobs

Separated debug shader blobs can be specified using a path and an API-specific mechanism, if the separation has been done manually. The path itself can either be an absolute path, which will be used directly every time, or it can be a relative path which allows the blob identifier to be specified relative to customisable search folders. If using a relative path, it can be as simple as a filename.

The search folders for shader debug info are specified in the settings window, under the Core category. You can configure as many search directories as you wish, and they will be searched in the listed order.

If no match is found after all of the directories have been tried, the first subdirectory in the path specified will be removed and the directories will be tried again in order. This way an absolute path can match if there is a trailing subset that exists in one of the configured search paths. Similarly for a relative path which has a non-matching prefix to the path but a trailing subpath that does exist.

Using the D3D11 API you can specify the path at runtime:

std::string pathName = "path/to/saved/blob.dxbc"; // path name is in UTF-8

ID3D11VertexShader *shader = ...;

// GUID value in renderdoc_app.h
GUID RENDERDOC_ShaderDebugMagicValue = RENDERDOC_ShaderDebugMagicValue_struct;

// string parameter must be NULL-terminated, and in UTF-8
shader->SetPrivateData(RENDERDOC_ShaderDebugMagicValue,
                       (UINT)pathName.length(), pathName.c_str());

You can also specify it using the Vulkan API:

std::string pathName = "path/to/saved/blob.dxbc"; // path name is in UTF-8

VkShaderModule shaderModule = ...;

// Both EXT_debug_marker and EXT_debug_utils can be used, this example uses
// EXT_debug_utils as EXT_debug_marker is deprecated
VkDebugUtilsObjectTagInfoEXT tagInfo = {VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT};
tagInfo.objectType = VK_OBJECT_TYPE_SHADER_MODULE;
tagInfo.objectHandle = (uint64_t)shaderModule;
// tag value in renderdoc_app.h
tagInfo.tagName = RENDERDOC_ShaderDebugMagicValue_truncated;
tagInfo.pTag = pathName.c_str();
tagInfo.tagSize = pathName.length();

vkSetDebugUtilsObjectTagEXT(device, &tagInfo);

D3D12 requires using a shader-compile-time specifier. This is done by passing /Fd to fxc or dxc. This switch requires a parameter which can either be a path to a file or a directory. If you specify a file, that path is then stored in the stripped blob as an absolute path. If you specify a directory the debug blob will be stored in that directory with a hash-based filename. The path stored in the stripped blob is then a relative path with just the filename.

See Also

  • How do I debug a shader?


How do I inspect a pixel value?

When in the texture viewer you can inspect the pixel values to obtain the exact contents of any pixel in the texture.

Selecting appropriate subresource

More details can be found in the Texture Viewer page, but the first step is to select the appropriate subresource - array element, cubemap face or mip slice.

The values that are picked out of the texture are always exact values, and will not be affected by the currently selected channels or range adaption control.

Picking a Pixel Value

At any point while hovering over the texture the status bar contains the current pixel location that the cursor is hovering over, as well as a basic color swatch to give some indication of where you are.

Hover Status Bar: The status bar showing position and color

When the right mouse button is pressed, the currently hovered pixel value will be displayed with the current float precision settings - for more information on how to tune these look at the window reference for the Settings Window.

For depth textures the depth and stencil values will be displayed separately. The stencil value (as with any integer formatted texture) will be displayed as an integer.

Picked Pixel: The value of a pixel that has been picked

If the right mouse button is just clicked, the picked pixel value will remain with the same value as the mouse moves. If you hold the right mouse button and drag, it will update as the mouse moves to allow some amount of refinement.

To make fine adjustments by a single pixel at a time, it’s easiest to use the arrow keys on the keyboard. Pressing these will shift the picked location by a single pixel in each direction.

Pixel Context Display

Whenever a pixel is picked, the pixel context display is updated to surround the currently selected pixel. This dialog is by default docked in the bottom right of the texture viewer, next to the thumbnail strip.

Pixel Context: The zoomed in context around the pixel currently selected

This context display shows a zoomed in view of the texture around the area that you’ve selected so that it’s easier to make small adjustments without zooming in and losing a sense of the whole texture.

The pixel context viewer can also allow you to launch pixel debugging, if the API supports it. Once a pixel is picked the button below the context is activated which will launch the shader debugger. More information about this is available: How do I debug a shader?.

It also allows you to launch a pixel history view if supported, showing every modification to this pixel in the frame up to the current point.

Pixel History

When you have a pixel selected, you can click ‘History’ to open up a pixel history view showing every modification to the selected texture from the start of the frame to the currently selected event.

This display shows each modifying event as its own row, colored as to whether any modifications happened from this event or not - green for fragments that passed all pipeline tests, red for where fragments failed some test, and light gray for arbitrary shader writable resources where it’s unknown if there was a write.

You can expand each event to see if there were multiple fragments, and see the shader output value from each fragment.

Right clicking will allow you to launch the shader debugger at the given event for the selected pixel. If you select a particular fragment or primitive, this will be the fragment that is debugged.

See Also

  • Texture Viewer


How do I specify a buffer format?

This page documents how to format buffer data, in cases where the default reflected format is missing or you want to customise it.

The format string can contain C and C++ style comments freely, but a C pre-processor is not supported.

By default the final interpreted format is defined by the list of global variables in the layout string, however if no global variables are defined the final struct to be defined is used as-if there were a single variable instance of that struct.

struct data
{
  float a;
  int b;
};

Is equivalent to

struct data
{
  float a;
  int b;
};

data d;

However note that if there are global variables, structs will not automatically be instantiated and must be declared as variables.

Basic types

Variables can be declared using familiar syntax from either GLSL or HLSL. A float would be declared as:

float myvalue;

Most common basic types are available:

  • bool - A 4-byte boolean.
  • byte, short, int, long - 1, 2, 4, and 8 byte signed integers respectively.
  • ubyte, ushort, uint, ulong - 1, 2, 4, and 8 byte unsigned integers respectively. It is also possible to prefix unsigned before a signed type.
  • half, float, double - 2, 4, and 8 byte floating point values.

These can be declared as vectors by appending the vector width. Similarly matrices can be declared by appending the vector and matrix dimensions.

GLSL declarations for float, int, and uint vectors and matrices are supported too.

float2 myvector2; // 2-vector of floats
float4 myvector4;
float2x2 mymat;   // 2x2 matrix
mat2 myGLmat;     // equivalent to float2x2
vec2 myGLvec;     // equivalent to float2

You can also declare any of these types as an array. Arrays can either have a fixed size, or an unbounded size - unbounded arrays are detailed below in the discussion of AoS vs SoA data.

float fixedArray[2];    // array of two floats
float3 unboundedArray[]; // unbounded array of float3s

Structs

Structs are declared similarly to in GLSL or HLSL, or in C.

struct MyStructName {
  float a;
  int b;
};

MyStructName str; // single instance of the struct
MyStructName arr[4]; // array of 4 instances

Structs can be nested freely, but cannot be forward declared so a struct can only reference structs defined before it.

Enums

Enums can be defined but must be defined using a base integer type to declare their size. Enum values must be literal integers, either in decimal or hexadecimal.

Values must be explicitly given, and automatic numbering or expression-based values are not supported.

enum MyEnum : uint {
  FirstValue = 5,
  HexValue = 0xf,
};

MyEnum e; // A uint will be read and interpreted as the above enum

Bitfields

Integer values can be bit-packed together using C style bitfields.

int first : 3;
int second : 5;
int third : 10;
int : 6; // anonymous values can be used to skip bits without declaring anything
int last : 8;

This declaration will read only a single 32-bit integer, and interpret the bits according to this packing.

Pointers

On APIs where GPU pointers can reside within memory, such as Vulkan, pointers can be declared with a base struct type and these will be read and interpreted from a 64-bit address in the underlying buffer.

struct MyStructName {
  float a;
  int b;
};

MyStructName *pointer;

Packing and layout rules

Graphics APIs define different rules for how data should be packed into memory, and this sometimes depends on the usage of the buffer within the API.

RenderDoc will use the most sensible default where possible - e.g. for D3D buffers that are known to be bound as constant buffers the constant buffer packing will be used, similarly for OpenGL uniform buffers using std140. However the packing can be explicitly specified and any automatic reflection-based format will declare the packing explicitly.

Once a packing format is specified, RenderDoc will calculate the necessary alignment and padding for each element to comply with the rules while otherwise tightly packing, the same as a normal shader declaration would.

The format for a buffer can be specified using #pack(packing_format). This can only be specified at global scope, not inside a structure, and the packing rules will apply for all subsequent declarations.

The five packing formats supported are:

  • cbuffer, d3dcbuffer or cb - D3D constant buffer packing.
  • structured, d3duav, or uav - D3D structured buffer packing (applies to buffer SRVs as well as UAVs).
  • std140, ubo, or gl - OpenGL std140 uniform buffer packing.
  • std430, ssbo - OpenGL std430 storage buffer packing.
  • scalar - Vulkan scalar buffer packing.

It is also possible to tweak particular packing properties with #pack(). Each property can be enabled or disabled by #pack(prop) or #pack(no_prop). Each property will relax some restrictions, so the strictest possible packing is std140 with all properties off, and the most lax packing is scalar with all properties on.

The available packing properties are:

  • vector_align_component - If enabled, vectors are only aligned to their component. If disabled, 2-vectors are aligned to 2x their component, 3-vectors and 4-vectors are aligned to 4x their components. This is disabled only for std140 and std430 by default.
  • vector_straddle_16b - If enabled, vectors are allowed to straddle 16-byte alignment boundaries. If disabled, vectors must be padded/aligned to not straddle. This is disabled only for std140, std430, and cbuffer by default.
  • tight_arrays - If enabled, arrays elements are only aligned to the element size. If disabled, each array element is aligned to a 16-byte boundary. This is disabled for std140 and cbuffer by default.
  • trailing_overlap - If enabled, elements can be placed in trailing padding from a previous element such as an array or struct. If disabled, each element’s padding is reserved and the next element must come after the padding. This disabled for std140, std430, and structured by default.

Annotations

The buffer format supports annotations on declarations to specify special properties. These use C++ [[annotation(parameter)]] syntax.

Struct definitions support the following annotations:

  • [[size(number)]] or [[byte_size(number)]] - Forces the struct to be padded up to a given size even if the contents don’t require it.
  • [[single]] or [[fixed]] - Forces the struct to be considered as a fixed SoA definition, even if in context the buffer viewer may default to AoS. See the below section for more details. Structs with this annotation may not be declared as a variable, and should instead be the implicit final struct in a definition.

Variable declarations support the following annotations:

  • [[offset(number)]] or [[byte_offset(number)]] - Forces this member to be at a given offset relative to its parent. This cannot place the member any earlier than it would have according to tight packing with the current packing rules.

  • [[pad]] or [[padding]] - Mark this member as padding, such that structure layout is calculated accounting for it but it is not displayed visibly.

  • [[single]] or [[fixed]] - Forces this variable to be considered as a fixed SoA definition, even if in context the buffer viewer may default to AoS. See the below section for more details. This must be a global variable, and it must be the only global variable in the format definition.

  • [[row_major]] or [[col_major]] - Declares the memory order for a matrix.

  • [[rgb]] - Will color the background of any repeated data by interpreting its contents as RGB color.

  • [[hex]] or [[hexadecimal]] - Will show integer data as hexadecimal.

  • [[bin]] or [[binary]] - Will show integer data as binary.

  • [[unorm]] or [[snorm]] - On 1-byte or 2-byte integer variables, will interpret them as unsigned or signed normalised data respectively.

  • [[packed(format)]] - Interprets a variable according to a standard bit-packed format. Supported formats are:

    • r11g11b10 which must be used with a float3 type.
    • r10g10b10a2 or r10g10b10a2_uint which must be used with a uint4 type. Can optionally be combined with [[unorm]] or [[snorm]].
    • r10g10b10a2_unorm which must be used with a uint4 type.
    • r10g10b10a2_snorm which must be used with a int4 type.

Array of Structs (AoS) vs Struct of Arrays (SoA)

The Buffer Viewer is capable of displaying both repeating data of a single format (AoS) as well as fixed non-repeating data (called SoA). Typically AoS is used for large buffers, where a small struct is repeated many times to form the elemnts in the buffer. SoA is used most commonly for constant buffers with a fixed amount of data, but can be used in any context. On some APIs it is possible for a buffer to contain some fixed data before the repeating data and thus it contains both types.

RenderDoc tries to use context to interpret buffer formats correctly, defaulting to AoS interpretation in cases where it is likely intended. However this can be hinted or overridden as desired.

To specify AoS data explicitly you can declare an unbounded array:

float3 unboundedArray[]; // unbounded array of float3s

When supported by the API, this can be preceeded by any fixed data in the buffer before the repeated AoS data. The buffer viewer will show both parts of the data separately, with a tree view for the fixed data and a table for the repeated data.

In the opposite direction, normally a loose collection of variables without any such unbounded array will be taken as the definition of a struct within an AoS view:

struct data
{
  float a;
  int2 b;
  float c;
};

However if the desire is to display this as a single fixed element where the fixed tree view is more appropriate, the structure or an variable of it can be annotated as [[single]] or [[fixed]].

[[single]]
struct data
{
  float a;
  int2 b;
  float c;
};

struct data
{
  float a;
  int2 b;
  float c;
};

[[single]]
data fixed_data;

This will force the struct to be displayed as a single instance, and not as a repeated AoS.

Saving and loading formats

Commonly used formats can be saved and these will be persisted from run to run.

To save the current format to an existing entry, select it and click on the save button.

To save to a new entry, either type the name directly into the New... at the bottom, double click on it to begin entering the name, or select it and click save then enter the name.

If the buffer view was opened with an automatically populated format, it will be available as a read-only <Auto-generated> entry.

Loading an entry can be accomplished by either double clicking on it, or selecting it and clicking goarrow. This will load the format and automatically apply it to the buffer view.

You can use undo/redo to undo the loading of a saved format, if you wish to go back to the previous format.

See Also

  • Buffer Viewer


How do I view a specific texture?

This page documents how to open a specific texture by name, without needing to find it via a current resource binding.

Texture list in Texture Viewer

In the texture viewer you can open a filterable list of all textures in the capture. This can be opened with the texture list icon [image]. When clicked on this will open a sidebar on the texture viewer that lists all textures.

Texture list: The sidebar showing the list of textures

This list of textures can be filtered by a custom string which will narrow the list of textures displayed, or simply by their creation flags as either a render target or a texture.

When selecting and opening one of the textures from here, a new tab is opened in the texture viewer that follows that texture.

Locked tab of a Texture

By default the tab open in the texture viewer follows whichever pipeline slot is currently selected. When a new event is selected this tab can display a new texture if the contents of that slot has changed.

If you want to follow a particular texture even as it becomes unbound or moves from output to input and vice versa, you can open a new locked tab that will stay consistently on this texture.

Texture Tabs: Default tab following pipeline slot vs Locked tab.

This can be done by locating the texture by name as above, then clicking on the entry in the list. This will open up a new tab for this texture which will not change regardless of the current pipeline state, or current event.

Opening a texture from the pipeline state viewer (How do I view details of an object?) will also open a new locked tab for the texture in question. You can also open a new locked tab by right clicking on the texture thumbnail while it is currently bound.

Opening new Tab: Opening a new locked tab for a texture.

See Also

  • How do I annotate a capture?
  • Texture Viewer


How do I view details of an object?

The pipeline state viewer allows you to view more details of given resources that are bound to the pipeline. The go arrow goarrow is a sign that more details for this resource are available.

Resources that are written in bold text with a link are clickable links that lead to the Resource Inspector with more information about a given resource.

Viewing Shaders

Each shader stage that is active on the pipeline can be expanded to see both the high-level shader language and the low-level disassembly. At the top of the pipeline stage there is a box showing the currently bound shader - by its entry point if known.

Bound Shader: Box showing the currently used shader.

Much of the information that is available from the shader is only available when debugging information is made available. More details are available separately.

Each file passed to the compiler for this the shader is shown with simple syntax highlighting, as well as the disassembly generated from the bytecode itself.

If available, the reflection data from the shader debugging information will be used in other areas of the pipeline state viewer. It will be used for naming texture slots, showing which resources that are bound are to be used in the shader, as well as showing the names of any constants that are used in the shader.

When this shader reflection information is available it will be integrated into the disassembly to make it easier to read.

Note from here you can also live-edit a shader by clicking the edit button [image].

Viewing Textures

The Texture Viewer is the primary way of viewing details of textures, so this section concerns itself with how textures are displayed in other parts of the UI, and how to open a texture in the texture viewer. More details can be found in How do I view a specific texture?.

A texture that is bound to the pipeline as a resource or output the relevant section of the pipeline will display their dimensions and format. In each place the go arrow goarrow will indicate that a new locked tab can be opened up in the texture viewer.

In addition to opening a new view of the texture, the timeline bar will also show the usage of this texture - a green triangle will indicate a place where the texture is written to, and a green triangle indicates a read operation. More details are available on the Timeline Bar page.

Viewing Buffers

When opened either from the vertex input section the pipeline state view, or from the Window menu under Mesh Viewer, the mesh viewer opens. This will show a 3D display of the mesh represented, as well as viewing the mesh buffers at different points in the pipeline. See Mesh Viewer.

Buffers bound to the pipeline can be opened as a raw buffer viewer. This will open up a view of the buffer similar to the mesh viewer, but with a customisable buffer format.

By default if the buffer is bound to the pipeline with a pre-existing structure that can be reflected from the shader then this will be the default, otherwise the default layout will be 4 32bit unsigned integers per element.

This layout can be customised by entering a format in a simple style that mimics defining a structure that outlines a single element in the buffer, for more information see How do I specify a buffer format?.

More details on this section are available on the Buffer Viewer page.

Custom Buffer Layout: Customising the layout of the buffer by defining a structure.

Note

This window supports copy and paste, so simply select the entries and ctrl-c to copy to the clipboard

Viewing Constant Buffers

Constant buffers can be viewed by clicking on their Go Arrow goarrow. This will open up a new docked section to the right of the pipeline state viewer that tracks that constant buffer slot.

Whenever this shader slot has a constant buffer in it, both the constant names and types as well as values will be displayed.

Constant Buffer: An updating preview of the contents of this constant buffer.

Note

This window supports copy and paste, so simply select the entries and ctrl-c to copy to the clipboard


How do I capture callstacks?

This page gives an overview of the callstack-capturing capability in RenderDoc, with details and important information about how to enable this.

Overview

It can be useful when tracking down problems to have an idea of where each API call came from. In any non-trivial program it’s not necessarily obvious where every single call was made, and giving a code-side callstack up to the API entry point can pinpoint errant calls that are causing problems.

Warning

On Windows the callstack gathering uses dbghelp.dll. If you’re using this dll for some other debugging functionality in your app it is highly recommended that you disable it, otherwise it can conflict and break RenderDoc’s callstack capture.

Note

Callstack gathering has a reasonable overhead during capture and can slow things down as well as cause more memory overhead. This can be mitigated with the ‘only action callstacks’ option that only lists callstacks for each action.

Launching Capture

When launching a capture (as in How do I capture a frame?) you should enable Collect callstacks. This will set RenderDoc to collect callstacks at every API entry point that will be serialised into the capture file.

Collect Callstacks: Option enabled on the capture dialog.

If you wish to save some time & overhead you can then enable Only action stacks. This will only collect callstacks when an action call is made. This can be a good-enough trade off that still gets you the information you need, at a lower cost. After this point you can run the program and capture as usual.

Replaying the capture

When the capture is loaded in RenderDoc the callstacks will be available in the API inspector. The bottom section of the dialog is a panel that can be expanded to show the callstack. Initially this section will indicate that symbols need to be resolved.

Callstack section: The callstack section expanded in API inspector.

To resolve the symbols referenced in the capture, go to the Tools menu and select Resolve Symbols. If this menu option isn’t available the callstacks did not successfully collect in the capture file.

The resolving symbols process may take some time the first few instances you use it, as it may have to download symbols from the Microsoft symbol server. Each module that is loaded in the application at the time of capture will be saved and its symbols searched for.

By default a symbol server will be used, as well as a few default locations such as the location indicated in the PE metadata (i.e. the original build location). If a pdb cannot be found you will be prompted for the location of the pdb, and this new location will then be remembered for subsequent pdbs.

PDB locate prompt: Prompt to locate a PDB that cannot be found.

If a PDB cannot be located then you have the option of permanently ignoring that PDB. This can be useful for third party libraries for which no PDB will ever be available. If you don’t ignore the PDB you will be prompted to locate it the next time you open a capture that references it.

Once the symbols have been successfully resolved the callstack section of the API inspector will contain any callstack that was collected for the given action or API call. You can select and copy any levels and paste them elsewhere if you wish.


How do I use a custom visualisation shader?

This page details how to set up a custom shader for visualisation. This can be used in the Texture Viewer to unpack or decode complex formats, or simply apply a custom complex transformation to the image beyond the default controls.

Introduction

The basic process of setting up the custom shader involves writing a shader file that will be compiled and used by RenderDoc. Note that you can use any language that is either natively accepted by the graphics API used, or any language that can be compiled to an accepted shader.

For example on D3D11 or D3D12, hlsl is the only language usable by default. On OpenGL only glsl can be used, but on Vulkan you can use glsl or use hlsl as long as a compiler is available.

There are several special global helpers that can be declared and used, which will be implemented and return values by RenderDoc. In addition there are automatic macros that can be used to bind resources and still write shaders which work on different APIs with different bindings.

Your pixel shader defines an operation that transforms the raw value from the input texture into a value that will then be displayed by the texture viewer. The usual texture viewer controls for range adaption and channels will still be available on the resulting texture.

To set up your shader, it’s recommended that you use the UI defined in the documentation for the Texture Viewer, but you can manually create a .hlsl or .glsl file in the application storage directory ( %APPDATA%/qrenderdoc/ on windows or ~/.local/share/qrenderdoc elsewhere). The file must contain an entry point main() that returns float4, and uses any of the below inputs. These shaders are loaded when RenderDoc loads a capture, and RenderDoc watches for any changes to the files (either externally or in the shader editor in RenderDoc) and automatically reloads them.

Note

Since .glsl is used for both Vulkan and OpenGL shaders, you can differentiate by the pre-defined macro VULKAN if you are writing a shader to be used for both.

Warning

Previously the custom shaders allowed more direct binding without helper functions or binding macros. These shaders will continue to work as backwards compatibility is maintained, however be aware that these bindings are API specific and so e.g. a shader written for OpenGL in glsl will not work on Vulkan unless care has been taken, or an HLSL shader between Vulkan and D3D. If portability is desired please update and use the new helpers and binding macros, or else be careful only to use custom shaders with the API they were written for.

Note

See the custom shader templates available in the contrib repository for complete examples.

Predefined inputs

There are several pre-defined inputs that can either be taken as parameters to the shader entry point, or defined as global variables with a particular name that will then be filled in. There are also definitions for the different type of input textures.

Warning

Type and capitalisation is important for these variables, so ensure you use the right declaration!

The shader editor when using the UI can be used to insert these snippets for you, with the right type and spelling. For GLSL these snippets are inserted at the top of the file just after any #version statement.

UV co-ordinates

/* HLSL */
float4 main(float4 pos : SV_Position, float4 uv : TEXCOORD0) : SV_Target0
{
  return 1;
}

/* GLSL */
layout (location = 0) in vec2 uv;

void main()
{
  // ...
}

This input is defined in HLSL as a second parameter to the shader entry point. The first defines the usual SV_Position system semantic, and the first two components of the second TEXCOORD0 parameter gives UV co-ordinates from 0 to 1 in each dimension over the size of the texture (or texture slice).

In GLSL it is bound as a vec2 input at location 0.

You can also use the auto-generated system co-ordinates - SV_Position or gl_FragCoord if you need co-ordinates in 0 to N,M for an NxM texture.

Note

You must bind these parameters like this in this order to ensure the linkage with the vertex shader matches.

Constant Parameters

There are several constant parameters available, each available via a helper function. They are detailed below with the values they contain.

Texture dimensions

uint4 RD_TexDim(); // hlsl
uvec4 RD_TexDim(); // glsl

uint4 RD_YUVDownsampleRate(); // hlsl
uvec4 RD_YUVDownsampleRate(); // vulkan glsl only
uint4 RD_YUVAChannels(); // hlsl
uvec4 RD_YUVAChannels(); // vulkan glsl only

RD_TexDim will return the following values:

  • .x Width
  • .y Height (if 2D or 3D)
  • .z Depth if 3D or array size if an array
  • .w Number of mip levels

RD_YUVDownsampleRate will return the following values:

  • .x Horizontal downsample rate. 1 for equal luma and chroma width, 2 for half rate.
  • .y Vertical downsample rate. 1 for equal luma and chroma height, 2 for half rate.
  • .z Number of planes in the input texture, 1 for packed, 2+ for planar
  • .w Number of bits per component, e.g. 8, 10 or 16.

RD_YUVAChannels will return an index indicating where each channel comes from in the source textures. The order is .x for Y, .y for U, .z for V and .w for A.

The indices for channels in the first texture in the normal 2D slot are 0, 1, 2, 3. Indices from 4 to 7 indicate channels in the second texture, and so on.

If a channel is not present, e.g. alpha is commonly not available, it will be set to 0xff == 255.

Selected Mip level

uint RD_SelectedMip(); // hlsl or glsl

This will return the selected mip level in the UI.

Selected Slice/Face

uint RD_SelectedSliceFace(); // hlsl or glsl

This variable will be filled out with the selected texture array slice (or cubemap face) in the UI.

Selected Multisample sample

int RD_SelectedSample(); // hlsl or glsl

This variable will be filled out with the selected multisample sample index as chosen in the UI. If the UI has ‘average value’ selected, this variable will be negative and with an absolute value equal to the number of samples.

So for example in a 4x MSAA texture, the valid values are 0, 1, 2, 3 to select a sample, or -4 for ‘average value’.

Selected RangeMin, RangeMax

float2 RD_SelectedRange(); // hlsl
vec2 RD_SelectedRange(); // glsl

This function will return a pair, with the current Minimum and Maximum values for the Range-selector in the Texture Viewer.

Current texture type

uint RD_TextureType(); // hlsl or glsl

This variable will be set to a given integer value, depending on the type of the current texture being displayed. This can be used to sample from the correct resource.

Note

The value varies depending on the API this shader will be used for, as each has different resource bindings. You should use the defines below to check, which will be portable across APIs

D3D11 or D3D12

  • RD_TextureType_1D - 1D texture
  • RD_TextureType_2D - 2D texture
  • RD_TextureType_3D - 3D texture
  • RD_TextureType_Depth - Depth
  • RD_TextureType_DepthStencil - Depth + Stencil
  • RD_TextureType_DepthMS - Depth (Multisampled)
  • RD_TextureType_DepthStencilMS - Depth + Stencil (Multisampled)
  • RD_TextureType_2DMS - 2D texture (Multisampled)

In all cases on D3D the bindings can be used for arrays or not, interchangeably.

OpenGL

  • RD_TextureType_1D - 1D texture
  • RD_TextureType_2D - 2D texture
  • RD_TextureType_3D - 3D texture
  • RD_TextureType_Cube - Cubemap
  • RD_TextureType_1D_Array - 1D array texture
  • RD_TextureType_2D_Array - 2D array texture
  • RD_TextureType_Cube_Array - Cube array texture
  • RD_TextureType_Rect - Rectangle texture
  • RD_TextureType_Buffer - Buffer texture
  • RD_TextureType_2DMS - 2D texture (Multisampled)
  • RD_TextureType_2DMS_Array - 2D array texture (Multisampled)

OpenGL has separate types and bindings for arrayed and non-arrayed textures.

Vulkan

  • RD_TextureType_1D - 1D texture
  • RD_TextureType_2D - 2D texture
  • RD_TextureType_3D - 3D texture
  • RD_TextureType_2DMS - 2D texture (Multisampled)

In all cases on Vulkan the bindings can be used for arrays or not, interchangeably.

Samplers

/* HLSL */
SamplerState pointSampler : register(RD_POINT_SAMPLER_BINDING);
SamplerState linearSampler : register(RD_LINEAR_SAMPLER_BINDING);

/* GLSL */
#ifdef VULKAN

layout(binding = RD_POINT_SAMPLER_BINDING) uniform sampler pointSampler;
layout(binding = RD_LINEAR_SAMPLER_BINDING) uniform sampler linearSampler;

#endif

These samplers are provided to allow you to sample from the resource as opposed to doing straight loads. Samplers are not available on OpenGL, so it is recommended to protect the glsl definitions with #ifdef VULKAN as shown.

Resources

HLSL

// Float Textures
Texture1DArray<float4> texDisplayTex1DArray : register(RD_FLOAT_1D_ARRAY_BINDING);
Texture2DArray<float4> texDisplayTex2DArray : register(RD_FLOAT_2D_ARRAY_BINDING);
Texture3D<float4> texDisplayTex3D : register(RD_FLOAT_3D_BINDING);
Texture2DMSArray<float4> texDisplayTex2DMSArray : register(RD_FLOAT_2DMS_ARRAY_BINDING);
Texture2DArray<float4> texDisplayYUVArray : register(RD_FLOAT_YUV_ARRAY_BINDING);

// only used on D3D
Texture2DArray<float2> texDisplayTexDepthArray : register(RD_FLOAT_DEPTH_ARRAY_BINDING);
Texture2DArray<uint2> texDisplayTexStencilArray : register(RD_FLOAT_STENCIL_ARRAY_BINDING);
Texture2DMSArray<float2> texDisplayTexDepthMSArray : register(RD_FLOAT_DEPTHMS_ARRAY_BINDING);
Texture2DMSArray<uint2> texDisplayTexStencilMSArray : register(RD_FLOAT_STENCILMS_ARRAY_BINDING);

// Int Textures
Texture1DArray<int4> texDisplayIntTex1DArray : register(RD_INT_1D_ARRAY_BINDING);
Texture2DArray<int4> texDisplayIntTex2DArray : register(RD_INT_2D_ARRAY_BINDING);
Texture3D<int4> texDisplayIntTex3D : register(RD_INT_3D_BINDING);
Texture2DMSArray<int4> texDisplayIntTex2DMSArray : register(RD_INT_2DMS_ARRAY_BINDING);

// Unsigned int Textures
Texture1DArray<uint4> texDisplayUIntTex1DArray : register(RD_UINT_1D_ARRAY_BINDING);
Texture2DArray<uint4> texDisplayUIntTex2DArray : register(RD_UINT_2D_ARRAY_BINDING);
Texture3D<uint4> texDisplayUIntTex3D : register(RD_UINT_3D_BINDING);
Texture2DMSArray<uint4> texDisplayUIntTex2DMSArray : register(RD_UINT_2DMS_ARRAY_BINDING);

GLSL

// Float Textures
layout (binding = RD_FLOAT_1D_ARRAY_BINDING) uniform sampler1DArray tex1DArray;
layout (binding = RD_FLOAT_2D_ARRAY_BINDING) uniform sampler2DArray tex2DArray;
layout (binding = RD_FLOAT_3D_BINDING) uniform sampler3D tex3D;
layout (binding = RD_FLOAT_2DMS_ARRAY_BINDING) uniform sampler2DMSArray tex2DMSArray;

// YUV textures only supported on vulkan
#ifdef VULKAN
layout(binding = RD_FLOAT_YUV_ARRAY_BINDING) uniform sampler2DArray texYUVArray[2];
#endif

// OpenGL has more texture types to match
#ifndef VULKAN
layout (binding = RD_FLOAT_1D_BINDING) uniform sampler1D tex1D;
layout (binding = RD_FLOAT_2D_BINDING) uniform sampler2D tex2D;
layout (binding = RD_FLOAT_CUBE_BINDING) uniform samplerCube texCube;
layout (binding = RD_FLOAT_CUBE_ARRAY_BINDING) uniform samplerCubeArray texCubeArray;
layout (binding = RD_FLOAT_RECT_BINDING) uniform sampler2DRect tex2DRect;
layout (binding = RD_FLOAT_BUFFER_BINDING) uniform samplerBuffer texBuffer;
layout (binding = RD_FLOAT_2DMS_BINDING) uniform sampler2DMS tex2DMS;
#endif

// Int Textures
layout (binding = RD_INT_1D_ARRAY_BINDING) uniform isampler1DArray texSInt1DArray;
layout (binding = RD_INT_2D_ARRAY_BINDING) uniform isampler2DArray texSInt2DArray;
layout (binding = RD_INT_3D_BINDING) uniform isampler3D texSInt3D;
layout (binding = RD_INT_2DMS_ARRAY_BINDING) uniform isampler2DMSArray texSInt2DMSArray;

#ifndef VULKAN
layout (binding = RD_INT_1D_BINDING) uniform isampler1D texSInt1D;
layout (binding = RD_INT_2D_BINDING) uniform isampler2D texSInt2D;
layout (binding = RD_INT_RECT_BINDING) uniform isampler2DRect texSInt2DRect;
layout (binding = RD_INT_BUFFER_BINDING) uniform isamplerBuffer texSIntBuffer;
layout (binding = RD_INT_2DMS_BINDING) uniform isampler2DMS texSInt2DMS;
#endif

// Unsigned int Textures
layout (binding = RD_UINT_1D_ARRAY_BINDING) uniform usampler1DArray texUInt1DArray;
layout (binding = RD_UINT_2D_ARRAY_BINDING) uniform usampler2DArray texUInt2DArray;
layout (binding = RD_UINT_3D_BINDING) uniform usampler3D texUInt3D;
layout (binding = RD_UINT_2DMS_ARRAY_BINDING) uniform usampler2DMSArray texUInt2DMSArray;

#ifndef VULKAN
layout (binding = RD_UINT_1D_BINDING) uniform usampler1D texUInt1D;
layout (binding = RD_UINT_2D_BINDING) uniform usampler2D texUInt2D;
layout (binding = RD_UINT_RECT_BINDING) uniform usampler2DRect texUInt2DRect;
layout (binding = RD_UINT_BUFFER_BINDING) uniform usamplerBuffer texUIntBuffer;
layout (binding = RD_UINT_2DMS_BINDING) uniform usampler2DMS texUInt2DMS;
#endif

These resources are bound sparsely with the appropriate type for the current texture. With a couple of exceptions there will only be one texture bound at any one time. Different APIs have different texture type matching requirements, so e.g. OpenGL has separate bindings for array and non-array texures, which will be reflected in the different RD_TextureType return values.

When a cubemap texture is bound, it is bound both to the 2D Array as well as the Cube Array. If a depth-stencil texture has both components, the relevant depth and stencil resources will both be bound at once.

To determine which resource to sample from you can use the RENDERDOC_TexType variable above.

Usually the float textures are used, but for unsigned and signed integer formats, the relevant integer resources are used.

As with the samplers, these textures are bound by slot and not by name, so while you are free to name the variables as you wish, you must bind them explicitly to the slots listed here.

Note

YUV textures may have additional planes bound as separate textures - for D3D this is texDisplayYUVArray and for Vulkan it’s texYUVArray above. Whether to use these planes or not is specified in the texture dimension variables.

See Also

  • Texture Viewer


How do I edit a shader?

This page details how to edit shaders. This applies both to custom visualisation shaders for the Texture Viewer, but can also be used to temporarily replace or edit a shader used in the actual scene.

How to edit a custom shader

Custom visualisation shaders allow you to define your own transformation on any texture you’re viewing before it is displayed. Mostly this is useful for decoding packed or custom-format data, or displaying some data in a more visually intuitive fashion.

These shaders live as files in the application storage directory ( %APPDATA%/qrenderdoc/ on windows or ~/.local/share/qrenderdoc elsewhere), and can be edited in your editor of choice, any changes saved will be reloaded. Note however that there is currently no way to see the compile warnings or errors produced when editing externally.

To edit a shader inside RenderDoc simply click the edit button [image] when you have selected your custom shader for use. This will launch a new window with the custom shader and any changes you make to this shader will be saved to the file and compiled and reflected in the texture viewer as long as you have that custom shader selected.

How to edit a scene shader

RenderDoc allows you to edit a shader used in the capture and make changes to it and see the effects in real-time.

To launch the shader editor, go to the pipeline stage you wish to change in the Pipeline State windows, and click on the edit button [image] next to the shader. If there are multiple edit options, a drop-down menu will be available - see below for more information about shader processing tools.

Any changes to the shader will affect any action using this shader, not just the currently-selected action. The changes will persist until the edit window is closed.

Shader processing tools

Each graphics API has a native shader format - for D3D11 and D3D12 this is DXBC bytecode, for Vulkan this is SPIR-V bytecode, and for OpenGL this is GLSL shader text. Additionally it’s possible for the bytecode shaders to contain embedded debug information with the original source code and compilation settings.

When editing a shader RenderDoc will display the original source if available, but otherwise it will attempt to invoke a shader processing tool to decompile the bytecode into a usable form. Multiple tools can be configured in the settings window and several for SPIR-V processing come with RenderDoc by default. If no tool is available RenderDoc displays a generated stub or default disassembly as a starting point.

Each shader tool is defined to translate from some input to some output, so for example a compiler might take HLSL and output DXBC, and a decompiler might take SPIR-V and output HLSL.

Once the edit window for a shader tool is open, the most appropriate tool to compile from the source into the API’s native format is selected, and the parameters used for compilation are populated from debug info if available. These can then be customised further.

Using the built-in shader editor

When you have launched the shader editor, the main window will be filled with the source of your shader. In here you can make edits and changes with the basic controls and syntax highlighting available with the Scintilla editor.

To compile the shader and apply your changes, either click the Apply changes button in the toolbar or press F5. This will compile the shader and apply it, any warnings and errors will be added to the errors panel below the main source.

You can choose the tool used to compile in the lower section, as well as configure any parameters to it. See above for more information about shader processing tools.

Warning

If there are errors compiling a visualisation shader, it will be removed from the texture viewer and normal RGB display will be used until you fix the error.

If there are errors compiling a shader-replacement shader, it will revert back to the original shader from the capture until the error is fixed.

In addition, when editing visualisation shaders a button will be available to insert several useful snippets for custom shaders with the pre-defined variables that can be bound. For more detail, see How do I use a custom visualisation shader?


How do I capture and replay over a network?

RenderDoc supports capture and replay over a network connection. While slightly more complicated than the default workflow of doing everything on one machine, there are a number of scenarios where this can be useful.

This is also the same mechanism used for Android capture and replay, except with built-in native support for supporting Android targets.

If you can run the minimal RenderDoc support for capturing on a target machine such as an embedded device or devkit, the bulk of the replay work can be done on an existing machine where the UI is running.

Likewise if you have a capture that you’d like to run on a different driver or hardware, you don’t have to set up a full environment to run RenderDoc, you can just run the minimal remote server.

Overview

RenderDoc’s network support has the core concept of a “Replay Context”.

By default you are in the “local” replay context. All operations happen relative to your own machine - from executables that you launch, to how replays are processed and instantiated. This is the familiar process, where you browse and launch executables on a machine and all the replaying happens locally.

To use a remote machine, you define a replay context for that machine. Everything else works exactly the same way, but executables are run on that machine and captures are replayed on that machine.

Configuring Remote Hosts

To configure a remote host, open the manager by opening the Tools menu and select Manage Remote Servers.

Remote Hosts: Configuring remote hosts for replay contexts.

This manager allows you to configure both which remote hosts are available, as well as starting and stopping the “Remote Server” on that host.

To add a new host, simply type its hostname in the hostname box and click Add. It will be added to the list of known remote hosts, and immediately a network lookup will happen to see if the remote server or any running RenderDoc-injected applications are alive.

Note

You can run multiple remote servers on a single hostname by listening on different ports and specifying that in the hostname as with hostname:12345.

At minimum, this is all you must configure. However it is recommended that you configure a command which can be run on the local machine which will remotely start the remote server on that host. The reason for this is that it allows easy capture each time with zero manual extra steps.

Remote Hosts: Configuring the properties of a remote host.

To configure such a command, enter it under the “Run Command” box and click Update. If you haven’t added the host yet, you can fill out both boxes at once and click Add. This command runs under the context of the host with the UI, and is an arbitrary command. When the remote server is needed, RenderDoc will run this command to attempt to launch it without needing any manual intervention.

The remote server can be run with the command renderdoccmd remoteserver. The exact syntax may depend on your operating system, see renderdoccmd remoteserver --help for more information, you might want to use the -d parameter to make the remote server run in the background instead of pausing interactively.

Note

If you are running on linux, it might be worth configuring the DISPLAY environment variable here - that way it will be inherited by every executable that the server runs. Otherwise you would have to configure the environment variable each time when capturing.

Warning

Note that by default the remote server listens to all private IPs, and will allow any connection from those IPs to run commands as the remote server’s user without authentication. See later in this document for configuration options to limit the vulnerability this poses.

If a run command is configured you can also manually run the server from this window, as well as shut it down. The remote server is not shut down even when the host UI closes, so the only way to shut it down are either manually from the host itself, or via this window.

An example for this for linux would be to use plink.exe and passwordless key authentication to run the command on a linux machine:

plink.exe user@host DISPLAY=:0.0 renderdoccmd remoteserver -d

Assuming that plink.exe is in PATH on the host machine, and renderdoccmd is on the host machine.

Switching to a Replay Context

Once a remote context is configured, you can switch to it in the bottom left of the status bar. This is only possible when there is no capture currently open.

Replay Context status: Switching to a remote replay context

The drop-down will show you which remote hosts you have configured are currently already running a remote server, with periodic refreshes. When a remote host is selected, RenderDoc will attempt to connect. If it fails to find an active server but a run command is configured it will execute the command to try and launch the remote server.

If you don’t have a run command configured, this is where you would need to launch the server manually. The server can be left running indefinitely until you want to stop it, as it will continue to live on after the UI closes.

Replay Context status: Status of a remote replay context

The status bar will show the current status of the replay context - whether the remote server could be reached, or if it was busy (as it can only be used for one user’s active replay context connection at a time). Likewise if the remote server unexpectedly goes away (e.g. because it was killed remotely, or due to network problems) then the status bar will show that too.

Working in a remote replay context

By and large, working in a remote replay context is designed to be transparent to the user. All the familiar operations and workflows will work as expected, perhaps with some small decrease in responsiveness that comes with a network connection’s added latency and possible lower specifications of the target system.

In the Capture Dialog window the file and directory browsing is by definition relative to the replay context you are working in. For this reason, a custom dialog is used to display the contents of the remote filesystem instead of the default system dialog for browsing the local computer.

Remote Hosts: Browsing the file system within the remote replay context

Likewise, any environment variables set will be relative to the target system’s environment and will not inherit anything from the host’s system. Specifically, the remote server is used to execute all target programs so the environment will be inherited from it.

Capture files will all be kept on the target system by default. They will only be copied back to the host machine when you explicitly save the file to a path. Otherwise they will be owned by the remote server, and cleaned up as appropriate.

Note

There is a case where temporary captures can be ‘leaked’ and not cleaned up. If you do not have a remote server run command configured and have captures left over when the program closes, there will be no way to either save or delete the temporary capture files. This doesn’t apply to deleting or saving captures while the program is still running.

The capture connection will warn you about this case and let you know when you are leaking temporary captures - you can delete them by hand if necessary, or you can switch to a replay context on that host and then you will be able to save and delete them as normal.

Note that this is the same as if a program is run locally without any connection to the UI made at all - the captures will leak with nothing left to take ownership of them. The difference is that if a connection is made, because the files are on the local machine they can be deleted or saved directly by the UI even after the program has closed.

Capture files made with a recent version of RenderDoc will store a coarse type of machine that was used at capture time, such as ‘Linux 64-bit’ or ‘Windows 32-bit’. If you have the local replay context active and the machine you are running on differs significantly from the machine that the capture was made on, the UI will prompt you to ask if you really want to replay it locally (which may or may not work depending on the API and contents of the capture), or switch to a remote context.

Remote Hosts: Prompting for remote replay of a notably different capture

Configuring the Remote Server

The remote server can be configured by a file in ~/.renderdoc or %APPDATA%/renderdoc called remoteserver.conf. This allows you to restrict which IPs can connect to the server, as well as whether execution is allowed.

To whitelist an IP range, add a line such as this:

whitelist 192.168.0.0/16

Which will allow any IP 192.168.x.x to connect. When the remote server starts, it prints the IP ranges it will allow. If no IP ranges are configured, it will by default listen to all private ranges - 10.0.0.0/24, 192.168.0.0/16, and 172.16.0.0/12.

To prevent the server from ever executing any commands regardless of whether the IP is allowed, add a line such as this:

noexec

This will prevent any execution from happening under any circumstances. Note that if you do this, you will have to launch renderdoc-injected commands another way and the workflow described in this document will not work as-is.

The file also allows blank lines and comments beginning with #.

See Also

  • Capture Connection
  • Capture Dialog


How do I annotate a capture?

RenderDoc allows annotation of captures in two ways - annotations that you provide from your application along with the other graphics API calls that you make, and annotations that are made in the UI while analysing a capture and can be saved with it.

The annotations provided with the graphics API calls from your application vary by the particular API and are documented below.

Annotations made in the UI are also described below. These can be useful for example when investigating a bug or repro case and passing on your findings natively to someone else, instead of having to include additional text like ‘texture 148 is the buggy texture’ you can directly mark up the capture.

All of the UI modifications can be saved with a capture. Pressing Ctrl-S or File → Save will save the capture with any changes that have been made to it in the UI. If you haven’t already saved a temporary capture, or the capture is on a remote context, this will need to you save it to a local path.

Application provided marker regions

When calling graphics API functions from your code you can provide annotations to group regions of the frame under names, with a nested hierarchy.

These markers are provided in an API specific way: D3D11 uses the D3DPERF or ID3DUserDefinedAnnotation APIs, D3D12 uses SetMarker/BeginEvent/EndEvent on lists or queues, OpenGL has many extensions but KHR_debug is guaranteed to always be available, and Vulkan uses VK_EXT_debug_utils.

In APIs such as D3D12 and Vulkan with queues and command buffers, the markers are processed in submission order and are allowed to cross primary command buffers, so a single region can cross several command buffers. Secondary command buffers or bundles can contain markers but they must be self-contained and not imbalanced.

Some of the APIs add the ability to provide a colour for a marker region, these colours are displayed in the Event Browser window.

Marker Regions: The Event browser showing several coloured marker regions.

Example code for D3D11:

// The ``D3DPERF`` APIs are exported by ``d3d9.dll``, but can still be used in D3D11
// for compatibility reasons

D3DPERF_BeginEvent(0xffffffff, L"Start of example");

D3DPERF_BeginEvent(0xff00ff00, L"Sub section");
// events inside the subsection
D3DPERF_EndEvent();

// events outside the subsection
D3DPERF_EndEvent();

// the newer ID3DUserDefinedAnnotation API is also supported
ID3DUserDefinedAnnotation *annot;
immediateContext->QueryInterface(__uuidof(ID3DUserDefinedAnnotation), (void **)&annot);

annot->BeginEvent(L"Sub section 2")

annot->EndEvent();

Example code for D3D12:

// 1 for the first parameter means the data is an ANSI string. Pass 0 for a wchar string.
// the length should include the NULL terminator
list->BeginEvent(1, "Begin Section", sizeof("Begin Section"));

list->EndEvent();

// queue-level markers can be provided similarly.

Example code for OpenGL using the KHR_debug extension. Many other extensions exist in GL to provide markers and will be made available by RenderDoc too.

// omitted code to initialise the extension function pointers

glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION, 0, -1, "Begin Section");

// contents of section here

glPopDebugGroupKHR();

Example code for Vulkan using the VK_EXT_debug_utils extension:

// omitted code to initialise the extension

VkCommandBuffer cmd = ...;

VkDebugUtilsLabelEXT markerInfo = {};
markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
markerInfo.pLabelName = "Begin Section";
vkCmdBeginDebugUtilsLabelEXT(cmd, &markerInfo);

// contents of section here

vkCmdEndDebugUtilsLabelEXT(cmd);

// queue-level markers can be provided similarly.

Application provided object names

Similar to the marker regions above, it is possible to give objects names via the graphics APIs and they will be displayed with those human-readable names instead of auto-generated names.

When a resource with a custom name is bound to the pipeline it will be listed like so:

Named Texture: The example texture bound with name displayed.

In a similar way any other resource can be named and this will be useful throughout the rest of the analysis. If a custom name is not provided, a default name will be generated - as seen above with the Render Pass and Framebuffer objects.

Again the exact method varies by API, as given in the examples below.

Note

RenderDoc does not support names that change within a capture. A resource only has one name, which is the most recent one set.

Example code for D3D11 using the SetPrivateData function:

// Creating an example resource - a 2D Texture.
ID3D11Texture2D *tex2d = NULL;
d3dDevice->CreateTexture2D(&descriptor, NULL, &tex2d);

// Give the texture a useful name
tex2d->SetPrivateData(WKPDID_D3DDebugObjectName, sizeof("Example Texture"), "Example Texture");

With D3D12 you can use the SetName function:

// Creating an example resource - a 2D Texture.
ID3D12Resource *tex2d = NULL;
d3dDevice->CreateCommittedResource(&heapProps, heapFlags, &descriptor, initState, &clearValue, __uuidof(ID3D12Resource), (void **)&tex2d);

// Give the texture a useful name
tex2d->SetName(L"Example Texture");

In OpenGL this can be done with GL_KHR_debug with the function glObjectLabel.

// Creating an example resource - a 2D Texture.
GLuint tex2d = 0;
glGenTextures(1, &tex2d);
glBindTexture(GL_TEXTURE_2D, tex2d);

// apply the name, -1 means NULL terminated
glObjectLabel(GL_TEXTURE, tex2d, -1, "Example Texture");

In Vulkan you can enable the VK_EXT_debug_utils extension, which is provided by RenderDoc, and use the vkSetDebugUtilsObjectNameEXT function.

// create the image
VkImage tex2d;
vkCreateImage(device, &createInfo, NULL, &tex2d);

// set the name
VkDebugUtilsObjectNameInfoEXT nameInfo = {};
nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
nameInfo.objectType = VK_OBJECT_TYPE_IMAGE;
nameInfo.objectHandle = (uint64_t)tex2d; // this cast may vary by platform/compiler
nameInfo.pObjectName = "Off-screen color framebuffer";
vkSetDebugUtilsObjectNameEXT(device, &nameInfo);

Bookmarks

The event browser allows you to make bookmarks on events of particular interest. This allows quick navigation of a frame or jumping back and forth between two events that may be quite separated.

The [image] bookmark button will allow you to bookmark an event, the shortcut key is Ctrl-B. Once you have several bookmarks, you can jump between them by pressing the Ctrl-1 to Ctrl-0 shortcuts from anywhere in the UI, without any need to focus the event browser.

Bookmarks bar: The bookmarks bar with several EIDs bookmarks.

When loading any capture with saved bookmarks they will be automatically populated into the UI. This will allow you to highlight particular problematic events and anyone opening the capture will be able to use the shortcuts above to jump immediately to where the problem is.

Resource Renaming

From within the Resource Inspector window, you can rename any resource in the capture. Whether the resource already had a custom-specified name, or if it had a default-generated name, you can provide overrides at any time.

To do so, simply select the resource in question in the resource inspector - either by clicking a link from where it is bound, or searching for it by name or type. Then click on the Rename Resource button next to the name, and it will open an editing textbox to let you change the name. When you’ve set the name, press Enter or click Rename Resource again. To cancel a rename, press Escape or click Reset name to restore the name to its original value.

Resource Inspector: Renaming a resource in a capture.

As with bookmarks, these renames can be saved with a capture and are automatically used when loading the capture subsequently. This can be useful to point the way to which resources are causing problems, or specifically how a given resource with a more general name is being used in this particular capture.

Capture Comments

In the Capture Comments window there is a simple text field allowing you to store any arbitrary text you want within the capture. This could be notes on the environment or build version that was stored.

By default, any capture that is newly opened that contains comments will show those comments first and foremost when opening. This behaviour can be disabled in the Settings Window.


How do I import or export a capture?

RenderDoc capture files are in an opaque format containing all of the data needed to construct every API object used in a capture, and then replay the captured frame.

The data is known internally as structured data and it can be examined in memory while a capture is opened, and exported to an external file in another format. Similarly, if the external file format contains the full set of data required then it can be imported as a RenderDoc capture.

In-capture access

The structured data is available through the python scripting. As an example, we look at one function call from a capture:

First we obtain the APIEvent that we want to examine, as the last event in an action’s list of events and find the chunk index it refers to:

event = pyrenderdoc.GetAction(111).events[-1]
print("event %d is at chunk %d" % (event.eventId, event.chunkIndex))

> event 111 is at chunk 223

The structured data is organised as one chunk per function call or logical unit of work, so in this case we can obtain the chunk corresponding to the function call we’re interested in.

Once we have the chunk, we can examine its members:

chunk = pyrenderdoc.GetStructuredFile().chunks[event.chunkIndex]

print("We have chunk '%s'" % chunk.name)

for child in chunk.data.children:
    print("Parameter %s" % child.name)

> Parameter commandBuffer
> Parameter RenderPassBegin
> Parameter contents
> Parameter DebugMessages

From here we can drill down even further to iterate into struct members, arrays, and all the way down to basic types.

Import/Export to file

RenderDoc offers several built-in file formats for export. Not all of these export the full set of data that can then be re-imported, some only export a certain subset.

One format that shows the full set of data is the XML exporter. There are two options - XML only, which is quick to export as it writes only the structured data, and XML+ZIP which is slower as it also exports the large buffers of data with things like texture and buffer contents.

The XML+ZIP format contains all of the data needed to construct a RenderDoc capture, and so it can also be imported from a file and loaded as a capture.

An example of the above function call exported as XML is here below:

<chunk id="1045" name="vkCmdBeginRenderPass" length="69" threadID="17140" timestamp="865021" duration="6">
  <ResourceId name="commandBuffer" typename="VkCommandBuffer" width="8" string="ResourceId::146">146</ResourceId>
  <struct name="RenderPassBegin" typename="VkRenderPassBeginInfo">
    <enum name="sType" typename="VkStructureType" string="VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO">43</enum>
    <null name="pNext" typename="VkGenericStruct" />
    <ResourceId name="renderPass" typename="VkRenderPass" width="8" string="ResourceId::158">158</ResourceId>
    <ResourceId name="framebuffer" typename="VkFramebuffer" width="8" string="ResourceId::130">130</ResourceId>
    <struct name="renderArea" typename="VkRect2D">
      <struct name="offset" typename="VkOffset2D">
        <int name="x" typename="int32_t" width="4">0</int>
        <int name="y" typename="int32_t" width="4">0</int>
      </struct>
      <struct name="extent" typename="VkExtent2D">
        <uint name="width" typename="uint32_t" width="4">1280</uint>
        <uint name="height" typename="uint32_t" width="4">720</uint>
      </struct>
    </struct>
    <uint name="clearValueCount" typename="uint32_t" width="4">0</uint>
    <array name="pClearValues" typename="VkClearValue" />
  </struct>
  <enum name="contents" typename="VkSubpassContents" string="VK_SUBPASS_CONTENTS_INLINE">0</enum>
  <array name="DebugMessages" typename="DebugMessage" hidden="true" />
</chunk>


How do I generate an RGP profile?

RenderDoc has integration with AMD’s Radeon GPU Profiler. This allows you to generate an RGP profile from a RenderDoc capture, embed the profile in the capture file, and synchronise the view of the frames between RenderDoc and RGP.

Enabling RGP integration

By default the RGP integration is disabled. To enable it go to the Settings window and in the Core section enable Enable Radeon GPU Profiler integration.

Generating a profile

To begin you will need to go to the Tools menu and select Create new RGP Profile. If this menu option isn’t available, you need to have the latest AMD drivers installed on your machine.

Selecting this menu item will open a small popup and spend a few second creating the profile itself. After the profile is created, the RGP profiling tool will automatically open up.

Note

If you haven’t configured the path to the RGP tool, you will be prompted to here. Once the path has been configured successfully the tool will open.

Opening a previously created profile

After generating a profile above, the RGP data is embedded in the .rdc file.

Since RGP can open a profile on any machine without needing AMD drivers or hardware, this embedded RGP profile can be opened at any time by going to the Tools menu and select Open RGP Profile.

The RGP tool will open just the same as if the profile was newly created.

Correlating information between RenderDoc and RGP

If using RGP version 1.2 or higher, once both tools are open they have a synchronised view of the underlying data.

This means that within RGP you can select an event, right click and choose Select RenderDoc Event. This will bring RenderDoc to the foreground with the event selected. Similarly in RenderDoc you can right-click on an event in the event browser and choose Select RGP Event which will perform the same operation in reverse.

Select an RGP event from RenderDoc

Select a RenderDoc event from RGP

Note

Since RGP and RenderDoc have different scopes, purposes, and views of the frame the numbering of events will not be the same between the two tools.


How do I register a python extension?

RenderDoc supports python extensions using the existing python API. These extensions can be configured to be persistent and load whenever the RenderDoc UI does, allowing users to extend the program with custom functionality.

Example extensions can be found at the community contributed repository. More information on writing an extension is available at Writing UI extensions.

Creating extensions

Extensions are simply python modules located in the user’s RenderDoc config folder, with a json manifest. The config folder varies by platform, on Windows it’s %APPDATA%\qrenderdoc\extensions and on linux it’s ~/.local/share/qrenderdoc/extensions. Each extension is a python module subfolder under this root. You can nest subfolders, e.g. extensions/foo/bar/first would be the extension foo.bar.first, and treated independently from extensions/foo/bar/second.

Next to each python module’s __init__.py you should create a file extension.json following this template:

{
    "extension_api": 1,
    "name": "Extension name for users",
    "version": "1.0",
    "minimum_renderdoc": "1.2",
    "description": "A longer description of your extension.\n\nIt can contain multiple lines",
    "author": "Your name <your@email.com>",
    "url": "url/to/repository"
}

In this JSON the extension_api field is currently fixed to 1.

The minimum_renderdoc field controls whether the extension can be enabled on a given RenderDoc version, and allows you to block incompatible versions of RenderDoc.

The name, description, version, author and url fields are all informational and presented to users when listing installed extensions.

Without this json manifest the extension will not be enumerated by RenderDoc and displayed to users.

Enabling extensions

To configure installed extensions, open the extension manager by opening the Tools menu and select Manage Extensions.

Extension Manager: Configures installed extensions.

From here a list of all installed extensions is presented. By default extensions are not loaded, to load an extension either select it and press Load or else tick the box in the Loaded column in the list. As with python modules, once loaded an extension cannot be unloaded until the program is restarted.

Once an extension is loaded to enable it permanently, tick the Always Load checkbox when the extension is selected. Once enabled this means the extension will always load when the UI starts without any user interaction. Extensions must be loaded first to ensure they can load without errors or crashes before enabling them to load at startup.

A loaded extension can be reloaded by pressing the Reload button which will attempt to unload and load the extension again to refresh the code. This may break so if you encounter any problems it’s recommended that you restart the program to ensure a clean reload.

Writing extensions

A python extension when loaded will have a register function called in its module, and such a function must exist at global scope. It’s defined like so for Extension API v1:

def register(version, pyrenderdoc):
    # version is the RenderDoc Major.Minor version as a string, such as "1.2"
    # pyrenderdoc is the CaptureContext handle, the same as the global available in the python shell

Optionally you can define an unregister function to be called if the extension is reloaded. This takes no parameters and is simply an opportunity to clean-up or remove anything persistent that shouldn’t hang around, before register is called again.

Extensions use the full python API with all of the power that comes with it. There are interfaces geared specifically towards extensions in the qrenderdoc module which allow registering callbacks for menu items.


How do I control the replay?

RenderDoc works by capturing a frame and all resources used in it, and then replaying them with introspection and analysis of the replayed commands.

The default replay works well for the large majority of cases, but there are some fine controls that can be useful. This page details how to change those options.

Opening a capture with options

When a capture is opened it normally opens with the default replay options. To change those options when loading a single capture you can use Open Capture with Options from the File menu.

This brings up a window that allows you to select the file (recent files are automatically populated with the most recent selected by default) and configure the settings.

Replay options

Use API Validation on replay Default: Disabled

Normally RenderDoc enables API validation during capture and saves any messages seen. That is the most reliable way to get API validation messages as there is a minimum of other work going on.

However if the capture was made without API validation enabled, this option allows you to instead get API validation messages from the first load of the capture. These will be visible in the Debug Messages window.

Note

Due to the heavier amount of analysis work happening during replay it is possible that some different or false-positive validation messages may come through. The best solution is always to use API validation on your program without RenderDoc running at all, since RenderDoc doesn’t handle all invalid API use, but if that is not possible you should prefer to enable validation at capture time.

GPU Selection Override Default: Default GPU selection

By default RenderDoc will try to select the closest GPU on replay to the one used in the capture. When the Default GPU selection entry is selected this algorithm is left to behave as normal.

The other entries in the list are the unique GPUs available on the system, together with the APIs they are available on. Some GPUs - such as the virtual WARP GPU for D3D - may not be available on all APIs.

If the overridden GPU is not available for a given capture, then the default selection algorithm will be used. However if the overridden GPU is available and fails to open the capture then the replay will fail - there is no attempt to fall back to a default GPU in that case.

Replay optimisation level Default: Balanced

RenderDoc’s replay contains some trade-offs between correctness and performance. This selection allows you to choose how far along that scale to go.

No Optimisation will disable all optimisations, which may be useful for isolating RenderDoc bugs.

Conservative will make some optimisations which should be invisible and undetectable to the user.

Balanced will make more optimisations which may be detectable but with a minor impact. Generally this will mean optimising out data or redundant behaviour which has no effect on the final replayed frame - for example clearing render targets where their contents can never be read by the commands in the frame, instead of restoring the contents from previous frames.

Fastest will make even more optimisations which may lead to confusing or ‘impossible’ data in the analysis. For example in the above case this would not even clear the render target meaning that data from later in the frame could leak back and be visible when selecting events earlier in the frame before the render target’s first use. This option will not sacrifice ultimate correctness, such that the final frame results will still be correct, however inspecting intermediate data may diverge from ground truth.

Note

Not all APIs are able to optimise to the same degree, so this option may not do anything or may do less on some APIs.

Changing the default options

In the Settings window under the Replay section you will see the same options available to allow you to change the options used globally whenever a capture is opened without specific replay options chosen.


Window reference

  • Texture Viewer
    • Overview
    • Main Texture Display
    • Information Status Bar
    • Thumbnail Strips
    • Pixel Context Display
    • Visible Range Control
    • Toolbar
      • Channels selector
      • Gamma display of Linear Data
      • Alpha background
      • Subresource selection
      • Save Texture
      • Open Texture List
      • View Texture as Buffer
      • Goto Location
      • Open Resource Inspector
      • Zoom Controls
      • Flip Y
      • Render Overlay
    • See Also
  • API Inspector
    • UI Elements
    • API Calls
    • Callstack
  • Mesh Viewer
    • Flycam controls
    • Mesh Preview
  • Buffer Viewer
    • Navigation
    • Exporting and display
    • See Also
  • Capture Dialog
    • Capturing
    • Inject into Process
    • Capture Options
    • Child Processes
    • Global Process Hook
    • See Also
  • Event Browser
    • Annotating your frame
    • Filtering displayed events
    • Event display
    • Selecting available columns
    • Timing actions
    • Browsing the frame
    • Bookmarks
    • Searching and Jumping
    • See Also
  • Settings Window
    • General options
    • Core options
    • Replay options
    • Texture Viewer options
    • Shader Viewer options
    • Event Browser options
    • Comments options
    • Android options
  • Pipeline State
    • Pipeline flowchart
    • Pipeline Section Display
    • See Also
  • Shader Viewer
    • Overview
  • Shader Messages
    • Adding shader prints
    • Fetching shader messages
    • Shader Messages
    • Shader Edits
  • Timeline Bar
    • Introduction
    • Timeline Display
    • Resource usage Display
    • Pixel history event Display
  • Capture Connection
    • Attaching to an existing instance
    • Capture Connection window
    • Child Processes
    • See Also
  • Debug Messages
    • Capturing with debug messages included
    • Debug Messages
  • Python Shell
    • Overview
    • See Also
  • Resource Inspector
    • Related Resources
    • Usage in Frame
    • Resource Initialisation Parameters
    • Renaming resources
  • Performance Counter Viewer
    • Counter selection
    • Counter Results
    • Hardware Counters
  • Capture Comments


Texture Viewer

The texture viewer is likely the most intuitive window in RenderDoc and commonly the most regularly used. It displays the contents of any texture in its current state at the given event, as well as providing controls to adjust and inspect it in different ways.

Overview

The texture viewer consists of a couple of different sections, which will be outlined here.

Several specific techniques or features used within the texture viewer have their own separate pages that go into more detail. You might find more useful information there if they cover what you are looking for:

  • How do I view a specific texture?
  • How do I inspect a pixel value?
  • How do I use a custom visualisation shader?

Texture Viewer: A labelled diagram showing the different parts of the texture viewer.

Main Texture Display

The main texture display takes up the largest portion of the window, and is simply a container for the textures to display.

It is a tabbed control, and the first tab is always present showing a particular texture slot on the current pipeline state such as an input texture, or the color/depth outputs. Other locked tabs can be opened up showing a single resource. More details are available on the page How do I view a specific texture?.

The mouse wheel can be used to zoom in and out of the texture. When zoomed in, holding the left mouse button and dragging will pan the image from side to side.

While over the image the status bar will show the current pixel that the mouse is over. Clicking or holding the right mouse button will pick this pixel and show its information in the status bar. More information is available on the page How do I inspect a pixel value?.

Information Status Bar

The status bar below the main texture display contains information on the currently visible texture.

  • The name (if available - if not an auto-generated name will be used).
  • Dimensions - Width, height, depth and array size as applicable.
  • Mip Count.
  • MSAA sample count and quality, if applicable.
  • Format - e.g. RGBA8_UNORM.

After this information there are a few displays that are pixel-based. The pixel that is under the cursor is displayed as a color swatch, followed by its co-ordinates. Then any picked pixel is displayed afterwards with its numeric value displayed.

Picked Pixels: Detailed information about the current pixel.

Thumbnail Strips

There are several thumbnail strip panels available, by default they are docked in the same location such that they are tabbed together, but they can be displayed side by side.

These strips display thumbnails of the resources bound to their respective parts of the pipeline, to give some context and allow quick preview without having to switch the main display between these textures.

The texture that the following tab is currently displaying is highlighted in red, and each thumbnail shows both the slot number and the name of the texture bound at that point. To follow a given slot simply left click on it. If the currently followed texture slot is empty (i.e. it was following a texture and then that slot became unbound in a different action) it will show up simply named “Unbound” and with no name or slot number.

Each thumbnail has a context menu available via right click. This menu allows you to open a locked tab (How do I view a specific texture?), jump to the resource inspector, as well as containing a list of all the uses of this texture - as read-only resource and writable output. This is similar to the resource display strip on the Timeline Bar. Clicking on any of these entries will jump to the first of the events in the event range listed.

Thumbnail Menu: Thumbnail context menu with several options.

Pixel Context Display

The Pixel context display is a small panel by default in the bottom right of the texture viewer.

Whenever a pixel is picked small area of the texture around it is rendered at maximum zoom to this panel. This gives you some context for the pixels nearby to the one you’re picking and allows fine refinement without needing to zoom in and lose your place in the overall image.

You can adjust the selected pixel with the arrow keys on your keyboard after picking, using this context to guide your selection.

Pixel context: Pixel context displaying the surrounds of the picked pixel.

From here, once you have selected a pixel, you can also launch the pixel debugger if you have the draw that you want to debug selected. You can also launch the Pixel History view which shows all modifications that have happened to the texture since the start of the frame to the currently selected event.

Visible Range Control

The visible range or range adaption control is very useful in easing display and inspection of images with a very narrow range of values, and is necessary for viewing any HDR images as it can be used to map a larger range down to LDR for display.

Range control: The range control narrowing the visible range mapped to [0,1] on output.

The primary controls are the black point and white point. These are shown in two text boxes at either side of the main range control. These are the current absolute black and white values - these values in the input texture are mapped to 0 and 1 respectively on output.

The range control itself has a black point and a white point that can be adjusted simply by clicking and dragging. These allow finer and more interactive adjustments. These handle only allow you to adjust the extremes within the range defined by the absolute black and white points in the text box.

There are four other buttons available for control of the range:

  • zoom Zoom in - This button will zoom the extreme values in to whichever fine values have been selected by the draggable handles.

    This is primarily useful when starting from some large range and using the handles to drag down to a more reasonable range, you can click zoom to then reduce the range down to just the one selected, so you can again get fine control.

    Before: The range control before zooming.

    After: The range control after zooming.

  • wand Autofit - This button automatically fits the range control to the min and max values in any visible channels in the texture. Oftentimes this is a good starting point for a range, although with some extreme textures it may adjust badly.

    Right clicking on this button will cause it to always auto-fit until you disable this. i.e. when you move to another event or another texture, the range will be auto-fit again. This is useful if jumping between events or textures where the visible ranges are very different.

  • Reset - Simply resets the range back to the default of [0, 1] - useful for resetting after changing to a new texture where the range settings aren’t applicable.

  • Histogram - This is a toggle switch. When enabled it will change the thin bar of the range control into a thicker bar that contains a range-value histogram, showing the distribution of values.

    The histogram is based on the straight numerical mean of all visible channels, and will update as the white and black points move.

    Values Histogram: A histogram showing the range distribution of values in the image.

Toolbar

The toolbar contains most of the tools for selecting which mip, slice, face of a texture to view as well as how to display it and if any transformations or overlays should be applied.

Note

The channel selection, and mip/slice selection, are stored by default as a per-texture state. In other words if you display a render target with only the alpha channel visible, then switching to view another texture will default back to RGB - and switching back to that render target will view alpha again.

Also visible range/range adaption control is detailed in the section above and will not be covered here.

Channels selector

RGBAChannels Default RGBA channels
RGBMChannels RGBM mode
YUVADecodeChannels YUVA Decode to RGBA
CustomDisplay Custom Shader mode

This selector switches between displaying standard RGBA channels, RGBM encoding with a custom multiplier and using a custom visualiser shader.

When in RGBA mode, by default only the RGB channels are displayed and alpha is forced to fully opaque. Each of the channels can be toggled off independently and any combination can be used. Any RGB channel which is disabled is forced to fully black in the output. When Alpha is enabled, the background will be rendered with a solid color or checkerboard pattern to indicate semi-transparent areas.

Also note that when a single channel is displayed solo, the image is rendered as grayscale in that channel rather than displaying a monochromatic colored image.

If the texture is a YUV format texture, this will show as YUVA and allow selecting the luminance and chrominance channels in a similar way to RGBA.

Tip

Right clicking on one of the channel buttons in the texture viewer (R, G, B, A) will either select only that channel, or if it’s already the only one selected it will select all of the others. This is useful e.g. to toggle between viewing RGB and alpha, or for looking at individual channels in a packed texture or render target.

Note that these channel selections are by default saved as per-texture state, so switching to a different texture will revert back to the default RGB, but going back to the first texture will remember which channels you were viewing. See the option in the Settings Window.

When RGBM is selected, the RGB value will be multiplied by the specified multiplier and then by the alpha value. This is a common encoding used to pack HDR values into an 8-bit RGBA image by using the alpha channel as a scaling factor.

When YUVA Decode is selected, the YUVA data will be transformed with a default full-range conversion using Rec. 709 conversion values.

With Custom selected a dropdown will be populated with any custom shaders available for decoding and displaying textures. When choosing a custom shader the raw image will be passed through this shader before being displayed with the usual controls on the main display. For more information see How do I use a custom visualisation shader?.

You can create a new custom shader with the add button, edit a shader with the [image] button, and delete an one with the delete button.

Gamma display of Linear Data

γ Gamma display

A proper explanation of this is available in the FAQ. In short, linear data is ‘over-corrected’ to look as expected, but this behaviour can be overridden by toggling off this option.

Alpha background

Choose background color
checkerboard Checkerboard background

When displaying a texture with alpha channel, the background of the main display changes to make the semi-transparent sections more obvious. With these two controls you can either choose a checkerboard pattern checkerboard or open a color picker to choose a solid color [image].

The currently enabled mode will be highlighted.

Subresource selection

The main display of the texture viewer can only display at most a single 2D subresource of an image at once.

For textures with mip-maps this control allows you to select the mip level to display - the overall size of the image will remain the same but will be point sampled from the given mip level.

For 3D textures and 2D arrays you can select the slice to display here from the drop-down, and for cubemaps you can select the face. For cubemap arrays these two controls are combined to show a list of the faces for the first cubemap, then the second, etc.

For Multisampled textures, this will allow you to select either a single sample to view across the image, or to see a default-resolved image.

Note that these selections are by default saved as per-texture state, so switching to a different texture will revert back to the default first slice or face, and top mip. Going back to the first texture though will remember which subresource you were viewing. See the option in the Settings Window.

Save Texture

save Save Texture

This allows you to save the currently visible texture. Several formats are supported including .dds, .exr, and options are available for mapping down complex formats (such as multisampled or 3D textures) to formats that don’t support them such as .png or .jpg.

Open Texture List

Open Texture List

This button opens the texture list of all textures present in the capture. More details can be seen in How do I view a specific texture?.

View Texture as Buffer

Open Texture data in Buffer Viewer

This button opens the texture in the raw buffer viewer. This lets you see the raw data of the underlying texture and format it as you wish if the data represents more complex data than is easy to display in the texture viewer.

Goto Location

find Goto pixel location

This button opens a small popup above the main texture view that lets you type in a pixel location to jump to. This is useful if you’re investigating a particular issue where you know what pixel the problem will lie on.

Note

This popup is also available with the keyboard shortcut Ctrl-G.

Open Resource Inspector

link Open resource inspector

This button opens a the currently visible texture in the resource inspector which allows you to see more details about how the object was created and any other resources it may be related to.

Note

This popup is also available with the keyboard shortcut Ctrl-G.

Zoom Controls

The zoom controls are fairly self explanatory - a pre-existing zoom value can be chosen from the drop down or a custom value (clamped to the minimum and maximum zoom) can be entered as a percentage. Click the 1:1 button to zoom to the exact size.

To automatically fit the texture to the space available in the window, regardless of its dimensions, you can click the [image] Fit button. This will toggle on and adjust the fit as different textures are displayed.

Flip Y

Flip Y

This button toggles flipping the co-ordinate system in Y, changing y=0 to be at the bottom of the window instead of at the top.

Render Overlay

This is a powerful tool for quickly diagnosing issues and can be very useful for locating what you’re looking for. Several overlays are available that can be rendered over any texture, although most of them are only meaningful for currently bound render targets.

These overlays are only relevant when the currently selected action is a rasterization draw, for other actions the overlays will be empty.

  • Highlight Drawcall will do show the area covered by the drawcall. It darkens everything except the current drawcall which is highlighted in a flat color. This makes whatever is being drawn stand out and can be useful for seeing where the current object is on screen, especially if rapidly browsing through the frame.

  • Wireframe Mesh will render a wireframe mesh of the current drawcall over the top of the image.

  • Depth Test will render an overlay over the drawcall, with red sections covering any part of the drawcall that never passed the depth test, and green sections covering areas that did pass the depth test. Note that if the drawcall overdraws itself then as long as at least one pass over a pixel passes the depth test then that pixel will be green.

  • Stencil Test performs similarly to the depth test, but for the stencil test.

  • Backface Cull works as above but with backface culling.

  • Viewport/Scissor shows a colored overlay on the image that corresponds to the viewport and scissor regions.

  • NaN/Inf/-ve display will render the image in grayscale (using the typical luminance calculation - dot(col.xyz, float3(0.2126, 0.7152, 0.0722)).xxx) with red pixels highlighting any NaNs found, green pixels highlighting any infinities, and blue pixels for any negative values. Note that in any case where only one or some channels in a multi-channel texture pass, that pixel will still be highlighted (so {0.5, -1.0, 0.0} would highlight blue).

  • Clipping will simply highlight in red any values that are below the current black point (as defined by the range control - see above), and in green any values above the white point. This can be useful in identifying invalid ranges if the range control is adjusted correctly, or in combination with a custom shader visualiser.

  • Clear before Pass will act as if the current target had been cleared right before the current pass. This can sometimes make it easier to see the results of a draw, especially if it is blending and only makes a subtle change. If the current API does not have the concept of a pass, it is defined as all the drawcalls with the same set of render targets.

    • If the current target is a render target, it is cleared to the Alpha background color.
    • If the current target is a depth/stencil target, the behavior depends on the depth function for the current draw. If it is EQUAL, NOT EQUAL, or ALWAYS, the target is not cleared. If it is LESS or LESS EQUAL, it is cleared to 1. If it is GREATER or GREATER EQUAL, it is cleared to 0. Stencil is never cleared.

  • Clear before Draw works similarly to the above overlay, but clearing immediately before the selected draw.

  • Quad Overdraw (Pass) will show a visualisation of the level of 2x2 quad overdraw in the ‘pass’ up to the selected draw. If the current API does not have the concept of a pass, it is defined as all the drawcalls with the same set of render targets.

  • Quad Overdraw (Draw) will show a similar visualisation to the above option, but limited only to the current drawcall.

  • Triangle Size (Pass) will show a visualisation of how much pixel area triangles in the meshes are covering in the ‘pass’ up to the selected draw, up to 4x4 pixels (16 square px) at most. If the current API does not have the concept of a pass, it is defined as all the drawcalls with the same set of render targets.

  • Triangle Size (Draw) will show a similar visualisation to the above option, but limited only to the current drawcall.

Note

These overlays are all rendered after most image controls are applied. For this reason the range control, channel controls and custom shaders do not affect the overlays.

See Also

  • How do I view a specific texture?
  • How do I inspect a pixel value?
  • How do I use a custom visualisation shader?.


API Inspector

Although not the most complex part of the RenderDoc’s UI, this page details the features and functionality of the API Inspector.

UI Elements

The API Inspector is divided into two sections - the top section is the most common, detailing the API calls and all of their parameters.

If an action is currently selected in the Event Browser, all the API calls between the previous action and this action will be shown - in other words if you select a draw, this may show several state-setting API calls binding shaders or resources before the draw. If an individual event is currently selected then that event’s API call will be shown.

The bottom section is less commonly used but shows the callstack from user code into the API entry point, if such a callstack is available and the symbols are resolved. For more information check out the page on How do I capture callstacks?.

API Calls

This section lists the series of API calls made between the preceding action and the currently selected action. The current action is always the last element in this list and is highlighted in bold. By default it is also the selected element.

Each API call can be expanded to see the parameters that were passed to it, in the form that they were serialised out to the capture.

API Calls: A list of API calls made up to the current action.

Callstack

The callstack section can be expanded by double clicking on the separator and collapsed in the same way. Once open its size can be adjusted by clicking and dragging on the separator.

This section will either show “No callstack available” or “Need to resolve symbols” as appropriate when the callstacks aren’t ready for display.

The callstack follows the currently selected API call in the other section, and will update both as that selected call change and as the current event changes (as this implicitly changes the API call selected to whichever the current action is).

For more information see How do I capture callstacks?

Callstack: The callstack in user code where this API call was made.


Mesh Viewer

The Mesh Viewer shows both the mesh data as well as a visual representation of the mesh at different stages - pre VS, post VS, etc. For instanced drawcalls you can choose which instance to view in the toolbar at the top.

Each vertex has a display that shows the mesh data, the format of which is pulled from the relevant stage of the pipeline - shader input or output, or vertex input attributes. You can choose to sync these views [image] as well as specify an offset which will stay consistent, so that you can see the same row as you move between different events.

Below this is a 3D view which will show one stage at any given time, and can be switched with the tabs above it. There are two control schemes for viewing the 3D mesh - Arcball which is the default for pre-transform (VS input), and Flycam controls which is the default for post-transform (VS output). You can switch between these at any time with the dropdown on the toolbar above the mesh view.

Note

When tessellation is active, VS out behaves similarly to VS in as they are both considered input data (rather than post-transform data).

You can reset the camera to its default location with the reset button [image]. For VS Input this resets to an arcball at some radius from the object. For VS Output this resets to a view from the projected eye.

You can also auto-fit the camera to the mesh for the VS Input mesh. The auto-fit button wand will fit the camera to the axis-aligned bounding box of the mesh.

To be able to view the post-transform mesh in view-space, RenderDoc attempts to guess the projection matrix and unprojects the output data.

By default the projection matrix is guessed as a standard perspective matrix. Using the post-projection w and z values and the aspect ratio of the output targets a reasonable approximation can be estimated. The FOV must be specified though - the default is 90 but this can be refined by opening the options.

Opening the options cog you can specify the FOV used in the projection matrix. If you used an orthographic matrix instead you can specify this - although this requires manual tuning of the matrix parameters.

Options: The options pop-out of the buffer viewer.

Also available in the options is a simple speed multiplier for the Flycam controls, to fine-tune how fast it moves to the dimensions of the mesh.

Flycam controls

The flycam controls available use the mouse to navigate and ‘look’, and the keyboard to ‘move’. Holding down the left mouse button will rotate the camera’s direction around the camera’s current position.

The arrow keys will move forward, back, left and right, according to the current direction of the camera. The traditional FPS ‘WASD’ controls will also function, relative to an english keyboard. E.g. on an AZERTY keyboard this will be ‘ZQSD’ instead.

Page up and Page down will move vertically ‘up’ and ‘down’ relative to the camera. This is also available on the main keyboard with ‘R’ and ‘F’ (again relative to an english keyboard).

Mesh Preview

In the 3D Mesh preview, you have the option to display the mesh with some colored visualisations, not just as a wireframe mesh. When using one of the visualisations, you can toggle the wireframe on and off.

  • Solid Color simply displays a solid color for each triangle.
  • Flat Shaded will perform basic flat lighting calculations based on triangle normals to give a better idea of the topology of the mesh.
  • Secondary will display the selected secondary mesh element.
  • Meshlet is only relevant when using mesh shaders, and will colourise each meshlet with a different colour.
  • Exploded will display a shaded mesh where vertex colors are a function of the vertex index (SV_VertexID or gl_VertexID). This means adjacent primitives that do not share the exact same vertices can be more easily seen by a hard break in coloring. Additionally, a slider allows displacing vertices along an explosion direction by an amount based on the vertex index, which also helps better visualise shared or disjoint vertices and can also help in visualising other mesh problems (e.g. hidden or duplicate vertices/primitives).

Exploded: Visualising a mesh with no vertex sharing.

Exploded: Visualising a mesh with widely shared vertices.

To select which element will be displayed as secondary, simply right click on the column you would like to use. This can be done on the input and output separately, and 4-component columns have the option to either show RGB as color, or alpha as grayscale.

The selection will be remembered as long as the mesh format stays consistent between actions.

You can also use this if the position data isn’t detected in your inputs and you’d like to choose which element contains the positions, or if you’d like to visualise some other data such as UV co-ordinates as positional (in effect rendering the mesh in uv-space).

Preview: Previewing the uv co-ordinates as color on the mesh.

When displaying the post-projection output - typically the VS output, but possibly tessellation/geometry output - you can select how much data to display.

The dropdown above the mesh view will let you choose to show this draw, previous instances as well, all instances in the drawcall, or the whole pass up to this point.

These let you narrow or expand the mesh outputs displayed. At minimum you will see the current draw - a specific instance, if the drawcall is an instanced draw. You can also display other instances in the same drawcall (either up to the selected instance, or all instances before or after the selected instance). Finally you can opt to display all other meshes up to the current draw in the same notional render pass.

The current draw is always dark tinted, instances within the same draw have a lighter red color, and other drawcalls in the pass will be light gray.


Buffer Viewer

When opening a buffer for view, it can display both fixed non-repeating “struct-of-arrays” (SoA) data, repeated “array-of-structs” (AoS) data, or where supported by the API it can display both - with the fixed data coming as a prefix to repeated data.

Note

“struct-of-arrays” (SoA) is used only in comparison to “array-of-structs” (AoS). The simple case of only fixed values with no arrays would also be considered SoA data, just with no arrays.

The format is defined initially by whatever reflection data is available. The format can be customised, as detailed in How do I specify a buffer format?.

Constant buffers are assumed to be AoS data in all cases. Other views of buffers via non-constant bindings such as UAVs and storage buffers, or views opened directly from a buffer from the resource inspector, will default towards SoA data unless the layout explicitly declares a fixed set of SoA data.

The buffer being viewed as an array of structs (AoS).

The buffer being viewed as a struct of arrays (SoA).

Navigation

The buffer viewer can specify the visible range to be interpreted, given a byte offset and length. Only bytes within this range will be displayed, with any other data from outside the range showing as ---.

The initial values of the offset and length will be taken from the relevant binding, or default to the entire buffer if no subset is referenced by the binding.

In addition to this, you can specify a row offset which is useful in remaining at the same row while watching the change in a buffer between different events.

Exporting and display

When displaying fixed SoA data as above, the padding can be visualised by enabling the align option.

Buffer data can be exported either as CSV values, or where the buffer is backed by byte memory as raw bytes.

See Also

  • How do I specify a buffer format?


Capture Dialog

The Capture Dialog (which doubles as the inject-into-process dialog) is the single point where programs are launched and captures are saved to disk.

After launching a capture a connection dialog will open to allow you to manage and open any captures you take. See Capture Connection for more details.

Note

NOTE: The Load Settings and Save Settings buttons on this dialog refer to loading and saving the set of settings and options configured on this dialog. They do not refer to loading and saving the capture files produced from capturing - that is done from the File menu.

Capturing

To capture a program you need to provide the details of the application to be launched, at minimum locating the executable to run.

The Program section of the dialog prompts for the executable to be launched, the working directory, any command-line arguments to be passed to the program. It also lets you specify any modifications you want to make to the environment variables.

Program Capture: Configuring and launching an exe directly from RenderDoc.

The … buttons next to the executable path and working directory can be used to browse through the file system. If you are working in a remote context then the file and directory browser will be replaced by one that browses in the file system of the remote context. By default if the working directory box is left empty then the directory containing the executable will be used as the working directory.

The … button next to the environment variables line will open up an editing that allows you to specify any changes to the environment variables that you’d like to make when launching the program. This could be used for example to set a configuration option, or perform necessary setup for correct running like configuring a path or setting the DISPLAY variable.

Environment Variables: changing the environment that the executable will run under.

In the environment variable editor you can choose the name of the variable to change, and the value to use. Then you can choose the function to use.

  • Set will overwrite any existing value or create the variable with the value you specify.

  • Prepend Value and Append Value will add the value you specify to the start or beginning of the existing variable. If the variable does not already exist it will be created with the value.

    When prepending or appending you can also choose the separator to apply, for example if you are modifying the PATH variable. You can choose either colons ( :), semi-colons ( ;), platform style ( ; on Windows and : on other platforms), or no separator at all. If the variable does not exist, the separator won’t be added, but if the variable does exist the separator will be added in between the existing value and the value you chose to add.

When you are ready to capture simply click the Capture button in the bottom right.

If you wish to save these particular settings you can click Save Settings to save them to a .cap file. This .cap file can either be loaded in manually, accessed through the File → Recent Captures menu. The .cap file can be associated with RenderDoc, and if so launching RenderDoc from this file will automatically load the capture settings. If Auto start is checked then double clicking on the .cap file will immediately trigger a capture with the given settings.

The last settings used to launch an executable will be automatically saved, and the next time you set up there will be a Load Last Settings - Executable button next to Save Settings and Load Settings. This can be useful if you didn’t save your configuration but want to quickly re-launch it.

Note

The process will be launched with the same permissions and by the same user as RenderDoc was launched. If your process requires specific permissions (such as administrator permissions) you will need to launch RenderDoc with these permissions.

Inject into Process

Caution

The process must not have invoked or initialised the API to be used, as this will be too late for RenderDoc to hook and capture it. At best RenderDoc will not capture, at worst it may cause crashes or undefined behaviour. Only inject to processes you can guarantee are early enough in their initialisation that they have not used the graphics API.

When invoked through File → Inject into Process the capture dialog modifies itself to give a list of processes running on the target system.

A list of processes is fetched once when the dialog is opened, but this can be refreshed by clicking on the Refresh button below the list. Select the process you would like to inject into and click Inject.

Injecting: Injecting into an already-running process via RenderDoc.

Capture Options

Allow Fullscreen Default: Enabled

Allow Fullscreen simply means that RenderDoc will not interfere with any attempt by the application to switch into an exclusive fullscreen video mode. While debugging sometimes this can be awkward as you may wish to quickly switch to your debugger or another program.

If this option is unchecked, RenderDoc will attempt to modify any such attempt to an equivalent windowed mode.

Allow VSync Default: Enabled

Allow VSync functions very similarly to Allow Fullscreen. When disabled, RenderDoc will prevent any attempt to VSync by the application. This can be useful given that there is a certain degree of inevitable overhead from running with RenderDoc and VSync can amplify that.

Seconds Delay Default: 0 Seconds (Disabled)

This option causes RenderDoc to stall for a defined number of seconds immediately after launching the process. Most commonly this is used so that you can launch a program in RenderDoc and immediately attach a traditional debugger before any significant code is executed.

This can be useful e.g. when early initialisation needs to be debugged.

Collect Callstacks Default: Disabled

This option will cause RenderDoc to save a callstack from user code into the API at every API call during the frame being captured. This can then be resolved later and used to determine where the application is calling each API call. More details can be found in How do I capture callstacks?.

Only Action Callstacks Default: Disabled

This option modifies the above capturing of callstacks to only be saved for action calls. This can reduce the CPU load, as well as file-size and memory overhead of capturing callstacks for every API call which may not be desired. Only valid if Collect Callstacks is enabled.

Enable API validation Default: Disabled

Enable API validation causes RenderDoc to enable the API’s built-in debugging, and where possible serialise this out and include it in the capture for later inspection in the Debug Messages window.

  • On D3D11 & D3D12 this will activate the D3D debug layer and save out any messages.
  • For OpenGL this means ARB_debug_output is automatically enabled.
  • For Vulkan the VK_LAYER_LUNARG_standard_validation meta-layer is enabled and VK_EXT_debug_report is used to fetch any warnings or errors. The overhead from enabling this option is largely the same as the overhead of enabling the debug device without RenderDoc involved.
Capture Child Processes Default: Disabled

This option causes RenderDoc to hook into process creation calls from the target application. When this option is enabled those child processes will be injected with RenderDoc in the same way as the parent - which can be useful if you must launch your program through a launcher or level of indirection and still wish to use RenderDoc with one of the child processes.

See below for more information on handling of child processes.

Note

Due to the hook implementation on linux, child processes will always be hooked regardless of whether this option is enabled or disabled.

Ref All Resources Default: Disabled

One method RenderDoc uses to keep capture file sizes down is to only include the referenced dependencies of a frame within a capture. This means that even if 100 textures are allocated and present, if 50 of them are never bound to the pipeline or otherwise referenced then they will not be included in the capture file. Enabling this option will cause RenderDoc to include all live resources at the time of capture regardless of whether they are used or not.

Capture All Cmd Lists Default: Disabled

Note

This option applies to D3D11 only. It may also have a significant performance hit.

By default RenderDoc only begins capturing when you hit the capture key - any commands issued before this point are not available and so if a deferred command list was created before you hit capture and replayed after, it would not be available and RenderDoc would have to fall back and capture again in the hopes that next frame everything will be available.

If the application creates a command list early and replays it indefinitely without recreating it, RenderDoc will essentially have missed its chance to capture it by the time you hit the capture key. Enabling this option will cause RenderDoc to pre-emptively capture all command lists just in case they are used.

Verify Buffer Access Default: Disabled

This option adds checking to any Map() calls that adds a boundary marker after any Map() pointer returned during a captured frame. These markers are checked on Unmap() and if they have been modified a message box will pop up alerting you to this, and you can click Yes to break in the debugger in the target application and investigate the problem.

It will also initialise any buffers with undefined contents after creation with a marker value to catch use of undefined contents that may not always be zero.

Note

This option is only supported on D3D11 and OpenGL currently, since Vulkan and D3D12 are lower overhead and do not have the infrastructure to intercept map writes.

Auto start Default: Disabled

This option is slightly different from the others in that it doesn’t change anything for an immediate capture. When a .cap settings file is saved with the details of a particular capture, if this option is enabled then loading a .cap file from the command line (i.e. most commonly from a file association) will trigger a capture as soon as RenderDoc loads. This is useful for saving a common capture setting and running it with just one click.

Queue Capture of Frame Default: Disabled

This option allows you to queue up a precise capture of a given frame number after the program has started.

Queueing up a capture beginning at frame 0 has a special meaning: Frames are defined as the period between two presents of a window. Frame 0 is defined as starting at initialisation and ending at the first presentation.

The definition of ‘initialisation’ varies by API, since it can be hard to clearly define initialisation time cleanly:

  • On Vulkan, frame 0 begins at the first VkDevice that is created. Since capture is instance-local, only this device’s parent instance will be capturing.
  • On D3D11, frame 0 begins at the first swapchain that is created, since it is common to create and destroy many ID3D11Device objects for enumeration purposes. Note that since capture is device-local, only the device associated with this first swapchain will be capturing and no frame will be captured if this device or swapchain are destroyed before they is used for presentation.
  • On D3D12, frame 0 begins at the first ID3D12Device that is created. Since capture is device-local, only this device will be capturing.
  • On OpenGL, frame 0 begins at the first GL context that is created with an CreateContextAttribs create function such as wglCreateContextAttribs or glXCreateContextAttribs. This is because many programs create and destroy ‘trampoline’ GL contexts before creating their first real context. Since capture is API-wide, the capture will include all work on other contexts up until the first presentation on any context, even if the presentation happens on a different context.

If no presentation happens in the program at all, frame 0 is still undefined and will most likely not capture anything. For purely headless programs you should use the in-application API to define the start and end of where you want to capture.

Child Processes

RenderDoc is able to automatically inject into any child processes started by the initial process launched from the UI. To do this simply check Capture Child Processes in the options above.

RenderDoc has a particular handling of child processes to help you navigate to the process of interest. Whenever a child process is launched, the UI is notified and a list of processes is displayed in a box on the Capture Connection window. You can double click on any of these entries to open up a new connection to that process, in a new window.

If a process exits, instead of just closing the connection window if there have been no captures, instead RenderDoc looks at the child processes - if there is only one child process, it assume that process must be of interest and immediately switches to tracking that process. If there are more than one child process open, the capture connection window will stay open to give you a chance to double click on those child processes to open a new connection window.

Global Process Hook

Danger

This option is risky and should not be used lightly. Know what you’re doing and use it as a last resort.

It is only supported on Windows currently.

To expose this option you have to enable it in the settings, to prevent it being used accidentally.

When you’ve entered a path, or filename, in the executable text at the top of the window, this option will then insert a global hook that causes every new process created to load a very small shim dll.

The shim dll will load, create a thread that checks to see if the process matches the path or filename specified, and then unload. If the process matches it will also inject RenderDoc and capturing will continue as normal. At this point you should first disable the global hook, then you can use the ‘Attach to running instance’ menu option to continue as normal.

RenderDoc implements this behaviour by modifying the AppInit_DLLs registry key to reference RenderDoc’s dlls. This is not a particularly safe method but it’s the only reliable method to do what we want. The shim dll is deliberately made as small and thin as possible, referencing only kernel32.dll, to minimise any risks.

Note

If you have ‘secure boot’ enabled in Windows, the AppInit_DLLs registry key will not work. To use the global process hook you must disable secure boot.

If RenderDoc crashes or something otherwise goes wrong while these registry keys are modified, the shim dll will continue to be injected into every process which is certainly not desirable. Should anything go wrong, RenderDoc writes a .reg file that restores the registry to its previous state in %TEMP%.

Again, this method should be a last resort. Given the risks you should always try to capture directly in some way before trying this.

See Also

  • Quick Start
  • How do I capture callstacks?
  • How do I capture a frame?
  • How do I capture and replay over a network?


Event Browser

The Event Browser is the primary method of browsing the frame and selecting different actions. It displays the user-annotated hierarchical display of sections.

Annotating your frame

The Event Browser becomes most useful when the application has user-defined annotations of sections and subsections of the frames, to allow for a more logical and ordered browsing of the frame.

Doing this is API and platform specific. More information on how to do it can be found in How do I annotate a capture?.

The colours of any marker regions provided by these API functions will be used to markup the row for the region as well as showing a bar along the left side of the tree showing which regions an event is in.

Filtering displayed events

By default the Event Browser only lists actions. Actions are events like draws, dispatches, copies, clears, resolves, and other calls that cause the GPU to do work or can affect memory and resources like textures and buffers. This is sometimes referred to as a drawcall, but the term action is used to be less ambiguous compared to actual rasterization drawing.

Often these are the only events you need to see to browse the frame, but there are cases where you may want to see some state setting calls to see where state is changed. To do this you can change the filter on the event browser from the default to include them.

Filter expressions can be quite complex and are explained in How do I filter visible events?.

The filter expression has a drop-down which allows you to select any of the pre-saved filters, and you can save new filters in the settings window.

Event display

Events displayed in the Event Browser are typically derived from the parameters to the API call itself. A small number of events will have custom generated names - these are typically for example indirect draws where it is more useful to see the used GPU draw parameters instead of the raw CPU side buffer, or for renderpasses where the load and store ops can be displayed.

There are controls to tweak these names available under the Settings & Help window when configuring the filter.

To show these options by way of example, take this default display of a section of a captured frame:

Default Display: The Event browser with the default event naming.

Show custom action names Default: Enabled

This option controls whether the custom names are used as detailed above for e.g. indirect draws and renderpasses. Note the effect that disabling it has on the renderpass beginning and command buffer boundary.

Disabled Custom Action Names: The Event browser with custom names disabled.

Show parameter names and values Default: Disabled

This option controls whether the names of parameters are included as well as their values. By default no parameter names are given and only the values are visible.

Note

This will have no effect on actions with custom names, as controlled above in Show custom action names.

Parameter names: The Event browser with parameter names displayed as well as parameter values.

Show all parameters Default: Disabled

This option controls whether all parameters are displayed, or whether only the most significant ones are included. Note that with all parameters displayed it can be hard to make anything out as some functions have uninteresting implicit parameters like the command buffer.

Note

This does not affect parameter values, which in the case of structures will still only show an elided struct in many cases. Also as above with Show parameter names and values this will have no effect on actions with custom names, as controlled above in Show custom action names.

All Parameters: A snippet of the Event browser showing all function parameters.

Selecting available columns

By default, the columns in the event browser are EID and Name. Name cannot be removed as it contains the tree, but otherwise the columns can be customised both to hide/display or reorder and resize.

To select which columns should be visible, right click the header or click the [image] select columns button. To rearrange the columns simply click and drag on the header.

Note

Note that when timing actions the duration column will automatically be added to display the data.

Timing actions

To time the GPU duration of each action, click the timer button time.

This will automatically run a process to get the time of each action and display it in the duration column, which will be added if necessary.

You can configure which time unit is used for the duration column on the fly in the Settings Window.

To examine more GPU counters than just plain duration, see Performance Counter Viewer.

Browsing the frame

The event browser is the primary way to browse through the frame. Events are listed as entries in the browser and the hierarchical labels mentioned above become tree nodes.

The currently selected event is highlighted and indicated with a green flag [image]. This is the event that RenderDoc is inspecting and is reflected in all the other windows of the UI.

Current Event: The Event browser showing several sections and the current event.

The EID (Event ID) column indicates the ID of the event. Event IDs are assigned starting from 1 and increase every time an API call is made. For this reason action EIDs are usually not contiguous because there are state setting events in between which also have EIDs.

Simply clicking on a different event will select it as current, and selecting an entry with some child events will act as if the final child is selected - in other words selecting a node with several children will show the results of all children having happened.

You can also use keyboard shortcuts to browse through the frame. Pressing up or down arrow key will move up and down through the visible elements, skipping over any sections which are collapsed. These keys will move into and out of a sub-section into the next sibling afterwards - essentially going straight up and down as if there is not a tree and it is a straight list.

The left and right arrows go into and out of hierarchy levels. When within a level pressing left will jump to the parent node of the current level. Pressing left again will collapse that node, and so on. Pressing right will (if on a node with children) expand that node.

Note

This window supports copy and paste, so simply select the entries and ctrl-c to copy to the clipboard

Bookmarks

The [image] bookmark button will allow you to bookmark an event, the shortcut key is Ctrl-B.

Bookmarks bar: The bookmarks bar with several EIDs bookmarks.

A list of bookmarked events will show up on a toolbar at the top of the event browser, they and the shortcut keys Ctrl-1 to Ctrl-0 will jump to the respective bookmarked EID. These shortcuts will work anywhere in the application.

For more information see How do I annotate a capture?.

Searching and Jumping

There are two other controls available in the Event Browser to aid in navigating the frame.

Pressing Ctrl-F will open the find-event toolbar find. This toolbar allows you to type in a partial text filter that will be matched against both labels and action events. The find will be executed when you press enter, although you can then adjust the text and re-search if you wish.

Tip

If you want to go to a particular event you can search for its EID. The find results will only show the matching event, and not any other events which might match that number by substring.

If the event found lies inside an unexpanded section, the sections will be expanded until the matching event is visible.

Matching events will be highlighted with a find icon find, and pressing enter repeatedly will jump between matching events.

The find toolbar isn’t dismissed until you press escape in the text box, or click on the find-event tool button find again.

You can also jump up and down between find results with the previous [image] and next [image] buttons.

Highlighted Results: The results of a find are highlighted with an icon.

See Also

  • How do I annotate a capture?


Settings Window

The settings window contains various advanced or niche settings that configure the analysis UI.

Some settings may not be saved until the application is closed, although most will come into immediate effect.

The settings are saved in the application-specific settings directory (On windows that’s %APPDATA%\qrenderdoc\UI.config and on linux that’s a path like ~/.local/share/qrenderdoc) if you wish to back up or reset these settings.

General options

Visual theme of the UI Default: Light or Dark depending on native color theme.

This allows you to choose what theme to use in RenderDoc. By default when first starting either the light or dark native RenderDoc theme will be selected, but you can change that or switch to any other supported theme here.

Note

The theme won’t fully apply until the next restart, although most elements will update immediately to give you a preview.

Global font scale Default: 100%

This option will apply a global font scale to all fonts in the UI. This will only apply to text elements, and other UI elements will take their scale from the system’s DPI scaling configuration.

Changing this option will need the UI to be restarted before it fully takes effect on all UI elements.

Prefer monospaced fonts in UI Default: Disabled

This option will use a monospaced font for every place in the UI where any data or output is displayed.

Changing this option will need the UI to be restarted before it fully takes effect on all UI elements.

Minimum decimal places on float values Default: 2

Defines the smallest number of decimal places to display on a float, padding with 0s.

Examples:

  • With a value of 2, 0.1234 will be displayed as 0.1234
  • With a value of 2, 1.0 will be displayed as 1.00
  • With a value of 6, 0.1234 will be displayed as 0.123400
  • With a value of 6, 1.0 will be displayed as 1.000000
Maximum decimal places on float values Default: 5

Defines the largest number of decimal places to display on a float.

Examples:

  • With a value of 5, 0.123456789 will be displayed as 0.12346
  • With a value of 5, 1.0 will be displayed as 1.00 depending on the above minimum
  • With a value of 10, 0.123456789 will be displayed as 0.123456789
  • With a value of 10, 1.0 will be displayed as 1.00 depending on the above minimum
Negative exponential cutoff value Default: 5

Any floating point numbers that are below E-v for this value v will be displayed in scientific notation rather than as a fixed point decimal.

Examples:

  • With a value of 5, 0.1234 will be displayed as 0.1234
  • With a value of 5, 0.000001 will be displayed as 1.0E-6
  • With a value of 10, 0.1234 will be displayed as 0.1234
  • With a value of 10, 0.000001 will be displayed as 0.000001
Positive exponential cutoff value Default: 7

Any floating point numbers that are larger E+v for this value v will be displayed in scientific notation rather than as a fixed point decimal.

Examples:

  • With a value of 7, 8000.5 will be displayed as 8005.5
  • With a value of 7, 123456789.0 will be displayed as 1.2345E8
  • With a value of 2, 8000.5 will be displayed as 8.0055E3
  • With a value of 2, 123456789.0 will be displayed as 1.2345E8
Offset or size fields format mode Default: Auto

Any fields which are displayed in the UI that represent byte offsets or sizes can be configured to display as either decimal, hexadecimal, or automatic.

In the default automatic mode the fields will be shown as decimal for small values up to a given threshold, and as hexadecimal for larger values. With this option they can be instead forced to always display as one or the other.

Directory for temporary capture files Default: %TEMP%

This allows you to choose where on disk temporary capture files are stored between when the capture is made, and when it is either discarded or saved to a permanent location on disk.

By default the system temporary directory is used, but if this lies on drive with limited space, large captures could become a problem so here you can redirect the storage elsewhere.

Default save directory for captures Default: Empty

This allows you to choose which directory the save dialog will default to when prompting to save a capture file. By default the value is empty, which means that it follows the system behaviour (e.g. to begin on whichever folder was last browsed to in a file dialog).

The folder must exist, it will not be created when browsed to.

Allow global process hooking Default: Disabled

This option enables the functionality allowing capturing of programs that aren’t launched directly from RenderDoc, but are launched from somewhere else.

This option can be dangerous which is why you have to deliberately enable it here. Be careful when using this and only do so when necessary - more details can be found in the global process hook details.

Enable process injection (restart required) Default: Disabled

On windows only RenderDoc is able to inject into running processes. By default this is disabled since it is almost never the right thing to do and can easily break, so you are strongly recommended to instead launch your program from RenderDoc’s launch process panel.

Injecting into processes can be unreliable and should only be used as a last resort when no other methods succeed, it should not be used as a primary method of launching applications.

Allow periodic anonymous update checks Default: Enabled

Every couple of days RenderDoc will send a single web request to a secure server to see if a new version is available and let you know about it. The only information transmitted is the version of RenderDoc that is running.

If you would prefer RenderDoc does not ever contact an external server, disable this checkbox. If you do this it’s recommended that you manually check for updates as new versions will be made available regularly with bugfixes.

Always replay captures locally Default: Disabled

Normally, when RenderDoc begins to load a capture file that was created on a different type of machine, it will prompt you to ask if you really want to replay it locally (and perhaps get different results or even failed loading), or if you’d like to choose a different replay context to replay it remotely on the type of machine it was recorded.

In that prompt you can choose to always replay captures locally, which enables this option. If enabled, RenderDoc will always just load the capture locally.

Anonymous Analytics

When you first run a build of RenderDoc that’s analytics-enabled, RenderDoc will prompt you for your preference.

You have three alternatives:

  • Gather anonymous low-detail statistics and submit automatically. This will gather analytics in the background and submit the anonymous report automatically each month to RenderDoc’s secure server.
  • Gather anonymous low-detail statistics, but manually verify before submitting. This will gather analytics in the background but prompt the user each month to verify the contents of the report before submitting the anonymous report to RenderDoc’s secure server.
  • Do not gather or submit any statistics. This will disable all statistics gathering completely.

This option allows you to change modes at any time, although note that if you previously had statistics disabled the program must be restarted to enable gathering.

The complete details of the analytics can be found in the page about Analytics.

Core options

Shader debug search paths Default: Empty

Here you can choose which locations to search in, and in which order, when looking up a relative path for unstripped debug info.

For more information you can consult How do I use shader debug information?.

Enable Radeon GPU Profiler integration Default: Off

Here you can choose to enable the RGP integration which is by default disabled.

For more information you can see How do I generate an RGP profile?.

Radeon GPU Profiler executable Default: Empty

Here you can choose where RadeonGPUProfiler executable is, for use with the RGP integration.

For more information you can see How do I generate an RGP profile?.

Replay options

In this panel you can configure the default options used for replaying captures.

The specific options are documented along with the explanation of how replay options affect the capture in How do I control the replay?.

Texture Viewer options

Reset Range on changing selection Default: Disabled

When changing texture from one to another, when this option is enabled the range control will reset itself to [0, 1]. This will happen between any two textures, and going back and forth between two textures will also reset the range.

Visible channels, mip/slice, and range saved per-texture Default: Enabled

Settings including which channels are displayed (red, green, blue, alpha or depth/stencil), the mip or slice/cubemap face to display, or the visible min/max range values are remembered with the texture you were looking at. In other words if you display a render target with only the alpha channel visible, then switching to view another texture will default back to RGB - and switching back to that render target will view alpha again.

Y-flipping state saved per-texture Default: Disabled

If the above setting is enabled, then also store the y-flip per texture. By default this is treated as a global toggle for all textures. With this setting enabled the flip will default to off for all textures, and then be saved per-texture.

Custom shader directories Default: Empty

Here you can choose additional locations to search for custom visualisation shaders, and in which order in case of duplicates.

For more information see How do I use a custom visualisation shader?.

Shader Viewer options

Rename disassembly registers Default: Enabled

This option tries to make the disassembly of shaders easier to read by substituting variable names where available in for constant register names.

Shader Processing Tools

Here you can configure external tools that convert between shader representations, including compilers from a high-level language like HLSL/GLSL to a bytecode, as well as disassemblers from bytecode back to high-level language.

Some built-in tools are supported such as SPIRV-Cross, glslang, spirv-dis and spirv-as. For these tools if they can be auto-detected they will already be present, and they may be distributed with RenderDoc builds in case a version isn’t installed on the system.

Other custom tools can be configured, but for those the command line arguments must be configured. The command line arguments will have certain substitutions made to customise to the needs of the compile:

  • {input_file} will be replaced by the input filename.
  • {output_file} will be replaced by the output filename.
  • {entry_point} will be replaced by the entry point name, only when compiling a shader.
  • {glsl_stage4} will be replaced by the glsl stage short-hand, one of: vert, tesc, tese, geom, frag, or comp.
  • {hlsl_stage2} will be replaced by the hlsl stage short-hand, one of: vs, hs, ds, gs, ps, or cs.
  • {spirv_ver} will be replaced by the SPIR-V version in use, e.g. spirv1.2 or spirv1.6.
  • {vulkan_ver} will be replaced by the Vulkan-identified SPIR-V version in use, e.g. vulkan1.0 or vulkan1.3. This value may be lossy, and will pick the next lowest version that compiles with a given SPIR-V version. E.g. SPIR-V 1.2 was not used by a vulkan version, so will be rounded down to vulkan1.0.

You must also select the input and output format of the tool, such as HLSL input and SPIR-V output. This will be used to match the tool against a given need at runtime with different types of shaders.

Custom parameters can also be added each time the tool is invoked on the shader editing panel. For full information about using shader processing tools to decompile or compile shaders, see the section on editing shaders.

Event Browser options

Time unit used for event browser timings Default: Microseconds

This option allows you to select the unit that will be shown in the duration column in the event browser when you time individual actions.

Seconds through to nanoseconds are supported.

Add fake markers if none present Default: Enable

If a capture is found to contain no markers whatsoever, RenderDoc will generate some default markers based on grouping actions by the different output targets that they are drawing to. Roughly forming ‘passes’ of different types.

You can disable this option here if you want to view a pure list of actions with no annotations.

This option only applies itself the next time you load a capture.

Apply marker colors Default: Enabled

Some APIs can provide an RGBA color alongside the marker name when setting or pushing a marker region. This option enables applying those colors in the UI. Usually you’d leave it on unless your code is passing garbage for the colors or something instead of 0s (which will then be ignored rather than coming out black).

This option only applies itself the next time you load a capture.

Colorise whole row for marker regions Default: Enabled

If the above option to apply colors is enabled, this will colorise the whole row in the event browser for any marker regions with colors, rather than just applying a strip of color along the side of their children.

This option only applies itself the next time you load a capture.

Comments options

Show capture commends on load Default: Enabled

If a capture is newly loaded (i.e. it is not in the recent captures list having been loaded before) and it contains a comments section, then the capture comments panel will be displayed and brought to the front to show the comments on load.

Newly created captures will not have any comments, they are only added through the UI, so this only applies to captures made somewhere else that have had comments added to them.

For more information, see How do I annotate a capture?.

Android options

Android SDK root path Default: Empty

RenderDoc requires some android tools from the android SDK to be able to function. In most cases it’s able to locate the tools automatically without any configuration needed, but if not this option allows you to manually locate the SDK root.

By default it will try to auto-locate those tools by looking in different environment variables like ANDROID_HOME and ANDROID_SDK, or else searching the default executable path. If it fails completely it will try to use the tools bundled with RenderDoc’s installation.

This setting, if present, will override all other search paths and be looked in first.

Java JDK root path Default: Empty

RenderDoc may require tools from the Java JDK in some rare circumstances. In most cases it’s able to locate the tools automatically without any configuration needed, but if not this option allows you to manually locate the JDK root.

By default it will try to auto-locate the tools by looking in JAVA_HOME or else searching the default executable path.

This setting, if present, will override all other search paths and be looked in first.

Max Connection Timeout Default: 30 seconds

Some Android programs take a long time to start up before they begin rendering. This setting allows you to define a timeout before RenderDoc will consider the execution and connection to have failed.

This only applies to running Android programs.


Pipeline State

The Pipeline Viewer is an information dense but simple window in RenderDoc. It shows all of the stateful settings of the graphics pipeline, including bound resources, rasterizer settings, etc.

Pipeline flowchart

At the top of the Pipeline Viewer is the pipeline flowchart - this shows the high-level block level diagram of the graphics pipeline.

Each block is a separate page which contains the relevant state and contents for that piece of the graphics pipeline, with specific details varying by API and the type of data to be displayed.

The currently selected block is outlined with red, and the page in view reflects the contents of that section of the pipeline. Light gray parts of the pipeline are those which are currently active and participating in this action. Dark gray parts of the pipeline are not enabled and can be considered pass-through/do-nothing.

Pipeline: Pictured here, the high-level parts of the Vulkan Pipeline.

Note

In D3D11 and OpenGL, the Stream-Out / Transform Feedback stage is available under the Geometry Shader block, with the buffers being used for stream-out shown.

Pipeline Section Display

The pipeline state viewer always displays the state of the pipeline after the execution of the action, as with the other viewers in RenderDoc.

Any resources that are bound to the pipeline can be opened in more detailed viewers, such as vertex buffers, constant buffers and textures. More details of this process can be found in the page How do I view details of an object?.

The pipeline view attempts to only show what is relevant, and not all possible stateful data. To do this (when available) it uses shader reflection data to only display slots which are actually in use by the shaders, and omit any that are unused. This can be overridden with the Show Unused Items [image] button.

On some APIs like Vulkan it may be common to use ‘bindless’ approaches where a large number of resources are bound and only a small number are accessed at any time. In these cases RenderDoc uses dynamic feedback to try to determine the set of resources accessed and only displays them. This can similarly be overridden with the Show Unused Items [image] button.

When showing disabled/unused bindings, they will be listed in italics.

In some cases whole sections will be omitted unless there is anything set there - this is primarily for unused or rarely used features like shader subroutines/class linkage, and Read/Write bindings (Image load store or UAVs).

Pipeline: Pictured here, texture bindings in a D3D11 pixel shader.

When a binding is empty, it will be displayed with a red background. By default as above only bindings that could be referenced by the shader are displayed, so empty bindings indicate that the shader may be reading from an unbound resource. With the Show Unused Items [image] button above, unused but empty bindings are still omitted for readability. To override this you can use the Show Empty Items [image] button which will show empty bindings.

If a binding is listed with a blue/green background this indicates that the binding has special parameters over and above the underlying resource. This could be for example an image with many mips or slices where not all of them are bound to the pipeline in the image view, or the view casts the image to a different compatible format.

Note

On OpenGL, incomplete textures will also be displayed with a red background. An explanation of why they are incomplete will be included in the tooltip when hovering over the entry.

Pipeline: The above pipeline section, collapsed to save space.

Sections can be expanded and collapsed by clicking on the title text above them to toggle them in and out of the collapsed state. This can be used to temporarily close down some sections that you don’t need to make room for more vertical space in sections you do need.

You can also export the pipeline state by clicking on the save export button, this will export the entire pipeline state in detail to an HTML file, so you can more easily compare between different logs and different events.

See Also

  • How do I view details of an object?


Shader Viewer

The Shader Viewer is used for displaying, editing, and debugging shaders.

Information about editing shaders can be found in other documents such as How do I edit a shader? and How do I use a custom visualisation shader?.

Debugging shaders is documented in How do I debug a shader?.

Overview

The shader viewer displaying a D3D11 shader

When opened from the Pipeline State for a given shader stage, the shader viewer display the shader itself as well as the input and output signatures. These signatures form the interface between this shader stage and the previous and next parts of the rendering pipeline. For example a vertex shader will list the fixed function vertex inputs, and the interpolated values that are passed to the next stage.

The shader viewer displays the source code in the formats that are available. When debugging information has embedded it there will be tabs for each original source file. For APIs using a bytecode IR the disassembly of that bytecode will also be displayed in a separate tab.

Several different disassembly forms are possible, depending on the API and available plugins and hardware support. Above the disassembly tab will be a drop-down listing the possible representations including hardware specific ISA formats like AMD GCN.

You can configure shader processing tools in the settings window which allows for various customised disassemblers such as SPIRV-Cross and spirv-dis for SPIR-V.

The disassembly options for a Vulkan SPIR-V shader


Shader Messages

The Shader Messages window shows messages obtained from shader prints in a given action.

When selecting an action you have the option to open the list of messages, which can be viewed in this window and filtered/processed.

Note

Currently this feature requires API support and is only implemented on Vulkan. If in future other APIs gain support for it they will be supported in the same way.

Adding shader prints

The exact mechanism for printing from shaders varies by API, so it is best to consult the documentation for each API for more information.

For Vulkan the SPIR-V extension NonSemantic.DebugPrintf is used to list printfs which are ignored by drivers but can be processed by tools like RenderDoc. This is exposed in GLSL via the GL_EXT_debug_printf extension and debugPrintfEXT() function, and in HLSL via the printf built-in function.

Fetching shader messages

Shader messages are not fetched for the whole capture at once, they are fetched on a per-action basis when that action is selected. If any messages appear they will be shown in the event browser next to the action, with a link that opens the shader message viewer for those messages. The messages can also be found linked from the pipeline state under each shader stage, which will pre-filter for only messages from that stage.

Shader Messages

The window itself is relatively simple. Each message retrieved from the api will be listed on its own row showing the shader invocation that printed the message along with its contents. The location itself will vary depending on the type of shaders - for vertices this will identify the instance and vertex, for pixels this will be the co-ordinate and sample, for compute threads this will be the group and thread.

For non-compute shaders each row has two buttons, one to go to the particular invocation (the pixel, or the vertex) and the other to debug the invocation. Clicking debug will set a breakpoint on the print statement and run to it immediately. For compute shaders the only option is to debug.

Note

Shaders which can’t be debugged due to unsupported functionality may still produce print statements. In this case they still cannot be debugged.

The messages can be filtered by text substring in the filter box, as well as by shader stage using the toggles.

Double clicking on any row will take you to the corresponding event ID in the event browser.

Shader Messages: The Shader Messages window showing some simple prints from a vertex shader.

Shader Edits

Since prints come from shaders, the expectation is that they are fixed for a given action and so they are cached and not re-fetched each time the action is selected.

However this doesn’t hold if the shader is edited, since the print could change or the control flow and inputs could change. When this happens any previous shader messages windows will show up as ‘stale’ until the action is selected where they will refresh themselves with the latest messages. If the action is already selected then the messages will update immediately.


Timeline Bar

The timeline bar shows an alternate view of the scene to the Event Browser. Displaying the scene with time running as the horizontal axis, although it does not show each section in size relative to its timing.

Introduction

The timeline bar shows the scene horizontally with the hierarchical frame markers being expandable from top to bottom.

This alternate view can be a useful way to get an overview of the whole frame, allowing you to jump around very different parts of the frame.

Given that the timeline bar shows the whole frame it also provides a secondary function of showing dependencies in a global way. For whichever texture is currently selected in the texture viewer, pixel history, or resource inspector, the timeline bar shows accesses of that texture throughout the frame. This can be especially useful for render targets that are cleared, written to and read from, as well as simply to see where a given texture is used in a frame without laboriously searching.

Timeline Bar: The timeline bar showing a birds-eye view of a typical application.

Timeline Display

By default the timeline bar views the whole frame, but with the mouse wheel you can zoom in and out. When zoomed in, you can scroll through the frame with the horizontal scroll bar.

Underneath expanded sections, a blue pip is rendered for each action. The currently selected event is shown as a green pip, as well as there being a light gray vertical line to indicate the current position, such that this is visible even when the relevant section is not expanded.

Clicking on any section will toggle it between expanded and unexpanded, and any sections underneath a section which is collapsed will remain in their previous state but will not be visible.

Left clicking on the timeline will jump to the event underneath that point on the horizontal display.

Resource usage Display

The timeline bar also shows the usage of the currently displayed texture.

If the Texture Viewer is active then whichever texture is being displayed will have its usage laid out across the frame on the timeline bar. If the Resource Inspector is active then whichever resource is currently being inspected will have its usage displayed.

If your textures have their names annotated you will see which texture is being inspected in the label for the usage bar.

A colored triangle will be drawn under each pip that reads from the texture. If the pips are too close together some triangles may be hidden, so zoom in anywhere that there is a great deal of usage in a small place to make it more visible.

Resource Usage: The usage bar showing reads and writes to a texture.

Pixel history event Display

When a pixel history window is focused, the timeline bar will show the results over each EID with a red triangle to show rejected pixels and green triangles to show passed pixels.

Pixel History Results: The timeline bar shows the results of a pixel’s history.


Capture Connection

The capture connection window opens up when you launch a capture of a program, as well as when you attach to an existing program.

Attaching to an existing instance

After you’ve launched a program through RenderDoc and its hooks are added you can freely disconnect (by closing the capture connection window) or close the main UI. You can then connect to this again later, either from the same computer or another computer connecting over the network. For more information, see the page about network capture and replay.

To connect to an existing hooked program, select File → Attach to Running Instance. This opens up the remote host management window that allows you to select a remote host to connect to. localhost is always in the list, but you can add and remove other hosts.

Warning

Please note that none of the connections RenderDoc makes or uses are encrypted or authenticated/protected, so if this is a concern you should look into securing the connections manually.

Remote Hosts: Attaching to a running instance either locally or remotely.

When the window opens, when you add a new host, or when you click refresh then the hosts will be queried across the network to see if a connection exists. While this is in progress the host will be listed in italics and with a busy icon.

Once a host has been scanned, if any instances are found then that host can be expanded to see the list, and details are listed about each instance. The name is OS-dependent but is usually the executable name. The API name is listed, as well as the username of any user that is already connected.

When you click connect, a capture connection window will be opened up - just the same as the window that is automatically opened when you start a program. Any captures that have already been made before you connect will then populate.

Note

If you connect to a running instance, any existing user will be disconnected. Just seeing the instances running on a host will not.

For more information about specifically a network capture-and-replay workflow, please see How do I capture and replay over a network?.

Capture Connection window

When a capture is launched (or attached to) the connection window is opened in the main UI. If you end up only taking one capture and closing the program afterwards the connection window will automatically close and open that capture. Similarly if you don’t take any captures at all the window will close when the program exits. These cases don’t need the management options the connection window provides.

While a program is running, a couple of tools are available for triggering specific captures, which can be used as well as the keystroke capture triggers in the application.

Connection Window: Tools for triggering specific frame captures.

Firstly you can trigger a capture, with an optional delay in seconds, and for an arbitrary number of frames. When you click Trigger Capture the delay will count down, and then the application will capture the selected number of sequential frames into separate captures. By default the delay is 0 seconds and only one frame is captured.

Next you can queue a capture at a specific frame number, if you know that a bug will happen at a given point.

Note

Capturing a frame in RenderDoc will cause a noticeable stall on any non-trivial application, so if you are investigating a timing issue often this can throw things off and hide the bug. However capturing multiple frames can be useful when you know a bug alternates every N frames, or you specifically want to debug how N sequential frames look and you know extreme frame times won’t skew the results.

During running or after the application has closed, all captures will appear as thumbnails here. As mentioned above, if only one capture is made and the application is closed the capture dialog will automatically begin to load it up in the UI. Otherwise you can use this window to browse the captures, save and delete any frame captures, and open them either in the currently running UI or in a new separate instance.

Connection Window: Viewing multiple captures taken in a program.

In this example we have a connection window open to the debugmarker sample from Sascha Willms’ Vulkan examples. Three captures have been made and we can see their thumbnails to help distinguish between them. This is visible at any point, regardless of whether you have close the program or not - you can simply switch back to RenderDoc while it’s running.

Note

Note, if you have remotely connected you will need to wait while the captures copy across the network to your PC, after which point everything behaves the same as a local capture.

From here you can save these captures out - as currently they are only temporary copies that will be cleaned up on close. You can also manually delete any capture you wish to discard.

Double clicking on any capture will close any current open capture in the RenderDoc UI, and open up that capture for inspection. You may also right click or use the drop-down menu on the open button to launch a new instance of RenderDoc for viewing the capture. This is mostly useful if you want to compare two captures side-by-side easily.

You can press F2 or single click on a selected capture (not double click) to rename the default label given to each capture. This can be useful if you’re changing something as you go or toggling an option and you want to remember which capture is which.

New instance: Launch new RenderDoc instance to open this capture.

Child Processes

RenderDoc is able to automatically inject into any child processes started by the initial process launched from the UI. To do this simply check Capture Child Processes when Capture Dialog.

RenderDoc has a particular handling of child processes to help you navigate to the process of interest. Whenever a child process is launched, the UI is notified and a list of processes is displayed in a box on the capture connection window. You can double click on any of these entries to open up a new connection to that process, in a new window.

If a process exits, instead of just closing the connection window if there have been no captures, instead RenderDoc looks at the child processes - if there is only one child process, it assume that process must be of interest and immediately switches to tracking that process. If there are more than one child process open, the capture connection window will stay open to give you a chance to double click on those child processes to open a new connection window.

See Also

  • How do I capture and replay over a network?
  • Capture Dialog


Debug Messages

The Debug Messages window shows messages from the API including warnings about performance issues or concerns about potential hazards, as well as errors on invalid use of the API.

RenderDoc will alert you if there are any debug messages to show from the capture by flashing in the status bar. Sometimes RenderDoc will also add new alerts there that aren’t part of the original capture if there are warnings or problems that it encounters while processing and analysing the capture.

Capturing with debug messages included

To include these debug messages in a capture, check on the Enable API validation option in the capture options. For more information see Capture Dialog

Debug Messages

This window is fairly simple. Each message retrieved from the api will be listed on its own row showing the event ID that triggered the message, along with a severity and category.

Double clicking on any row will take you to the corresponding event ID in the event browser.

Debug Messages: The Debug Messages window showing some API messages.


Python Shell

The python shell allows flexible of RenderDoc, including the ability to run simple scripts over the whole dataset in ways not easy to do in the UI. Depending on the build-time configuration the Qt UI itself may also be exposed to python for customisation.

Overview

The python shell

You can open the python shell from the window menu. It offers both an interactive shell and a window that can open and run scripts and display the output.

The full python API reference contains the explicit detail of the whole API, but you can also use the help() command to obtain information about a particular object or function call.

To get started the pyrenderdoc object corresponds to a qrenderdoc.CaptureContext object through which the internal API and UI windows can be obtained.

For Qt integration, if available, you can import PySide2 which provides python bindings for the Qt API.

See Also

  • Python API
  • How do I register a python extension?


Resource Inspector

The resource inspector window allows you to see a full list of all API objects included in the frame capture. You can see the relationships between objects - such as parent/child links - as well as the full creation details of any object.

Links to the resource inspector exist throughout the UI indicated by a bold resource name and the link icon.

Resource Inspector: Examining the details of a resource in a capture.

Related Resources

For the selected resource, if there are any parent resources which this resource depends on, they will be listed under related resources. Similarly in the parent resource, any children are listed here too. This lets you easily click from one to the other.

An example of a parent-child relationship is a ‘view’ type object that is created in reference to a concrete ‘image’ or ‘texture’ type object.

Usage in Frame

Some resources such as textures and buffers have information available about where and how they’re used in the frame.

In this list, each entry lists an EID range and a type of usage.

Resource Initialisation Parameters

Before any API object is used in the frame, it must be initialised and set up exactly as it was in the captured application.

The function calls used to initialise the object are listed here, which will normally contain at least one creation function.

Renaming resources

To rename resources, click on the Rename Resource button next to the name, and it will open an editing textbox to let you change the name. When you’ve set the name, press Enter or click Rename Resource again. To cancel a rename, press Escape or click Reset name to restore the name to its original value.

This name will be used consistently throughout the UI anywhere the resource is referenced, and will update whenever you rename it again.

Resource Inspector: Renaming a resource in a capture.

For more information, see How do I annotate a capture?.


Performance Counter Viewer

The performance counter viewer provides a very simple way to fetch the results of GPU counters across all events in a capture.

Counter selection

Once a capture is opened, clicking the Capture Counters button will open up the selection dialog, listing all of the counters available.

Performance Counter Viewer: Selecting the set of counters.

On the left-hand side will be a tree view with the available counters. These will be grouped in a hierarchy to allow for easier browsing.

When a counter is selected, the counter description will list a brief summary of what value or quantity the counter is measuring and may indicate where it is useful.

Each counter has a checkbox, as well as each category. Counters can be toggled individually, or else whole categories can be toggled on and off at once which enables or disables all counters within that category. On the lower right is a list of all enabled counters - double clicking on any counter will jump to it in the list and display its description.

The set of counters to be sampled can be saved and loaded to a configuration file using the Save and Load buttons.

Counter Results

When clicking Sample Counters in the counter selection dialog above, RenderDoc will then iterate over every event and fetch all of the data for the selected counters, and display it in a large table.

Performance Counter Viewer: Viewing the results of the counters.

By default the table is sorted by EID, but each column is sortable individually so that you can easily identify the action with the highest or lowest value for any given counter.

Clicking the save button lets you save the results of the counters as CSV.

Hardware Counters

RenderDoc ships with support for AMD’s GPA library, which will allow access to AMD’s hardware counters when running with a supported AMD GPU.

RenderDoc also has support for nVidia’s NvPerfKit library, but it does not ship as the library’s license forbids redistribution. To enable support, place the NvPmApi.Core.dll file into either plugins/nv/counters/x64 for 64-bit RenderDoc builds and plugins/nv/counters/x86 for 32-bit RenderDoc builds.


Capture Comments

Capture Comments: Adding free-form text notes to be saved with a capture

The capture comments panel allows for adding arbitrary comments to a capture. This is mostly used for annotating a capture since the comments written here will be available to anyone loading the capture. It’s also a useful to permanently store the build or machine configuration where the capture was created.

Previous


Index

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

A

  • Abbrev() (renderdoc.PipeState method)
  • ActionDescription (class in renderdoc)
  • ActionFlags (class in renderdoc)
  • ActionFlags.Auto (in module renderdoc)
  • ActionFlags.BeginPass (in module renderdoc)
  • ActionFlags.BuildAccStruct (in module renderdoc)
  • ActionFlags.Clear (in module renderdoc)
  • ActionFlags.ClearColor (in module renderdoc)
  • ActionFlags.ClearDepthStencil (in module renderdoc)
  • ActionFlags.CmdList (in module renderdoc)
  • ActionFlags.CommandBufferBoundary (in module renderdoc)
  • ActionFlags.Copy (in module renderdoc)
  • ActionFlags.Dispatch (in module renderdoc)
  • ActionFlags.DispatchRay (in module renderdoc)
  • ActionFlags.Drawcall (in module renderdoc)
  • ActionFlags.EndPass (in module renderdoc)
  • ActionFlags.GenMips (in module renderdoc)
  • ActionFlags.Indexed (in module renderdoc)
  • ActionFlags.Indirect (in module renderdoc)
  • ActionFlags.Instanced (in module renderdoc)
  • ActionFlags.MeshDispatch (in module renderdoc)
  • ActionFlags.MultiAction (in module renderdoc)
  • ActionFlags.NoFlags (in module renderdoc)
  • ActionFlags.PassBoundary (in module renderdoc)
  • ActionFlags.PopMarker (in module renderdoc)
  • ActionFlags.Present (in module renderdoc)
  • ActionFlags.PushMarker (in module renderdoc)
  • ActionFlags.Resolve (in module renderdoc)
  • ActionFlags.SetMarker (in module renderdoc)
  • actionId (renderdoc.ActionDescription attribute)
  • active (renderdoc.GLFeedback attribute)
    • (renderdoc.VKXFBBuffer attribute)
  • AddCaptureViewer() (qrenderdoc.CaptureContext method)
  • AddChild() (renderdoc.SDObject method)
  • AddDockWindow() (qrenderdoc.CaptureContext method)
  • AddFakeMarkers() (renderdoc.ReplayController method)
  • AddGridWidget() (qrenderdoc.MiniQtHelper method)
  • AddMessages() (qrenderdoc.CaptureContext method)
  • AddRecentFile() (in module qrenderdoc)
  • AddRemoteHost() (qrenderdoc.PersistantConfig method)
  • AddressMode (class in renderdoc)
  • AddressMode.ClampBorder (in module renderdoc)
  • AddressMode.ClampEdge (in module renderdoc)
  • AddressMode.Mirror (in module renderdoc)
  • AddressMode.MirrorClamp (in module renderdoc)
  • AddressMode.MirrorOnce (in module renderdoc)
  • AddressMode.MirrorRepeat (in module renderdoc)
  • AddressMode.Repeat (in module renderdoc)
  • AddressMode.Wrap (in module renderdoc)
  • addressR (renderdoc.GLSampler attribute)
  • addressS (renderdoc.GLSampler attribute)
  • addressT (renderdoc.GLSampler attribute)
  • addressU (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • addressV (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • addressW (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • AddThumbnail() (renderdoc.ReplayOutput method)
  • AddWatch() (qrenderdoc.ShaderViewer method)
  • AddWidget() (qrenderdoc.MiniQtHelper method)
  • after (renderdoc.ShaderVariableChange attribute)
  • allowFullscreen (renderdoc.CaptureOptions attribute)
  • AllowGlobalHook (qrenderdoc.PersistantConfig attribute)
  • AllowProcessInject (qrenderdoc.PersistantConfig attribute)
  • allowRestart (renderdoc.MeshFormat attribute)
  • allowVSync (renderdoc.CaptureOptions attribute)
  • alpha (qrenderdoc.MiniQtHelper.SetLabelImage parameter)
    • (qrenderdoc.TextureViewer.SetChannelVisibility parameter)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSave attribute)
    • (renderdoc.TextureSwizzle4 attribute)
  • alphaBlend (renderdoc.ColorBlend attribute)
  • alphaCol (renderdoc.TextureSave attribute)
  • AlphaMapping (class in renderdoc)
  • AlphaMapping.BlendToCheckerboard (in module renderdoc)
  • AlphaMapping.BlendToColor (in module renderdoc)
  • AlphaMapping.Discard (in module renderdoc)
  • AlphaMapping.Preserve (in module renderdoc)
  • alphaToCoverage (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D12BlendState attribute)
    • (renderdoc.GLRasterizerState attribute)
  • alphaToCoverageEnable (renderdoc.VKColorBlendState attribute)
  • alphaToOne (renderdoc.GLRasterizerState attribute)
  • alphaToOneEnable (renderdoc.VKColorBlendState attribute)
  • AlwaysLoad_Extensions (qrenderdoc.PersistantConfig attribute)
  • AlwaysReplayLocally (qrenderdoc.PersistantConfig attribute)
  • ampShader (renderdoc.D3D12State attribute)
  • Analytics_ManualCheck (qrenderdoc.PersistantConfig attribute)
  • Analytics_TotalOptOut (qrenderdoc.PersistantConfig attribute)
  • antialiasedLines (renderdoc.D3D11RasterizerState attribute)
  • api (renderdoc.GetDriverInformation parameter)
    • (renderdoc.IsD3D parameter)
    • (renderdoc.NewCaptureData attribute)
  • APIEvent (class in renderdoc)
  • APIEvent.NoChunk (in module renderdoc)
  • APIInspector (class in qrenderdoc)
  • APIProperties (class in renderdoc)
  • APIProps() (qrenderdoc.CaptureContext method)
  • apis (renderdoc.GPUDevice attribute)
  • apiUse (renderdoc.TargetControlMessage attribute)
  • APIUseData (class in renderdoc)
  • apiValidation (renderdoc.CaptureOptions attribute)
    • (renderdoc.ReplayOptions attribute)
  • app (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.RemoteServer.ExecuteAndInject parameter)
  • appname (qrenderdoc.CaptureContext.TempCaptureFilename parameter)
  • args (qrenderdoc.ShaderProcessingTool attribute)
    • (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
    • (qrenderdoc.ShaderProcessingTool.DisassembleShader parameter)
    • (renderdoc.InitialiseReplay parameter)
  • arrayByteStride (renderdoc.ShaderConstantType attribute)
  • arrayElement (qrenderdoc.TextureViewer.ViewFollowedResource parameter)
  • ArrayIdx (renderdoc.PipeState.GetConstantBuffer parameter)
  • arrayIndex (renderdoc.BindpointIndex attribute)
    • (renderdoc.ShaderVariable.SetBinding parameter)
  • arraySize (renderdoc.Bindpoint attribute)
  • arraysize (renderdoc.TextureDescription attribute)
  • AsBool() (renderdoc.SDObject method)
  • AsFloat() (renderdoc.SDObject method)
  • AsInt() (renderdoc.SDObject method)
  • aspect (renderdoc.MeshDisplay attribute)
  • AsResourceId() (renderdoc.SDObject method)
  • AsString() (renderdoc.SDObject method)
  • AsyncInvoke() (qrenderdoc.ReplayManager method)
  • atomicBuffers (renderdoc.GLState attribute)
  • attachments (renderdoc.VKFramebuffer attribute)
  • attributes (renderdoc.GLVertexInput attribute)
    • (renderdoc.VKVertexInput attribute)
  • author (qrenderdoc.ExtensionMetadata attribute)
  • autofit (qrenderdoc.TextureViewer.SetZoomLevel parameter)
  • autogeneratedName (renderdoc.ResourceDescription attribute)
  • autoStart (qrenderdoc.CaptureSettings attribute)
  • ax (renderdoc.Camera.RotateArcball parameter)
  • AxisMapping (class in renderdoc)
  • axisMapping (renderdoc.MeshDisplay attribute)
  • ay (renderdoc.Camera.RotateArcball parameter)

B

  • b (renderdoc.SDObjectPODData attribute)
  • backFace (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLStencilState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • backfaceCulled (renderdoc.PixelModification attribute)
  • backgroundColor (renderdoc.TextureDisplay attribute)
  • base (qrenderdoc.ExtensionManager.RegisterContextMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterPanelMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterWindowMenu parameter)
  • baseLayer (renderdoc.VKImageLayout attribute)
  • baseMip (renderdoc.VKImageLayout attribute)
  • baseShadingRate (renderdoc.D3D12RasterizerState attribute)
  • basetype (renderdoc.SDType attribute)
  • baseType (renderdoc.ShaderConstantType attribute)
  • baseVertex (renderdoc.ActionDescription attribute)
    • (renderdoc.MeshFormat attribute)
  • basic (renderdoc.SDObjectData attribute)
  • BecomeRemoteServer() (in module renderdoc)
  • before (renderdoc.ShaderVariableChange attribute)
  • BGRAOrder() (renderdoc.ResourceFormat method)
  • bind (qrenderdoc.CaptureContext.DebugShader parameter)
    • (renderdoc.Bindpoint attribute)
    • (renderdoc.BindpointIndex attribute)
    • (renderdoc.D3D12ConstantBuffer attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.ShaderVariable.SetBinding parameter)
  • binding (renderdoc.VKVertexAttribute attribute)
  • bindings (renderdoc.VKDescriptorSet attribute)
    • (renderdoc.VKVertexInput attribute)
  • Bindpoint (class in renderdoc)
  • bindPoint (renderdoc.BoundResourceArray attribute)
    • (renderdoc.ConstantBlock attribute)
    • (renderdoc.ShaderResource attribute)
    • (renderdoc.ShaderSampler attribute)
  • BindpointIndex (class in renderdoc)
  • bindpointMapping (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D12Shader attribute)
    • (renderdoc.GLShader attribute)
    • (renderdoc.VKShader attribute)
  • binds (renderdoc.VKDescriptorBinding attribute)
  • bindset (renderdoc.Bindpoint attribute)
    • (renderdoc.BindpointIndex attribute)
    • (renderdoc.ShaderVariable.SetBinding parameter)
  • bindslots (renderdoc.ConstantBindStats attribute)
    • (renderdoc.OutputTargetStats attribute)
    • (renderdoc.ResourceBindStats attribute)
    • (renderdoc.SamplerBindStats attribute)
    • (renderdoc.VertexBindStats attribute)
  • BindType (class in renderdoc)
  • BindType.ConstantBuffer (in module renderdoc)
  • BindType.ImageSampler (in module renderdoc)
  • BindType.InputAttachment (in module renderdoc)
  • BindType.ReadOnlyBuffer (in module renderdoc)
  • BindType.ReadOnlyImage (in module renderdoc)
  • BindType.ReadOnlyResource (in module renderdoc)
  • BindType.ReadOnlyTBuffer (in module renderdoc)
  • BindType.ReadWriteBuffer (in module renderdoc)
  • BindType.ReadWriteImage (in module renderdoc)
  • BindType.ReadWriteResource (in module renderdoc)
  • BindType.ReadWriteTBuffer (in module renderdoc)
  • BindType.Sampler (in module renderdoc)
  • BindType.Unknown (in module renderdoc)
  • bitFieldOffset (renderdoc.ShaderConstant attribute)
  • bitFieldSize (renderdoc.ShaderConstant attribute)
  • blackpoint (qrenderdoc.TextureViewer.SetHistogramRange parameter)
  • blackPoint (renderdoc.TextureComponentMapping attribute)
  • BlendEquation (class in renderdoc)
  • blendFactor (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D12BlendState attribute)
    • (renderdoc.GLBlendState attribute)
    • (renderdoc.VKColorBlendState attribute)
  • BlendMultiplier (class in renderdoc)
  • BlendMultiplier.DstAlpha (in module renderdoc)
  • BlendMultiplier.DstCol (in module renderdoc)
  • BlendMultiplier.FactorAlpha (in module renderdoc)
  • BlendMultiplier.FactorRGB (in module renderdoc)
  • BlendMultiplier.InvDstAlpha (in module renderdoc)
  • BlendMultiplier.InvDstCol (in module renderdoc)
  • BlendMultiplier.InvFactorAlpha (in module renderdoc)
  • BlendMultiplier.InvFactorRGB (in module renderdoc)
  • BlendMultiplier.InvSrc1Alpha (in module renderdoc)
  • BlendMultiplier.InvSrc1Col (in module renderdoc)
  • BlendMultiplier.InvSrcAlpha (in module renderdoc)
  • BlendMultiplier.InvSrcCol (in module renderdoc)
  • BlendMultiplier.One (in module renderdoc)
  • BlendMultiplier.Src1Alpha (in module renderdoc)
  • BlendMultiplier.Src1Col (in module renderdoc)
  • BlendMultiplier.SrcAlpha (in module renderdoc)
  • BlendMultiplier.SrcAlphaSat (in module renderdoc)
  • BlendMultiplier.SrcCol (in module renderdoc)
  • BlendMultiplier.Zero (in module renderdoc)
  • BlendOperation (class in renderdoc)
  • BlendOperation.Add (in module renderdoc)
  • BlendOperation.Maximum (in module renderdoc)
  • BlendOperation.Minimum (in module renderdoc)
  • BlendOperation.ReversedSubtract (in module renderdoc)
  • BlendOperation.Subtract (in module renderdoc)
  • blends (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D12BlendState attribute)
    • (renderdoc.FrameStatistics attribute)
    • (renderdoc.GLBlendState attribute)
    • (renderdoc.VKColorBlendState attribute)
  • blendState (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
    • (renderdoc.GLFrameBuffer attribute)
  • BlendStats (class in renderdoc)
  • BlockFormat() (renderdoc.ResourceFormat method)
  • BlockInvoke() (qrenderdoc.ReplayManager method)
  • blue (qrenderdoc.MiniQtHelper.SetWidgetBackgroundColor parameter)
    • (qrenderdoc.TextureViewer.SetChannelVisibility parameter)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSwizzle4 attribute)
  • bold (qrenderdoc.MiniQtHelper.SetWidgetFont parameter)
  • borderColor (renderdoc.D3D11Sampler attribute)
    • (renderdoc.GLSampler attribute)
  • borderColorType (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • borderColorValue (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • BoundCBuffer (class in renderdoc)
  • BoundResource (class in renderdoc)
  • BoundResourceArray (class in renderdoc)
  • BoundVBuffer (class in renderdoc)
  • BringToFront() (qrenderdoc.MainWindow method)
  • BucketRecordType (class in renderdoc)
  • BucketRecordType.Linear (in module renderdoc)
  • BucketRecordType.Pow2 (in module renderdoc)
  • buff (renderdoc.ReplayController.GetBufferData parameter)
  • buffer (renderdoc.CaptureFile.OpenBuffer parameter)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
  • bufferBacked (renderdoc.ConstantBlock attribute)
  • BufferCategory (class in renderdoc)
  • BufferCategory.Constants (in module renderdoc)
  • BufferCategory.Index (in module renderdoc)
  • BufferCategory.Indirect (in module renderdoc)
  • BufferCategory.NoFlags (in module renderdoc)
  • BufferCategory.ReadWrite (in module renderdoc)
  • BufferCategory.Vertex (in module renderdoc)
  • BufferDescription (class in renderdoc)
  • bufferFlags (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • BufferFormatter_SavedFormats (qrenderdoc.PersistantConfig attribute)
  • bufferId (renderdoc.VKConditionalRendering attribute)
  • bufferResourceId (renderdoc.GLFeedback attribute)
    • (renderdoc.VKXFBBuffer attribute)
  • buffers (renderdoc.SDFile attribute)
    • (renderdoc.VKTransformFeedback attribute)
  • bufferStructCount (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • BufferViewer (class in qrenderdoc)
  • BufIdx (renderdoc.PipeState.GetConstantBuffer parameter)
  • BugReport (class in qrenderdoc)
  • BuildCustomShader() (renderdoc.ReplayController method)
  • BuildTargetShader() (renderdoc.ReplayController method)
  • BuiltinWindowClosed() (qrenderdoc.CaptureContext method)
  • busy (renderdoc.TargetControlMessage attribute)
  • BusyData (class in renderdoc)
  • bx (renderdoc.Camera.RotateArcball parameter)
  • by (renderdoc.Camera.RotateArcball parameter)
  • bytecode (renderdoc.D3D11InputAssembly attribute)
  • byteOffset (qrenderdoc.CaptureContext.ViewBuffer parameter)
    • (renderdoc.BoundCBuffer attribute)
    • (renderdoc.BoundVBuffer attribute)
    • (renderdoc.D3D11IndexBuffer attribute)
    • (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D11StreamOutBind attribute)
    • (renderdoc.D3D11VertexBuffer attribute)
    • (renderdoc.D3D12ConstantBuffer attribute)
    • (renderdoc.D3D12IndexBuffer attribute)
    • (renderdoc.D3D12Layout attribute)
    • (renderdoc.D3D12StreamOutBind attribute)
    • (renderdoc.D3D12VertexBuffer attribute)
    • (renderdoc.GLBuffer attribute)
    • (renderdoc.GLFeedback attribute)
    • (renderdoc.GLVertexAttribute attribute)
    • (renderdoc.GLVertexBuffer attribute)
    • (renderdoc.ShaderConstant attribute)
    • (renderdoc.VertexInputAttribute attribute)
    • (renderdoc.VKBindingElement attribute)
    • (renderdoc.VKConditionalRendering attribute)
    • (renderdoc.VKIndexBuffer attribute)
    • (renderdoc.VKVertexAttribute attribute)
    • (renderdoc.VKVertexBuffer attribute)
    • (renderdoc.VKXFBBuffer attribute)
  • byteSize (qrenderdoc.CaptureContext.ViewBuffer parameter)
    • (renderdoc.BoundCBuffer attribute)
    • (renderdoc.BoundVBuffer attribute)
    • (renderdoc.ConstantBlock attribute)
    • (renderdoc.D3D12ConstantBuffer attribute)
    • (renderdoc.D3D12IndexBuffer attribute)
    • (renderdoc.D3D12StreamOutBind attribute)
    • (renderdoc.D3D12VertexBuffer attribute)
    • (renderdoc.GLBuffer attribute)
    • (renderdoc.GLFeedback attribute)
    • (renderdoc.NewCaptureData attribute)
    • (renderdoc.SDType attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.VKBindingElement attribute)
    • (renderdoc.VKVertexBuffer attribute)
    • (renderdoc.VKXFBBuffer attribute)
  • byteStride (renderdoc.BoundVBuffer attribute)
    • (renderdoc.D3D11IndexBuffer attribute)
    • (renderdoc.D3D11VertexBuffer attribute)
    • (renderdoc.D3D12IndexBuffer attribute)
    • (renderdoc.D3D12VertexBuffer attribute)
    • (renderdoc.GLVertexBuffer attribute)
    • (renderdoc.VKIndexBuffer attribute)
    • (renderdoc.VKVertexBuffer attribute)

C

  • c (renderdoc.IsAMDCounter parameter)
    • (renderdoc.IsARMCounter parameter)
    • (renderdoc.IsGenericCounter parameter)
    • (renderdoc.IsIntelCounter parameter)
    • (renderdoc.IsNvidiaCounter parameter)
    • (renderdoc.IsVulkanExtendedCounter parameter)
    • (renderdoc.SDObjectPODData attribute)
  • callback (qrenderdoc.ExtensionManager.RegisterContextMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterPanelMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterWindowMenu parameter)
    • (qrenderdoc.MainWindow.RegisterShortcut parameter)
    • (qrenderdoc.MiniQtHelper.InvokeOntoUIThread parameter)
    • (qrenderdoc.ReplayManager.GetHomeFolder parameter)
    • (qrenderdoc.ReplayManager.ListFolder parameter)
  • calls (renderdoc.BlendStats attribute)
    • (renderdoc.ConstantBindStats attribute)
    • (renderdoc.DepthStencilStats attribute)
    • (renderdoc.DispatchStats attribute)
    • (renderdoc.DrawcallStats attribute)
    • (renderdoc.IndexBindStats attribute)
    • (renderdoc.LayoutBindStats attribute)
    • (renderdoc.OutputTargetStats attribute)
    • (renderdoc.RasterizationStats attribute)
    • (renderdoc.ResourceBindStats attribute)
    • (renderdoc.ResourceUpdateStats attribute)
    • (renderdoc.SamplerBindStats attribute)
    • (renderdoc.ShaderChangeStats attribute)
    • (renderdoc.VertexBindStats attribute)
  • callstack (renderdoc.CaptureAccess.GetResolve parameter)
    • (renderdoc.SDChunkMetaData attribute)
    • (renderdoc.ShaderDebugState attribute)
  • cam (renderdoc.MeshDisplay attribute)
  • Camera (class in renderdoc)
  • CameraType (class in renderdoc)
  • CameraType.Arcball (in module renderdoc)
  • CameraType.FPSLook (in module renderdoc)
  • CancelReplayLoop() (qrenderdoc.ReplayManager method)
    • (renderdoc.ReplayController method)
  • CanGlobalHook() (in module renderdoc)
  • CanSelfHostedCapture() (in module renderdoc)
  • capProgress (renderdoc.TargetControlMessage attribute)
  • caption (qrenderdoc.ExtensionManager.OpenDirectoryName parameter)
    • (qrenderdoc.ExtensionManager.OpenFileName parameter)
    • (qrenderdoc.ExtensionManager.SaveFileName parameter)
  • capturableWindowCount (renderdoc.TargetControlMessage attribute)
  • CaptureAccess (class in renderdoc)
  • captureAllCmdLists (renderdoc.CaptureOptions attribute)
  • captureCallstacks (renderdoc.CaptureOptions attribute)
  • captureCallstacksOnlyActions (renderdoc.CaptureOptions attribute)
  • CaptureContext (class in qrenderdoc)
  • CaptureDialog (class in qrenderdoc)
  • CaptureFile (class in renderdoc)
  • captureFile (qrenderdoc.CaptureContext.LoadCapture parameter)
    • (qrenderdoc.CaptureContext.SaveCaptureTo parameter)
  • capturefile (qrenderdoc.ReplayManager.DeleteCapture parameter)
    • (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
    • (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.InjectIntoProcess parameter)
  • CaptureFileFormat (class in renderdoc)
  • captureId (renderdoc.NewCaptureData attribute)
    • (renderdoc.TargetControl.CopyCapture parameter)
    • (renderdoc.TargetControl.DeleteCapture parameter)
  • CaptureModifications (class in qrenderdoc)
  • CaptureModifications.All (in module qrenderdoc)
  • CaptureModifications.Bookmarks (in module qrenderdoc)
  • CaptureModifications.EditedShaders (in module qrenderdoc)
  • CaptureModifications.NoModifications (in module qrenderdoc)
  • CaptureModifications.Notes (in module qrenderdoc)
  • CaptureModifications.Renames (in module qrenderdoc)
  • CaptureOptions (class in renderdoc)
  • CaptureSettings (class in qrenderdoc)
  • captureTime (renderdoc.FrameDescription attribute)
  • CaptureViewer (class in qrenderdoc)
  • category (renderdoc.CounterDescription attribute)
    • (renderdoc.DebugMessage attribute)
  • cbufslot (renderdoc.ReplayController.GetCBufferVariableContents parameter)
  • CBUsage() (in module renderdoc)
  • changed (qrenderdoc.MiniQtHelper.CreateCheckbox parameter)
    • (qrenderdoc.MiniQtHelper.CreateComboBox parameter)
    • (qrenderdoc.MiniQtHelper.CreateRadiobox parameter)
    • (qrenderdoc.MiniQtHelper.CreateTextBox parameter)
  • changes (renderdoc.ShaderDebugState attribute)
  • channelExtract (renderdoc.TextureSave attribute)
  • channels (renderdoc.ReplayController.GetHistogram parameter)
  • channelUsedMask (renderdoc.SigParameter attribute)
  • checkableWidget (qrenderdoc.MiniQtHelper.IsWidgetChecked parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetChecked parameter)
  • checkDate (qrenderdoc.BugReport attribute)
  • checked (qrenderdoc.MiniQtHelper.SetWidgetChecked parameter)
  • CheckRemoteServerConnection() (in module renderdoc)
  • CheckStatus() (qrenderdoc.RemoteHost method)
  • CheckUpdate_AllowChecks (qrenderdoc.PersistantConfig attribute)
  • CheckUpdate_CurrentVersion (qrenderdoc.PersistantConfig attribute)
  • CheckUpdate_LastUpdate (qrenderdoc.PersistantConfig attribute)
  • CheckUpdate_UpdateAvailable (qrenderdoc.PersistantConfig attribute)
  • CheckUpdate_UpdateResponse (qrenderdoc.PersistantConfig attribute)
  • child (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
    • (qrenderdoc.MiniQtHelper.AddWidget parameter)
    • (qrenderdoc.MiniQtHelper.InsertWidget parameter)
    • (renderdoc.SDObject.AddChild parameter)
  • childName (renderdoc.SDObject.FindChild parameter)
    • (renderdoc.SDObject.FindChildRecursively parameter)
  • children (renderdoc.ActionDescription attribute)
  • chromaFilter (renderdoc.VKBindingElement attribute)
  • ChromaSampleLocation (class in renderdoc)
  • ChromaSampleLocation.CositedEven (in module renderdoc)
  • ChromaSampleLocation.Midpoint (in module renderdoc)
  • chunkID (renderdoc.SDChunkMetaData attribute)
  • chunkIndex (renderdoc.APIEvent attribute)
  • chunks (renderdoc.SDFile attribute)
  • classInstances (renderdoc.D3D11Shader attribute)
  • ClearContainedWidgets() (qrenderdoc.MiniQtHelper method)
  • ClearThumbnails() (renderdoc.ReplayOutput method)
  • clientName (renderdoc.BusyData attribute)
    • (renderdoc.CreateTargetControl parameter)
  • clients (renderdoc.ResourceUpdateStats attribute)
  • clipNegativeOneToOne (renderdoc.GLFixedVertexProcessing attribute)
  • clipOriginLowerLeft (renderdoc.GLFixedVertexProcessing attribute)
  • clipPlanes (renderdoc.GLFixedVertexProcessing attribute)
  • Close() (qrenderdoc.PersistantConfig method)
  • CloseCapture() (qrenderdoc.CaptureContext method)
    • (renderdoc.RemoteServer method)
  • CloseCurrentDialog() (qrenderdoc.MiniQtHelper method)
  • closed (qrenderdoc.MiniQtHelper.CreateToplevelWidget parameter)
  • CloseToplevelWidget() (qrenderdoc.MiniQtHelper method)
  • cmd (qrenderdoc.CaptureDialog.SetCommandLine parameter)
    • (qrenderdoc.RemoteHost.SetRunCommand parameter)
  • cmdLine (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
    • (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.RemoteServer.ExecuteAndInject parameter)
  • code (renderdoc.ResultDetails attribute)
  • col (renderdoc.ModificationValue attribute)
  • colEnd (renderdoc.LineColumnInfo attribute)
  • collapsible (qrenderdoc.MiniQtHelper.CreateGroupBox parameter)
  • ColMajor() (renderdoc.ShaderConstantType method)
    • (renderdoc.ShaderVariable method)
  • colorAttachments (renderdoc.GLFBO attribute)
    • (renderdoc.VKRenderPass attribute)
  • ColorBlend (class in renderdoc)
  • colorBlend (renderdoc.ColorBlend attribute)
    • (renderdoc.VKState attribute)
  • colorFeedbackAllowed (renderdoc.VKCurrentPass attribute)
  • colStart (renderdoc.LineColumnInfo attribute)
  • column (qrenderdoc.BufferViewer.ScrollToColumn parameter)
    • (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
  • columns (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderVariable attribute)
    • (renderdoc.SourceVariableMapping attribute)
  • columnSpan (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
  • combo (qrenderdoc.MiniQtHelper.GetComboCount parameter)
    • (qrenderdoc.MiniQtHelper.SelectComboOption parameter)
    • (qrenderdoc.MiniQtHelper.SetComboOptions parameter)
  • commandLine (qrenderdoc.CaptureSettings attribute)
  • Comments_ShowOnLoad (qrenderdoc.PersistantConfig attribute)
  • CommentView (class in qrenderdoc)
  • comp (renderdoc.TextureSave attribute)
  • CompareFunction (class in renderdoc)
  • compareFunction (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • CompareFunction.AlwaysTrue (in module renderdoc)
  • CompareFunction.Equal (in module renderdoc)
  • CompareFunction.Greater (in module renderdoc)
  • CompareFunction.GreaterEqual (in module renderdoc)
  • CompareFunction.Less (in module renderdoc)
  • CompareFunction.LessEqual (in module renderdoc)
  • CompareFunction.Never (in module renderdoc)
  • CompareFunction.NotEqual (in module renderdoc)
  • compareMask (renderdoc.StencilFace attribute)
  • compByteWidth (renderdoc.ResourceFormat attribute)
  • compCount (renderdoc.ResourceFormat attribute)
    • (renderdoc.SigParameter attribute)
  • compileConstants (renderdoc.ConstantBlock attribute)
  • compileFlags (renderdoc.ReplayController.BuildCustomShader parameter)
    • (renderdoc.ReplayController.BuildTargetShader parameter)
    • (renderdoc.ShaderDebugInfo attribute)
  • compiler (renderdoc.ShaderDebugInfo attribute)
  • CompileShader() (qrenderdoc.ShaderProcessingTool method)
  • completer (qrenderdoc.EventBrowser.RegisterEventFilterFunction parameter)
  • completeStatus (renderdoc.GLTexture attribute)
  • component (renderdoc.DebugVariableReference attribute)
  • compressedFileSize (renderdoc.FrameDescription attribute)
  • compressedSize (renderdoc.SectionProperties attribute)
  • CompType (class in renderdoc)
  • compType (renderdoc.ResourceFormat attribute)
  • CompType.Depth (in module renderdoc)
  • CompType.Float (in module renderdoc)
  • CompType.SInt (in module renderdoc)
  • CompType.SNorm (in module renderdoc)
  • CompType.SScaled (in module renderdoc)
  • CompType.Typeless (in module renderdoc)
  • CompType.UInt (in module renderdoc)
  • CompType.UNorm (in module renderdoc)
  • CompType.UNormSRGB (in module renderdoc)
  • CompType.UScaled (in module renderdoc)
  • compute (renderdoc.ShaderMessageLocation attribute)
    • (renderdoc.VKState attribute)
  • computeShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • conditionalRendering (renderdoc.VKState attribute)
  • config (renderdoc.ReplayOutput.SetMeshDisplay parameter)
    • (renderdoc.ReplayOutput.SetTextureDisplay parameter)
  • Config() (qrenderdoc.CaptureContext method)
  • ConfigFilePath() (in module qrenderdoc)
  • Connect() (qrenderdoc.RemoteHost method)
  • Connected() (renderdoc.TargetControl method)
  • connection (renderdoc.CreateXCBWindowingData parameter)
  • ConnectToRemoteServer() (qrenderdoc.CaptureContext method)
    • (qrenderdoc.ReplayManager method)
  • ConservativeRaster (class in renderdoc)
  • ConservativeRaster.Disabled (in module renderdoc)
  • ConservativeRaster.Overestimate (in module renderdoc)
  • ConservativeRaster.Underestimate (in module renderdoc)
  • conservativeRasterization (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • ConstantBindStats (class in renderdoc)
  • ConstantBindStats.BucketCount (in module renderdoc)
  • ConstantBindStats.BucketType (in module renderdoc)
  • ConstantBlock (class in renderdoc)
  • constantBlocks (renderdoc.ShaderBindpointMapping attribute)
    • (renderdoc.ShaderDebugTrace attribute)
    • (renderdoc.ShaderReflection attribute)
  • constantBuffers (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D12RootSignatureRange attribute)
  • constants (renderdoc.FrameStatistics attribute)
  • contents (qrenderdoc.CaptureContext.SetNotes parameter)
    • (renderdoc.CaptureAccess.WriteSection parameter)
    • (renderdoc.ShaderSourceFile attribute)
  • ContextMenu (class in qrenderdoc)
  • ContextMenu.EventBrowser_Event (in module qrenderdoc)
  • ContextMenu.MeshPreview_GSOutVertex (in module qrenderdoc)
  • ContextMenu.MeshPreview_MeshOutVertex (in module qrenderdoc)
  • ContextMenu.MeshPreview_TaskOutVertex (in module qrenderdoc)
  • ContextMenu.MeshPreview_Vertex (in module qrenderdoc)
  • ContextMenu.MeshPreview_VSInVertex (in module qrenderdoc)
  • ContextMenu.MeshPreview_VSOutVertex (in module qrenderdoc)
  • ContextMenu.TextureViewer_InputThumbnail (in module qrenderdoc)
  • ContextMenu.TextureViewer_OutputThumbnail (in module qrenderdoc)
  • ContextMenu.TextureViewer_Thumbnail (in module qrenderdoc)
  • ContextMenu.Unknown (in module qrenderdoc)
  • ContinueDebug() (renderdoc.ReplayController method)
  • Convert() (renderdoc.CaptureFile method)
  • convertSupported (renderdoc.CaptureFileFormat attribute)
  • CopyCapture() (renderdoc.TargetControl method)
  • CopyCaptureFromRemote() (qrenderdoc.ReplayManager method)
    • (renderdoc.RemoteServer method)
  • CopyCaptureToRemote() (qrenderdoc.ReplayManager method)
    • (renderdoc.RemoteServer method)
  • copyDestination (renderdoc.ActionDescription attribute)
  • copyDestinationSubresource (renderdoc.ActionDescription attribute)
  • CopyFileTo() (renderdoc.CaptureFile method)
  • copySource (renderdoc.ActionDescription attribute)
  • copySourceSubresource (renderdoc.ActionDescription attribute)
  • counter (renderdoc.CounterDescription attribute)
    • (renderdoc.CounterResult attribute)
    • (renderdoc.ReplayController.DescribeCounter parameter)
  • counterBufferOffset (renderdoc.VKXFBBuffer attribute)
  • counterBufferResourceId (renderdoc.VKXFBBuffer attribute)
  • counterByteOffset (renderdoc.D3D12View attribute)
  • CounterDescription (class in renderdoc)
  • counterResourceId (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • CounterResult (class in renderdoc)
  • counters (renderdoc.ReplayController.FetchCounters parameter)
  • CounterUnit (class in renderdoc)
  • CounterUnit.Absolute (in module renderdoc)
  • CounterUnit.Bytes (in module renderdoc)
  • CounterUnit.Celsius (in module renderdoc)
  • CounterUnit.Cycles (in module renderdoc)
  • CounterUnit.Hertz (in module renderdoc)
  • CounterUnit.Percentage (in module renderdoc)
  • CounterUnit.Ratio (in module renderdoc)
  • CounterUnit.Seconds (in module renderdoc)
  • CounterUnit.Volt (in module renderdoc)
  • CounterValue (class in renderdoc)
  • counts (renderdoc.DrawcallStats attribute)
  • CrashReport_EmailAddress (qrenderdoc.PersistantConfig attribute)
  • CrashReport_EmailNagged (qrenderdoc.PersistantConfig attribute)
  • CrashReport_LastOpenedCapture (qrenderdoc.PersistantConfig attribute)
  • CrashReport_ReportedBugs (qrenderdoc.PersistantConfig attribute)
  • CrashReport_ShouldRememberEmail (qrenderdoc.PersistantConfig attribute)
  • CreateAndroidWindowingData() (in module renderdoc)
  • CreateBuiltinWindow() (qrenderdoc.CaptureContext method)
  • CreateButton() (qrenderdoc.MiniQtHelper method)
  • CreateCheckbox() (qrenderdoc.MiniQtHelper method)
  • CreateComboBox() (qrenderdoc.MiniQtHelper method)
  • CreateGgpWindowingData() (in module renderdoc)
  • CreateGridContainer() (qrenderdoc.MiniQtHelper method)
  • CreateGroupBox() (qrenderdoc.MiniQtHelper method)
  • CreateHeadlessWindowingData() (in module renderdoc)
  • CreateHorizontalContainer() (qrenderdoc.MiniQtHelper method)
  • CreateLabel() (qrenderdoc.MiniQtHelper method)
  • CreateMacOSWindowingData() (in module renderdoc)
  • CreateOutput() (renderdoc.ReplayController method)
  • CreateOutputRenderingWidget() (qrenderdoc.MiniQtHelper method)
  • CreateProgressBar() (qrenderdoc.MiniQtHelper method)
  • CreateRadiobox() (qrenderdoc.MiniQtHelper method)
  • CreateRemoteServerConnection() (in module renderdoc)
  • CreateRGPProfile() (renderdoc.ReplayController method)
  • CreateSpacer() (qrenderdoc.MiniQtHelper method)
  • CreateSpinbox() (qrenderdoc.MiniQtHelper method)
  • CreateTargetControl() (in module renderdoc)
  • CreateTextBox() (qrenderdoc.MiniQtHelper method)
  • CreateToplevelWidget() (qrenderdoc.MiniQtHelper method)
  • CreateVerticalContainer() (qrenderdoc.MiniQtHelper method)
  • CreateWaylandWindowingData() (in module renderdoc)
  • CreateWin32WindowingData() (in module renderdoc)
  • CreateWindowingData() (qrenderdoc.CaptureContext method)
  • CreateXCBWindowingData() (in module renderdoc)
  • CreateXlibWindowingData() (in module renderdoc)
  • creationFlags (renderdoc.BufferDescription attribute)
    • (renderdoc.TextureDescription attribute)
  • cubeCruciform (renderdoc.TextureSliceMapping attribute)
  • cubemap (renderdoc.TextureDescription attribute)
  • CullMode (class in renderdoc)
  • cullMode (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • CullMode.Back (in module renderdoc)
  • CullMode.Front (in module renderdoc)
  • CullMode.FrontAndBack (in module renderdoc)
  • CullMode.NoCull (in module renderdoc)
  • CurAction() (qrenderdoc.CaptureContext method)
  • CurD3D11PipelineState() (qrenderdoc.CaptureContext method)
  • CurD3D12PipelineState() (qrenderdoc.CaptureContext method)
  • CurEvent() (qrenderdoc.CaptureContext method)
  • CurGLPipelineState() (qrenderdoc.CaptureContext method)
  • curInstance (renderdoc.MeshDisplay attribute)
  • CurPipelineState() (qrenderdoc.CaptureContext method)
  • currentPass (renderdoc.VKState attribute)
  • CurrentRemote() (qrenderdoc.ReplayManager method)
  • CurrentResource() (qrenderdoc.ResourceInspector method)
  • CurrentStep() (qrenderdoc.ShaderViewer method)
  • CurRootActions() (qrenderdoc.CaptureContext method)
  • CurSelectedAction() (qrenderdoc.CaptureContext method)
  • CurSelectedEvent() (qrenderdoc.CaptureContext method)
  • curView (renderdoc.MeshDisplay attribute)
  • CurVulkanPipelineState() (qrenderdoc.CaptureContext method)
  • CurWindowingSystem() (qrenderdoc.CaptureContext method)
  • customLocations (renderdoc.VKSampleLocations attribute)
  • customName (renderdoc.ActionDescription attribute)
  • CustomShaderEncodings() (qrenderdoc.CaptureContext method)
  • customShaderId (renderdoc.TextureDisplay attribute)
  • CustomShaderSourcePrefixes() (qrenderdoc.CaptureContext method)
  • CycleActiveWindow() (renderdoc.TargetControl method)

D

  • d (renderdoc.CounterValue attribute)
    • (renderdoc.SDObjectPODData attribute)
  • D3D11BlendState (class in renderdoc)
  • D3D11ConstantBuffer (class in renderdoc)
  • D3D11DepthStencilState (class in renderdoc)
  • D3D11IndexBuffer (class in renderdoc)
  • D3D11InputAssembly (class in renderdoc)
  • D3D11Layout (class in renderdoc)
  • D3D11Layout.TightlyPacked (in module renderdoc)
  • D3D11OutputMerger (class in renderdoc)
  • D3D11Predication (class in renderdoc)
  • D3D11Rasterizer (class in renderdoc)
  • D3D11RasterizerState (class in renderdoc)
  • D3D11Sampler (class in renderdoc)
  • D3D11Shader (class in renderdoc)
  • D3D11State (class in renderdoc)
  • D3D11StreamOut (class in renderdoc)
  • D3D11StreamOut.NoRasterization (in module renderdoc)
  • D3D11StreamOutBind (class in renderdoc)
  • D3D11VertexBuffer (class in renderdoc)
  • D3D11View (class in renderdoc)
  • D3D12BlendState (class in renderdoc)
  • D3D12ConstantBuffer (class in renderdoc)
  • D3D12DepthStencilState (class in renderdoc)
  • D3D12IndexBuffer (class in renderdoc)
  • D3D12InputAssembly (class in renderdoc)
  • D3D12Layout (class in renderdoc)
  • D3D12Layout.TightlyPacked (in module renderdoc)
  • D3D12OM (class in renderdoc)
  • D3D12Rasterizer (class in renderdoc)
  • D3D12RasterizerState (class in renderdoc)
  • D3D12ResourceData (class in renderdoc)
  • D3D12ResourceState (class in renderdoc)
  • D3D12RootSignatureRange (class in renderdoc)
  • D3D12Sampler (class in renderdoc)
  • D3D12Shader (class in renderdoc)
  • D3D12State (class in renderdoc)
  • D3D12StreamOut (class in renderdoc)
  • D3D12StreamOut.NoRasterization (in module renderdoc)
  • D3D12StreamOutBind (class in renderdoc)
  • D3D12VertexBuffer (class in renderdoc)
  • D3D12View (class in renderdoc)
  • D3DBufferViewFlags (class in renderdoc)
  • D3DBufferViewFlags.Append (in module renderdoc)
  • D3DBufferViewFlags.Counter (in module renderdoc)
  • D3DBufferViewFlags.NoFlags (in module renderdoc)
  • D3DBufferViewFlags.Raw (in module renderdoc)
  • darkChecker (renderdoc.SetColors parameter)
  • darkTheme (renderdoc.SetColors parameter)
  • data (qrenderdoc.MiniQtHelper.SetLabelImage parameter)
    • (renderdoc.SDObject attribute)
    • (renderdoc.Thumbnail attribute)
  • debugContext (qrenderdoc.CaptureContext.DebugShader parameter)
  • debuggable (renderdoc.ShaderDebugInfo attribute)
  • debugger (renderdoc.ReplayController.ContinueDebug parameter)
    • (renderdoc.ShaderDebugTrace attribute)
  • debugInfo (renderdoc.ShaderReflection attribute)
  • DebugMessage (class in renderdoc)
  • debugMessages (renderdoc.FrameDescription attribute)
  • DebugMessages() (qrenderdoc.CaptureContext method)
  • DebugMessageView (class in qrenderdoc)
  • debugOutputMute (renderdoc.CaptureOptions attribute)
  • DebugOverlay (class in renderdoc)
  • DebugOverlay.BackfaceCull (in module renderdoc)
  • DebugOverlay.ClearBeforeDraw (in module renderdoc)
  • DebugOverlay.ClearBeforePass (in module renderdoc)
  • DebugOverlay.Clipping (in module renderdoc)
  • DebugOverlay.Depth (in module renderdoc)
  • DebugOverlay.Drawcall (in module renderdoc)
  • DebugOverlay.NaN (in module renderdoc)
  • DebugOverlay.NoOverlay (in module renderdoc)
  • DebugOverlay.QuadOverdrawDraw (in module renderdoc)
  • DebugOverlay.QuadOverdrawPass (in module renderdoc)
  • DebugOverlay.Stencil (in module renderdoc)
  • DebugOverlay.TriangleSizeDraw (in module renderdoc)
  • DebugOverlay.TriangleSizePass (in module renderdoc)
  • DebugOverlay.ViewportScissor (in module renderdoc)
  • DebugOverlay.Wireframe (in module renderdoc)
  • DebugPixel() (renderdoc.ReplayController method)
  • DebugPixelInputs (class in renderdoc)
  • DebugShader() (qrenderdoc.CaptureContext method)
  • debugStatus (renderdoc.ShaderDebugInfo attribute)
  • DebugThread() (renderdoc.ReplayController method)
  • DebugVariableReference (class in renderdoc)
  • DebugVariableType (class in renderdoc)
  • DebugVariableType.Constant (in module renderdoc)
  • DebugVariableType.Input (in module renderdoc)
  • DebugVariableType.ReadOnlyResource (in module renderdoc)
  • DebugVariableType.ReadWriteResource (in module renderdoc)
  • DebugVariableType.Sampler (in module renderdoc)
  • DebugVariableType.Undefined (in module renderdoc)
  • DebugVariableType.Variable (in module renderdoc)
  • DebugVertex() (renderdoc.ReplayController method)
  • decimalPlaces (qrenderdoc.MiniQtHelper.CreateSpinbox parameter)
  • DecodeFromString() (renderdoc.CaptureOptions method)
  • decodeYUV (renderdoc.TextureDisplay attribute)
  • DefaultArguments() (qrenderdoc.ShaderProcessingTool method)
  • DefaultCaptureSaveDirectory (qrenderdoc.PersistantConfig attribute)
  • defaultInnerLevel (renderdoc.GLFixedVertexProcessing attribute)
  • defaultOuterLevel (renderdoc.GLFixedVertexProcessing attribute)
  • DefaultReplayOptions (qrenderdoc.PersistantConfig attribute)
  • defaultValue (renderdoc.ShaderConstant attribute)
  • degraded (renderdoc.APIProperties attribute)
  • DegradedCapture_LastUpdate (qrenderdoc.PersistantConfig attribute)
  • delayForDebugger (renderdoc.CaptureOptions attribute)
  • DeleteCapture() (qrenderdoc.ReplayManager method)
    • (renderdoc.TargetControl method)
  • DeleteChildren() (renderdoc.SDObject method)
  • delta (qrenderdoc.MiniQtHelper.UpdateProgressBarValue parameter)
  • depth (renderdoc.ModificationValue attribute)
    • (renderdoc.TextureDescription attribute)
  • depthAttachment (renderdoc.GLFBO attribute)
  • depthBias (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • depthBiasClamp (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • depthBiasEnable (renderdoc.VKRasterizer attribute)
  • depthBounds (renderdoc.GLDepthState attribute)
  • depthBoundsEnable (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • depthBoundsFailed (renderdoc.PixelModification attribute)
  • depthClamp (renderdoc.GLRasterizerState attribute)
  • depthClampEnable (renderdoc.VKRasterizer attribute)
  • depthClip (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
  • depthClipEnable (renderdoc.VKRasterizer attribute)
  • depthClipped (renderdoc.PixelModification attribute)
  • depthEnable (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLDepthState attribute)
  • depthFailOperation (renderdoc.StencilFace attribute)
  • depthFeedbackAllowed (renderdoc.VKCurrentPass attribute)
  • depthFunction (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLDepthState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • depthNegativeOneToOne (renderdoc.VKViewState attribute)
  • depthOut (renderdoc.ActionDescription attribute)
  • depthReadChannel (renderdoc.GLTexture attribute)
  • depthReadOnly (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
  • depths (renderdoc.FrameStatistics attribute)
  • depthState (renderdoc.GLState attribute)
  • depthStencil (renderdoc.VKState attribute)
  • depthstencilAttachment (renderdoc.VKRenderPass attribute)
  • depthstencilResolveAttachment (renderdoc.VKRenderPass attribute)
  • depthStencilState (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
  • DepthStencilStats (class in renderdoc)
  • depthTarget (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
  • depthTestEnable (renderdoc.VKDepthStencil attribute)
  • depthTestFailed (renderdoc.PixelModification attribute)
  • depthWriteEnable (renderdoc.VKDepthStencil attribute)
  • depthWrites (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLDepthState attribute)
  • derivatives (renderdoc.GLHints attribute)
  • derivedResources (renderdoc.ResourceDescription attribute)
  • DescribeCounter() (renderdoc.ReplayController method)
  • description (qrenderdoc.EventBrowser.RegisterEventFilterFunction parameter)
    • (qrenderdoc.ExtensionMetadata attribute)
    • (renderdoc.CaptureFileFormat attribute)
    • (renderdoc.CounterDescription attribute)
    • (renderdoc.DebugMessage attribute)
  • descriptorCount (renderdoc.VKDescriptorBinding attribute)
  • descriptorSetResourceId (renderdoc.VKDescriptorSet attribute)
  • descriptorSets (renderdoc.VKPipeline attribute)
  • destination (renderdoc.BlendEquation attribute)
  • DestroyWidget() (qrenderdoc.MiniQtHelper method)
  • destType (renderdoc.TextureSave attribute)
  • deviceID (renderdoc.GPUDevice attribute)
  • DeviceProtocolController (class in renderdoc)
  • DiagnosticLogView (class in qrenderdoc)
  • DialogButton (class in qrenderdoc)
  • DialogButton.Abort (in module qrenderdoc)
  • DialogButton.Apply (in module qrenderdoc)
  • DialogButton.Cancel (in module qrenderdoc)
  • DialogButton.Close (in module qrenderdoc)
  • DialogButton.Discard (in module qrenderdoc)
  • DialogButton.Help (in module qrenderdoc)
  • DialogButton.Ignore (in module qrenderdoc)
  • DialogButton.No (in module qrenderdoc)
  • DialogButton.NoToAll (in module qrenderdoc)
  • DialogButton.OK (in module qrenderdoc)
  • DialogButton.Open (in module qrenderdoc)
  • DialogButton.Reset (in module qrenderdoc)
  • DialogButton.RestoreDefaults (in module qrenderdoc)
  • DialogButton.Retry (in module qrenderdoc)
  • DialogButton.Save (in module qrenderdoc)
  • DialogButton.SaveAll (in module qrenderdoc)
  • DialogButton.Yes (in module qrenderdoc)
  • DialogButton.YesToAll (in module qrenderdoc)
  • dimension (renderdoc.TextureDescription attribute)
  • dir (qrenderdoc.CaptureDialog.SetWorkingDirectory parameter)
    • (qrenderdoc.ExtensionManager.OpenDirectoryName parameter)
    • (qrenderdoc.ExtensionManager.OpenFileName parameter)
    • (qrenderdoc.ExtensionManager.SaveFileName parameter)
  • directories (renderdoc.ReplayController.SetCustomShaderIncludes parameter)
  • directShaderWrite (renderdoc.PixelModification attribute)
  • DisablePixelContext() (renderdoc.ReplayOutput method)
  • DisassembleShader() (qrenderdoc.ShaderProcessingTool method)
    • (renderdoc.ReplayController method)
  • disassemblyLine (qrenderdoc.ShaderViewer.ToggleBreakpointOnDisassemblyLine parameter)
    • (renderdoc.LineColumnInfo attribute)
    • (renderdoc.ShaderMessage attribute)
  • discard (renderdoc.GLFixedVertexProcessing attribute)
  • DiscardFrameCapture (C++ function)
  • discardRectangles (renderdoc.VKViewState attribute)
  • discardRectanglesExclusive (renderdoc.VKViewState attribute)
  • DisconnectFromRemoteServer() (qrenderdoc.ReplayManager method)
  • dispatchBase (renderdoc.ActionDescription attribute)
  • dispatchDimension (renderdoc.ActionDescription attribute)
  • dispatches (renderdoc.FrameStatistics attribute)
  • dispatchSize (renderdoc.MeshFormat attribute)
  • DispatchStats (class in renderdoc)
  • dispatchThreadsDimension (renderdoc.ActionDescription attribute)
    • (renderdoc.ShaderReflection attribute)
  • display (qrenderdoc.CaptureContext.ViewPixelHistory parameter)
    • (renderdoc.CreateWaylandWindowingData parameter)
    • (renderdoc.CreateXlibWindowingData parameter)
  • Display() (renderdoc.ReplayOutput method)
  • dist (renderdoc.Camera.SetArcballDistance parameter)
  • dither (renderdoc.GLFrameBuffer attribute)
  • dllname (renderdoc.CanSelfHostedCapture parameter)
    • (renderdoc.EndSelfHostCapture parameter)
    • (renderdoc.StartSelfHostCapture parameter)
  • DockReference (class in qrenderdoc)
  • DockReference.AddTo (in module qrenderdoc)
  • DockReference.BottomOf (in module qrenderdoc)
  • DockReference.BottomWindowSide (in module qrenderdoc)
  • DockReference.EmptySpace (in module qrenderdoc)
  • DockReference.LastUsedArea (in module qrenderdoc)
  • DockReference.LeftOf (in module qrenderdoc)
  • DockReference.LeftToolArea (in module qrenderdoc)
  • DockReference.LeftWindowSide (in module qrenderdoc)
  • DockReference.MainToolArea (in module qrenderdoc)
  • DockReference.NewFloatingArea (in module qrenderdoc)
  • DockReference.NoArea (in module qrenderdoc)
  • DockReference.RightOf (in module qrenderdoc)
  • DockReference.RightWindowSide (in module qrenderdoc)
  • DockReference.TopOf (in module qrenderdoc)
  • DockReference.TopWindowSide (in module qrenderdoc)
  • DockReference.TransientPopupArea (in module qrenderdoc)
  • dockWindow (qrenderdoc.CaptureContext.RaiseDockWindow parameter)
  • domainOriginUpperLeft (renderdoc.VKTessellation attribute)
  • domainShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
  • drawBuffers (renderdoc.GLFBO attribute)
  • DrawcallStats (class in renderdoc)
  • DrawcallStats.BucketCount (in module renderdoc)
  • DrawcallStats.BucketSize (in module renderdoc)
  • DrawcallStats.BucketType (in module renderdoc)
  • drawFBO (renderdoc.GLFrameBuffer attribute)
  • drawIndex (renderdoc.ActionDescription attribute)
  • draws (renderdoc.FrameStatistics attribute)
  • DrawThumbnail() (renderdoc.ReplayOutput method)
  • driver (renderdoc.GPUDevice attribute)
  • DriverInformation (class in renderdoc)
  • driverName (renderdoc.CaptureFile.SetMetadata parameter)
  • DriverName() (renderdoc.CaptureAccess method)
  • DumpObject() (in module renderdoc)
  • Duplicate() (renderdoc.SDChunk method)
    • (renderdoc.SDObject method)
  • durationMicro (renderdoc.SDChunkMetaData attribute)
  • dynamic (renderdoc.VKRenderPass attribute)
  • dynamicallyUsed (renderdoc.BoundResource attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.VKBindingElement attribute)
  • dynamicallyUsedCount (renderdoc.BoundResourceArray attribute)
    • (renderdoc.D3D12RootSignatureRange attribute)
    • (renderdoc.VKDescriptorBinding attribute)

E

  • editable (qrenderdoc.MiniQtHelper.CreateComboBox parameter)
  • editBaseFile (renderdoc.ShaderDebugInfo attribute)
  • EditShader() (qrenderdoc.CaptureContext method)
  • elementByteSize (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • elements (renderdoc.ShaderConstantType attribute)
  • ElementSize() (renderdoc.ResourceFormat method)
  • enabled (qrenderdoc.MiniQtHelper.SetWidgetEnabled parameter)
    • (renderdoc.ColorBlend attribute)
    • (renderdoc.GLVertexAttribute attribute)
    • (renderdoc.Scissor attribute)
    • (renderdoc.Viewport attribute)
  • EncodeAsString() (renderdoc.CaptureOptions method)
  • encoded (renderdoc.CaptureOptions.DecodeFromString parameter)
  • encoding (renderdoc.IsTextRepresentation parameter)
    • (renderdoc.ShaderDebugInfo attribute)
    • (renderdoc.ShaderReflection attribute)
    • (renderdoc.ShaderSourcePrefix attribute)
  • EndFrameCapture (C++ function)
  • EndSelfHostCapture() (in module renderdoc)
  • entry (renderdoc.ReplayController.BuildCustomShader parameter)
    • (renderdoc.ReplayController.BuildTargetShader parameter)
    • (renderdoc.ReplayController.GetShader parameter)
  • entryLocation (renderdoc.ShaderDebugInfo attribute)
  • entryPoint (qrenderdoc.CaptureContext.EditShader parameter)
    • (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.ShaderReflection attribute)
    • (renderdoc.VKShader attribute)
  • entrySourceName (renderdoc.ShaderDebugInfo attribute)
  • EnumerateCounters() (renderdoc.ReplayController method)
  • enumerateGPUs (renderdoc.GlobalEnvironment attribute)
  • EnumerateRemoteTargets() (in module renderdoc)
  • env (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
    • (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.InjectIntoProcess parameter)
    • (renderdoc.RemoteServer.ExecuteAndInject parameter)
  • environment (qrenderdoc.CaptureSettings attribute)
  • EnvironmentModification (class in renderdoc)
  • EnvMod (class in renderdoc)
  • EnvMod.Append (in module renderdoc)
  • EnvMod.Prepend (in module renderdoc)
  • EnvMod.Set (in module renderdoc)
  • EnvSep (class in renderdoc)
  • EnvSep.Colon (in module renderdoc)
  • EnvSep.NoSep (in module renderdoc)
  • EnvSep.Platform (in module renderdoc)
  • EnvSep.SemiColon (in module renderdoc)
  • ErrorDialog() (qrenderdoc.ExtensionManager method)
  • errors (qrenderdoc.ShaderViewer.ShowErrors parameter)
  • EventBookmark (class in qrenderdoc)
  • EventBrowser (class in qrenderdoc)
  • EventBrowser.AutoCompleteCallback() (in module qrenderdoc)
  • EventBrowser.EventFilterCallback() (in module qrenderdoc)
  • EventBrowser.FilterParseCallback() (in module qrenderdoc)
  • EventBrowser_AddFake (qrenderdoc.PersistantConfig attribute)
  • EventBrowser_ApplyColors (qrenderdoc.PersistantConfig attribute)
  • EventBrowser_ColorEventRow (qrenderdoc.PersistantConfig attribute)
  • EventBrowser_TimeUnit (qrenderdoc.PersistantConfig attribute)
  • eventId (qrenderdoc.CaptureContext.GetAction parameter)
    • (qrenderdoc.CaptureContext.RemoveBookmark parameter)
    • (qrenderdoc.CaptureContext.SetEventID parameter)
    • (qrenderdoc.CaptureViewer.OnEventChanged parameter)
    • (qrenderdoc.CaptureViewer.OnSelectedEventChanged parameter)
    • (qrenderdoc.EventBookmark attribute)
    • (qrenderdoc.EventBrowser.GetActionForEID parameter)
    • (qrenderdoc.EventBrowser.GetAPIEventForEID parameter)
    • (qrenderdoc.EventBrowser.GetEventName parameter)
    • (qrenderdoc.EventBrowser.IsAPIEventVisible parameter)
    • (qrenderdoc.RGPInterop.HasRGPEvent parameter)
    • (qrenderdoc.RGPInterop.SelectRGPEvent parameter)
    • (renderdoc.ActionDescription attribute)
    • (renderdoc.APIEvent attribute)
    • (renderdoc.CounterResult attribute)
    • (renderdoc.DebugMessage attribute)
    • (renderdoc.EventUsage attribute)
    • (renderdoc.PixelModification attribute)
    • (renderdoc.ReplayController.SetFrameEvent parameter)
  • events (renderdoc.ActionDescription attribute)
  • EventUsage (class in renderdoc)
  • exclude (qrenderdoc.CaptureContext.SetEventID parameter)
  • exe (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
  • executable (qrenderdoc.CaptureSettings attribute)
    • (qrenderdoc.ShaderProcessingTool attribute)
  • ExecuteAndInject() (in module renderdoc)
    • (qrenderdoc.ReplayManager method)
    • (renderdoc.RemoteServer method)
  • ExecuteResult (class in renderdoc)
  • exploderScale (renderdoc.MeshDisplay attribute)
  • ExportCapture() (qrenderdoc.CaptureContext method)
  • exportfile (qrenderdoc.CaptureContext.ExportCapture parameter)
  • expression (qrenderdoc.ShaderViewer.AddWatch parameter)
  • extension (renderdoc.CaptureFileFormat attribute)
  • extensionAPI (qrenderdoc.ExtensionMetadata attribute)
  • ExtensionManager (class in qrenderdoc)
  • ExtensionManager.ExtensionCallback() (in module qrenderdoc)
  • ExtensionMetadata (class in qrenderdoc)
  • Extensions() (qrenderdoc.CaptureContext method)
  • extensionURL (qrenderdoc.ExtensionMetadata attribute)
  • ExternalTool_RadeonGPUProfiler (qrenderdoc.PersistantConfig attribute)
  • extraPrimitiveOverestimationSize (renderdoc.VKRasterizer attribute)

F

  • f (renderdoc.CounterValue attribute)
  • f16v (renderdoc.ShaderValue attribute)
  • f32v (renderdoc.ShaderValue attribute)
  • f64v (renderdoc.ShaderValue attribute)
  • failOperation (renderdoc.StencilFace attribute)
  • farBound (renderdoc.GLDepthState attribute)
  • farPlane (renderdoc.MeshFormat attribute)
  • feedbackLoop (renderdoc.VKRenderPass attribute)
  • feedbackResourceId (renderdoc.GLFeedback attribute)
  • FetchCounters() (renderdoc.ReplayController method)
  • file (qrenderdoc.AddRecentFile parameter)
    • (qrenderdoc.RemoveRecentFile parameter)
    • (renderdoc.CaptureFile.Convert parameter)
    • (renderdoc.CaptureFile.SetStructuredData parameter)
    • (renderdoc.LogMessage parameter)
  • FileChanged() (renderdoc.ReplayController method)
  • fileIndex (renderdoc.LineColumnInfo attribute)
  • filename (qrenderdoc.CaptureContext.OpenRGPProfile parameter)
    • (qrenderdoc.CaptureDialog.LoadSettings parameter)
    • (qrenderdoc.CaptureDialog.SaveSettings parameter)
    • (qrenderdoc.CaptureDialog.SetExecutableFilename parameter)
    • (qrenderdoc.ConfigFilePath parameter)
    • (qrenderdoc.PersistantConfig.Load parameter)
    • (qrenderdoc.PythonShell.LoadScriptFromFilename parameter)
    • (renderdoc.CaptureFile.Convert parameter)
    • (renderdoc.CaptureFile.CopyFileTo parameter)
    • (renderdoc.CaptureFile.OpenFile parameter)
    • (renderdoc.PathEntry attribute)
    • (renderdoc.RemoteServer.CopyCaptureToRemote parameter)
    • (renderdoc.RemoteServer.TakeOwnershipCapture parameter)
    • (renderdoc.SetDebugLogFile parameter)
    • (renderdoc.ShaderSourceFile attribute)
  • fileOffset (renderdoc.APIEvent attribute)
    • (renderdoc.FrameDescription attribute)
  • filePath (qrenderdoc.ExtensionMetadata attribute)
  • files (qrenderdoc.CaptureContext.EditShader parameter)
    • (renderdoc.ShaderDebugInfo attribute)
  • FileType (class in renderdoc)
  • filetype (renderdoc.CaptureFile.Convert parameter)
    • (renderdoc.CaptureFile.OpenBuffer parameter)
    • (renderdoc.CaptureFile.OpenFile parameter)
  • FileType.BMP (in module renderdoc)
  • FileType.DDS (in module renderdoc)
  • FileType.EXR (in module renderdoc)
  • FileType.HDR (in module renderdoc)
  • FileType.JPG (in module renderdoc)
  • FileType.PNG (in module renderdoc)
  • FileType.Raw (in module renderdoc)
  • FileType.TGA (in module renderdoc)
  • FillMode (class in renderdoc)
  • fillMode (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • FillMode.Point (in module renderdoc)
  • FillMode.Solid (in module renderdoc)
  • FillMode.Wireframe (in module renderdoc)
  • filter (qrenderdoc.EventBrowser.RegisterEventFilterFunction parameter)
    • (qrenderdoc.ExtensionManager.OpenFileName parameter)
    • (qrenderdoc.ExtensionManager.SaveFileName parameter)
    • (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.TextureFilter attribute)
    • (renderdoc.VKBindingElement attribute)
  • FilterFunction (class in renderdoc)
  • FilterFunction.Comparison (in module renderdoc)
  • FilterFunction.Maximum (in module renderdoc)
  • FilterFunction.Minimum (in module renderdoc)
  • FilterFunction.Normal (in module renderdoc)
  • FilterMode (class in renderdoc)
  • FilterMode.Anisotropic (in module renderdoc)
  • FilterMode.Cubic (in module renderdoc)
  • FilterMode.Linear (in module renderdoc)
  • FilterMode.NoFilter (in module renderdoc)
  • FilterMode.Point (in module renderdoc)
  • FindChild() (renderdoc.SDObject method)
  • FindChildByName() (qrenderdoc.MiniQtHelper method)
  • FindChildRecursively() (renderdoc.SDObject method)
  • FindSectionByName() (renderdoc.CaptureAccess method)
  • FindSectionByType() (renderdoc.CaptureAccess method)
  • firstElement (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • firstIndex (renderdoc.BoundResourceArray attribute)
  • firstMip (renderdoc.BoundResource attribute)
    • (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.GLTexture attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • firstSlice (renderdoc.BoundResource attribute)
    • (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • firstUsedIndex (renderdoc.D3D12RootSignatureRange attribute)
    • (renderdoc.VKDescriptorBinding attribute)
  • flag (renderdoc.ResourceFormat.SetBGRAOrder parameter)
  • flags (qrenderdoc.CaptureContext.EditShader parameter)
    • (renderdoc.ActionDescription attribute)
    • (renderdoc.PathEntry attribute)
    • (renderdoc.SDChunkMetaData attribute)
    • (renderdoc.SDType attribute)
    • (renderdoc.SectionProperties attribute)
    • (renderdoc.ShaderCompileFlags attribute)
    • (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderDebugState attribute)
    • (renderdoc.ShaderVariable attribute)
    • (renderdoc.VKPipeline attribute)
  • flipY (renderdoc.MeshFormat attribute)
    • (renderdoc.TextureDisplay attribute)
  • floatCast (renderdoc.GLVertexAttribute attribute)
  • floatCastWrong (renderdoc.VertexInputAttribute attribute)
  • FloatToHalf() (in module renderdoc)
  • floatValue (renderdoc.PixelValue attribute)
  • FloatVector (class in renderdoc)
  • flt (renderdoc.FloatToHalf parameter)
  • fmt (qrenderdoc.CaptureContext.ExportCapture parameter)
    • (qrenderdoc.CaptureContext.ImportCapture parameter)
  • focus (qrenderdoc.TextureViewer.ViewTexture parameter)
  • FollowType (class in qrenderdoc)
  • followType (qrenderdoc.TextureViewer.ViewFollowedResource parameter)
  • FollowType.OutputColor (in module qrenderdoc)
  • FollowType.OutputDepth (in module qrenderdoc)
  • FollowType.OutputDepthResolve (in module qrenderdoc)
  • FollowType.ReadOnly (in module qrenderdoc)
  • FollowType.ReadWrite (in module qrenderdoc)
  • font (qrenderdoc.MiniQtHelper.SetWidgetFont parameter)
  • Font_Family (qrenderdoc.PersistantConfig attribute)
  • Font_GlobalScale (qrenderdoc.PersistantConfig attribute)
  • Font_MonoFamily (qrenderdoc.PersistantConfig attribute)
  • Font_PreferMonospaced (qrenderdoc.PersistantConfig attribute)
  • fontSize (qrenderdoc.MiniQtHelper.SetWidgetFont parameter)
  • force (qrenderdoc.CaptureContext.SetEventID parameter)
    • (renderdoc.ReplayController.SetFrameEvent parameter)
  • forceConnection (renderdoc.CreateTargetControl parameter)
  • forcedSampleCount (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
  • forceExplicitReconstruction (renderdoc.VKBindingElement attribute)
  • forceGPUDeviceID (renderdoc.ReplayOptions attribute)
  • forceGPUDriverName (renderdoc.ReplayOptions attribute)
  • forceGPUVendor (renderdoc.ReplayOptions attribute)
  • format (qrenderdoc.CaptureContext.ViewBuffer parameter)
    • (qrenderdoc.CaptureContext.ViewTextureAsBuffer parameter)
    • (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
    • (renderdoc.GLVertexAttribute attribute)
    • (renderdoc.MeshFormat attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.VertexInputAttribute attribute)
    • (renderdoc.VKVertexAttribute attribute)
  • Formatter_MaxFigures (qrenderdoc.PersistantConfig attribute)
  • Formatter_MinFigures (qrenderdoc.PersistantConfig attribute)
  • Formatter_NegExp (qrenderdoc.PersistantConfig attribute)
  • Formatter_OffsetSizeDisplayMode (qrenderdoc.PersistantConfig attribute)
  • Formatter_PosExp (qrenderdoc.PersistantConfig attribute)
  • fov (renderdoc.MeshDisplay attribute)
  • fragIndex (renderdoc.PixelModification attribute)
  • fragmentDensityAttachment (renderdoc.VKRenderPass attribute)
  • fragmentDensityOffsets (renderdoc.VKRenderPass attribute)
  • fragmentShader (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • framebuffer (renderdoc.GLState attribute)
    • (renderdoc.VKCurrentPass attribute)
  • framebufferSRGB (renderdoc.GLFrameBuffer attribute)
  • FrameDescription (class in renderdoc)
  • FrameDescription.NoFrameNumber (in module renderdoc)
  • FrameInfo() (qrenderdoc.CaptureContext method)
  • frameNumber (renderdoc.FrameDescription attribute)
    • (renderdoc.NewCaptureData attribute)
    • (renderdoc.TargetControl.QueueCapture parameter)
  • FrameStatistics (class in renderdoc)
  • FreeCustomShader() (renderdoc.ReplayController method)
  • FreeTargetResource() (renderdoc.ReplayController method)
  • FreeTrace() (renderdoc.ReplayController method)
  • FriendlyName() (qrenderdoc.RemoteHost method)
  • from (qrenderdoc.CaptureContext.RegisterReplacement parameter)
  • frontCCW (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • frontFace (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLStencilState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • function (renderdoc.StencilFace attribute)

G

  • genericEnabled (renderdoc.VertexInputAttribute attribute)
  • genericValue (renderdoc.GLVertexAttribute attribute)
    • (renderdoc.VertexInputAttribute attribute)
  • geometry (renderdoc.ShaderMessageLocation attribute)
  • geometryShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • GetAction() (qrenderdoc.CaptureContext method)
  • GetActionForEID() (qrenderdoc.EventBrowser method)
  • GetAPI() (renderdoc.TargetControl method)
  • GetAPIEventForEID() (qrenderdoc.EventBrowser method)
  • GetAPIInspector() (qrenderdoc.CaptureContext method)
  • GetAPIProperties() (renderdoc.ReplayController method)
  • GetAPIVersion (C++ function)
  • GetAvailableGPUs() (renderdoc.CaptureAccess method)
  • GetBinding() (renderdoc.ShaderVariable method)
  • GetBindpointMapping() (renderdoc.PipeState method)
  • GetBookmarks() (qrenderdoc.CaptureContext method)
  • GetBuffer() (qrenderdoc.CaptureContext method)
  • GetBufferData() (renderdoc.ReplayController method)
  • GetBuffers() (qrenderdoc.CaptureContext method)
    • (renderdoc.ReplayController method)
  • GetBusyClient() (renderdoc.TargetControl method)
  • GetCapture (C++ function)
  • GetCaptureAccess() (qrenderdoc.ReplayManager method)
  • GetCaptureDialog() (qrenderdoc.CaptureContext method)
  • GetCaptureFile() (qrenderdoc.ReplayManager method)
  • GetCaptureFileFormats() (renderdoc.CaptureFile method)
  • GetCaptureFilename() (qrenderdoc.CaptureContext method)
  • GetCaptureFilePathTemplate (C++ function)
  • GetCaptureModifications() (qrenderdoc.CaptureContext method)
  • GetCaptureOptionF32 (C++ function)
  • GetCaptureOptionU32 (C++ function)
  • GetCBufferVariableContents() (renderdoc.ReplayController method)
  • GetChannelVisibilityBits() (qrenderdoc.TextureViewer method)
  • GetChild() (qrenderdoc.MiniQtHelper method)
    • (renderdoc.SDObject method)
  • GetColorBlends() (renderdoc.PipeState method)
  • GetComboCount() (qrenderdoc.MiniQtHelper method)
  • GetComments() (qrenderdoc.CommentView method)
  • GetCommentView() (qrenderdoc.CaptureContext method)
  • GetCommitHash() (in module renderdoc)
  • GetComputePipelineObject() (renderdoc.PipeState method)
  • GetConfigSetting() (in module renderdoc)
  • GetConstantBuffer() (renderdoc.PipeState method)
  • GetCurrentFileContents() (qrenderdoc.ShaderViewer method)
  • GetCurrentFilterText() (qrenderdoc.EventBrowser method)
  • GetCurrentProcessingTime() (qrenderdoc.ReplayManager method)
  • GetCurrentProcessMemoryUsage() (in module renderdoc)
  • GetCurrentResource() (qrenderdoc.TextureViewer method)
  • GetCustomShaderEncodings() (renderdoc.ReplayController method)
  • GetCustomShaderSourcePrefixes() (renderdoc.ReplayController method)
  • GetCustomShaderTexID() (renderdoc.ReplayOutput method)
  • GetD3D11PipelineState() (renderdoc.ReplayController method)
  • GetD3D12PipelineState() (renderdoc.ReplayController method)
  • GetDebugMessages() (renderdoc.ReplayController method)
  • GetDebugMessageView() (qrenderdoc.CaptureContext method)
  • GetDebugOverlayTexID() (renderdoc.ReplayOutput method)
  • GetDefaultCaptureOptions() (in module renderdoc)
  • GetDepthResolveTarget() (renderdoc.PipeState method)
  • GetDepthTarget() (renderdoc.PipeState method)
  • GetDeviceProtocolController() (in module renderdoc)
  • GetDevices() (renderdoc.DeviceProtocolController method)
  • GetDiagnosticLogView() (qrenderdoc.CaptureContext method)
  • GetDimensions() (renderdoc.ReplayOutput method)
  • GetDisassemblyTargets() (renderdoc.ReplayController method)
  • GetDriverInformation() (in module renderdoc)
  • GetEvent() (qrenderdoc.ShaderMessageViewer method)
  • GetEventBrowser() (qrenderdoc.CaptureContext method)
  • GetEventName() (qrenderdoc.EventBrowser method)
  • GetFatalError() (qrenderdoc.CaptureContext method)
  • GetFatalErrorStatus() (renderdoc.ReplayController method)
  • GetFirstAction() (qrenderdoc.CaptureContext method)
  • GetForward() (renderdoc.Camera method)
  • GetFrameInfo() (renderdoc.ReplayController method)
  • GetFriendlyName() (renderdoc.DeviceProtocolController method)
  • GetGLPipelineState() (renderdoc.ReplayController method)
  • GetGraphicsPipelineObject() (renderdoc.PipeState method)
  • GetHistogram() (renderdoc.ReplayController method)
  • GetHistogramRange() (qrenderdoc.TextureViewer method)
  • GetHomeFolder() (qrenderdoc.ReplayManager method)
    • (renderdoc.RemoteServer method)
  • GetIBuffer() (renderdoc.PipeState method)
  • GetInstalledExtensions() (qrenderdoc.ExtensionManager method)
  • GetLastAction() (qrenderdoc.CaptureContext method)
  • GetLogFile() (in module renderdoc)
  • GetMainWindow() (qrenderdoc.CaptureContext method)
  • GetMeshPreview() (qrenderdoc.CaptureContext method)
  • GetMiniQtHelper() (qrenderdoc.ExtensionManager method)
  • GetMinMax() (renderdoc.ReplayController method)
  • GetName() (renderdoc.ActionDescription method)
  • GetNotes() (qrenderdoc.CaptureContext method)
  • GetNumCaptures (C++ function)
  • GetNumChildren() (qrenderdoc.MiniQtHelper method)
  • GetOutputTargets() (renderdoc.PipeState method)
  • GetOverlayBits (C++ function)
  • GetParent() (qrenderdoc.MiniQtHelper method)
    • (renderdoc.SDObject method)
  • GetPerformanceCounterViewer() (qrenderdoc.CaptureContext method)
  • GetPickedLocation() (qrenderdoc.TextureViewer method)
  • GetPID() (renderdoc.TargetControl method)
  • GetPipelineState() (renderdoc.ReplayController method)
  • GetPipelineViewer() (qrenderdoc.CaptureContext method)
  • GetPointer() (renderdoc.ShaderVariable method)
  • GetPosition() (renderdoc.Camera method)
  • GetPostVSData() (renderdoc.ReplayController method)
  • GetPrimitiveTopology() (renderdoc.PipeState method)
  • GetProgressBarMaximum() (qrenderdoc.MiniQtHelper method)
  • GetProgressBarMinimum() (qrenderdoc.MiniQtHelper method)
  • GetProgressBarValue() (qrenderdoc.MiniQtHelper method)
  • GetProtocolName() (renderdoc.DeviceProtocolController method)
  • GetPythonShell() (qrenderdoc.CaptureContext method)
  • GetRasterizedStream() (renderdoc.PipeState method)
  • GetReadOnlyResources() (renderdoc.PipeState method)
  • GetReadWriteResources() (renderdoc.PipeState method)
  • GetRemoteHost() (qrenderdoc.PersistantConfig method)
  • GetRemoteHosts() (qrenderdoc.PersistantConfig method)
  • GetRemoteSupport() (qrenderdoc.ReplayManager method)
  • GetResolve() (renderdoc.CaptureAccess method)
  • GetResource() (qrenderdoc.CaptureContext method)
  • GetResourceInspector() (qrenderdoc.CaptureContext method)
  • GetResourceLayout() (renderdoc.PipeState method)
  • GetResourceName() (qrenderdoc.CaptureContext method)
  • GetResourceNameUnsuffixed() (qrenderdoc.CaptureContext method)
  • GetResourceReplacement() (qrenderdoc.CaptureContext method)
  • GetResources() (qrenderdoc.CaptureContext method)
    • (renderdoc.ReplayController method)
  • GetRestartIndex() (renderdoc.PipeState method)
  • GetRGPInterop() (qrenderdoc.CaptureContext method)
  • GetRight() (renderdoc.Camera method)
  • GetRootActions() (renderdoc.ReplayController method)
  • GetSamplers() (renderdoc.PipeState method)
  • GetScissor() (renderdoc.PipeState method)
  • GetScriptText() (qrenderdoc.PythonShell method)
  • GetSectionContents() (renderdoc.CaptureAccess method)
  • GetSectionCount() (renderdoc.CaptureAccess method)
  • GetSectionProperties() (renderdoc.CaptureAccess method)
  • GetSelectedSubresource() (qrenderdoc.TextureViewer method)
  • GetShader() (renderdoc.PipeState method)
    • (renderdoc.ReplayController method)
  • GetShaderEntryPoint() (renderdoc.PipeState method)
  • GetShaderEntryPoints() (renderdoc.ReplayController method)
  • GetShaderMessages() (qrenderdoc.ShaderMessageViewer method)
    • (renderdoc.PipeState method)
  • GetShaderReflection() (renderdoc.PipeState method)
  • GetSpinboxValue() (qrenderdoc.MiniQtHelper method)
  • GetStatisticsViewer() (qrenderdoc.CaptureContext method)
  • GetStencilFaces() (renderdoc.PipeState method)
  • GetStructuredData() (renderdoc.CaptureFile method)
  • GetStructuredFile() (qrenderdoc.CaptureContext method)
    • (renderdoc.ReplayController method)
  • GetSupportedDeviceProtocols() (in module renderdoc)
  • GetSupportedWindowSystems() (renderdoc.ReplayController method)
  • GetTarget() (renderdoc.TargetControl method)
  • GetTargetShaderEncodings() (renderdoc.ReplayController method)
  • GetTexture() (qrenderdoc.CaptureContext method)
  • GetTextureData() (renderdoc.ReplayController method)
  • GetTextureOverlay() (qrenderdoc.TextureViewer method)
  • GetTextures() (qrenderdoc.CaptureContext method)
    • (renderdoc.ReplayController method)
  • GetTextureViewer() (qrenderdoc.CaptureContext method)
  • GetThumbnail() (renderdoc.CaptureFile method)
  • GetTimelineBar() (qrenderdoc.CaptureContext method)
  • GetUp() (renderdoc.Camera method)
  • GetUsage() (renderdoc.ReplayController method)
  • GetVBuffers() (renderdoc.PipeState method)
  • GetVersionString() (in module renderdoc)
  • GetVertexInputs() (renderdoc.PipeState method)
  • GetViewport() (renderdoc.PipeState method)
  • GetVulkanPipelineState() (renderdoc.ReplayController method)
  • GetWidgetName() (qrenderdoc.MiniQtHelper method)
  • GetWidgetText() (qrenderdoc.MiniQtHelper method)
  • GetWidgetType() (qrenderdoc.MiniQtHelper method)
  • GetWidgetWindowingData() (qrenderdoc.MiniQtHelper method)
  • GetZoomLevel() (qrenderdoc.TextureViewer method)
  • givenName (renderdoc.ResourceDescription.SetCustomName parameter)
  • GLAttachment (class in renderdoc)
  • GLBlendState (class in renderdoc)
  • GLBuffer (class in renderdoc)
  • GLDepthState (class in renderdoc)
  • GLFBO (class in renderdoc)
  • GLFeedback (class in renderdoc)
  • GLFixedVertexProcessing (class in renderdoc)
  • GLFrameBuffer (class in renderdoc)
  • GLHints (class in renderdoc)
  • GLImageLoadStore (class in renderdoc)
  • globalEnv (renderdoc.InitialiseReplay parameter)
  • GlobalEnvironment (class in renderdoc)
  • GLRasterizer (class in renderdoc)
  • GLRasterizerState (class in renderdoc)
  • GLSampler (class in renderdoc)
  • GLShader (class in renderdoc)
  • GLState (class in renderdoc)
  • GLStencilState (class in renderdoc)
  • GLTexture (class in renderdoc)
  • GLVertexAttribute (class in renderdoc)
  • GLVertexBuffer (class in renderdoc)
  • GLVertexInput (class in renderdoc)
  • GotoLocation() (qrenderdoc.TextureViewer method)
  • gpuAddress (renderdoc.BufferDescription attribute)
  • GPUCounter (class in renderdoc)
  • GPUCounter.ASInvocations (in module renderdoc)
  • GPUCounter.CSInvocations (in module renderdoc)
  • GPUCounter.DSInvocations (in module renderdoc)
  • GPUCounter.EventGPUDuration (in module renderdoc)
  • GPUCounter.FirstAMD (in module renderdoc)
  • GPUCounter.FirstARM (in module renderdoc)
  • GPUCounter.FirstIntel (in module renderdoc)
  • GPUCounter.FirstNvidia (in module renderdoc)
  • GPUCounter.FirstVulkanExtended (in module renderdoc)
  • GPUCounter.FSInvocations (in module renderdoc)
  • GPUCounter.GSInvocations (in module renderdoc)
  • GPUCounter.GSPrimitives (in module renderdoc)
  • GPUCounter.HSInvocations (in module renderdoc)
  • GPUCounter.IAPrimitives (in module renderdoc)
  • GPUCounter.InputVerticesRead (in module renderdoc)
  • GPUCounter.LastAMD (in module renderdoc)
  • GPUCounter.LastARM (in module renderdoc)
  • GPUCounter.LastIntel (in module renderdoc)
  • GPUCounter.LastNvidia (in module renderdoc)
  • GPUCounter.LastVulkanExtended (in module renderdoc)
  • GPUCounter.MSInvocations (in module renderdoc)
  • GPUCounter.PSInvocations (in module renderdoc)
  • GPUCounter.RasterizedPrimitives (in module renderdoc)
  • GPUCounter.RasterizerInvocations (in module renderdoc)
  • GPUCounter.SamplesPassed (in module renderdoc)
  • GPUCounter.TCSInvocations (in module renderdoc)
  • GPUCounter.TESInvocations (in module renderdoc)
  • GPUCounter.TSInvocations (in module renderdoc)
  • GPUCounter.VSInvocations (in module renderdoc)
  • GPUDevice (class in renderdoc)
  • GPUVendor (class in renderdoc)
  • GPUVendor.AMD (in module renderdoc)
  • GPUVendor.ARM (in module renderdoc)
  • GPUVendor.Broadcom (in module renderdoc)
  • GPUVendor.Imagination (in module renderdoc)
  • GPUVendor.Intel (in module renderdoc)
  • GPUVendor.nVidia (in module renderdoc)
  • GPUVendor.Qualcomm (in module renderdoc)
  • GPUVendor.Samsung (in module renderdoc)
  • GPUVendor.Software (in module renderdoc)
  • GPUVendor.Unknown (in module renderdoc)
  • GPUVendor.Verisilicon (in module renderdoc)
  • GPUVendorFromPCIVendor() (in module renderdoc)
  • graphics (renderdoc.VKState attribute)
  • GraphicsAPI (class in renderdoc)
  • GraphicsAPI.D3D11 (in module renderdoc)
  • GraphicsAPI.D3D12 (in module renderdoc)
  • GraphicsAPI.OpenGL (in module renderdoc)
  • GraphicsAPI.Vulkan (in module renderdoc)
  • green (qrenderdoc.MiniQtHelper.SetWidgetBackgroundColor parameter)
    • (qrenderdoc.TextureViewer.SetChannelVisibility parameter)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSwizzle4 attribute)
  • gridHeight (renderdoc.VKSampleLocations attribute)
  • gridWidth (renderdoc.VKSampleLocations attribute)
  • groupid (renderdoc.ReplayController.DebugThread parameter)

H

  • half (renderdoc.HalfToFloat parameter)
  • HalfToFloat() (in module renderdoc)
  • HasAlignedPostVSData() (renderdoc.PipeState method)
  • HasAPIInspector() (qrenderdoc.CaptureContext method)
  • HasCallstacks() (renderdoc.CaptureAccess method)
  • HasCaptureDialog() (qrenderdoc.CaptureContext method)
  • HasCommentView() (qrenderdoc.CaptureContext method)
  • HasDebugMessageView() (qrenderdoc.CaptureContext method)
  • HasDiagnosticLogView() (qrenderdoc.CaptureContext method)
  • HasEqualValue() (renderdoc.SDObject method)
  • HasEventBrowser() (qrenderdoc.CaptureContext method)
  • HasMeshPreview() (qrenderdoc.CaptureContext method)
  • HasPerformanceCounterViewer() (qrenderdoc.CaptureContext method)
  • HasPipelineViewer() (qrenderdoc.CaptureContext method)
  • HasPythonShell() (qrenderdoc.CaptureContext method)
  • HasResourceCustomName() (qrenderdoc.CaptureContext method)
  • HasResourceInspector() (qrenderdoc.CaptureContext method)
  • HasRGPEvent() (qrenderdoc.RGPInterop method)
  • HasStatisticsViewer() (qrenderdoc.CaptureContext method)
  • HasTextureViewer() (qrenderdoc.CaptureContext method)
  • HasTimelineBar() (qrenderdoc.CaptureContext method)
  • hdrMultiplier (renderdoc.TextureDisplay attribute)
  • height (qrenderdoc.MiniQtHelper.SetLabelImage parameter)
    • (renderdoc.CreateHeadlessWindowingData parameter)
    • (renderdoc.ReplayOutput.DrawThumbnail parameter)
    • (renderdoc.ReplayOutput.SetDimensions parameter)
    • (renderdoc.Scissor attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.Thumbnail attribute)
    • (renderdoc.Viewport attribute)
    • (renderdoc.VKFramebuffer attribute)
    • (renderdoc.VKRenderArea attribute)
  • HighlightHistory() (qrenderdoc.TimelineBar method)
  • HighlightResourceUsage() (qrenderdoc.TimelineBar method)
  • highlightVert (renderdoc.MeshDisplay attribute)
  • hints (renderdoc.GLState attribute)
  • history (qrenderdoc.PixelHistoryView.SetHistory parameter)
    • (qrenderdoc.TimelineBar.HighlightHistory parameter)
  • hookIntoChildren (renderdoc.CaptureOptions attribute)
  • horizontal (qrenderdoc.MiniQtHelper.CreateProgressBar parameter)
    • (qrenderdoc.MiniQtHelper.CreateSpacer parameter)
  • host (qrenderdoc.CaptureContext.ConnectToRemoteServer parameter)
    • (qrenderdoc.PersistantConfig.AddRemoteHost parameter)
    • (qrenderdoc.PersistantConfig.RemoveRemoteHost parameter)
    • (qrenderdoc.ReplayManager.ConnectToRemoteServer parameter)
  • hostname (qrenderdoc.PersistantConfig.GetRemoteHost parameter)
  • Hostname() (qrenderdoc.RemoteHost method)
  • hullShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)

I

  • i (renderdoc.SDObjectPODData attribute)
  • id (qrenderdoc.CaptureContext.EditShader parameter)
    • (qrenderdoc.CaptureContext.GetBuffer parameter)
    • (qrenderdoc.CaptureContext.GetResource parameter)
    • (qrenderdoc.CaptureContext.GetResourceName parameter)
    • (qrenderdoc.CaptureContext.GetResourceNameUnsuffixed parameter)
    • (qrenderdoc.CaptureContext.GetResourceReplacement parameter)
    • (qrenderdoc.CaptureContext.GetTexture parameter)
    • (qrenderdoc.CaptureContext.HasResourceCustomName parameter)
    • (qrenderdoc.CaptureContext.IsAutogeneratedName parameter)
    • (qrenderdoc.CaptureContext.IsResourceReplaced parameter)
    • (qrenderdoc.CaptureContext.SetResourceCustomName parameter)
    • (qrenderdoc.CaptureContext.UnregisterReplacement parameter)
    • (qrenderdoc.CaptureContext.ViewBuffer parameter)
    • (qrenderdoc.CaptureContext.ViewPixelHistory parameter)
    • (qrenderdoc.CaptureContext.ViewTextureAsBuffer parameter)
    • (qrenderdoc.ResourceInspector.Inspect parameter)
    • (qrenderdoc.TimelineBar.HighlightHistory parameter)
    • (qrenderdoc.TimelineBar.HighlightResourceUsage parameter)
    • (renderdoc.PipeState.GetResourceLayout parameter)
    • (renderdoc.ReplayController.FreeCustomShader parameter)
    • (renderdoc.ReplayController.FreeTargetResource parameter)
    • (renderdoc.ReplayController.GetUsage parameter)
    • (renderdoc.ReplayController.RemoveReplacement parameter)
    • (renderdoc.SDObjectPODData attribute)
  • ident (renderdoc.CreateTargetControl parameter)
    • (renderdoc.ExecuteResult attribute)
    • (renderdoc.NewChildData attribute)
  • idx (qrenderdoc.CaptureContext.ViewConstantBuffer parameter)
    • (renderdoc.ReplayController.DebugVertex parameter)
  • imageFormat (renderdoc.GLImageLoadStore attribute)
  • imageResourceId (renderdoc.VKAttachment attribute)
  • images (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • immediate (renderdoc.D3D12RootSignatureRange attribute)
  • immutableSampler (renderdoc.VKBindingElement attribute)
  • ImportCapture() (qrenderdoc.CaptureContext method)
  • importfile (qrenderdoc.CaptureContext.ImportCapture parameter)
  • independentBlend (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D12BlendState attribute)
  • index (qrenderdoc.MiniQtHelper.GetChild parameter)
    • (qrenderdoc.MiniQtHelper.InsertWidget parameter)
    • (qrenderdoc.TextureViewer.ViewFollowedResource parameter)
    • (renderdoc.CaptureAccess.GetSectionContents parameter)
    • (renderdoc.CaptureAccess.GetSectionProperties parameter)
    • (renderdoc.PipeState.GetScissor parameter)
    • (renderdoc.PipeState.GetViewport parameter)
    • (renderdoc.SDObject.GetChild parameter)
    • (renderdoc.SDObject.RemoveChild parameter)
  • IndexBindStats (class in renderdoc)
  • indexBuffer (renderdoc.D3D11InputAssembly attribute)
    • (renderdoc.D3D12InputAssembly attribute)
    • (renderdoc.GLVertexInput attribute)
    • (renderdoc.VKInputAssembly attribute)
  • indexByteOffset (renderdoc.MeshFormat attribute)
  • indexByteSize (renderdoc.MeshFormat attribute)
  • indexByteStride (renderdoc.GLVertexInput attribute)
    • (renderdoc.MeshFormat attribute)
  • indexOffset (renderdoc.ActionDescription attribute)
  • indexResourceId (renderdoc.MeshFormat attribute)
  • indexStripCutValue (renderdoc.D3D12InputAssembly attribute)
  • indices (renderdoc.FrameStatistics attribute)
  • indirect (renderdoc.DispatchStats attribute)
    • (renderdoc.DrawcallStats attribute)
  • InitCamera() (in module renderdoc)
  • initDataSize (renderdoc.FrameDescription attribute)
  • initialisationChunks (renderdoc.ResourceDescription attribute)
  • InitialiseReplay() (in module renderdoc)
  • InitResolver() (renderdoc.CaptureAccess method)
  • inject (qrenderdoc.CaptureDialog.SetInjectMode parameter)
    • (qrenderdoc.CaptureSettings attribute)
  • InjectIntoProcess() (in module renderdoc)
  • inlineBlock (renderdoc.VKBindingElement attribute)
  • inlineData (renderdoc.BoundCBuffer attribute)
    • (renderdoc.VKDescriptorSet attribute)
  • inlineDataBytes (renderdoc.ConstantBlock attribute)
  • input (qrenderdoc.ShaderProcessingTool attribute)
  • inputAssembly (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
    • (renderdoc.VKState attribute)
  • inputAttachments (renderdoc.VKRenderPass attribute)
  • inputAttributes (renderdoc.ShaderBindpointMapping attribute)
  • inputs (renderdoc.ReplayController.DebugPixel parameter)
    • (renderdoc.ShaderDebugTrace attribute)
  • inputSignature (renderdoc.ShaderReflection attribute)
  • inputSlot (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
  • InsertWidget() (qrenderdoc.MiniQtHelper method)
  • Inspect() (qrenderdoc.ResourceInspector method)
  • instance (qrenderdoc.BufferViewer.SetCurrentInstance parameter)
    • (renderdoc.ReplayController.GetPostVSData parameter)
    • (renderdoc.ShaderVertexMessageLocation attribute)
  • instanced (renderdoc.DrawcallStats attribute)
    • (renderdoc.MeshFormat attribute)
  • instanceDataStepRate (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
  • instanceDivisor (renderdoc.GLVertexBuffer attribute)
    • (renderdoc.VKVertexBinding attribute)
  • instanceOffset (renderdoc.ActionDescription attribute)
  • instanceRate (renderdoc.VertexInputAttribute attribute)
  • instid (renderdoc.ReplayController.DebugVertex parameter)
  • instInfo (renderdoc.ShaderDebugTrace attribute)
  • instruction (qrenderdoc.ShaderViewer.ToggleBreakpointOnInstruction parameter)
    • (renderdoc.InstructionSourceInfo attribute)
  • InstructionSourceInfo (class in renderdoc)
  • instStepRate (renderdoc.MeshFormat attribute)
  • interactive (renderdoc.CaptureAccess.InitResolver parameter)
  • interfaces (renderdoc.ShaderReflection attribute)
  • intValue (renderdoc.PixelValue attribute)
  • InvokeOntoUIThread() (qrenderdoc.MiniQtHelper method)
  • IsAMDCounter() (in module renderdoc)
  • IsAPIEventVisible() (qrenderdoc.EventBrowser method)
  • IsARMCounter() (in module renderdoc)
  • IsAutogeneratedName() (qrenderdoc.CaptureContext method)
  • IsBusy() (qrenderdoc.RemoteHost method)
  • IsCaptureD3D11() (renderdoc.PipeState method)
  • IsCaptureD3D12() (renderdoc.PipeState method)
  • IsCaptureGL() (renderdoc.PipeState method)
  • IsCaptureLoaded() (qrenderdoc.CaptureContext method)
    • (renderdoc.PipeState method)
  • IsCaptureLoading() (qrenderdoc.CaptureContext method)
  • IsCaptureLocal() (qrenderdoc.CaptureContext method)
  • IsCaptureTemporary() (qrenderdoc.CaptureContext method)
  • IsCaptureVK() (renderdoc.PipeState method)
  • IsConnected() (qrenderdoc.RemoteHost method)
  • IsD3D() (in module renderdoc)
  • IsExtensionLoaded() (qrenderdoc.ExtensionManager method)
  • IsFakeMarker() (renderdoc.ActionDescription method)
  • IsFrameCapturing (C++ function)
  • IsGenericCounter() (in module renderdoc)
  • IsGlobalHookActive() (in module renderdoc)
  • IsIndependentBlendingEnabled() (renderdoc.PipeState method)
  • IsInjectMode() (qrenderdoc.CaptureDialog method)
  • IsIntelCounter() (in module renderdoc)
  • isInverted (renderdoc.VKConditionalRendering attribute)
  • IsLocalhost() (qrenderdoc.RemoteHost method)
  • IsNvidiaCounter() (in module renderdoc)
  • IsOutOfDate() (qrenderdoc.ShaderMessageViewer method)
  • isPassing (renderdoc.D3D11Predication attribute)
    • (renderdoc.VKConditionalRendering attribute)
  • isReadOnly (renderdoc.ShaderResource attribute)
  • IsReleaseBuild() (in module renderdoc)
  • IsResourceReplaced() (qrenderdoc.CaptureContext method)
  • IsRestartEnabled() (renderdoc.PipeState method)
  • IsServerRunning() (qrenderdoc.RemoteHost method)
  • IsStrip() (in module renderdoc)
  • IsSupported() (renderdoc.DeviceProtocolController method)
  • IsTargetControlConnected (C++ function)
  • IsTessellationEnabled() (renderdoc.PipeState method)
  • IsTextRepresentation() (in module renderdoc)
  • isTexture (renderdoc.ShaderResource attribute)
  • IsValid() (qrenderdoc.RemoteHost method)
    • (renderdoc.ModificationValue method)
  • IsVersionMismatch() (qrenderdoc.RemoteHost method)
  • IsVulkanExtendedCounter() (in module renderdoc)
  • IsWidgetChecked() (qrenderdoc.MiniQtHelper method)
  • IsWidgetEnabled() (qrenderdoc.MiniQtHelper method)
  • IsWidgetVisible() (qrenderdoc.MiniQtHelper method)
  • IsZoomAutoFit() (qrenderdoc.TextureViewer method)
  • italic (qrenderdoc.MiniQtHelper.SetWidgetFont parameter)

J

  • jpegQuality (renderdoc.TextureSave attribute)

K

  • key (qrenderdoc.CaptureContext.GetNotes parameter)
    • (qrenderdoc.CaptureContext.SetNotes parameter)
  • killReplay (renderdoc.BecomeRemoteServer parameter)
  • KnownShaderTool (class in renderdoc)
  • KnownShaderTool.dxcDXIL (in module renderdoc)
  • KnownShaderTool.dxcSPIRV (in module renderdoc)
  • KnownShaderTool.fxc (in module renderdoc)
  • KnownShaderTool.glslangValidatorGLSL (in module renderdoc)
  • KnownShaderTool.glslangValidatorGLSL_OpenGL (in module renderdoc)
  • KnownShaderTool.glslangValidatorHLSL (in module renderdoc)
  • KnownShaderTool.slangDXIL (in module renderdoc)
  • KnownShaderTool.slangSPIRV (in module renderdoc)
  • KnownShaderTool.spirv_as (in module renderdoc)
  • KnownShaderTool.spirv_as_OpenGL (in module renderdoc)
  • KnownShaderTool.SPIRV_Cross (in module renderdoc)
  • KnownShaderTool.SPIRV_Cross_OpenGL (in module renderdoc)
  • KnownShaderTool.spirv_dis (in module renderdoc)
  • KnownShaderTool.spirv_dis_OpenGL (in module renderdoc)
  • KnownShaderTool.Unknown (in module renderdoc)
  • knownTool (qrenderdoc.CaptureContext.EditShader parameter)

L

  • LastCaptureExe (qrenderdoc.PersistantConfig attribute)
  • LastCaptureFilePath (qrenderdoc.PersistantConfig attribute)
  • LastCapturePath (qrenderdoc.PersistantConfig attribute)
  • LastCapturePath() (qrenderdoc.RemoteHost method)
  • LastFileBrowsePath (qrenderdoc.PersistantConfig attribute)
  • lastmod (renderdoc.PathEntry attribute)
  • lastUsedIndex (renderdoc.D3D12RootSignatureRange attribute)
    • (renderdoc.VKDescriptorBinding attribute)
  • Launch() (qrenderdoc.RemoteHost method)
  • LaunchReplayUI (C++ function)
  • layer (renderdoc.CreateMacOSWindowingData parameter)
  • layered (renderdoc.GLImageLoadStore attribute)
  • layers (renderdoc.VKFramebuffer attribute)
  • LayoutBindStats (class in renderdoc)
  • layoutResourceId (renderdoc.VKDescriptorSet attribute)
  • layouts (renderdoc.D3D11InputAssembly attribute)
    • (renderdoc.D3D12InputAssembly attribute)
    • (renderdoc.FrameStatistics attribute)
    • (renderdoc.VKImageData attribute)
  • len (renderdoc.ReplayController.GetBufferData parameter)
  • length (renderdoc.BufferDescription attribute)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.SDChunkMetaData attribute)
  • lightChecker (renderdoc.SetColors parameter)
  • line (renderdoc.LogMessage parameter)
  • linearDisplayAsGamma (renderdoc.TextureDisplay attribute)
  • LineColumnInfo (class in renderdoc)
  • lineEnd (renderdoc.LineColumnInfo attribute)
  • lineInfo (renderdoc.InstructionSourceInfo attribute)
  • LineRaster (class in renderdoc)
  • LineRaster.Bresenham (in module renderdoc)
  • LineRaster.Default (in module renderdoc)
  • LineRaster.Rectangular (in module renderdoc)
  • LineRaster.RectangularD3D (in module renderdoc)
  • LineRaster.RectangularSmooth (in module renderdoc)
  • lineRasterMode (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • lineSmoothing (renderdoc.GLHints attribute)
  • lineSmoothingEnabled (renderdoc.GLHints attribute)
  • lineStart (renderdoc.LineColumnInfo attribute)
  • lineStippleFactor (renderdoc.VKRasterizer attribute)
  • lineStipplePattern (renderdoc.VKRasterizer attribute)
  • lineWidth (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • listenhost (renderdoc.BecomeRemoteServer parameter)
  • ListFolder() (qrenderdoc.ReplayManager method)
    • (renderdoc.RemoteServer method)
  • Load() (qrenderdoc.PersistantConfig method)
  • LoadCapture() (qrenderdoc.CaptureContext method)
  • LoadExtension() (qrenderdoc.ExtensionManager method)
  • LoadScriptFromFilename() (qrenderdoc.PythonShell method)
  • LoadSettings() (qrenderdoc.CaptureDialog method)
  • local (qrenderdoc.CaptureContext.LoadCapture parameter)
    • (qrenderdoc.ReplayManager.DeleteCapture parameter)
    • (renderdoc.NewCaptureData attribute)
  • localpath (qrenderdoc.ReplayManager.CopyCaptureFromRemote parameter)
    • (qrenderdoc.ReplayManager.CopyCaptureToRemote parameter)
    • (renderdoc.RemoteServer.CopyCaptureFromRemote parameter)
    • (renderdoc.TargetControl.CopyCapture parameter)
  • LocalProxies() (renderdoc.RemoteServer method)
  • LocalProxyAPI (qrenderdoc.PersistantConfig attribute)
  • localRenderer (renderdoc.APIProperties attribute)
  • LocalReplaySupport() (renderdoc.CaptureFile method)
  • location (renderdoc.ShaderMessage attribute)
    • (renderdoc.VKVertexAttribute attribute)
  • log (qrenderdoc.ShaderToolOutput attribute)
  • logfile (renderdoc.RemoteServer.OpenCapture parameter)
    • (renderdoc.StartGlobalHook parameter)
  • LogicOperation (class in renderdoc)
  • logicOperation (renderdoc.ColorBlend attribute)
  • LogicOperation.And (in module renderdoc)
  • LogicOperation.AndInverted (in module renderdoc)
  • LogicOperation.AndReverse (in module renderdoc)
  • LogicOperation.Clear (in module renderdoc)
  • LogicOperation.Copy (in module renderdoc)
  • LogicOperation.CopyInverted (in module renderdoc)
  • LogicOperation.Equivalent (in module renderdoc)
  • LogicOperation.Invert (in module renderdoc)
  • LogicOperation.Nand (in module renderdoc)
  • LogicOperation.NoOp (in module renderdoc)
  • LogicOperation.Nor (in module renderdoc)
  • LogicOperation.Or (in module renderdoc)
  • LogicOperation.OrInverted (in module renderdoc)
  • LogicOperation.OrReverse (in module renderdoc)
  • LogicOperation.Set (in module renderdoc)
  • LogicOperation.Xor (in module renderdoc)
  • logicOperationEnabled (renderdoc.ColorBlend attribute)
  • LogMessage() (in module renderdoc)
  • LogType (class in renderdoc)
  • LogType.Comment (in module renderdoc)
  • LogType.Debug (in module renderdoc)
  • LogType.Error (in module renderdoc)
  • LogType.Fatal (in module renderdoc)
  • LogType.Warning (in module renderdoc)

M

  • machineIdent (renderdoc.CaptureFile.SetMetadata parameter)
  • magnify (renderdoc.TextureFilter attribute)
  • MainWindow (class in qrenderdoc)
  • MainWindow.ShortcutCallback() (in module qrenderdoc)
  • makeSDArray() (in module renderdoc)
  • makeSDBool() (in module renderdoc)
  • makeSDEnum() (in module renderdoc)
  • makeSDFloat() (in module renderdoc)
  • makeSDInt32() (in module renderdoc)
  • makeSDInt64() (in module renderdoc)
  • makeSDResourceId() (in module renderdoc)
  • makeSDString() (in module renderdoc)
  • makeSDStruct() (in module renderdoc)
  • makeSDUInt32() (in module renderdoc)
  • makeSDUInt64() (in module renderdoc)
  • mapToArray (renderdoc.TextureSampleMapping attribute)
  • mark (qrenderdoc.CaptureContext.SetBookmark parameter)
  • markerColor (renderdoc.ActionDescription attribute)
  • MarkMessagesRead() (qrenderdoc.CaptureContext method)
  • MaskForStage() (in module renderdoc)
  • MaskOverlayBits (C++ function)
  • matrixByteStride (renderdoc.ShaderConstantType attribute)
  • maxAnisotropy (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • maxBounds (renderdoc.MeshDisplay attribute)
  • maxDepth (renderdoc.Viewport attribute)
  • maxDepthBounds (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • maximum (qrenderdoc.MiniQtHelper.SetProgressBarRange parameter)
  • maxLOD (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • maxsize (renderdoc.CaptureFile.GetThumbnail parameter)
  • maxVal (qrenderdoc.MiniQtHelper.SetSpinboxBounds parameter)
  • maxval (renderdoc.ReplayController.GetHistogram parameter)
  • members (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderVariable attribute)
  • mesh (renderdoc.ShaderMessageLocation attribute)
  • meshColor (renderdoc.MeshFormat attribute)
  • MeshDataStage (class in renderdoc)
  • MeshDataStage.AmpOut (in module renderdoc)
  • MeshDataStage.GSOut (in module renderdoc)
  • MeshDataStage.MeshOut (in module renderdoc)
  • MeshDataStage.TaskOut (in module renderdoc)
  • MeshDataStage.VSIn (in module renderdoc)
  • MeshDataStage.VSOut (in module renderdoc)
  • MeshDisplay (class in renderdoc)
  • MeshDisplay.NoHighlight (in module renderdoc)
  • MeshFormat (class in renderdoc)
  • meshGroup (renderdoc.ShaderMeshMessageLocation attribute)
  • meshletIndexOffset (renderdoc.MeshFormat attribute)
  • meshletOffset (renderdoc.MeshFormat attribute)
  • MeshletSize (class in renderdoc)
  • meshletSizes (renderdoc.MeshFormat attribute)
  • meshShader (renderdoc.D3D12State attribute)
    • (renderdoc.VKState attribute)
  • message (renderdoc.ShaderMessage attribute)
  • Message() (renderdoc.ResultDetails method)
  • MessageCategory (class in renderdoc)
  • MessageCategory.Application_Defined (in module renderdoc)
  • MessageCategory.Cleanup (in module renderdoc)
  • MessageCategory.Compilation (in module renderdoc)
  • MessageCategory.Deprecated (in module renderdoc)
  • MessageCategory.Execution (in module renderdoc)
  • MessageCategory.Initialization (in module renderdoc)
  • MessageCategory.Miscellaneous (in module renderdoc)
  • MessageCategory.Performance (in module renderdoc)
  • MessageCategory.Portability (in module renderdoc)
  • MessageCategory.Resource_Manipulation (in module renderdoc)
  • MessageCategory.Shaders (in module renderdoc)
  • MessageCategory.State_Creation (in module renderdoc)
  • MessageCategory.State_Getting (in module renderdoc)
  • MessageCategory.State_Setting (in module renderdoc)
  • MessageCategory.Undefined (in module renderdoc)
  • MessageDialog() (qrenderdoc.ExtensionManager method)
  • messageID (renderdoc.DebugMessage attribute)
  • MessageSeverity (class in renderdoc)
  • MessageSeverity.High (in module renderdoc)
  • MessageSeverity.Info (in module renderdoc)
  • MessageSeverity.Low (in module renderdoc)
  • MessageSeverity.Medium (in module renderdoc)
  • MessageSource (class in renderdoc)
  • MessageSource.API (in module renderdoc)
  • MessageSource.GCNPerformance (in module renderdoc)
  • MessageSource.GeneralPerformance (in module renderdoc)
  • MessageSource.IncorrectAPIUse (in module renderdoc)
  • MessageSource.RedundantAPIUse (in module renderdoc)
  • MessageSource.RuntimeWarning (in module renderdoc)
  • MessageSource.UnsupportedConfiguration (in module renderdoc)
  • metadata (renderdoc.SDChunk attribute)
  • method (qrenderdoc.ReplayManager.AsyncInvoke parameter)
    • (qrenderdoc.ReplayManager.BlockInvoke parameter)
  • minBounds (renderdoc.MeshDisplay attribute)
  • minDepth (renderdoc.Viewport attribute)
  • minDepthBounds (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.VKDepthStencil attribute)
  • minify (renderdoc.TextureFilter attribute)
  • minimum (qrenderdoc.MiniQtHelper.SetProgressBarRange parameter)
  • MiniQtHelper (class in qrenderdoc)
  • MiniQtHelper.InvokeCallback() (in module qrenderdoc)
  • MiniQtHelper.WidgetCallback() (in module qrenderdoc)
  • minLOD (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • minLODClamp (renderdoc.D3D12View attribute)
  • minSampleShading (renderdoc.VKMultiSample attribute)
  • minSampleShadingRate (renderdoc.GLRasterizerState attribute)
  • minVal (qrenderdoc.MiniQtHelper.SetSpinboxBounds parameter)
  • minval (renderdoc.ReplayController.GetHistogram parameter)
  • mip (renderdoc.Subresource attribute)
    • (renderdoc.TextureFilter attribute)
    • (renderdoc.TextureSave attribute)
  • mipBias (renderdoc.VKBindingElement attribute)
  • mipLevel (renderdoc.GLAttachment attribute)
    • (renderdoc.GLImageLoadStore attribute)
  • mipLODBias (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.GLSampler attribute)
  • mips (renderdoc.TextureDescription attribute)
  • mod (renderdoc.EnvironmentModification attribute)
  • modifications (qrenderdoc.CaptureDialog.SetEnvironmentModifications parameter)
  • ModificationValue (class in renderdoc)
  • module
    • qrenderdoc
  • msgs (qrenderdoc.CaptureContext.AddMessages parameter)
  • msQual (renderdoc.TextureDescription attribute)
  • msSamp (renderdoc.TextureDescription attribute)
  • multisample (renderdoc.VKState attribute)
  • multiSampleCount (renderdoc.D3D12OM attribute)
  • multisampleEnable (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
  • multiSampleQuality (renderdoc.D3D12OM attribute)
  • MultiviewBroadcastCount() (renderdoc.PipeState method)
  • multiviews (renderdoc.VKRenderPass attribute)

N

  • N (renderdoc.PatchList_Topology parameter)
  • name (qrenderdoc.CaptureContext.SetResourceCustomName parameter)
    • (qrenderdoc.EventBrowser.RegisterEventFilterFunction parameter)
    • (qrenderdoc.EventBrowser.UnregisterEventFilterFunction parameter)
    • (qrenderdoc.ExtensionManager.IsExtensionLoaded parameter)
    • (qrenderdoc.ExtensionManager.LoadExtension parameter)
    • (qrenderdoc.ExtensionMetadata attribute)
    • (qrenderdoc.MiniQtHelper.FindChildByName parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetName parameter)
    • (qrenderdoc.ShaderProcessingTool attribute)
    • (renderdoc.APIUseData attribute)
    • (renderdoc.CaptureAccess.FindSectionByName parameter)
    • (renderdoc.CaptureFileFormat attribute)
    • (renderdoc.ConstantBlock attribute)
    • (renderdoc.CounterDescription attribute)
    • (renderdoc.D3D12ResourceState attribute)
    • (renderdoc.DebugVariableReference attribute)
    • (renderdoc.EnvironmentModification attribute)
    • (renderdoc.GetConfigSetting parameter)
    • (renderdoc.GPUDevice attribute)
    • (renderdoc.makeSDArray parameter)
    • (renderdoc.makeSDBool parameter)
    • (renderdoc.makeSDEnum parameter)
    • (renderdoc.makeSDFloat parameter)
    • (renderdoc.makeSDInt32 parameter)
    • (renderdoc.makeSDInt64 parameter)
    • (renderdoc.makeSDResourceId parameter)
    • (renderdoc.makeSDString parameter)
    • (renderdoc.makeSDStruct parameter)
    • (renderdoc.makeSDUInt32 parameter)
    • (renderdoc.makeSDUInt64 parameter)
    • (renderdoc.ResourceDescription attribute)
    • (renderdoc.SDObject attribute)
    • (renderdoc.SDType attribute)
    • (renderdoc.SectionProperties attribute)
    • (renderdoc.SetConfigSetting parameter)
    • (renderdoc.ShaderCompileFlag attribute)
    • (renderdoc.ShaderConstant attribute)
    • (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderEntryPoint attribute)
    • (renderdoc.ShaderResource attribute)
    • (renderdoc.ShaderSampler attribute)
    • (renderdoc.ShaderVariable attribute)
    • (renderdoc.SourceVariableMapping attribute)
    • (renderdoc.VertexInputAttribute attribute)
    • (renderdoc.VKImageLayout attribute)
  • Name() (qrenderdoc.RemoteHost method)
    • (renderdoc.ResourceFormat method)
  • nearBound (renderdoc.GLDepthState attribute)
  • nearPlane (renderdoc.MeshFormat attribute)
  • needSemanticIndex (renderdoc.SigParameter attribute)
  • newCapture (renderdoc.TargetControlMessage attribute)
  • NewCaptureData (class in renderdoc)
  • newChild (renderdoc.TargetControlMessage attribute)
  • NewChildData (class in renderdoc)
  • newWindow (qrenderdoc.CaptureContext.AddDockWindow parameter)
  • next (renderdoc.ActionDescription attribute)
  • nextIdent (renderdoc.EnumerateRemoteTargets parameter)
  • nextInstruction (renderdoc.ShaderDebugState attribute)
  • Null() (renderdoc.ResourceId static method)
  • nulls (renderdoc.BlendStats attribute)
    • (renderdoc.ConstantBindStats attribute)
    • (renderdoc.DepthStencilStats attribute)
    • (renderdoc.IndexBindStats attribute)
    • (renderdoc.LayoutBindStats attribute)
    • (renderdoc.OutputTargetStats attribute)
    • (renderdoc.RasterizationStats attribute)
    • (renderdoc.ResourceBindStats attribute)
    • (renderdoc.SamplerBindStats attribute)
    • (renderdoc.ShaderChangeStats attribute)
    • (renderdoc.VertexBindStats attribute)
  • NumChildren() (renderdoc.SDObject method)
  • numControlPoints (renderdoc.VKTessellation attribute)
  • numElements (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
  • numFrames (renderdoc.TargetControl.QueueCapture parameter)
    • (renderdoc.TargetControl.TriggerCapture parameter)
  • numIndices (renderdoc.ActionDescription attribute)
    • (renderdoc.MeshFormat attribute)
    • (renderdoc.MeshletSize attribute)
  • numInstances (renderdoc.ActionDescription attribute)
  • numLayer (renderdoc.VKImageLayout attribute)
  • numMip (renderdoc.VKImageLayout attribute)
  • numMips (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.GLTexture attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • numQueuedFrames (qrenderdoc.CaptureSettings attribute)
  • numSlices (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.GLAttachment attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • numVertices (renderdoc.MeshletSize attribute)
  • NumVerticesPerPrimitive() (in module renderdoc)

O

  • o (renderdoc.LineColumnInfo.SourceEqual parameter)
  • obj (renderdoc.DumpObject parameter)
    • (renderdoc.SDObject.HasEqualValue parameter)
  • objectName (qrenderdoc.CaptureContext.CreateBuiltinWindow parameter)
  • Offset (class in renderdoc)
  • offset (renderdoc.ReplayController.GetBufferData parameter)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.SourceVariableMapping attribute)
  • offsetClamp (renderdoc.GLRasterizerState attribute)
  • OffsetSizeDisplayMode (class in qrenderdoc)
  • OffsetSizeDisplayMode.Auto (in module qrenderdoc)
  • OffsetSizeDisplayMode.Decimal (in module qrenderdoc)
  • OffsetSizeDisplayMode.Hexadecimal (in module qrenderdoc)
  • OK() (renderdoc.ResultDetails method)
  • OnCaptureClosed() (qrenderdoc.CaptureViewer method)
  • OnCaptureLoaded() (qrenderdoc.CaptureViewer method)
  • OnEventChanged() (qrenderdoc.CaptureViewer method)
  • onlyUsed (renderdoc.PipeState.GetReadOnlyResources parameter)
    • (renderdoc.PipeState.GetReadWriteResources parameter)
  • OnSelectedEventChanged() (qrenderdoc.CaptureViewer method)
  • OpenBuffer() (renderdoc.CaptureFile method)
  • OpenCapture() (renderdoc.CaptureFile method)
    • (renderdoc.RemoteServer method)
  • OpenCaptureFile() (in module renderdoc)
  • OpenDirectoryName() (qrenderdoc.ExtensionManager method)
  • OpenFile() (renderdoc.CaptureFile method)
  • OpenFileName() (qrenderdoc.ExtensionManager method)
  • OpenRGPProfile() (qrenderdoc.CaptureContext method)
  • openSupported (renderdoc.CaptureFileFormat attribute)
  • operation (renderdoc.BlendEquation attribute)
  • optimisation (renderdoc.ReplayOptions attribute)
  • option (qrenderdoc.MiniQtHelper.SelectComboOption parameter)
  • options (qrenderdoc.CaptureSettings attribute)
    • (qrenderdoc.ExtensionManager.QuestionDialog parameter)
    • (qrenderdoc.MiniQtHelper.SetComboOptions parameter)
  • opts (qrenderdoc.CaptureContext.LoadCapture parameter)
    • (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
    • (renderdoc.CaptureFile.OpenCapture parameter)
    • (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.InjectIntoProcess parameter)
    • (renderdoc.RemoteServer.ExecuteAndInject parameter)
    • (renderdoc.RemoteServer.OpenCapture parameter)
    • (renderdoc.StartGlobalHook parameter)
  • origFilename (qrenderdoc.CaptureContext.LoadCapture parameter)
  • original (renderdoc.ReplayController.ReplaceResource parameter)
  • ortho (renderdoc.MeshDisplay attribute)
  • other (renderdoc.SDFile.Swap parameter)
  • output (qrenderdoc.MiniQtHelper.SetWidgetReplayOutput parameter)
    • (qrenderdoc.ShaderProcessingTool attribute)
  • OutputAbbrev() (renderdoc.PipeState method)
  • outputMerger (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
  • outputs (renderdoc.ActionDescription attribute)
    • (renderdoc.D3D11StreamOut attribute)
    • (renderdoc.D3D12StreamOut attribute)
    • (renderdoc.FrameStatistics attribute)
  • outputSignature (renderdoc.ShaderReflection attribute)
  • OutputTargetStats (class in renderdoc)
  • outputTopology (renderdoc.ShaderReflection attribute)
  • overlay (qrenderdoc.TextureViewer.SetTextureOverlay parameter)
    • (renderdoc.TextureDisplay attribute)

P

  • package (qrenderdoc.ExtensionMetadata attribute)
  • PanelMenu (class in qrenderdoc)
  • PanelMenu.BufferViewer (in module qrenderdoc)
  • PanelMenu.EventBrowser (in module qrenderdoc)
  • PanelMenu.MeshPreview (in module qrenderdoc)
  • PanelMenu.PipelineStateViewer (in module qrenderdoc)
  • PanelMenu.TextureViewer (in module qrenderdoc)
  • PanelMenu.Unknown (in module qrenderdoc)
  • param (qrenderdoc.APIInspector.RevealParameter parameter)
    • (qrenderdoc.ResourceInspector.RevealParameter parameter)
  • parent (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
    • (qrenderdoc.MiniQtHelper.AddWidget parameter)
    • (qrenderdoc.MiniQtHelper.ClearContainedWidgets parameter)
    • (qrenderdoc.MiniQtHelper.FindChildByName parameter)
    • (qrenderdoc.MiniQtHelper.GetChild parameter)
    • (qrenderdoc.MiniQtHelper.InsertWidget parameter)
    • (renderdoc.ActionDescription attribute)
  • parentResources (renderdoc.ResourceDescription attribute)
  • parser (qrenderdoc.EventBrowser.RegisterEventFilterFunction parameter)
  • Passed() (renderdoc.PixelModification method)
  • passOperation (renderdoc.StencilFace attribute)
  • PatchList_Count() (in module renderdoc)
  • PatchList_Topology() (in module renderdoc)
  • path (qrenderdoc.RemoteHost.SetLastCapturePath parameter)
    • (qrenderdoc.ReplayManager.ListFolder parameter)
    • (renderdoc.NewCaptureData attribute)
    • (renderdoc.RemoteServer.ListFolder parameter)
    • (renderdoc.ReplayController.SaveTexture parameter)
  • PathEntry (class in renderdoc)
  • pathmatch (renderdoc.StartGlobalHook parameter)
  • PathProperty (class in renderdoc)
  • PathProperty.Directory (in module renderdoc)
  • PathProperty.ErrorAccessDenied (in module renderdoc)
  • PathProperty.ErrorInvalidPath (in module renderdoc)
  • PathProperty.ErrorUnknown (in module renderdoc)
  • PathProperty.Executable (in module renderdoc)
  • PathProperty.Hidden (in module renderdoc)
  • PathProperty.NoFlags (in module renderdoc)
  • paused (renderdoc.GLFeedback attribute)
  • pbar (qrenderdoc.MiniQtHelper.GetProgressBarMaximum parameter)
    • (qrenderdoc.MiniQtHelper.GetProgressBarMinimum parameter)
    • (qrenderdoc.MiniQtHelper.GetProgressBarValue parameter)
    • (qrenderdoc.MiniQtHelper.ResetProgressBar parameter)
    • (qrenderdoc.MiniQtHelper.SetProgressBarRange parameter)
    • (qrenderdoc.MiniQtHelper.SetProgressBarValue parameter)
    • (qrenderdoc.MiniQtHelper.UpdateProgressBarValue parameter)
  • percentage (qrenderdoc.CaptureContext.AddDockWindow parameter)
  • PerformanceCounterViewer (class in qrenderdoc)
  • perInstance (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
    • (renderdoc.VertexInputAttribute attribute)
    • (renderdoc.VKVertexBinding attribute)
  • perPrimitiveOffset (renderdoc.MeshFormat attribute)
  • perPrimitiveRate (renderdoc.SigParameter attribute)
  • perPrimitiveStride (renderdoc.MeshFormat attribute)
  • PersistantConfig (class in qrenderdoc)
  • persistentSize (renderdoc.FrameDescription attribute)
  • PickPixel() (renderdoc.ReplayController method)
  • PickVertex() (renderdoc.ReplayOutput method)
  • pid (renderdoc.InjectIntoProcess parameter)
  • Ping() (renderdoc.RemoteServer method)
  • PingRemote() (qrenderdoc.ReplayManager method)
  • pipeline (qrenderdoc.CaptureContext.DebugShader parameter)
    • (qrenderdoc.CaptureContext.ViewShader parameter)
    • (renderdoc.ReplayController.DisassembleShader parameter)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.ReplayController.GetShader parameter)
  • pipelineComputeLayoutResourceId (renderdoc.VKPipeline attribute)
  • pipelineFragmentLayoutResourceId (renderdoc.VKPipeline attribute)
  • pipelinePreRastLayoutResourceId (renderdoc.VKPipeline attribute)
  • pipelineResourceId (renderdoc.D3D12State attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.VKPipeline attribute)
  • pipelineShadingRate (renderdoc.VKRasterizer attribute)
  • PipelineStage (class in qrenderdoc)
  • PipelineStage.Blending (in module qrenderdoc)
  • PipelineStage.ColorDepthOutput (in module qrenderdoc)
  • PipelineStage.ComputeShader (in module qrenderdoc)
  • PipelineStage.DepthTest (in module qrenderdoc)
  • PipelineStage.DomainShader (in module qrenderdoc)
  • PipelineStage.FragmentShader (in module qrenderdoc)
  • PipelineStage.GeometryShader (in module qrenderdoc)
  • PipelineStage.HullShader (in module qrenderdoc)
  • PipelineStage.PixelShader (in module qrenderdoc)
  • PipelineStage.Rasterizer (in module qrenderdoc)
  • PipelineStage.SampleMask (in module qrenderdoc)
  • PipelineStage.StencilTest (in module qrenderdoc)
  • PipelineStage.TessControlShader (in module qrenderdoc)
  • PipelineStage.TessEvalShader (in module qrenderdoc)
  • PipelineStage.VertexInput (in module qrenderdoc)
  • PipelineStage.VertexShader (in module qrenderdoc)
  • PipelineStage.ViewportsScissors (in module qrenderdoc)
  • PipelineStateViewer (class in qrenderdoc)
  • pipelineType (renderdoc.APIProperties attribute)
  • PipeState (class in renderdoc)
  • pixel (renderdoc.ShaderMessageLocation attribute)
  • pixelHistory (renderdoc.APIProperties attribute)
  • PixelHistory() (renderdoc.ReplayController method)
  • PixelHistoryView (class in qrenderdoc)
  • PixelModification (class in renderdoc)
  • pixelShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
  • PixelValue (class in renderdoc)
  • planes (renderdoc.ResourceFormat.SetYUVPlaneCount parameter)
  • pointer (renderdoc.PointerVal attribute)
    • (renderdoc.ShaderVariable.SetTypedPointer parameter)
    • (renderdoc.ShaderVariable.SetTypelessPointer parameter)
  • pointerTypeID (renderdoc.PointerVal attribute)
    • (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderVariable.SetTypedPointer parameter)
  • pointerTypes (renderdoc.ShaderReflection attribute)
  • PointerVal (class in renderdoc)
  • pointFadeThreshold (renderdoc.GLRasterizerState attribute)
  • pointOriginUpperLeft (renderdoc.GLRasterizerState attribute)
  • pointSize (renderdoc.GLRasterizerState attribute)
  • polySmoothing (renderdoc.GLHints attribute)
  • polySmoothingEnabled (renderdoc.GLHints attribute)
  • port (renderdoc.BecomeRemoteServer parameter)
  • position (renderdoc.MeshDisplay attribute)
  • postMod (renderdoc.PixelModification attribute)
  • predication (renderdoc.D3D11State attribute)
  • predicationSkipped (renderdoc.PixelModification attribute)
  • prefix (renderdoc.ShaderSourcePrefix attribute)
  • preMod (renderdoc.PixelModification attribute)
  • presenting (renderdoc.APIUseData attribute)
  • pressed (qrenderdoc.MiniQtHelper.CreateButton parameter)
  • previewWindow (renderdoc.BecomeRemoteServer parameter)
  • previous (renderdoc.ActionDescription attribute)
  • primitive (renderdoc.DebugPixelInputs attribute)
    • (renderdoc.ShaderGeometryMessageLocation attribute)
    • (renderdoc.ShaderPixelMessageLocation attribute)
    • (renderdoc.VertexOffset parameter)
  • primitiveID (renderdoc.PixelModification attribute)
  • primitiveRestart (renderdoc.GLVertexInput attribute)
  • primitiveRestartEnable (renderdoc.VKInputAssembly attribute)
  • processId (renderdoc.NewChildData attribute)
  • programmablePointSize (renderdoc.GLRasterizerState attribute)
  • programResourceId (renderdoc.GLShader attribute)
  • progress (renderdoc.CaptureAccess.InitResolver parameter)
    • (renderdoc.CaptureFile.Convert parameter)
    • (renderdoc.CaptureFile.OpenBuffer parameter)
    • (renderdoc.CaptureFile.OpenCapture parameter)
    • (renderdoc.CaptureFile.OpenFile parameter)
    • (renderdoc.RemoteServer.CopyCaptureFromRemote parameter)
    • (renderdoc.RemoteServer.CopyCaptureToRemote parameter)
    • (renderdoc.RemoteServer.OpenCapture parameter)
    • (renderdoc.TargetControl.ReceiveMessage parameter)
  • project (renderdoc.LogMessage parameter)
  • props (renderdoc.CaptureAccess.WriteSection parameter)
  • protocol (renderdoc.GetDeviceProtocolController parameter)
  • Protocol() (qrenderdoc.RemoteHost method)
  • provokingVertexFirst (renderdoc.VKRasterizer attribute)
  • provokingVertexLast (renderdoc.GLVertexInput attribute)
  • proxyid (renderdoc.RemoteServer.OpenCapture parameter)
  • pushConstantRangeByteOffset (renderdoc.VKShader attribute)
  • pushConstantRangeByteSize (renderdoc.VKShader attribute)
  • pushconsts (renderdoc.VKState attribute)
  • pushDescriptor (renderdoc.VKDescriptorSet attribute)
  • PythonShell (class in qrenderdoc)

Q

  • qrenderdoc
    • module
  • QualityHint (class in renderdoc)
  • QualityHint.DontCare (in module renderdoc)
  • QualityHint.Fastest (in module renderdoc)
  • QualityHint.Nicest (in module renderdoc)
  • QuestionDialog() (qrenderdoc.ExtensionManager method)
  • QueueCapture() (renderdoc.TargetControl method)
  • queuedFrameCap (qrenderdoc.CaptureSettings attribute)

R

  • RaiseDockWindow() (qrenderdoc.CaptureContext method)
  • rangeMax (renderdoc.TextureDisplay attribute)
  • rangeMin (renderdoc.TextureDisplay attribute)
  • RasterizationStats (class in renderdoc)
  • rasterizedStream (renderdoc.D3D11StreamOut attribute)
    • (renderdoc.D3D12StreamOut attribute)
    • (renderdoc.VKTransformFeedback attribute)
  • rasterizer (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • rasterizerDiscardEnable (renderdoc.VKRasterizer attribute)
  • rasters (renderdoc.FrameStatistics attribute)
  • rasterSamples (renderdoc.VKMultiSample attribute)
  • rawBytes (renderdoc.ShaderReflection attribute)
  • rawOutput (renderdoc.TextureDisplay attribute)
  • rdcfile (qrenderdoc.CaptureContext.ImportCapture parameter)
  • readAllowed (renderdoc.GLImageLoadStore attribute)
  • ReadbackOutputTexture() (renderdoc.ReplayOutput method)
  • readBuffer (renderdoc.GLFBO attribute)
  • readFBO (renderdoc.GLFrameBuffer attribute)
  • readOnlyResources (renderdoc.ShaderBindpointMapping attribute)
    • (renderdoc.ShaderDebugTrace attribute)
    • (renderdoc.ShaderReflection attribute)
  • readWriteResources (renderdoc.ShaderBindpointMapping attribute)
    • (renderdoc.ShaderDebugTrace attribute)
    • (renderdoc.ShaderReflection attribute)
  • ReceiveMessage() (renderdoc.TargetControl method)
  • RecentCaptureFiles (qrenderdoc.PersistantConfig attribute)
  • RecentCaptureSettings (qrenderdoc.PersistantConfig attribute)
  • recentList (qrenderdoc.AddRecentFile parameter)
    • (qrenderdoc.RemoveRecentFile parameter)
  • RecompressCapture() (qrenderdoc.CaptureContext method)
  • recorded (renderdoc.FrameStatistics attribute)
  • RecordedMachineIdent() (renderdoc.CaptureFile method)
  • rects (renderdoc.RasterizationStats attribute)
  • red (qrenderdoc.MiniQtHelper.SetWidgetBackgroundColor parameter)
    • (qrenderdoc.TextureViewer.SetChannelVisibility parameter)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSwizzle4 attribute)
  • redundants (renderdoc.BlendStats attribute)
    • (renderdoc.DepthStencilStats attribute)
    • (renderdoc.RasterizationStats attribute)
    • (renderdoc.ShaderChangeStats attribute)
  • ref (qrenderdoc.CaptureContext.AddDockWindow parameter)
  • refAllResources (renderdoc.CaptureOptions attribute)
  • reference (renderdoc.StencilFace attribute)
  • refl (renderdoc.ReplayController.DisassembleShader parameter)
  • reflection (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D12Shader attribute)
    • (renderdoc.GLShader attribute)
    • (renderdoc.VKShader attribute)
  • Refresh() (qrenderdoc.APIInspector method)
  • RefreshStatus() (qrenderdoc.CaptureContext method)
  • refWindow (qrenderdoc.CaptureContext.AddDockWindow parameter)
  • regChannelMask (renderdoc.SigParameter attribute)
  • regIndex (renderdoc.SigParameter attribute)
  • RegisterContextMenu() (qrenderdoc.ExtensionManager method)
  • RegisterEventFilterFunction() (qrenderdoc.EventBrowser method)
  • RegisterPanelMenu() (qrenderdoc.ExtensionManager method)
  • RegisterReplacement() (qrenderdoc.CaptureContext method)
  • RegisterShortcut() (qrenderdoc.MainWindow method)
  • registerSpace (renderdoc.D3D12RootSignatureRange attribute)
  • RegisterWindowMenu() (qrenderdoc.ExtensionManager method)
  • RemoteHost (class in qrenderdoc)
  • remotepath (qrenderdoc.ReplayManager.CopyCaptureFromRemote parameter)
    • (renderdoc.RemoteServer.CopyCaptureFromRemote parameter)
  • remoteReplay (renderdoc.APIProperties attribute)
  • RemoteServer (class in renderdoc)
  • RemoteServer.NoPreference (in module renderdoc)
  • RemoteSupportedReplays() (renderdoc.RemoteServer method)
  • RemoveBookmark() (qrenderdoc.CaptureContext method)
  • RemoveCaptureViewer() (qrenderdoc.CaptureContext method)
  • RemoveChild() (renderdoc.SDObject method)
  • RemoveHooks (C++ function)
  • RemoveRecentFile() (in module qrenderdoc)
  • RemoveRemoteHost() (qrenderdoc.PersistantConfig method)
  • RemoveReplacement() (renderdoc.ReplayController method)
  • rend (renderdoc.RemoteServer.CloseCapture parameter)
  • renderArea (renderdoc.VKCurrentPass attribute)
  • RENDERDOC_CaptureOption (C++ enum)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_AllowFullscreen (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_AllowVSync (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_APIValidation (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureAllCmdLists (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureCallstacks (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_CaptureCallstacksOnlyActions (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_DebugOutputMute (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_DelayForDebugger (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_HookIntoChildren (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_RefAllResources (C++ enumerator)
  • RENDERDOC_CaptureOption::eRENDERDOC_Option_VerifyBufferWrites (C++ enumerator)
  • RENDERDOC_GetAPI (C++ function)
  • RENDERDOC_InputButton (C++ enum)
  • RENDERDOC_InputButton::eRENDERDOC_Key_0 (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_A (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Backspace (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Delete (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Divide (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_End (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_F1 (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Home (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Insert (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Multiply (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_PageDn (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_PageUp (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Pause (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Plus (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_PrtScrn (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Subtract (C++ enumerator)
  • RENDERDOC_InputButton::eRENDERDOC_Key_Tab (C++ enumerator)
  • RENDERDOC_OverlayBits (C++ enum)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_All (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_CaptureList (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_Default (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_Enabled (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_FrameNumber (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_FrameRate (C++ enumerator)
  • RENDERDOC_OverlayBits::eRENDERDOC_Overlay_None (C++ enumerator)
  • renderpass (renderdoc.VKCurrentPass attribute)
  • renderTargets (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
  • replacement (renderdoc.ReplayController.ReplaceResource parameter)
  • ReplaceResource() (renderdoc.ReplayController method)
  • Replay() (qrenderdoc.CaptureContext method)
  • ReplayController (class in renderdoc)
  • ReplayController.KillCallback() (in module renderdoc)
  • ReplayController.NoPreference (in module renderdoc)
  • ReplayController.PreviewWindowCallback() (in module renderdoc)
  • ReplayController.ProgressCallback() (in module renderdoc)
  • ReplayLoop() (renderdoc.ReplayController method)
  • ReplayManager (class in qrenderdoc)
  • ReplayManager.DirectoryBrowseCallback() (in module qrenderdoc)
  • ReplayManager.InvokeCallback() (in module qrenderdoc)
  • ReplayOptimisationLevel (class in renderdoc)
  • ReplayOptimisationLevel.Balanced (in module renderdoc)
  • ReplayOptimisationLevel.Conservative (in module renderdoc)
  • ReplayOptimisationLevel.Fastest (in module renderdoc)
  • ReplayOptimisationLevel.NoOptimisation (in module renderdoc)
  • ReplayOptions (class in renderdoc)
  • ReplayOutput (class in renderdoc)
  • ReplayOutput.NoResult (in module renderdoc)
  • ReplayOutputType (class in renderdoc)
  • ReplayOutputType.Headless (in module renderdoc)
  • ReplayOutputType.Mesh (in module renderdoc)
  • ReplayOutputType.Texture (in module renderdoc)
  • ReplaySupport (class in renderdoc)
  • ReplaySupport.SuggestRemote (in module renderdoc)
  • ReplaySupport.Supported (in module renderdoc)
  • ReplaySupport.Unsupported (in module renderdoc)
  • reportId (qrenderdoc.BugReport attribute)
  • requiredSubgroupSize (renderdoc.VKShader attribute)
  • requiresBuffers (renderdoc.CaptureFileFormat attribute)
  • ResetArcball() (renderdoc.Camera method)
  • ResetProgressBar() (qrenderdoc.MiniQtHelper method)
  • resolveAttachments (renderdoc.VKRenderPass attribute)
  • ResourceBindStats (class in renderdoc)
  • ResourceDescription (class in renderdoc)
  • ResourceFormat (class in renderdoc)
  • ResourceFormatType (class in renderdoc)
  • ResourceFormatType.A8 (in module renderdoc)
  • ResourceFormatType.ASTC (in module renderdoc)
  • ResourceFormatType.BC1 (in module renderdoc)
  • ResourceFormatType.BC2 (in module renderdoc)
  • ResourceFormatType.BC3 (in module renderdoc)
  • ResourceFormatType.BC4 (in module renderdoc)
  • ResourceFormatType.BC5 (in module renderdoc)
  • ResourceFormatType.BC6 (in module renderdoc)
  • ResourceFormatType.BC7 (in module renderdoc)
  • ResourceFormatType.D16S8 (in module renderdoc)
  • ResourceFormatType.D24S8 (in module renderdoc)
  • ResourceFormatType.D32S8 (in module renderdoc)
  • ResourceFormatType.EAC (in module renderdoc)
  • ResourceFormatType.ETC2 (in module renderdoc)
  • ResourceFormatType.PVRTC (in module renderdoc)
  • ResourceFormatType.R10G10B10A2 (in module renderdoc)
  • ResourceFormatType.R11G11B10 (in module renderdoc)
  • ResourceFormatType.R4G4 (in module renderdoc)
  • ResourceFormatType.R4G4B4A4 (in module renderdoc)
  • ResourceFormatType.R5G5B5A1 (in module renderdoc)
  • ResourceFormatType.R5G6B5 (in module renderdoc)
  • ResourceFormatType.R9G9B9E5 (in module renderdoc)
  • ResourceFormatType.Regular (in module renderdoc)
  • ResourceFormatType.S8 (in module renderdoc)
  • ResourceFormatType.Undefined (in module renderdoc)
  • ResourceFormatType.YUV10 (in module renderdoc)
  • ResourceFormatType.YUV12 (in module renderdoc)
  • ResourceFormatType.YUV16 (in module renderdoc)
  • ResourceFormatType.YUV8 (in module renderdoc)
  • ResourceId (class in renderdoc)
  • resourceId (qrenderdoc.TextureViewer.ViewTexture parameter)
    • (renderdoc.BoundCBuffer attribute)
    • (renderdoc.BoundResource attribute)
    • (renderdoc.BoundVBuffer attribute)
    • (renderdoc.BufferDescription attribute)
    • (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D11ConstantBuffer attribute)
    • (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D11IndexBuffer attribute)
    • (renderdoc.D3D11InputAssembly attribute)
    • (renderdoc.D3D11Predication attribute)
    • (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D11Sampler attribute)
    • (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D11StreamOutBind attribute)
    • (renderdoc.D3D11VertexBuffer attribute)
    • (renderdoc.D3D12ConstantBuffer attribute)
    • (renderdoc.D3D12IndexBuffer attribute)
    • (renderdoc.D3D12ResourceData attribute)
    • (renderdoc.D3D12Shader attribute)
    • (renderdoc.D3D12StreamOutBind attribute)
    • (renderdoc.D3D12VertexBuffer attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.GLAttachment attribute)
    • (renderdoc.GLBuffer attribute)
    • (renderdoc.GLFBO attribute)
    • (renderdoc.GLImageLoadStore attribute)
    • (renderdoc.GLSampler attribute)
    • (renderdoc.GLTexture attribute)
    • (renderdoc.GLVertexBuffer attribute)
    • (renderdoc.ResourceDescription attribute)
    • (renderdoc.ShaderReflection attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSave attribute)
    • (renderdoc.VKFramebuffer attribute)
    • (renderdoc.VKImageData attribute)
    • (renderdoc.VKIndexBuffer attribute)
    • (renderdoc.VKRenderPass attribute)
    • (renderdoc.VKShader attribute)
    • (renderdoc.VKVertexBuffer attribute)
  • ResourceInspector (class in qrenderdoc)
  • ResourceNameCacheID() (qrenderdoc.CaptureContext method)
  • resourceResourceId (renderdoc.D3D11View attribute)
    • (renderdoc.VKBindingElement attribute)
  • resources (renderdoc.BoundResourceArray attribute)
    • (renderdoc.FrameStatistics attribute)
  • resourceStates (renderdoc.D3D12State attribute)
  • ResourceType (class in renderdoc)
  • ResourceType.AccelerationStructure (in module renderdoc)
  • ResourceType.Buffer (in module renderdoc)
  • ResourceType.CommandBuffer (in module renderdoc)
  • ResourceType.Device (in module renderdoc)
  • ResourceType.Memory (in module renderdoc)
  • ResourceType.PipelineState (in module renderdoc)
  • ResourceType.Pool (in module renderdoc)
  • ResourceType.Query (in module renderdoc)
  • ResourceType.Queue (in module renderdoc)
  • ResourceType.RenderPass (in module renderdoc)
  • ResourceType.Sampler (in module renderdoc)
  • ResourceType.Shader (in module renderdoc)
  • ResourceType.ShaderBinding (in module renderdoc)
  • ResourceType.StateObject (in module renderdoc)
  • ResourceType.SwapchainImage (in module renderdoc)
  • ResourceType.Sync (in module renderdoc)
  • ResourceType.Texture (in module renderdoc)
  • ResourceType.Unknown (in module renderdoc)
  • ResourceType.View (in module renderdoc)
  • ResourceUpdateStats (class in renderdoc)
  • ResourceUpdateStats.BucketCount (in module renderdoc)
  • ResourceUpdateStats.BucketType (in module renderdoc)
  • ResourceUsage (class in renderdoc)
  • ResourceUsage.All_Constants (in module renderdoc)
  • ResourceUsage.All_Resource (in module renderdoc)
  • ResourceUsage.All_RWResource (in module renderdoc)
  • ResourceUsage.Barrier (in module renderdoc)
  • ResourceUsage.Clear (in module renderdoc)
  • ResourceUsage.ColorTarget (in module renderdoc)
  • ResourceUsage.Copy (in module renderdoc)
  • ResourceUsage.CopyDst (in module renderdoc)
  • ResourceUsage.CopySrc (in module renderdoc)
  • ResourceUsage.CPUWrite (in module renderdoc)
  • ResourceUsage.CS_Constants (in module renderdoc)
  • ResourceUsage.CS_Resource (in module renderdoc)
  • ResourceUsage.CS_RWResource (in module renderdoc)
  • ResourceUsage.DepthStencilTarget (in module renderdoc)
  • ResourceUsage.Discard (in module renderdoc)
  • ResourceUsage.DS_Constants (in module renderdoc)
  • ResourceUsage.DS_Resource (in module renderdoc)
  • ResourceUsage.DS_RWResource (in module renderdoc)
  • ResourceUsage.GenMips (in module renderdoc)
  • ResourceUsage.GS_Constants (in module renderdoc)
  • ResourceUsage.GS_Resource (in module renderdoc)
  • ResourceUsage.GS_RWResource (in module renderdoc)
  • ResourceUsage.HS_Constants (in module renderdoc)
  • ResourceUsage.HS_Resource (in module renderdoc)
  • ResourceUsage.HS_RWResource (in module renderdoc)
  • ResourceUsage.IndexBuffer (in module renderdoc)
  • ResourceUsage.Indirect (in module renderdoc)
  • ResourceUsage.InputTarget (in module renderdoc)
  • ResourceUsage.MS_Constants (in module renderdoc)
  • ResourceUsage.MS_Resource (in module renderdoc)
  • ResourceUsage.MS_RWResource (in module renderdoc)
  • ResourceUsage.PS_Constants (in module renderdoc)
  • ResourceUsage.PS_Resource (in module renderdoc)
  • ResourceUsage.PS_RWResource (in module renderdoc)
  • ResourceUsage.Resolve (in module renderdoc)
  • ResourceUsage.ResolveDst (in module renderdoc)
  • ResourceUsage.ResolveSrc (in module renderdoc)
  • ResourceUsage.StreamOut (in module renderdoc)
  • ResourceUsage.TS_Constants (in module renderdoc)
  • ResourceUsage.TS_Resource (in module renderdoc)
  • ResourceUsage.TS_RWResource (in module renderdoc)
  • ResourceUsage.Unused (in module renderdoc)
  • ResourceUsage.VertexBuffer (in module renderdoc)
  • ResourceUsage.VS_Constants (in module renderdoc)
  • ResourceUsage.VS_Resource (in module renderdoc)
  • ResourceUsage.VS_RWResource (in module renderdoc)
  • restartIndex (renderdoc.GLVertexInput attribute)
    • (renderdoc.MeshFormat attribute)
  • resType (renderdoc.ShaderResource attribute)
  • result (qrenderdoc.ShaderToolOutput attribute)
    • (renderdoc.ExecuteResult attribute)
  • resultByteWidth (renderdoc.CounterDescription attribute)
  • ResultCode (class in renderdoc)
  • ResultCode.AndroidABINotFound (in module renderdoc)
  • ResultCode.AndroidAPKFolderNotFound (in module renderdoc)
  • ResultCode.AndroidAPKInstallFailed (in module renderdoc)
  • ResultCode.AndroidAPKVerifyFailed (in module renderdoc)
  • ResultCode.AndroidGrantPermissionsFailed (in module renderdoc)
  • ResultCode.APIDataCorrupted (in module renderdoc)
  • ResultCode.APIHardwareUnsupported (in module renderdoc)
  • ResultCode.APIIncompatibleVersion (in module renderdoc)
  • ResultCode.APIInitFailed (in module renderdoc)
  • ResultCode.APIReplayFailed (in module renderdoc)
  • ResultCode.APIUnsupported (in module renderdoc)
  • ResultCode.CompressionFailed (in module renderdoc)
  • ResultCode.DataNotAvailable (in module renderdoc)
  • ResultCode.DeviceLost (in module renderdoc)
  • ResultCode.FileCorrupted (in module renderdoc)
  • ResultCode.FileIncompatibleVersion (in module renderdoc)
  • ResultCode.FileIOFailed (in module renderdoc)
  • ResultCode.FileNotFound (in module renderdoc)
  • ResultCode.FileUnrecognised (in module renderdoc)
  • ResultCode.ImageUnsupported (in module renderdoc)
  • ResultCode.IncompatibleProcess (in module renderdoc)
  • ResultCode.InjectionFailed (in module renderdoc)
  • ResultCode.InternalError (in module renderdoc)
  • ResultCode.InvalidParameter (in module renderdoc)
  • ResultCode.JDWPFailure (in module renderdoc)
  • ResultCode.NetworkIOFailed (in module renderdoc)
  • ResultCode.NetworkRemoteBusy (in module renderdoc)
  • ResultCode.NetworkVersionMismatch (in module renderdoc)
  • ResultCode.OutOfMemory (in module renderdoc)
  • ResultCode.RemoteServerConnectionLost (in module renderdoc)
  • ResultCode.Succeeded (in module renderdoc)
  • ResultCode.UnknownError (in module renderdoc)
  • ResultDetails (class in renderdoc)
  • resultType (renderdoc.CounterDescription attribute)
  • ResUsage() (in module renderdoc)
  • RevealParameter() (qrenderdoc.APIInspector method)
    • (qrenderdoc.ResourceInspector method)
  • revertCallback (qrenderdoc.CaptureContext.EditShader parameter)
  • rgpCapture (renderdoc.APIProperties attribute)
  • RGPInterop (class in qrenderdoc)
  • rootElements (renderdoc.D3D12State attribute)
  • rootSignatureIndex (renderdoc.D3D12RootSignatureRange attribute)
  • rootSignatureResourceId (renderdoc.D3D12State attribute)
  • rootValues (renderdoc.D3D12ConstantBuffer attribute)
  • RotateArcball() (renderdoc.Camera method)
  • row (qrenderdoc.BufferViewer.ScrollToRow parameter)
    • (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
  • RowMajor() (renderdoc.ShaderConstantType method)
    • (renderdoc.ShaderVariable method)
  • rows (renderdoc.ShaderConstantType attribute)
    • (renderdoc.ShaderVariable attribute)
    • (renderdoc.SourceVariableMapping attribute)
  • rowSpan (qrenderdoc.MiniQtHelper.AddGridWidget parameter)
  • RunCommand() (qrenderdoc.RemoteHost method)
  • RunForward() (qrenderdoc.ShaderViewer method)
  • RunScript() (qrenderdoc.PythonShell method)
  • RWResUsage() (in module renderdoc)

S

  • s16v (renderdoc.ShaderValue attribute)
  • s32v (renderdoc.ShaderValue attribute)
  • s64v (renderdoc.ShaderValue attribute)
  • s8v (renderdoc.ShaderValue attribute)
  • sample (renderdoc.DebugPixelInputs attribute)
    • (renderdoc.ShaderPixelMessageLocation attribute)
    • (renderdoc.Subresource attribute)
    • (renderdoc.TextureSave attribute)
  • sampleCoverage (renderdoc.GLRasterizerState attribute)
  • sampleCoverageInvert (renderdoc.GLRasterizerState attribute)
  • sampleCoverageValue (renderdoc.GLRasterizerState attribute)
  • sampleIndex (renderdoc.TextureSampleMapping attribute)
  • sampleLocations (renderdoc.VKMultiSample attribute)
  • sampleMask (renderdoc.D3D11BlendState attribute)
    • (renderdoc.D3D12Rasterizer attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKMultiSample attribute)
  • sampleMasked (renderdoc.PixelModification attribute)
  • sampleMaskValue (renderdoc.GLRasterizerState attribute)
  • SamplerBindStats (class in renderdoc)
  • samplerResourceId (renderdoc.VKBindingElement attribute)
  • samplers (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D12RootSignatureRange attribute)
    • (renderdoc.FrameStatistics attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.ShaderBindpointMapping attribute)
    • (renderdoc.ShaderDebugTrace attribute)
    • (renderdoc.ShaderReflection attribute)
  • samplerSwizzle (renderdoc.VKBindingElement attribute)
  • sampleShading (renderdoc.GLRasterizerState attribute)
  • sampleShadingEnable (renderdoc.VKMultiSample attribute)
  • Save() (qrenderdoc.PersistantConfig method)
  • saveCallback (qrenderdoc.CaptureContext.EditShader parameter)
  • SaveCaptureTo() (qrenderdoc.CaptureContext method)
  • SaveConfigSettings() (in module renderdoc)
  • saveData (renderdoc.ReplayController.SaveTexture parameter)
  • SaveFileName() (qrenderdoc.ExtensionManager method)
  • SaveSettings() (qrenderdoc.CaptureDialog method)
  • SaveShaderFile() (qrenderdoc.PipelineStateViewer method)
  • SaveTexture() (renderdoc.ReplayController method)
  • scale (renderdoc.TextureDisplay attribute)
  • Scissor (class in renderdoc)
  • scissor (renderdoc.VKViewportScissor attribute)
  • scissorClipped (renderdoc.PixelModification attribute)
  • scissorEnable (renderdoc.D3D11RasterizerState attribute)
  • scissors (renderdoc.D3D11Rasterizer attribute)
    • (renderdoc.D3D12Rasterizer attribute)
    • (renderdoc.GLRasterizer attribute)
  • script (qrenderdoc.PythonShell.SetScriptText parameter)
  • ScrollToColumn() (qrenderdoc.BufferViewer method)
  • ScrollToRow() (qrenderdoc.BufferViewer method)
  • SDBasic (class in renderdoc)
  • SDBasic.Array (in module renderdoc)
  • SDBasic.Boolean (in module renderdoc)
  • SDBasic.Buffer (in module renderdoc)
  • SDBasic.Character (in module renderdoc)
  • SDBasic.Chunk (in module renderdoc)
  • SDBasic.Enum (in module renderdoc)
  • SDBasic.Float (in module renderdoc)
  • SDBasic.Null (in module renderdoc)
  • SDBasic.Resource (in module renderdoc)
  • SDBasic.SignedInteger (in module renderdoc)
  • SDBasic.String (in module renderdoc)
  • SDBasic.Struct (in module renderdoc)
  • SDBasic.UnsignedInteger (in module renderdoc)
  • SDChunk (class in renderdoc)
  • SDChunkFlags (class in renderdoc)
  • SDChunkFlags.HasCallstack (in module renderdoc)
  • SDChunkFlags.NoFlags (in module renderdoc)
  • SDChunkFlags.OpaqueChunk (in module renderdoc)
  • SDChunkMetaData (class in renderdoc)
  • SDFile (class in renderdoc)
  • SDObject (class in renderdoc)
  • SDObjectData (class in renderdoc)
  • SDObjectPODData (class in renderdoc)
  • SDType (class in renderdoc)
  • SDTypeFlags (class in renderdoc)
  • SDTypeFlags.FixedArray (in module renderdoc)
  • SDTypeFlags.HasCustomString (in module renderdoc)
  • SDTypeFlags.Hidden (in module renderdoc)
  • SDTypeFlags.HiddenChildren (in module renderdoc)
  • SDTypeFlags.Important (in module renderdoc)
  • SDTypeFlags.ImportantChildren (in module renderdoc)
  • SDTypeFlags.NoFlags (in module renderdoc)
  • SDTypeFlags.Nullable (in module renderdoc)
  • SDTypeFlags.NullString (in module renderdoc)
  • SDTypeFlags.OffsetOrSize (in module renderdoc)
  • SDTypeFlags.Union (in module renderdoc)
  • seamless (renderdoc.VKBindingElement attribute)
  • seamlessCubeMap (renderdoc.GLSampler attribute)
  • second (renderdoc.MeshDisplay attribute)
  • SectionFlags (class in renderdoc)
  • SectionFlags.ASCIIStored (in module renderdoc)
  • SectionFlags.LZ4Compressed (in module renderdoc)
  • SectionFlags.NoFlags (in module renderdoc)
  • SectionFlags.ZstdCompressed (in module renderdoc)
  • SectionProperties (class in renderdoc)
  • SectionType (class in renderdoc)
  • SectionType.AMDRGPProfile (in module renderdoc)
  • SectionType.Bookmarks (in module renderdoc)
  • SectionType.D3D12Core (in module renderdoc)
  • SectionType.D3D12SDKLayers (in module renderdoc)
  • SectionType.EditedShaders (in module renderdoc)
  • SectionType.EmbeddedLogfile (in module renderdoc)
  • SectionType.ExtendedThumbnail (in module renderdoc)
  • SectionType.FrameCapture (in module renderdoc)
  • SectionType.Notes (in module renderdoc)
  • SectionType.ResolveDatabase (in module renderdoc)
  • SectionType.ResourceRenames (in module renderdoc)
  • SectionType.Unknown (in module renderdoc)
  • SelectComboOption() (qrenderdoc.MiniQtHelper method)
  • selectedEventId (qrenderdoc.CaptureContext.SetEventID parameter)
  • SelectPipelineStage() (qrenderdoc.PipelineStateViewer method)
  • SelectRGPEvent() (qrenderdoc.RGPInterop method)
  • semanticIdxName (renderdoc.SigParameter attribute)
  • semanticIndex (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
    • (renderdoc.SigParameter attribute)
  • semanticName (renderdoc.D3D11Layout attribute)
    • (renderdoc.D3D12Layout attribute)
    • (renderdoc.SigParameter attribute)
  • sep (renderdoc.EnvironmentModification attribute)
  • servers (renderdoc.ResourceUpdateStats attribute)
  • SetActiveWindow (C++ function)
  • SetArcballDistance() (renderdoc.Camera method)
  • SetBGRAOrder() (renderdoc.ResourceFormat method)
  • SetBinding() (renderdoc.ShaderVariable method)
  • SetBookmark() (qrenderdoc.CaptureContext method)
  • SetCaptureFileComments (C++ function)
  • SetCaptureFilePathTemplate (C++ function)
  • SetCaptureKeys (C++ function)
  • SetCaptureOptionF32 (C++ function)
  • SetCaptureOptionU32 (C++ function)
  • SetCaptureTitle (C++ function)
  • SetChannelVisibility() (qrenderdoc.TextureViewer method)
  • SetColors() (in module renderdoc)
  • SetComboOptions() (qrenderdoc.MiniQtHelper method)
  • SetCommandLine() (qrenderdoc.CaptureDialog method)
  • SetComments() (qrenderdoc.CommentView method)
  • SetConfigSetting() (in module renderdoc)
  • SetCurrentFilterText() (qrenderdoc.EventBrowser method)
  • SetCurrentInstance() (qrenderdoc.BufferViewer method)
  • SetCurrentStep() (qrenderdoc.ShaderViewer method)
  • SetCurrentView() (qrenderdoc.BufferViewer method)
  • SetCustomName() (renderdoc.ResourceDescription method)
  • SetCustomShaderIncludes() (renderdoc.ReplayController method)
  • SetDebugLogFile() (in module renderdoc)
  • SetDimensions() (renderdoc.ReplayOutput method)
  • SetEmptyRegionsVisible() (qrenderdoc.EventBrowser method)
  • SetEnvironmentModifications() (qrenderdoc.CaptureDialog method)
  • SetEventID() (qrenderdoc.CaptureContext method)
  • SetExecutableFilename() (qrenderdoc.CaptureDialog method)
  • SetFocusToggleKeys (C++ function)
  • SetFPSRotation() (renderdoc.Camera method)
  • SetFrameEvent() (renderdoc.ReplayController method)
  • SetHistogramRange() (qrenderdoc.TextureViewer method)
  • SetHistory() (qrenderdoc.PixelHistoryView method)
  • SetInjectMode() (qrenderdoc.CaptureDialog method)
  • SetInvalid() (renderdoc.ModificationValue method)
  • SetLabelImage() (qrenderdoc.MiniQtHelper method)
  • SetLastCapturePath() (qrenderdoc.RemoteHost method)
  • SetMeshDisplay() (renderdoc.ReplayOutput method)
  • SetMetadata() (renderdoc.CaptureFile method)
  • SetNotes() (qrenderdoc.CaptureContext method)
  • SetPixelContext() (renderdoc.ReplayOutput method)
  • SetPixelContextLocation() (renderdoc.ReplayOutput method)
  • SetPosition() (renderdoc.Camera method)
  • SetPreviewStage() (qrenderdoc.BufferViewer method)
  • SetProgressBarRange() (qrenderdoc.MiniQtHelper method)
  • SetProgressBarValue() (qrenderdoc.MiniQtHelper method)
  • SetResourceCustomName() (qrenderdoc.CaptureContext method)
  • SetRunCommand() (qrenderdoc.RemoteHost method)
  • sets (renderdoc.BlendStats attribute)
    • (renderdoc.ConstantBindStats attribute)
    • (renderdoc.DepthStencilStats attribute)
    • (renderdoc.IndexBindStats attribute)
    • (renderdoc.LayoutBindStats attribute)
    • (renderdoc.OutputTargetStats attribute)
    • (renderdoc.RasterizationStats attribute)
    • (renderdoc.ResourceBindStats attribute)
    • (renderdoc.SamplerBindStats attribute)
    • (renderdoc.ShaderChangeStats attribute)
    • (renderdoc.VertexBindStats attribute)
  • SetScriptText() (qrenderdoc.PythonShell method)
  • SetSelectedSubresource() (qrenderdoc.TextureViewer method)
  • SetSettings() (qrenderdoc.CaptureDialog method)
  • SetShowAllParameters() (qrenderdoc.EventBrowser method)
  • SetShowParameterNames() (qrenderdoc.EventBrowser method)
  • SetSpinboxBounds() (qrenderdoc.MiniQtHelper method)
  • SetSpinboxValue() (qrenderdoc.MiniQtHelper method)
  • SetStructuredData() (renderdoc.CaptureFile method)
  • SetStyle() (qrenderdoc.PersistantConfig method)
  • SetTextureDisplay() (renderdoc.ReplayOutput method)
  • SetTextureOverlay() (qrenderdoc.TextureViewer method)
  • settings (qrenderdoc.CaptureDialog.SetSettings parameter)
  • Settings() (qrenderdoc.CaptureDialog method)
  • SetTypedPointer() (renderdoc.ShaderVariable method)
  • SetTypelessPointer() (renderdoc.ShaderVariable method)
  • SetupFormatting() (qrenderdoc.PersistantConfig method)
  • SetUseCustomActionNames() (qrenderdoc.EventBrowser method)
  • SetWidgetBackgroundColor() (qrenderdoc.MiniQtHelper method)
  • SetWidgetChecked() (qrenderdoc.MiniQtHelper method)
  • SetWidgetEnabled() (qrenderdoc.MiniQtHelper method)
  • SetWidgetFont() (qrenderdoc.MiniQtHelper method)
  • SetWidgetName() (qrenderdoc.MiniQtHelper method)
  • SetWidgetReplayOutput() (qrenderdoc.MiniQtHelper method)
  • SetWidgetText() (qrenderdoc.MiniQtHelper method)
  • SetWidgetVisible() (qrenderdoc.MiniQtHelper method)
  • SetWorkingDirectory() (qrenderdoc.CaptureDialog method)
  • SetYUVPlaneCount() (renderdoc.ResourceFormat method)
  • SetYUVSubsampling() (renderdoc.ResourceFormat method)
  • SetZoomLevel() (qrenderdoc.TextureViewer method)
  • severity (renderdoc.DebugMessage attribute)
  • shader (qrenderdoc.CaptureContext.DebugShader parameter)
    • (qrenderdoc.CaptureContext.ViewShader parameter)
    • (qrenderdoc.PipelineStateViewer.SaveShaderFile parameter)
    • (qrenderdoc.ShaderProcessingTool.DisassembleShader parameter)
    • (renderdoc.PointerVal attribute)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.ReplayController.GetShader parameter)
    • (renderdoc.ReplayController.GetShaderEntryPoints parameter)
    • (renderdoc.ShaderVariable.SetTypedPointer parameter)
  • ShaderBindpointMapping (class in renderdoc)
  • ShaderBuiltin (class in renderdoc)
  • ShaderBuiltin.Barycentrics (in module renderdoc)
  • ShaderBuiltin.BaseInstance (in module renderdoc)
  • ShaderBuiltin.BaseVertex (in module renderdoc)
  • ShaderBuiltin.ClipDistance (in module renderdoc)
  • ShaderBuiltin.ColorOutput (in module renderdoc)
  • ShaderBuiltin.CullDistance (in module renderdoc)
  • ShaderBuiltin.CullPrimitive (in module renderdoc)
  • ShaderBuiltin.DepthOutput (in module renderdoc)
  • ShaderBuiltin.DepthOutputGreaterEqual (in module renderdoc)
  • ShaderBuiltin.DepthOutputLessEqual (in module renderdoc)
  • ShaderBuiltin.DeviceIndex (in module renderdoc)
  • ShaderBuiltin.DispatchSize (in module renderdoc)
  • ShaderBuiltin.DispatchThreadIndex (in module renderdoc)
  • ShaderBuiltin.DomainLocation (in module renderdoc)
  • ShaderBuiltin.DrawIndex (in module renderdoc)
  • ShaderBuiltin.FragAreaSize (in module renderdoc)
  • ShaderBuiltin.FragInvocationCount (in module renderdoc)
  • ShaderBuiltin.GroupFlatIndex (in module renderdoc)
  • ShaderBuiltin.GroupIndex (in module renderdoc)
  • ShaderBuiltin.GroupSize (in module renderdoc)
  • ShaderBuiltin.GroupThreadIndex (in module renderdoc)
  • ShaderBuiltin.GSInstanceIndex (in module renderdoc)
  • ShaderBuiltin.IndexInSubgroup (in module renderdoc)
  • ShaderBuiltin.InsideTessFactor (in module renderdoc)
  • ShaderBuiltin.InstanceIndex (in module renderdoc)
  • ShaderBuiltin.IsFrontFace (in module renderdoc)
  • ShaderBuiltin.IsFullyCovered (in module renderdoc)
  • ShaderBuiltin.IsHelper (in module renderdoc)
  • ShaderBuiltin.MSAACoverage (in module renderdoc)
  • ShaderBuiltin.MSAASampleIndex (in module renderdoc)
  • ShaderBuiltin.MSAASamplePosition (in module renderdoc)
  • ShaderBuiltin.MultiViewIndex (in module renderdoc)
  • ShaderBuiltin.NumSubgroups (in module renderdoc)
  • ShaderBuiltin.OuterTessFactor (in module renderdoc)
  • ShaderBuiltin.OutputControlPointIndex (in module renderdoc)
  • ShaderBuiltin.OutputIndices (in module renderdoc)
  • ShaderBuiltin.PackedFragRate (in module renderdoc)
  • ShaderBuiltin.PatchNumVertices (in module renderdoc)
  • ShaderBuiltin.PointCoord (in module renderdoc)
  • ShaderBuiltin.PointSize (in module renderdoc)
  • ShaderBuiltin.Position (in module renderdoc)
  • ShaderBuiltin.PrimitiveIndex (in module renderdoc)
  • ShaderBuiltin.RTIndex (in module renderdoc)
  • ShaderBuiltin.StencilReference (in module renderdoc)
  • ShaderBuiltin.SubgroupEqualMask (in module renderdoc)
  • ShaderBuiltin.SubgroupGreaterEqualMask (in module renderdoc)
  • ShaderBuiltin.SubgroupGreaterMask (in module renderdoc)
  • ShaderBuiltin.SubgroupIndexInWorkgroup (in module renderdoc)
  • ShaderBuiltin.SubgroupLessEqualMask (in module renderdoc)
  • ShaderBuiltin.SubgroupLessMask (in module renderdoc)
  • ShaderBuiltin.SubgroupSize (in module renderdoc)
  • ShaderBuiltin.Undefined (in module renderdoc)
  • ShaderBuiltin.VertexIndex (in module renderdoc)
  • ShaderBuiltin.ViewportIndex (in module renderdoc)
  • ShaderChangeStats (class in renderdoc)
  • ShaderCompileFlag (class in renderdoc)
  • ShaderCompileFlags (class in renderdoc)
  • ShaderComputeMessageLocation (class in renderdoc)
  • ShaderConstant (class in renderdoc)
  • ShaderConstantType (class in renderdoc)
  • ShaderDebugger (class in renderdoc)
  • shaderDebugging (renderdoc.APIProperties attribute)
  • ShaderDebugInfo (class in renderdoc)
  • ShaderDebugState (class in renderdoc)
  • ShaderDebugTrace (class in renderdoc)
  • shaderDiscarded (renderdoc.PixelModification attribute)
  • ShaderEncoding (class in renderdoc)
  • shaderEncoding (qrenderdoc.CaptureContext.EditShader parameter)
  • ShaderEncoding.DXBC (in module renderdoc)
  • ShaderEncoding.DXIL (in module renderdoc)
  • ShaderEncoding.GLSL (in module renderdoc)
  • ShaderEncoding.HLSL (in module renderdoc)
  • ShaderEncoding.OpenGLSPIRV (in module renderdoc)
  • ShaderEncoding.OpenGLSPIRVAsm (in module renderdoc)
  • ShaderEncoding.Slang (in module renderdoc)
  • ShaderEncoding.SPIRV (in module renderdoc)
  • ShaderEncoding.SPIRVAsm (in module renderdoc)
  • ShaderEncoding.Unknown (in module renderdoc)
  • ShaderEntryPoint (class in renderdoc)
  • ShaderEvents (class in renderdoc)
  • ShaderEvents.GeneratedNanOrInf (in module renderdoc)
  • ShaderEvents.NoEvent (in module renderdoc)
  • ShaderEvents.SampleLoadGather (in module renderdoc)
  • ShaderGeometryMessageLocation (class in renderdoc)
  • ShaderGeometryMessageLocation.NoLocation (in module renderdoc)
  • ShaderMeshMessageLocation (class in renderdoc)
  • ShaderMeshMessageLocation.NotUsed (in module renderdoc)
  • ShaderMessage (class in renderdoc)
  • ShaderMessageLocation (class in renderdoc)
  • shaderMessages (renderdoc.VKState attribute)
  • ShaderMessageViewer (class in qrenderdoc)
  • shaderOut (renderdoc.PixelModification attribute)
  • ShaderPixelMessageLocation (class in renderdoc)
  • ShaderPixelMessageLocation.NoLocation (in module renderdoc)
  • ShaderProcessingTool (class in qrenderdoc)
  • ShaderProcessors (qrenderdoc.PersistantConfig attribute)
  • ShaderReflection (class in renderdoc)
  • ShaderResource (class in renderdoc)
  • shaderResourceId (renderdoc.GLShader attribute)
  • shaders (renderdoc.FrameStatistics attribute)
  • ShaderSampler (class in renderdoc)
  • shadersMutable (renderdoc.APIProperties attribute)
  • ShaderSourceFile (class in renderdoc)
  • ShaderSourcePrefix (class in renderdoc)
  • ShaderStage (class in renderdoc)
  • ShaderStage.Amplification (in module renderdoc)
  • ShaderStage.Compute (in module renderdoc)
  • ShaderStage.Domain (in module renderdoc)
  • ShaderStage.Fragment (in module renderdoc)
  • ShaderStage.Geometry (in module renderdoc)
  • ShaderStage.Hull (in module renderdoc)
  • ShaderStage.Mesh (in module renderdoc)
  • ShaderStage.Pixel (in module renderdoc)
  • ShaderStage.Task (in module renderdoc)
  • ShaderStage.Tess_Control (in module renderdoc)
  • ShaderStage.Tess_Eval (in module renderdoc)
  • ShaderStage.Vertex (in module renderdoc)
  • ShaderStageMask (class in renderdoc)
  • ShaderStageMask.All (in module renderdoc)
  • ShaderStageMask.Amplification (in module renderdoc)
  • ShaderStageMask.Compute (in module renderdoc)
  • ShaderStageMask.Domain (in module renderdoc)
  • ShaderStageMask.Fragment (in module renderdoc)
  • ShaderStageMask.Geometry (in module renderdoc)
  • ShaderStageMask.Hull (in module renderdoc)
  • ShaderStageMask.Mesh (in module renderdoc)
  • ShaderStageMask.Pixel (in module renderdoc)
  • ShaderStageMask.Task (in module renderdoc)
  • ShaderStageMask.Tess_Control (in module renderdoc)
  • ShaderStageMask.Tess_Eval (in module renderdoc)
  • ShaderStageMask.Unknown (in module renderdoc)
  • ShaderStageMask.Vertex (in module renderdoc)
  • shaderStorageBuffers (renderdoc.GLState attribute)
  • ShaderToolOutput (class in qrenderdoc)
  • ShaderValue (class in renderdoc)
  • ShaderVariable (class in renderdoc)
  • ShaderVariableChange (class in renderdoc)
  • ShaderVariableFlags (class in renderdoc)
  • ShaderVariableFlags.BinaryDisplay (in module renderdoc)
  • ShaderVariableFlags.HexDisplay (in module renderdoc)
  • ShaderVariableFlags.NoFlags (in module renderdoc)
  • ShaderVariableFlags.R10G10B10A2 (in module renderdoc)
  • ShaderVariableFlags.R11G11B10 (in module renderdoc)
  • ShaderVariableFlags.RGBDisplay (in module renderdoc)
  • ShaderVariableFlags.RowMajorMatrix (in module renderdoc)
  • ShaderVariableFlags.SNorm (in module renderdoc)
  • ShaderVariableFlags.Truncated (in module renderdoc)
  • ShaderVariableFlags.UNorm (in module renderdoc)
  • ShaderVertexMessageLocation (class in renderdoc)
  • ShaderViewer (class in qrenderdoc)
  • ShaderViewer.RevertCallback() (in module qrenderdoc)
  • ShaderViewer.SaveCallback() (in module qrenderdoc)
  • shadingRateAttachment (renderdoc.VKRenderPass attribute)
  • ShadingRateCombiner (class in renderdoc)
  • ShadingRateCombiner.Keep (in module renderdoc)
  • ShadingRateCombiner.Max (in module renderdoc)
  • ShadingRateCombiner.Min (in module renderdoc)
  • ShadingRateCombiner.Multiply (in module renderdoc)
  • ShadingRateCombiner.Override (in module renderdoc)
  • ShadingRateCombiner.Passthrough (in module renderdoc)
  • ShadingRateCombiner.Replace (in module renderdoc)
  • shadingRateCombiners (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • shadingRateImage (renderdoc.D3D12RasterizerState attribute)
  • shadingRateTexelSize (renderdoc.VKRenderPass attribute)
  • shortcut (qrenderdoc.MainWindow.RegisterShortcut parameter)
    • (qrenderdoc.MainWindow.UnregisterShortcut parameter)
  • show (qrenderdoc.EventBrowser.SetEmptyRegionsVisible parameter)
    • (qrenderdoc.EventBrowser.SetShowAllParameters parameter)
    • (qrenderdoc.EventBrowser.SetShowParameterNames parameter)
  • showAllInstances (renderdoc.MeshDisplay attribute)
  • showAlpha (renderdoc.MeshFormat attribute)
  • ShowAPIInspector() (qrenderdoc.CaptureContext method)
  • showBBox (renderdoc.MeshDisplay attribute)
  • ShowCaptureDialog() (qrenderdoc.CaptureContext method)
  • ShowCommentView() (qrenderdoc.CaptureContext method)
  • ShowDebugMessageView() (qrenderdoc.CaptureContext method)
  • ShowDiagnosticLogView() (qrenderdoc.CaptureContext method)
  • ShowErrors() (qrenderdoc.ShaderViewer method)
  • ShowEventBrowser() (qrenderdoc.CaptureContext method)
  • ShowMeshData() (qrenderdoc.BufferViewer method)
  • ShowMeshPreview() (qrenderdoc.CaptureContext method)
  • ShowPerformanceCounterViewer() (qrenderdoc.CaptureContext method)
  • ShowPipelineViewer() (qrenderdoc.CaptureContext method)
  • showPrevInstances (renderdoc.MeshDisplay attribute)
  • ShowPythonShell() (qrenderdoc.CaptureContext method)
  • ShowReplayUI (C++ function)
  • ShowResourceInspector() (qrenderdoc.CaptureContext method)
  • ShowStatisticsViewer() (qrenderdoc.CaptureContext method)
  • ShowTextureViewer() (qrenderdoc.CaptureContext method)
  • ShowTimelineBar() (qrenderdoc.CaptureContext method)
  • showWholePass (renderdoc.MeshDisplay attribute)
  • ShowWidgetAsDialog() (qrenderdoc.MiniQtHelper method)
  • Shutdown() (renderdoc.Camera method)
    • (renderdoc.CaptureFile method)
    • (renderdoc.ReplayController method)
    • (renderdoc.ReplayOutput method)
    • (renderdoc.TargetControl method)
  • ShutdownConnection() (renderdoc.RemoteServer method)
  • ShutdownReplay() (in module renderdoc)
  • ShutdownServer() (qrenderdoc.ReplayManager method)
  • ShutdownServerAndConnection() (renderdoc.RemoteServer method)
  • signatureIndex (renderdoc.SourceVariableMapping attribute)
  • SigParameter (class in renderdoc)
  • SigParameter.NoIndex (in module renderdoc)
  • singleLine (qrenderdoc.MiniQtHelper.CreateTextBox parameter)
  • size (renderdoc.PathEntry attribute)
  • sizes (renderdoc.ConstantBindStats attribute)
    • (renderdoc.ResourceUpdateStats attribute)
  • slice (renderdoc.GLAttachment attribute)
    • (renderdoc.GLImageLoadStore attribute)
    • (renderdoc.Subresource attribute)
    • (renderdoc.TextureSave attribute)
  • sliceGridWidth (renderdoc.TextureSliceMapping attribute)
  • sliceIndex (renderdoc.TextureSliceMapping attribute)
  • slicesAsGrid (renderdoc.TextureSliceMapping attribute)
  • slopeScaledDepthBias (renderdoc.D3D11RasterizerState attribute)
    • (renderdoc.D3D12RasterizerState attribute)
    • (renderdoc.GLRasterizerState attribute)
    • (renderdoc.VKRasterizer attribute)
  • slot (qrenderdoc.CaptureContext.ViewConstantBuffer parameter)
  • softMemoryLimit (renderdoc.CaptureOptions attribute)
  • source (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
    • (renderdoc.BlendEquation attribute)
    • (renderdoc.DebugMessage attribute)
    • (renderdoc.ReplayController.BuildCustomShader parameter)
    • (renderdoc.ReplayController.BuildTargetShader parameter)
  • sourceDebugInformation (renderdoc.ShaderDebugInfo attribute)
  • sourceEncoding (renderdoc.ReplayController.BuildCustomShader parameter)
    • (renderdoc.ReplayController.BuildTargetShader parameter)
  • SourceEqual() (renderdoc.LineColumnInfo method)
  • SourceVariableMapping (class in renderdoc)
  • sourceVars (renderdoc.InstructionSourceInfo attribute)
    • (renderdoc.ShaderDebugTrace attribute)
  • Special() (renderdoc.ResourceFormat method)
  • specializationData (renderdoc.VKShader attribute)
  • specializationIds (renderdoc.VKShader attribute)
  • spinbox (qrenderdoc.MiniQtHelper.GetSpinboxValue parameter)
    • (qrenderdoc.MiniQtHelper.SetSpinboxBounds parameter)
    • (qrenderdoc.MiniQtHelper.SetSpinboxValue parameter)
  • spirvVer (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
  • srgbBorder (renderdoc.VKBindingElement attribute)
  • SRGBCorrected() (renderdoc.ResourceFormat method)
  • srvs (renderdoc.D3D11Shader attribute)
  • stage (qrenderdoc.BufferViewer.ScrollToColumn parameter)
    • (qrenderdoc.BufferViewer.ScrollToRow parameter)
    • (qrenderdoc.BufferViewer.SetPreviewStage parameter)
    • (qrenderdoc.BufferViewer.ShowMeshData parameter)
    • (qrenderdoc.CaptureContext.EditShader parameter)
    • (qrenderdoc.CaptureContext.ViewConstantBuffer parameter)
    • (qrenderdoc.PipelineStateViewer.SelectPipelineStage parameter)
    • (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
    • (qrenderdoc.TextureViewer.ViewFollowedResource parameter)
    • (renderdoc.CBUsage parameter)
    • (renderdoc.D3D11Shader attribute)
    • (renderdoc.D3D12Shader attribute)
    • (renderdoc.GLShader attribute)
    • (renderdoc.MaskForStage parameter)
    • (renderdoc.PipeState.Abbrev parameter)
    • (renderdoc.PipeState.GetBindpointMapping parameter)
    • (renderdoc.PipeState.GetConstantBuffer parameter)
    • (renderdoc.PipeState.GetReadOnlyResources parameter)
    • (renderdoc.PipeState.GetReadWriteResources parameter)
    • (renderdoc.PipeState.GetSamplers parameter)
    • (renderdoc.PipeState.GetShader parameter)
    • (renderdoc.PipeState.GetShaderEntryPoint parameter)
    • (renderdoc.PipeState.GetShaderReflection parameter)
    • (renderdoc.PipeState.HasAlignedPostVSData parameter)
    • (renderdoc.ReplayController.GetCBufferVariableContents parameter)
    • (renderdoc.ReplayController.GetPostVSData parameter)
    • (renderdoc.ResUsage parameter)
    • (renderdoc.RWResUsage parameter)
    • (renderdoc.ShaderDebugTrace attribute)
    • (renderdoc.ShaderEntryPoint attribute)
    • (renderdoc.ShaderMessage attribute)
    • (renderdoc.ShaderReflection attribute)
    • (renderdoc.VKShader attribute)
  • stageFlags (renderdoc.VKDescriptorBinding attribute)
  • stages (qrenderdoc.CaptureContext.ViewShaderMessages parameter)
  • StartFrameCapture (C++ function)
  • StartGlobalHook() (in module renderdoc)
  • StartRemoteServer() (renderdoc.DeviceProtocolController method)
  • StartSelfHostCapture() (in module renderdoc)
  • state (renderdoc.D3D11Rasterizer attribute)
    • (renderdoc.D3D12Rasterizer attribute)
    • (renderdoc.GLRasterizer attribute)
  • states (renderdoc.D3D12ResourceData attribute)
  • StatisticsViewer (class in qrenderdoc)
  • stats (renderdoc.FrameDescription attribute)
  • status (renderdoc.MeshFormat attribute)
  • stencil (renderdoc.ModificationValue attribute)
  • stencilAttachment (renderdoc.GLFBO attribute)
  • stencilEnable (renderdoc.D3D11DepthStencilState attribute)
    • (renderdoc.D3D12DepthStencilState attribute)
    • (renderdoc.GLStencilState attribute)
  • StencilFace (class in renderdoc)
  • stencilFeedbackAllowed (renderdoc.VKCurrentPass attribute)
  • StencilOperation (class in renderdoc)
  • StencilOperation.DecSat (in module renderdoc)
  • StencilOperation.DecWrap (in module renderdoc)
  • StencilOperation.IncSat (in module renderdoc)
  • StencilOperation.IncWrap (in module renderdoc)
  • StencilOperation.Invert (in module renderdoc)
  • StencilOperation.Keep (in module renderdoc)
  • StencilOperation.Replace (in module renderdoc)
  • StencilOperation.Zero (in module renderdoc)
  • stencilReadOnly (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D12OM attribute)
  • stencilState (renderdoc.GLState attribute)
  • stencilTestEnable (renderdoc.VKDepthStencil attribute)
  • stencilTestFailed (renderdoc.PixelModification attribute)
  • step (qrenderdoc.MiniQtHelper.CreateSpinbox parameter)
    • (qrenderdoc.ShaderViewer.SetCurrentStep parameter)
  • stepIndex (renderdoc.ShaderDebugState attribute)
  • StopGlobalHook() (in module renderdoc)
  • stream (renderdoc.SigParameter attribute)
  • streamOut (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
  • string (renderdoc.SDObjectData attribute)
  • structtype (renderdoc.makeSDStruct parameter)
  • structured (renderdoc.D3D11View attribute)
  • structuredFile (renderdoc.ActionDescription.GetName parameter)
  • sub (qrenderdoc.CaptureContext.ViewTextureAsBuffer parameter)
    • (qrenderdoc.TextureViewer.SetSelectedSubresource parameter)
    • (renderdoc.ReplayController.GetHistogram parameter)
    • (renderdoc.ReplayController.GetMinMax parameter)
    • (renderdoc.ReplayController.GetTextureData parameter)
    • (renderdoc.ReplayController.PickPixel parameter)
    • (renderdoc.ReplayController.PixelHistory parameter)
    • (renderdoc.ReplayOutput.AddThumbnail parameter)
    • (renderdoc.ReplayOutput.DrawThumbnail parameter)
  • submenus (qrenderdoc.ExtensionManager.RegisterContextMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterPanelMenu parameter)
    • (qrenderdoc.ExtensionManager.RegisterWindowMenu parameter)
  • submitDate (qrenderdoc.BugReport attribute)
  • subpass (renderdoc.VKRenderPass attribute)
  • Subresource (class in renderdoc)
  • subresource (renderdoc.TextureDisplay attribute)
  • subroutines (renderdoc.GLShader attribute)
  • subsampling (renderdoc.ResourceFormat.SetYUVSubsampling parameter)
  • success (qrenderdoc.MiniQtHelper.CloseCurrentDialog parameter)
  • supported (renderdoc.APIUseData attribute)
  • supportMessage (renderdoc.APIUseData attribute)
  • SupportsBarriers() (renderdoc.PipeState method)
  • SupportsMultiplePrograms() (renderdoc.DeviceProtocolController method)
  • SupportsResourceArrays() (renderdoc.PipeState method)
  • suspended (renderdoc.VKRenderPass attribute)
  • Swap() (renderdoc.SDFile method)
  • swizzle (renderdoc.D3D12View attribute)
    • (renderdoc.GLAttachment attribute)
    • (renderdoc.GLTexture attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • synchronous (qrenderdoc.ReplayManager.GetHomeFolder parameter)
    • (qrenderdoc.ReplayManager.ListFolder parameter)
  • systemValue (renderdoc.SigParameter attribute)

T

  • tableIndex (renderdoc.D3D12ConstantBuffer attribute)
    • (renderdoc.D3D12Sampler attribute)
    • (renderdoc.D3D12View attribute)
  • tag (qrenderdoc.ReplayManager.AsyncInvoke parameter)
  • TakeOwnershipCapture() (renderdoc.RemoteServer method)
  • target (renderdoc.ReplayController.DisassembleShader parameter)
  • TargetControl (class in renderdoc)
  • TargetControlMessage (class in renderdoc)
  • TargetControlMessageType (class in renderdoc)
  • TargetControlMessageType.Busy (in module renderdoc)
  • TargetControlMessageType.CapturableWindowCount (in module renderdoc)
  • TargetControlMessageType.CaptureCopied (in module renderdoc)
  • TargetControlMessageType.CaptureProgress (in module renderdoc)
  • TargetControlMessageType.Disconnected (in module renderdoc)
  • TargetControlMessageType.NewCapture (in module renderdoc)
  • TargetControlMessageType.NewChild (in module renderdoc)
  • TargetControlMessageType.Noop (in module renderdoc)
  • TargetControlMessageType.RegisterAPI (in module renderdoc)
  • TargetControlMessageType.RequestShow (in module renderdoc)
  • TargetControlMessageType.Unknown (in module renderdoc)
  • TargetShaderEncodings() (qrenderdoc.CaptureContext method)
  • taskGroup (renderdoc.ShaderMeshMessageLocation attribute)
  • TaskGroupSize (class in renderdoc)
  • taskPayload (renderdoc.ShaderReflection attribute)
  • taskShader (renderdoc.VKState attribute)
  • taskSizes (renderdoc.MeshFormat attribute)
  • TempCaptureFilename() (qrenderdoc.CaptureContext method)
  • temporary (qrenderdoc.CaptureContext.LoadCapture parameter)
  • TemporaryCaptureDirectory (qrenderdoc.PersistantConfig attribute)
  • tessControlShader (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • tessellation (renderdoc.VKState attribute)
  • tessEvalShader (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • tex (renderdoc.ReplayController.GetTextureData parameter)
  • texid (renderdoc.ReplayController.ReplayLoop parameter)
  • text (qrenderdoc.CommentView.SetComments parameter)
    • (qrenderdoc.EventBookmark attribute)
    • (qrenderdoc.EventBrowser.SetCurrentFilterText parameter)
    • (qrenderdoc.ExtensionManager.ErrorDialog parameter)
    • (qrenderdoc.ExtensionManager.MessageDialog parameter)
    • (qrenderdoc.ExtensionManager.QuestionDialog parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetText parameter)
    • (renderdoc.LogMessage parameter)
  • texture (renderdoc.ReplayController.PixelHistory parameter)
  • TextureCategory (class in renderdoc)
  • TextureCategory.ColorTarget (in module renderdoc)
  • TextureCategory.DepthTarget (in module renderdoc)
  • TextureCategory.NoFlags (in module renderdoc)
  • TextureCategory.ShaderRead (in module renderdoc)
  • TextureCategory.ShaderReadWrite (in module renderdoc)
  • TextureCategory.SwapBuffer (in module renderdoc)
  • TextureComponentMapping (class in renderdoc)
  • textureCompression (renderdoc.GLHints attribute)
  • TextureDescription (class in renderdoc)
  • TextureDisplay (class in renderdoc)
  • TextureDisplay.ResolveSamples (in module renderdoc)
  • TextureFilter (class in renderdoc)
  • textureId (renderdoc.ReplayController.GetHistogram parameter)
    • (renderdoc.ReplayController.GetMinMax parameter)
    • (renderdoc.ReplayController.PickPixel parameter)
    • (renderdoc.ReplayOutput.AddThumbnail parameter)
    • (renderdoc.ReplayOutput.DrawThumbnail parameter)
  • textures (renderdoc.GLState attribute)
  • TextureSampleMapping (class in renderdoc)
  • TextureSampleMapping.ResolveSamples (in module renderdoc)
  • TextureSave (class in renderdoc)
  • TextureSliceMapping (class in renderdoc)
  • TextureSwizzle (class in renderdoc)
  • TextureSwizzle.Alpha (in module renderdoc)
  • TextureSwizzle.Blue (in module renderdoc)
  • TextureSwizzle.Green (in module renderdoc)
  • TextureSwizzle.One (in module renderdoc)
  • TextureSwizzle.Red (in module renderdoc)
  • TextureSwizzle.Zero (in module renderdoc)
  • TextureSwizzle4 (class in renderdoc)
  • TextureType (class in renderdoc)
  • TextureType.Buffer (in module renderdoc)
  • TextureType.Texture1D (in module renderdoc)
  • TextureType.Texture1DArray (in module renderdoc)
  • TextureType.Texture2D (in module renderdoc)
  • TextureType.Texture2DArray (in module renderdoc)
  • TextureType.Texture2DMS (in module renderdoc)
  • TextureType.Texture2DMSArray (in module renderdoc)
  • TextureType.Texture3D (in module renderdoc)
  • TextureType.TextureCube (in module renderdoc)
  • TextureType.TextureCubeArray (in module renderdoc)
  • TextureType.TextureRect (in module renderdoc)
  • TextureType.Unknown (in module renderdoc)
  • TextureViewer (class in qrenderdoc)
  • TextureViewer_PerTexSettings (qrenderdoc.PersistantConfig attribute)
  • TextureViewer_PerTexYFlip (qrenderdoc.PersistantConfig attribute)
  • TextureViewer_ResetRange (qrenderdoc.PersistantConfig attribute)
  • TextureViewer_ShaderDirs (qrenderdoc.PersistantConfig attribute)
  • thread (renderdoc.ShaderComputeMessageLocation attribute)
    • (renderdoc.ShaderMeshMessageLocation attribute)
  • threadid (renderdoc.ReplayController.DebugThread parameter)
  • threadID (renderdoc.SDChunkMetaData attribute)
  • thumbData (renderdoc.CaptureFile.SetMetadata parameter)
  • thumbHeight (renderdoc.CaptureFile.SetMetadata parameter)
    • (renderdoc.NewCaptureData attribute)
  • Thumbnail (class in renderdoc)
  • thumbnail (renderdoc.NewCaptureData attribute)
  • thumbType (renderdoc.CaptureFile.SetMetadata parameter)
  • thumbWidth (renderdoc.CaptureFile.SetMetadata parameter)
    • (renderdoc.NewCaptureData attribute)
  • tileOnlyMSAASampleCount (renderdoc.VKRenderPass attribute)
  • timeBase (renderdoc.CaptureFile.SetMetadata parameter)
  • timeFreq (renderdoc.CaptureFile.SetMetadata parameter)
  • TimelineBar (class in qrenderdoc)
  • timestamp (renderdoc.NewCaptureData attribute)
  • TimestampBase() (renderdoc.CaptureFile method)
  • TimestampFrequency() (renderdoc.CaptureFile method)
  • timestampMicro (renderdoc.SDChunkMetaData attribute)
  • TimeUnit (class in qrenderdoc)
  • TimeUnit.Microseconds (in module qrenderdoc)
  • TimeUnit.Milliseconds (in module qrenderdoc)
  • TimeUnit.Nanoseconds (in module qrenderdoc)
  • TimeUnit.Seconds (in module qrenderdoc)
  • Tips_HasSeenFirst (qrenderdoc.PersistantConfig attribute)
  • title (qrenderdoc.ExtensionManager.ErrorDialog parameter)
    • (qrenderdoc.ExtensionManager.MessageDialog parameter)
    • (qrenderdoc.ExtensionManager.QuestionDialog parameter)
    • (renderdoc.NewCaptureData attribute)
  • to (qrenderdoc.CaptureContext.RegisterReplacement parameter)
  • ToggleBreakpointOnDisassemblyLine() (qrenderdoc.ShaderViewer method)
  • ToggleBreakpointOnInstruction() (qrenderdoc.ShaderViewer method)
  • tool (qrenderdoc.ShaderProcessingTool attribute)
    • (renderdoc.ToolExecutable parameter)
    • (renderdoc.ToolInput parameter)
    • (renderdoc.ToolOutput parameter)
  • ToolExecutable() (in module renderdoc)
  • ToolInput() (in module renderdoc)
  • ToolOutput() (in module renderdoc)
  • Topology (class in renderdoc)
  • topology (renderdoc.D3D11InputAssembly attribute)
    • (renderdoc.D3D12InputAssembly attribute)
    • (renderdoc.GLVertexInput attribute)
    • (renderdoc.IsStrip parameter)
    • (renderdoc.MeshFormat attribute)
    • (renderdoc.NumVerticesPerPrimitive parameter)
    • (renderdoc.PatchList_Count parameter)
    • (renderdoc.VertexOffset parameter)
    • (renderdoc.VKInputAssembly attribute)
  • Topology.LineList (in module renderdoc)
  • Topology.LineList_Adj (in module renderdoc)
  • Topology.LineLoop (in module renderdoc)
  • Topology.LineStrip (in module renderdoc)
  • Topology.LineStrip_Adj (in module renderdoc)
  • Topology.PatchList (in module renderdoc)
  • Topology.PatchList_10CPs (in module renderdoc)
  • Topology.PatchList_11CPs (in module renderdoc)
  • Topology.PatchList_12CPs (in module renderdoc)
  • Topology.PatchList_13CPs (in module renderdoc)
  • Topology.PatchList_14CPs (in module renderdoc)
  • Topology.PatchList_15CPs (in module renderdoc)
  • Topology.PatchList_16CPs (in module renderdoc)
  • Topology.PatchList_17CPs (in module renderdoc)
  • Topology.PatchList_18CPs (in module renderdoc)
  • Topology.PatchList_19CPs (in module renderdoc)
  • Topology.PatchList_1CPs (in module renderdoc)
  • Topology.PatchList_20CPs (in module renderdoc)
  • Topology.PatchList_21CPs (in module renderdoc)
  • Topology.PatchList_22CPs (in module renderdoc)
  • Topology.PatchList_23CPs (in module renderdoc)
  • Topology.PatchList_24CPs (in module renderdoc)
  • Topology.PatchList_25CPs (in module renderdoc)
  • Topology.PatchList_26CPs (in module renderdoc)
  • Topology.PatchList_27CPs (in module renderdoc)
  • Topology.PatchList_28CPs (in module renderdoc)
  • Topology.PatchList_29CPs (in module renderdoc)
  • Topology.PatchList_2CPs (in module renderdoc)
  • Topology.PatchList_30CPs (in module renderdoc)
  • Topology.PatchList_31CPs (in module renderdoc)
  • Topology.PatchList_32CPs (in module renderdoc)
  • Topology.PatchList_3CPs (in module renderdoc)
  • Topology.PatchList_4CPs (in module renderdoc)
  • Topology.PatchList_5CPs (in module renderdoc)
  • Topology.PatchList_6CPs (in module renderdoc)
  • Topology.PatchList_7CPs (in module renderdoc)
  • Topology.PatchList_8CPs (in module renderdoc)
  • Topology.PatchList_9CPs (in module renderdoc)
  • Topology.PointList (in module renderdoc)
  • Topology.TriangleFan (in module renderdoc)
  • Topology.TriangleList (in module renderdoc)
  • Topology.TriangleList_Adj (in module renderdoc)
  • Topology.TriangleStrip (in module renderdoc)
  • Topology.TriangleStrip_Adj (in module renderdoc)
  • Topology.Unknown (in module renderdoc)
  • trace (qrenderdoc.CaptureContext.DebugShader parameter)
    • (renderdoc.ReplayController.FreeTrace parameter)
  • transformFeedback (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • TriggerCapture (C++ function)
  • TriggerCapture() (qrenderdoc.CaptureDialog method)
    • (renderdoc.TargetControl method)
  • TriggerMultiFrameCapture (C++ function)
  • type (renderdoc.CaptureAccess.FindSectionByType parameter)
    • (renderdoc.CaptureFile.GetThumbnail parameter)
    • (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12RootSignatureRange attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.DebugVariableReference attribute)
    • (renderdoc.GLImageLoadStore attribute)
    • (renderdoc.GLTexture attribute)
    • (renderdoc.InitCamera parameter)
    • (renderdoc.LogMessage parameter)
    • (renderdoc.MeshDisplay attribute)
    • (renderdoc.ReplayController.BuildCustomShader parameter)
    • (renderdoc.ReplayController.BuildTargetShader parameter)
    • (renderdoc.ReplayController.CreateOutput parameter)
    • (renderdoc.ResourceDescription attribute)
    • (renderdoc.ResourceFormat attribute)
    • (renderdoc.SDObject attribute)
    • (renderdoc.SectionProperties attribute)
    • (renderdoc.ShaderConstant attribute)
    • (renderdoc.ShaderVariable attribute)
    • (renderdoc.SourceVariableMapping attribute)
    • (renderdoc.TargetControlMessage attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.Thumbnail attribute)
    • (renderdoc.VarTypeByteSize parameter)
    • (renderdoc.VarTypeCompType parameter)
    • (renderdoc.VKBindingElement attribute)
  • typeCast (qrenderdoc.TextureViewer.ViewTexture parameter)
    • (renderdoc.BoundResource attribute)
    • (renderdoc.ReplayController.GetHistogram parameter)
    • (renderdoc.ReplayController.GetMinMax parameter)
    • (renderdoc.ReplayController.PickPixel parameter)
    • (renderdoc.ReplayController.PixelHistory parameter)
    • (renderdoc.ReplayOutput.AddThumbnail parameter)
    • (renderdoc.ReplayOutput.DrawThumbnail parameter)
    • (renderdoc.TextureDisplay attribute)
    • (renderdoc.TextureSave attribute)
  • typeConflict (renderdoc.GLTexture attribute)
  • types (renderdoc.ResourceBindStats attribute)
    • (renderdoc.ResourceUpdateStats attribute)

U

  • u (renderdoc.SDObjectPODData attribute)
  • u16v (renderdoc.ShaderValue attribute)
  • u32 (renderdoc.CounterValue attribute)
  • u32v (renderdoc.ShaderValue attribute)
  • u64 (renderdoc.CounterValue attribute)
  • u64v (renderdoc.ShaderValue attribute)
  • u8v (renderdoc.ShaderValue attribute)
  • uavs (renderdoc.D3D11OutputMerger attribute)
    • (renderdoc.D3D11Shader attribute)
  • uavStartSlot (renderdoc.D3D11OutputMerger attribute)
  • uintValue (renderdoc.PixelValue attribute)
  • UIStyle (qrenderdoc.PersistantConfig attribute)
  • unboundPS (renderdoc.PixelModification attribute)
  • uncompressedFileSize (renderdoc.FrameDescription attribute)
  • uncompressedSize (renderdoc.SectionProperties attribute)
  • uniformBuffers (renderdoc.GLState attribute)
  • unit (qrenderdoc.UnitSuffix parameter)
    • (renderdoc.CounterDescription attribute)
  • UnitSuffix() (in module qrenderdoc)
  • UnloadCrashHandler (C++ function)
  • unnormalized (renderdoc.D3D12Sampler attribute)
    • (renderdoc.VKBindingElement attribute)
  • unproject (renderdoc.MeshFormat attribute)
  • UnreadMessageCount() (qrenderdoc.CaptureContext method)
  • unreadUpdates (qrenderdoc.BugReport attribute)
  • UnregisterEventFilterFunction() (qrenderdoc.EventBrowser method)
  • UnregisterReplacement() (qrenderdoc.CaptureContext method)
  • UnregisterShortcut() (qrenderdoc.MainWindow method)
  • UnsupportedAndroid_LastUpdate (qrenderdoc.PersistantConfig attribute)
  • UpdateDurationColumn() (qrenderdoc.EventBrowser method)
    • (qrenderdoc.PerformanceCounterViewer method)
  • UpdateEnumeratedProtocolDevices() (qrenderdoc.PersistantConfig method)
  • UpdateGlobalHook() (qrenderdoc.CaptureDialog method)
  • UpdateProgressBarValue() (qrenderdoc.MiniQtHelper method)
  • UpdateRemoteHost() (qrenderdoc.CaptureDialog method)
  • updates (renderdoc.FrameStatistics attribute)
  • URL (renderdoc.CheckRemoteServerConnection parameter)
    • (renderdoc.CreateRemoteServerConnection parameter)
    • (renderdoc.CreateTargetControl parameter)
    • (renderdoc.DeviceProtocolController.GetFriendlyName parameter)
    • (renderdoc.DeviceProtocolController.IsSupported parameter)
    • (renderdoc.DeviceProtocolController.StartRemoteServer parameter)
    • (renderdoc.DeviceProtocolController.SupportsMultiplePrograms parameter)
    • (renderdoc.EnumerateRemoteTargets parameter)
  • URL() (qrenderdoc.BugReport method)
  • usage (renderdoc.EventUsage attribute)
  • use (qrenderdoc.EventBrowser.SetUseCustomActionNames parameter)
  • UseBorder() (renderdoc.D3D11Sampler method)
    • (renderdoc.D3D12Sampler method)
    • (renderdoc.GLSampler method)
    • (renderdoc.VKBindingElement method)
  • used (renderdoc.Bindpoint attribute)
    • (renderdoc.VertexInputAttribute attribute)
  • Uuid (class in renderdoc)
  • uuid (renderdoc.CounterDescription attribute)

V

  • val (renderdoc.makeSDBool parameter)
    • (renderdoc.makeSDEnum parameter)
    • (renderdoc.makeSDFloat parameter)
    • (renderdoc.makeSDInt32 parameter)
    • (renderdoc.makeSDInt64 parameter)
    • (renderdoc.makeSDResourceId parameter)
    • (renderdoc.makeSDString parameter)
    • (renderdoc.makeSDUInt32 parameter)
    • (renderdoc.makeSDUInt64 parameter)
  • value (qrenderdoc.MiniQtHelper.SetProgressBarValue parameter)
    • (qrenderdoc.MiniQtHelper.SetSpinboxValue parameter)
    • (renderdoc.CounterResult attribute)
    • (renderdoc.D3D11Predication attribute)
    • (renderdoc.EnvironmentModification attribute)
    • (renderdoc.ShaderCompileFlag attribute)
    • (renderdoc.ShaderVariable attribute)
  • variables (renderdoc.ConstantBlock attribute)
    • (renderdoc.SourceVariableMapping attribute)
  • variableType (renderdoc.ShaderResource attribute)
  • varName (renderdoc.SigParameter attribute)
  • VarType (class in renderdoc)
  • varType (renderdoc.SigParameter attribute)
  • VarType.Bool (in module renderdoc)
  • VarType.ConstantBlock (in module renderdoc)
  • VarType.Double (in module renderdoc)
  • VarType.Enum (in module renderdoc)
  • VarType.Float (in module renderdoc)
  • VarType.GPUPointer (in module renderdoc)
  • VarType.Half (in module renderdoc)
  • VarType.ReadOnlyResource (in module renderdoc)
  • VarType.ReadWriteResource (in module renderdoc)
  • VarType.Sampler (in module renderdoc)
  • VarType.SByte (in module renderdoc)
  • VarType.SInt (in module renderdoc)
  • VarType.SLong (in module renderdoc)
  • VarType.SShort (in module renderdoc)
  • VarType.Struct (in module renderdoc)
  • VarType.UByte (in module renderdoc)
  • VarType.UInt (in module renderdoc)
  • VarType.ULong (in module renderdoc)
  • VarType.Unknown (in module renderdoc)
  • VarType.UShort (in module renderdoc)
  • VarTypeByteSize() (in module renderdoc)
  • VarTypeCompType() (in module renderdoc)
  • vecCount (renderdoc.D3D11ConstantBuffer attribute)
  • vecOffset (renderdoc.D3D11ConstantBuffer attribute)
  • vendor (renderdoc.APIProperties attribute)
    • (renderdoc.DriverInformation attribute)
    • (renderdoc.GPUDevice attribute)
  • vendorID (renderdoc.GPUVendorFromPCIVendor parameter)
  • verifyBufferAccess (renderdoc.CaptureOptions attribute)
  • version (qrenderdoc.ExtensionMetadata attribute)
    • (renderdoc.DriverInformation attribute)
    • (renderdoc.SDFile attribute)
    • (renderdoc.SectionProperties attribute)
  • VersionMismatchError() (qrenderdoc.RemoteHost method)
  • vertex (renderdoc.ShaderMessageLocation attribute)
  • vertexArrayObject (renderdoc.GLVertexInput attribute)
  • VertexBindStats (class in renderdoc)
  • vertexBuffer (renderdoc.VertexInputAttribute attribute)
  • vertexBufferBinding (renderdoc.VKVertexBinding attribute)
  • vertexBuffers (renderdoc.D3D11InputAssembly attribute)
    • (renderdoc.D3D12InputAssembly attribute)
    • (renderdoc.GLVertexInput attribute)
    • (renderdoc.VKVertexInput attribute)
  • vertexBufferSlot (renderdoc.GLVertexAttribute attribute)
  • vertexByteOffset (renderdoc.MeshFormat attribute)
  • vertexByteSize (renderdoc.MeshFormat attribute)
  • vertexByteStride (renderdoc.MeshFormat attribute)
  • vertexIndex (renderdoc.ShaderVertexMessageLocation attribute)
  • vertexInput (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • VertexInputAttribute (class in renderdoc)
  • vertexOffset (renderdoc.ActionDescription attribute)
  • VertexOffset() (in module renderdoc)
  • vertexProcessing (renderdoc.GLState attribute)
  • vertexResourceId (renderdoc.MeshFormat attribute)
  • vertexShader (renderdoc.D3D11State attribute)
    • (renderdoc.D3D12State attribute)
    • (renderdoc.GLState attribute)
    • (renderdoc.VKState attribute)
  • vertices (renderdoc.FrameStatistics attribute)
  • vertid (renderdoc.ReplayController.DebugVertex parameter)
  • view (qrenderdoc.BufferViewer.SetCurrentView parameter)
    • (qrenderdoc.CaptureContext.ViewPixelHistory parameter)
    • (renderdoc.CreateMacOSWindowingData parameter)
    • (renderdoc.DebugPixelInputs attribute)
    • (renderdoc.EventUsage attribute)
    • (renderdoc.ReplayController.DebugVertex parameter)
    • (renderdoc.ReplayController.GetPostVSData parameter)
    • (renderdoc.ShaderGeometryMessageLocation attribute)
    • (renderdoc.ShaderPixelMessageLocation attribute)
    • (renderdoc.ShaderVertexMessageLocation attribute)
  • ViewBuffer() (qrenderdoc.CaptureContext method)
  • viewClipped (renderdoc.PixelModification attribute)
  • ViewConstantBuffer() (qrenderdoc.CaptureContext method)
  • viewer (qrenderdoc.CaptureContext.AddCaptureViewer parameter)
    • (qrenderdoc.CaptureContext.RemoveCaptureViewer parameter)
  • ViewFollowedResource() (qrenderdoc.TextureViewer method)
  • viewFormat (renderdoc.D3D11View attribute)
    • (renderdoc.D3D12View attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • ViewPixelHistory() (qrenderdoc.CaptureContext method)
  • Viewport (class in renderdoc)
  • viewports (renderdoc.D3D11Rasterizer attribute)
    • (renderdoc.D3D12Rasterizer attribute)
    • (renderdoc.GLRasterizer attribute)
    • (renderdoc.RasterizationStats attribute)
  • viewportScissor (renderdoc.VKState attribute)
  • viewportScissors (renderdoc.VKViewState attribute)
  • viewResourceId (renderdoc.D3D11View attribute)
    • (renderdoc.VKAttachment attribute)
    • (renderdoc.VKBindingElement attribute)
  • views (renderdoc.D3D12RootSignatureRange attribute)
  • ViewShader() (qrenderdoc.CaptureContext method)
  • ViewShaderMessages() (qrenderdoc.CaptureContext method)
  • ViewTexture() (qrenderdoc.TextureViewer method)
  • ViewTextureAsBuffer() (qrenderdoc.CaptureContext method)
  • visibility (renderdoc.D3D12RootSignatureRange attribute)
  • visible (qrenderdoc.MiniQtHelper.SetWidgetVisible parameter)
  • Visualisation (class in renderdoc)
  • Visualisation.Explode (in module renderdoc)
  • Visualisation.Lit (in module renderdoc)
  • Visualisation.Meshlet (in module renderdoc)
  • Visualisation.NoSolid (in module renderdoc)
  • Visualisation.Secondary (in module renderdoc)
  • Visualisation.Solid (in module renderdoc)
  • visualisationMode (renderdoc.MeshDisplay attribute)
  • VKAttachment (class in renderdoc)
  • VKBindingElement (class in renderdoc)
  • VKColorBlendState (class in renderdoc)
  • VKConditionalRendering (class in renderdoc)
  • VKCurrentPass (class in renderdoc)
  • VKDepthStencil (class in renderdoc)
  • VKDescriptorBinding (class in renderdoc)
  • VKDescriptorSet (class in renderdoc)
  • VKFramebuffer (class in renderdoc)
  • VKImageData (class in renderdoc)
  • VKImageLayout (class in renderdoc)
  • VKIndexBuffer (class in renderdoc)
  • VKInputAssembly (class in renderdoc)
  • VKMultiSample (class in renderdoc)
  • VKPipeline (class in renderdoc)
  • VKRasterizer (class in renderdoc)
  • VKRenderArea (class in renderdoc)
  • VKRenderPass (class in renderdoc)
  • VKSampleLocations (class in renderdoc)
  • VKShader (class in renderdoc)
  • VKState (class in renderdoc)
  • VKTessellation (class in renderdoc)
  • VKTransformFeedback (class in renderdoc)
  • VKVertexAttribute (class in renderdoc)
  • VKVertexBinding (class in renderdoc)
  • VKVertexBuffer (class in renderdoc)
  • VKVertexInput (class in renderdoc)
  • VKViewportScissor (class in renderdoc)
  • VKViewState (class in renderdoc)
  • VKXFBBuffer (class in renderdoc)
  • vp (renderdoc.VKViewportScissor attribute)
  • vtxExploderSliderSNorm (renderdoc.MeshDisplay attribute)

W

  • w (renderdoc.FloatVector attribute)
  • waitForExit (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.InjectIntoProcess parameter)
  • waylandDisplay (renderdoc.GlobalEnvironment attribute)
  • whitepoint (qrenderdoc.TextureViewer.SetHistogramRange parameter)
  • whitePoint (renderdoc.TextureComponentMapping attribute)
  • widget (qrenderdoc.MainWindow.RegisterShortcut parameter)
    • (qrenderdoc.MainWindow.UnregisterShortcut parameter)
    • (qrenderdoc.MiniQtHelper.CloseToplevelWidget parameter)
    • (qrenderdoc.MiniQtHelper.DestroyWidget parameter)
    • (qrenderdoc.MiniQtHelper.GetNumChildren parameter)
    • (qrenderdoc.MiniQtHelper.GetParent parameter)
    • (qrenderdoc.MiniQtHelper.GetWidgetName parameter)
    • (qrenderdoc.MiniQtHelper.GetWidgetText parameter)
    • (qrenderdoc.MiniQtHelper.GetWidgetType parameter)
    • (qrenderdoc.MiniQtHelper.GetWidgetWindowingData parameter)
    • (qrenderdoc.MiniQtHelper.IsWidgetEnabled parameter)
    • (qrenderdoc.MiniQtHelper.IsWidgetVisible parameter)
    • (qrenderdoc.MiniQtHelper.SetLabelImage parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetBackgroundColor parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetEnabled parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetFont parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetName parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetReplayOutput parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetText parameter)
    • (qrenderdoc.MiniQtHelper.SetWidgetVisible parameter)
    • (qrenderdoc.MiniQtHelper.ShowWidgetAsDialog parameter)
  • Widget() (qrenderdoc.APIInspector method)
    • (qrenderdoc.BufferViewer method)
    • (qrenderdoc.CaptureDialog method)
    • (qrenderdoc.CommentView method)
    • (qrenderdoc.DebugMessageView method)
    • (qrenderdoc.DiagnosticLogView method)
    • (qrenderdoc.EventBrowser method)
    • (qrenderdoc.MainWindow method)
    • (qrenderdoc.PerformanceCounterViewer method)
    • (qrenderdoc.PipelineStateViewer method)
    • (qrenderdoc.PixelHistoryView method)
    • (qrenderdoc.PythonShell method)
    • (qrenderdoc.ResourceInspector method)
    • (qrenderdoc.ShaderMessageViewer method)
    • (qrenderdoc.ShaderViewer method)
    • (qrenderdoc.StatisticsViewer method)
    • (qrenderdoc.TextureViewer method)
    • (qrenderdoc.TimelineBar method)
  • width (qrenderdoc.MiniQtHelper.SetLabelImage parameter)
    • (renderdoc.CreateHeadlessWindowingData parameter)
    • (renderdoc.ReplayOutput.DrawThumbnail parameter)
    • (renderdoc.ReplayOutput.SetDimensions parameter)
    • (renderdoc.Scissor attribute)
    • (renderdoc.TextureDescription attribute)
    • (renderdoc.Thumbnail attribute)
    • (renderdoc.Viewport attribute)
    • (renderdoc.VKFramebuffer attribute)
    • (renderdoc.VKRenderArea attribute)
  • window (qrenderdoc.CaptureContext.BuiltinWindowClosed parameter)
    • (qrenderdoc.CaptureContext.CreateWindowingData parameter)
    • (qrenderdoc.ReplayManager.CopyCaptureFromRemote parameter)
    • (qrenderdoc.ReplayManager.CopyCaptureToRemote parameter)
    • (qrenderdoc.ShaderProcessingTool.CompileShader parameter)
    • (qrenderdoc.ShaderProcessingTool.DisassembleShader parameter)
    • (renderdoc.CreateAndroidWindowingData parameter)
    • (renderdoc.CreateWaylandWindowingData parameter)
    • (renderdoc.CreateWin32WindowingData parameter)
    • (renderdoc.CreateXCBWindowingData parameter)
    • (renderdoc.CreateXlibWindowingData parameter)
    • (renderdoc.ReplayController.CreateOutput parameter)
    • (renderdoc.ReplayController.CreateRGPProfile parameter)
    • (renderdoc.ReplayController.ReplayLoop parameter)
    • (renderdoc.ReplayOutput.AddThumbnail parameter)
    • (renderdoc.ReplayOutput.SetPixelContext parameter)
  • WindowingData (class in renderdoc)
  • WindowingSystem (class in renderdoc)
  • WindowingSystem.Android (in module renderdoc)
  • WindowingSystem.GGP (in module renderdoc)
  • WindowingSystem.Headless (in module renderdoc)
  • WindowingSystem.MacOS (in module renderdoc)
  • WindowingSystem.Unknown (in module renderdoc)
  • WindowingSystem.Wayland (in module renderdoc)
  • WindowingSystem.Win32 (in module renderdoc)
  • WindowingSystem.XCB (in module renderdoc)
  • WindowingSystem.Xlib (in module renderdoc)
  • WindowMenu (class in qrenderdoc)
  • WindowMenu.File (in module qrenderdoc)
  • WindowMenu.Help (in module qrenderdoc)
  • WindowMenu.NewMenu (in module qrenderdoc)
  • WindowMenu.Tools (in module qrenderdoc)
  • WindowMenu.Unknown (in module qrenderdoc)
  • WindowMenu.Window (in module qrenderdoc)
  • windowTitle (qrenderdoc.MiniQtHelper.CreateToplevelWidget parameter)
  • wireframeDraw (renderdoc.MeshDisplay attribute)
  • withPipeline (renderdoc.ReplayController.GetDisassemblyTargets parameter)
  • words (renderdoc.Uuid attribute)
  • workgroup (renderdoc.ShaderComputeMessageLocation attribute)
  • workingDir (qrenderdoc.CaptureSettings attribute)
    • (qrenderdoc.ReplayManager.ExecuteAndInject parameter)
    • (renderdoc.ExecuteAndInject parameter)
    • (renderdoc.RemoteServer.ExecuteAndInject parameter)
  • writeAllowed (renderdoc.GLImageLoadStore attribute)
  • writeMask (renderdoc.ColorBlend attribute)
    • (renderdoc.StencilFace attribute)
  • WriteSection() (renderdoc.CaptureAccess method)
  • writtenCountByteOffset (renderdoc.D3D12StreamOutBind attribute)
  • writtenCountResourceId (renderdoc.D3D12StreamOutBind attribute)

X

  • x (qrenderdoc.CaptureContext.ViewPixelHistory parameter)
    • (qrenderdoc.TextureViewer.GotoLocation parameter)
    • (renderdoc.Camera.SetFPSRotation parameter)
    • (renderdoc.Camera.SetPosition parameter)
    • (renderdoc.FloatVector attribute)
    • (renderdoc.Offset attribute)
    • (renderdoc.ReplayController.DebugPixel parameter)
    • (renderdoc.ReplayController.PickPixel parameter)
    • (renderdoc.ReplayController.PixelHistory parameter)
    • (renderdoc.ReplayOutput.PickVertex parameter)
    • (renderdoc.ReplayOutput.SetPixelContextLocation parameter)
    • (renderdoc.Scissor attribute)
    • (renderdoc.ShaderPixelMessageLocation attribute)
    • (renderdoc.TaskGroupSize attribute)
    • (renderdoc.Viewport attribute)
    • (renderdoc.VKRenderArea attribute)
  • xAxis (renderdoc.AxisMapping attribute)
  • xChromaOffset (renderdoc.VKBindingElement attribute)
  • xlibDisplay (renderdoc.GlobalEnvironment attribute)
  • xOffset (renderdoc.TextureDisplay attribute)

Y

  • y (qrenderdoc.CaptureContext.ViewPixelHistory parameter)
    • (qrenderdoc.TextureViewer.GotoLocation parameter)
    • (renderdoc.Camera.SetFPSRotation parameter)
    • (renderdoc.Camera.SetPosition parameter)
    • (renderdoc.FloatVector attribute)
    • (renderdoc.Offset attribute)
    • (renderdoc.ReplayController.DebugPixel parameter)
    • (renderdoc.ReplayController.PickPixel parameter)
    • (renderdoc.ReplayController.PixelHistory parameter)
    • (renderdoc.ReplayOutput.PickVertex parameter)
    • (renderdoc.ReplayOutput.SetPixelContextLocation parameter)
    • (renderdoc.Scissor attribute)
    • (renderdoc.ShaderPixelMessageLocation attribute)
    • (renderdoc.TaskGroupSize attribute)
    • (renderdoc.Viewport attribute)
    • (renderdoc.VKRenderArea attribute)
  • yAxis (renderdoc.AxisMapping attribute)
  • YcbcrConversion (class in renderdoc)
  • YcbcrConversion.BT2020 (in module renderdoc)
  • YcbcrConversion.BT601 (in module renderdoc)
  • YcbcrConversion.BT709 (in module renderdoc)
  • YcbcrConversion.RangeOnly (in module renderdoc)
  • YcbcrConversion.Raw (in module renderdoc)
  • ycbcrModel (renderdoc.VKBindingElement attribute)
  • YcbcrRange (class in renderdoc)
  • ycbcrRange (renderdoc.VKBindingElement attribute)
  • YcbcrRange.ITUFull (in module renderdoc)
  • YcbcrRange.ITUNarrow (in module renderdoc)
  • ycbcrSampler (renderdoc.VKBindingElement attribute)
  • yChromaOffset (renderdoc.VKBindingElement attribute)
  • yOffset (renderdoc.TextureDisplay attribute)
  • YUVPlaneCount() (renderdoc.ResourceFormat method)
  • YUVSubsampling() (renderdoc.ResourceFormat method)

Z

  • z (renderdoc.Camera.SetFPSRotation parameter)
    • (renderdoc.Camera.SetPosition parameter)
    • (renderdoc.FloatVector attribute)
    • (renderdoc.TaskGroupSize attribute)
  • zAxis (renderdoc.AxisMapping attribute)
  • zoom (qrenderdoc.TextureViewer.SetZoomLevel parameter)


Introduction

Welcome to RenderDoc - a graphics debugger currently available for Vulkan, D3D11, D3D12, OpenGL, and OpenGL ES development on Windows, Linux, Android, and Nintendo Switch TM.

This document serves as reference guide, introductory document and explanation of which features are available in RenderDoc and how to best use them.

The latest information and discussion is always available on the GitHub repository.

License

RenderDoc is released under the MIT license, so there are no restrictions on your use of it either commercially or non-commercially. This includes the source release available on GitHub.

Details of the licenses of third party software used in RenderDoc are included in the LICENSE file in the RenderDoc directory as well as in the Credits & Acknowledgements.

How to browse this documentation

If you just want to dive straight in and learn how to get started using RenderDoc consider looking at the Quick Start section which gives a simple introduction on how to get started. Afterwards there are reference pages on each of the windows available in RenderDoc which can be referred to as you use the program, or skimmed to get a feel for the functionality available.

Those of you familiar with other graphics debuggers will likely find much of RenderDoc recognisable, you might want to check out the FAQ, Features, Tips & Tricks or browse the How do I …? sections which detail how some common tasks are accomplished.

Regardless of your experience or patience for documentation it’s recommended that you read the Gotchas & Known Issues as this details current limitations of the program.

Important notes

  • RenderDoc is generally stable but you will still likely encounter bugs depending on your use case, especially as with graphics there is a lot of potential surface area and interactions. I am always happy to spend time to fix bugs, but bear in mind that I need information about how to reproduce your specific situation. If you’re able to provide public reproducible steps please file an issue on GitHub, or if you need to share information privately please email me.
  • On the other side of the coin, please do give feedback when RenderDoc works for you and request features that would make your life easier or improve your workflow.
  • There are a few common issues you might run into, so if you have any problems check the FAQ, or the GitHub issues list to see if it’s been reported.

Documentation and Tutorials

Aside from the documentation that you are reading, I have recorded some YouTube video tutorials showing the use of some basic features and an introduction/overview. Note that these are quite old, from the first release of RenderDoc, but the basic workflows and operation is still similar.

There is also a great presentation by @Icetigris which goes into some details of how RenderDoc can be used in real world situations: Slides are available here

Contact info, Feedback, Bug reports

If you want to get in touch with any feature requests, suggestions, comments etc then feel free to contact me: Contact me.

Bug reports can be submitted directly via email, or also on the GitHub issues list where you can also find the full source code.

The Builds page always has the latest stable build downloads, as well as builds made from the source code each night for the bleeding edge. Stable releases update every two months or so and are the typical releases to stick to for the most reliable experience.

See Also

  • RenderDoc Homepage
  • Builds page