Common Pipeline State Abstraction

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