API Reference: Common Pipeline State Abstraction¶

This is the API reference for the functions, classes, and enums in the renderdoc module which represents the underlying interface that the UI is built on top of. For more high-level information and instructions on using the python API, see Python API.

Sections

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

GetAllUsedDescriptors(onlyUsed=False)¶

GetAllUsedDescriptors() → None

Retrieves all descriptor information for all descriptors accessed at the current event.

Parameters: onlyUsed# (bool) – Omit descriptors bound or declared but not accessed.
Returns: All descriptors accessed at the current event.
Return type: List[UsedDescriptor]

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

GetConstantBlock(stage, index, arrayIdx)¶

Retrieves the constant block at a given binding.

Parameters

stage# (ShaderStage) – The shader stage to fetch from.
index# (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

UsedDescriptor

GetConstantBlocks(stage, onlyUsed=False)¶

GetConstantBlocks(stage) → None

Retrieves the constant blocks used by a particular shader stage.

Parameters

stage# (ShaderStage) – The shader stage to fetch from.
onlyUsed# (bool) – Omit descriptors bound or declared but not accessed.

Returns

The currently bound constant blocks.

Return type

List[UsedDescriptor]

GetDepthResolveTarget()¶

Retrieves the read/write resources bound to the depth-stencil resolve output.

Returns: The currently bound depth-stencil resolve resource.
Return type: Descriptor

GetDepthTarget()¶

Retrieves the read/write resources bound to the depth-stencil output.

Returns: The currently bound depth-stencil resource.
Return type: Descriptor

GetDescriptorAccess()¶

Retrieves the current list of descriptor accesses, as cached from a call to ReplayController.GetDescriptorAccess(). The return value is identical, this is here for convenience of access.

Returns: The descriptor accesses.
Return type: List[DescriptorAccess]

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[Descriptor]

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 used by a particular shader stage.

Parameters

stage# (ShaderStage) – The shader stage to fetch from.
onlyUsed# (bool) – Omit descriptors bound or declared but not accessed.

Returns

The currently bound read-only resources.

Return type

List[UsedDescriptor]

GetReadWriteResources(stage, onlyUsed=False)¶

GetReadWriteResources(stage) → None

Retrieves the read/write resources used by a particular shader stage.

Parameters

stage# (ShaderStage) – The shader stage to fetch from.
onlyUsed# (bool) – Omit descriptors bound or declared but not accessed.

Returns

The currently bound read/write resources.

Return type

List[UsedDescriptor]

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, onlyUsed=False)¶

GetSamplers(stage) → None

Retrieves the samplers bound to a particular shader stage.

Parameters

stage# (ShaderStage) – The shader stage to fetch from.
onlyUsed# (bool) – Omit descriptors bound or declared but not accessed.

Returns

The currently bound sampler resources.

Return type

List[UsedDescriptor]

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.UsedDescriptor¶

Combined information about a single descriptor that has been used, both the information about its access and its contents.

This is a helper struct for the common pipeline state abstraction to trade off simplicity of access against optimal access.

access¶

The access information of which shader reflection object accessed which descriptor.

Type: DescriptorAccess

descriptor¶

The contents of the accessed descriptor, if it is a normal non-sampler descriptor.

For sampler descriptors this is empty.

Type: Descriptor

sampler¶

The contents of the accessed descriptor, if it is a sampler descriptor.

For normal descriptors this is empty.

Type: SamplerDescriptor

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.

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