# 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

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