# Formats

Contents

- Formats

  - Resource Format

## Resource Format

class `renderdoc.``ResourceFormat`

  Description of the format of a resource or element.

  `BGRAOrder`()
    Returns

      `True` if the components are to be read in `BGRA` order.

    Note

    The convention is that components are in RGBA order. Whether that means first byte to last byte, or in bit-packed formats red in the lowest bits.

    With BGRA order this means blue is in the first byte/lowest bits, but alpha is still always expected in the last byte/uppermost bits.

    Return type

      bool

  `BlockFormat`()
    Returns

      `True` if the `ResourceFormat` is a block-compressed type.

    Return type

      bool

  `ElementSize`()

    Return the size of a single element in this format, usually a pixel. For regular sized formats this is just `compByteWidth` times `compCount`, for special packed formats it’s the tightly packed size of a single element, with no padding.

    Block-compressed formats define an ‘element’ as a whole block of texels.

    YUV formats where texel size varies depending on subsampling will return the size of a decompressed texel.

    Returns

      The size of an element

    Return type

      int

  `Name`()
    Returns

      The name of the format.

    Return type

      str

  `SRGBCorrected`()

    Equivalent to checking if `compType` is `CompType.UNormSRGB`

    Returns

      `True` if the components are SRGB corrected on read and write.

    Return type

      bool

  `SetBGRAOrder`(flag)

    Set BGRA order flag. See `BGRAOrder()`.

    Parameters

      flag (bool) – The new flag value.

  `SetYUVPlaneCount`(planes)

    Set number of YUV planes. See `YUVPlaneCount()`.

    Invalid values will result in 1 being set.

    Parameters

      planes (int) – The new number of YUV planes.

  `SetYUVSubsampling`(subsampling)

    Set YUV subsampling rate. See `YUVSubsampling()`.

    The value should be e.g. 444 for 4:4:4 or 422 for 4:2:2. Invalid values will result in 0 being set.

    Parameters

      subsampling (int) – The new subsampling rate.

  `Special`()
    Returns

      `True` if the `ResourceFormat` is a ‘special’ non-regular type.

    Return type

      bool

  `YUVPlaneCount`()

    Get the number of planes for a YUV format. Only valid when `type` is a YUV format like `ResourceFormatType.YUV8`.

    For other formats, 1 is returned.

    Returns

      The number of planes

    Return type

      int

  `YUVSubsampling`()

    Get the subsampling rate for a YUV format. Only valid when `type` is a YUV format like `ResourceFormatType.YUV8`.

    For other formats, 0 is returned.

    Returns

      The subsampling rate, e.g. 444 for 4:4:4 or 420 for 4:2:0

    Return type

      int

  `compByteWidth`

    The width in bytes of each component.

  `compCount`

    The number of components in each element.

  `compType`

    The `type` of each component.

  `type`

    Return the size of a single element in this format, usually a pixel. For regular sized formats this is just `compByteWidth` times `compCount`, for special packed formats it’s the tightly packed size of a single element, with no padding.

    Block-compressed formats define an ‘element’ as a whole block of texels.

    YUV formats where texel size varies depending on subsampling will return the size of a decompressed texel.

    Returns

      The size of an element

    Return type

      int

class `renderdoc.``ResourceFormatType`(value)

  A resource format’s particular type. This accounts for either block-compressed textures or formats that don’t have equal byte-multiple sizes for each channel.

  `Regular`

    This format has no special layout, so its format is described by a number of components, a `CompType` and a byte width per component.

  `Undefined`

    This format is undefined or unknown, or does not map to any known regular format.

  `BC1`

    A block-compressed texture in `BC1` format (RGB with 1-bit alpha, 0.5 bytes per pixel)

    Formerly known as `DXT1`, commonly used for color maps.

  `BC2`

    A block-compressed texture in `BC2` format (RGB with 4-bit alpha, 1 byte per pixel)

    Formerly known as `DXT3`, rarely used.

  `BC3`

    A block-compressed texture in `BC3` format (RGBA, 1 byte per pixel)

    Formerly known as `DXT5`, commonly used for color + alpha maps, or color with attached single channel data.

  `BC4`

    A block-compressed texture in `BC4` format (Single channel, 0.5 bytes per pixel)

    Commonly used for single component data such as gloss or height data.

  `BC5`

    A block-compressed texture in `BC5` format (Two channels, 1 byte per pixel)

    Commonly used for normal maps.

  `BC6`

    A block-compressed texture in `BC6` format (RGB floating point, 1 byte per pixel)

    Commonly used for HDR data of all kinds.

  `BC7`

    A block-compressed texture in `BC7` format (RGB or RGBA, 1 byte per pixel)

    Commonly used for high quality color maps, with or without alpha.

  `ETC2`

    A block-compressed texture in `ETC2` format (RGB with 1-bit alpha, 0.5 bytes per pixel)

    Commonly used on mobile or embedded platforms.

    Note that the mode added in `EAC` with 1 byte per pixel and full 8-bit alpha is grouped as `EAC`, with a component count of 4. See `EAC`.

  `EAC`

    A block-compressed texture in `EAC` format, expanded from `ETC2`.

    Commonly used on mobile or embedded platforms.

    The single and dual channel formats encode 11-bit data with 0.5 bytes per channel (so the single channel format is 0.5 bytes per pixel total, and the dual channel format is 1 byte per pixel total). The four channel format is encoded similarly to ETC2 for the base RGB data and similarly to the single channel format for the alpha, giving 1 byte per pixel total. See `ETC2`.

  `ASTC`

    A block-compressed texture in `ASTC` format (Representation varies a lot)

    The ASTC format encodes each block as 16 bytes, but the block size can vary from 4x4 (so 1 byte per pixel) up to 12x12 (0.11 bytes per pixel).

    Each block can encode between one and three channels of data, either correlated or uncorrelated, in low or high dynamic range.

    Commonly used on mobile or embedded platforms.

  `R10G10B10A2`

    Each pixel is stored in 32 bits. Red, green and blue are stored in 10-bits each and alpha in 2 bits. The data can either be `unsigned normalised` or `unsigned integer`.

  `R11G11B10`

    Each pixel is stored in 32 bits. Red and green are stored as an 11-bit float with no sign bit, 5-bit exponent and 6-bit mantissa. Blue is stored with 5-bit exponent and 5-bit mantissa.

  `R5G6B5`

    Each pixel is stored in 16 bits. Red and blue are stored as 5 bits, and green is stored as six. The data is `unsigned normalised`.

  `R5G5B5A1`

    Each pixel is stored in 16 bits. Red, green, and blue are stored as 5 bits, with 1-bit alpha. The data is `unsigned normalised`.

  `R9G9B9E5`

    Each pixel is stored in 32 bits. Red, green, and blue are stored with individual 9-bit mantissas and a shared 5-bit exponent. There are no sign bits.

  `R4G4B4A4`

    Each pixel is stored in 16 bits. Red, green, blue, and alpha are stored as 4-bit `unsigned normalised` values.

  `R4G4`

    Each pixel is stored in 8 bits. Red and green are stored as 4-bit `unsigned normalised` values.

  `D16S8`

    Each pixel is considered a packed depth-stencil value with 16 bit normalised depth and 8 bit stencil.

  `D24S8`

    Each pixel is considered a packed depth-stencil value with 24 bit normalised depth and 8 bit stencil.

  `D32S8`

    Each pixel is considered a packed depth-stencil value with 32 bit floating point depth and 8 bit stencil.

  `S8`

    Each pixel is an 8 bit stencil value.

  `YUV8`

    The pixel data is 8-bit in YUV subsampled format. More information about subsampling setup is stored separately

  `YUV10`

    The pixel data is 10-bit in YUV subsampled format. More information about subsampling setup is stored separately

  `YUV12`

    The pixel data is 12-bit in YUV subsampled format. More information about subsampling setup is stored separately

  `YUV16`

    The pixel data is 16-bit in YUV subsampled format. More information about subsampling setup is stored separately

  `PVRTC`

    PowerVR properitary texture compression format.

  `A8`

    8-bit unsigned normalised alpha - equivalent to standard R8 with a pre-baked swizzle.

class `renderdoc.``CompType`(value)

  Represents the component type of a channel in a texture or element in a structure.

  `Typeless`

    A component that has no concrete type.

  `Float`

    An IEEE floating point value of 64-bit, 32-bit or 16-bit size.

  `UNorm`

    An unsigned normalised floating point value. This is converted by dividing the input value by the maximum representable unsigned integer value, to produce a value in the range `[0, 1]`

  `SNorm`

    A signed normalised floating point value in range. This is converted by dividing the input value by the maximum representable positive signed integer value, to produce a value in the range `[-1, 1]`. As a special case, the maximum negative signed integer is also mapped to `-1` so there are two representations of -1. This means there is only one `0` value and that there is the same range of available values for positive and negative values.

    For example, signed 16-bit integers range from `-32768` to `+32767`. `-32768` is mapped to `-1`, and then any other value is divided by `32767` giving an equal set of values in the range `[-1, 0]` as in the range `[0, 1]`.

  `UInt`

    An unsigned integer value.

  `SInt`

    A signed integer value.

  `UScaled`

    An unsigned scaled floating point value. This is converted from the input unsigned integer without any normalisation as with `UNorm`, so the resulting values range from `0` to the maximum unsigned integer value `2^N - 1`.

  `SScaled`

    A signed scaled floating point value. This is converted from the input unsigned integer without any normalisation as with `SNorm`, so the resulting values range from the minimum signed integer value `-2^(N-1)` to the maximum signed integer value `2^(N-1) - 1`.

  `Depth`

    An opaque value storing depth information, either `floating point` for 32-bit depth values or else `unsigned normalised` for other bit sizes.

  `UNormSRGB`

    Similar to `UNorm` normalised between the minimum and maximum unsigned values to `0.0` - `1.0`, but with an sRGB gamma curve applied.