Table of Contents

Enum PixelFormat

Namespace
Stride.Graphics
Assembly
Stride.dll

Defines various types of pixel formats.

[DataContract]
public enum PixelFormat
Extension Methods

Fields

A8_UNorm = 65

A single-component, 8-bit unsigned normalized integer format for alpha only.

B5G5R5A1_UNorm = 86

A four-component, 16-bit unsigned normalized integer format that supports 5 bits for each color channel and 1-bit alpha.

B5G6R5_UNorm = 85

A three-component, 16-bit unsigned normalized integer format that supports 5 bits for blue, 6 bits for green, and 5 bits for red.

B8G8R8A8_Typeless = 90

A four-component, 32-bit format that supports 8 bits for each color channel and 8-bit alpha.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

B8G8R8A8_UNorm = 87

A four-component, 32-bit unsigned normalized integer format that supports 8 bits for each color channel and 8-bit alpha.

B8G8R8A8_UNorm_SRgb = 91

A four-component, 32-bit unsigned normalized integer format that supports 8 bits for each color channel and 8-bit alpha, where the data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.

B8G8R8X8_Typeless = 92

A four-component, 32-bit format that supports 8 bits for each color channel, and 8 bits are unused.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

B8G8R8X8_UNorm = 88

A four-component, 32-bit unsigned normalized integer format that supports 8 bits for each color channel and a remaining unused 8-bit part.

B8G8R8X8_UNorm_SRgb = 93

A four-component, 32-bit unsigned-normalized standard RGB format that supports 8 bits for each color channel, and 8 bits are unused. , where the data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.

BC1_Typeless = 70

A four-component, 64-bit block-compression format using the BC1 encoding, where the alpha channel is optionally encoded in 1 bit (either fully opaque or fully transparent), and the RGB color is encoded in 2 bits per pixel to select from a 4-color (or 3-color + transparent) color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC1 format is tipically used for diffuse maps that do not require alpha transparency or where the alpha channel is not important.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC1_UNorm = 71

A four-component, 64-bit unsigned normalized integer block-compression format using the BC1 encoding, where the alpha channel is optionally encoded in 1 bit (either fully opaque or fully transparent), and the RGB color is encoded in 2 bits per pixel to select from a 4-color (or 3-color + transparent) color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC1 format is tipically used for diffuse maps that do not require alpha transparency or where the alpha channel is not important.

BC1_UNorm_SRgb = 72

A four-component, 64-bit unsigned normalized integer block-compression format for sRGB data using the BC1 encoding, where the alpha channel is optionally encoded in 1 bit (either fully opaque or fully transparent), and the RGB color is encoded in 2 bits per pixel to select from a 4-color (or 3-color + transparent) color palette.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC1 format is tipically used for diffuse maps that do not require alpha transparency or where the alpha channel is not important.

BC2_Typeless = 73

A four-component, 128-bit block-compression format using the BC2 encoding, where the alpha channel is encoded in 4 bits (for 16 levels of transparency, quantized, not interpolated), and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC2 format is tipically used for UI, decals, or sharp masks, although it is now considered somewhat outdated.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC2_UNorm = 74

A four-component, 128-bit unsigned normalized integer block-compression format using the BC2 encoding, where the alpha channel is encoded in 4 bits (for 16 levels of transparency, quantized, not interpolated), and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC2 format is tipically used for UI, decals, or sharp masks, although it is now considered somewhat outdated.

BC2_UNorm_SRgb = 75

A four-component, 128-bit unsigned normalized integer block-compression format for sRGB data using the BC2 encoding, where the alpha channel is encoded in 4 bits (for 16 levels of transparency, quantized, not interpolated), and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC2 format is tipically used for UI, decals, or sharp masks, although it is now considered somewhat outdated.

BC3_Typeless = 76

A four-component, 128-bit block-compression format using the BC3 encoding, where the alpha channel is encoded as two 8-bit alpha endpoints and 3 bits per pixel to select from 6 interpolated alpha values, and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC3 format is tipically used for smooth and soft transparency, like foliage, shadows, hair, or smoke.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC3_UNorm = 77

A four-component, 128-bit unsigned normalized integer block-compression format using the BC3 encoding, where the alpha channel is encoded as two 8-bit alpha endpoints and 3 bits per pixel to select from 6 interpolated alpha values, and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC3 format is tipically used for smooth and soft transparency, like foliage, shadows, hair, or smoke.

BC3_UNorm_SRgb = 78

A four-component, 128-bit unsigned normalized integer block-compression format for sRGB data using the BC3 encoding, where the alpha channel is encoded as two 8-bit alpha endpoints and 3 bits per pixel to select from 6 interpolated alpha values, and the RGB color is encoded in 2 bits per pixel to select from a 4-color color palette.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC3 format is tipically used for smooth and soft transparency, like foliage, shadows, hair, or smoke.

BC4_SNorm = 81

A single-component, 64-bit signed normalized integer block-compression format using the BC4 encoding, where the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC4 format is tipically used for grayscale Textures, smooth masks, or heightmaps.

BC4_Typeless = 79

A single-component, 64-bit block-compression format using the BC4 encoding, where the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC4 format is tipically used for grayscale Textures, smooth masks, or heightmaps.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC4_UNorm = 80

A single-component, 64-bit unsigned normalized integer block-compression format using the BC4 encoding, where the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC4 format is tipically used for grayscale Textures, smooth masks, or heightmaps.

BC5_SNorm = 84

A two-component, 128-bit signed normalized integer block-compression format using the BC5 encoding, where for each channel the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values. This is essentially a BC4 format for each channel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC5 format is tipically used for dual-channel data like normal maps (X and Y) or vector fields.

BC5_Typeless = 82

A two-component, 128-bit block-compression format using the BC5 encoding, where for each channel the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values. This is essentially a BC4 format for each channel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC5 format is tipically used for dual-channel data like normal maps (X and Y) or vector fields.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC5_UNorm = 83

A two-component, 128-bit unsigned normalized integer block-compression format using the BC5 encoding, where for each channel the data is encoded as two 8-bit endpoints and 3 bits per pixel to select from 6 interpolated values. This is essentially a BC4 format for each channel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC5 format is tipically used for dual-channel data like normal maps (X and Y) or vector fields.

BC6H_Sf16 = 96

A three-component, 128-bit signed floating-point block-compression format for full-range HDR data using the BC6H encoding, where the color channels are encoded as 16-bit Half values and selected and interpolated according to the BC6H algorithm.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC6H format is best used for HDR environment maps, lightprobes, or any Texture with values beyond the [0,1] range.

BC6H_Typeless = 94

A three-component, 128-bit block-compression format for HDR data using the BC6H encoding, where the color channels are encoded as 16-bit Half values and selected and interpolated according to the BC6H algorithm.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC6H format is best used for HDR environment maps, lightprobes, or any Texture with values beyond the [0,1] range.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC6H_Uf16 = 95

A three-component, 128-bit unsigned floating-point block-compression format for positive-only HDR data using the BC6H encoding, where the color channels are encoded as 16-bit Half values and selected and interpolated according to the BC6H algorithm.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC6H format is best used for HDR environment maps, lightprobes, or any Texture with values beyond the [0,1] range.

BC7_Typeless = 97

A three- or four-component, 128-bit block-compression format using the BC7 encoding, where it can encode the RGB channels and an optional 1-8-bit alpha channel according to the BC7 algorithm.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC7 format is best for high-quality color Textures, like albedo maps, UI, or detailed color surfaces.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

BC7_UNorm = 98

A three- or four-component, 128-bit unsigned normalized integer block-compression format using the BC7 encoding, where it can encode the RGB channels and an optional 1-8-bit alpha channel according to the BC7 algorithm.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC7 format is best for high-quality color Textures, like albedo maps, UI, or detailed color surfaces.

BC7_UNorm_SRgb = 99

A three- or four-component, 128-bit unsigned normalized integer block-compression format for sRGB data using the BC7 encoding, where it can encode the RGB channels and an optional 1-8-bit alpha channel according to the BC7 algorithm.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
The BC7 format is best for high-quality color Textures, like albedo maps, UI, or detailed color surfaces.

D16_UNorm = 55

A single-component, 16-bit unsigned normalized integer format that supports 16 bits for depth.

D24_UNorm_S8_UInt = 45

A two-component, 32-bit format consisting of a 24-bit unsigned normalized integer component for depth and a 8-bit unsigned integer component for stencil.

D32_Float = 40

A single-component, 32-bit floating-point format that supports 32 bits for depth.

D32_Float_S8X24_UInt = 20

A composite format consisting of a 32-bit floating-point component intended for depth, plus a 8-bit unsigned-integer component intended for stencil values in an additional 32-bit part where the last 24 bits are unused (for padding).

EAC_R11_Signed = 1093

A single-component, 64-bit block-compression format using the EAC R11 signed encoding, where the red channel is encoded as a signed 11-bit value per pixel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Typically used for single-channel signed data such as normal maps or vector fields (reconstructing the second component).

EAC_R11_Unsigned = 1092

A single-component, 64-bit block-compression format using the EAC R11 unsigned encoding, where the red channel is encoded as an unsigned 11-bit value per pixel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Typically used for single-channel data such as heightmaps or masks.

EAC_RG11_Signed = 1095

A two-component, 128-bit block-compression format using the EAC RG11 signed encoding, where the red and green channels are encoded as signed 11-bit values per pixel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Used for dual-channel signed data such as normal maps or vector fields.

EAC_RG11_Unsigned = 1094

A two-component, 128-bit block-compression format using the EAC RG11 unsigned encoding, where the red and green channels are encoded as unsigned 11-bit values per pixel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Used for dual-channel data such as normal maps or vector fields.

ETC1 = 1088

A three-component, 64-bit block-compression format using the ETC1 encoding, where the RGB color is encoded in 4 bits per pixel. Does not support alpha.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Commonly used for opaque textures on mobile devices.

ETC2_RGB = 1089

A three-component, 64-bit block-compression format using the ETC2 RGB encoding, where the RGB color is encoded in 4 bits per pixel. Does not support alpha.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Widely supported on modern mobile and embedded GPUs for general color data.

ETC2_RGBA = 1090

A four-component, 128-bit block-compression format using the ETC2 RGBA encoding, where the RGB color is encoded in 4 bits per pixel and the alpha channel is encoded in 4 bits per pixel.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Used for Textures requiring full alpha support on mobile and embedded devices.

ETC2_RGBA_SRgb = 1096

A four-component, 128-bit block-compression format using the ETC2 RGBA encoding for sRGB data, where the RGB color is encoded in 4 bits per pixel and the alpha channel is encoded in 4 bits per pixel.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Tipically used for color textures with transparency on mobile and embedded devices.

ETC2_RGB_A1 = 1091

A four-component, 64-bit block-compression format using the ETC2 RGB+A1 encoding, where the RGB color is encoded in 4 bits per pixel and the alpha channel is encoded as a single bit (1-bit alpha mask).
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Suitable for Textures with simple transparency (fully opaque or fully transparent pixels).

ETC2_RGB_SRgb = 1097

A three-component, 64-bit block-compression format using the ETC2 RGB encoding for sRGB data, where the RGB color is encoded in 4 bits per pixel.
The data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.
The block-compression formats operate only on 4x4 blocks, so Textures using this format must have dimensions that are multiples of 4.
Tipically used for color textures without alpha on mobile and embedded devices.

G8R8_G8B8_UNorm = 69

A four-component, 32-bit unsigned normalized integer format packed in a form analogous to the YUY2 format. Each 32-bit block describes a pair of pixels (RGB, RGB) with 8-bit RGB components where the R/B values are repeated, and the G values are unique to each pixel.

None = 0

The format is not known.

R10G10B10A2_Typeless = 23

A four-component, 32-bit format that supports 10 bits for each color and 2 bits for alpha.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R10G10B10A2_UInt = 25

A four-component, 32-bit unsigned integer format that supports 10 bits for each color and 2 bits for alpha.

R10G10B10A2_UNorm = 24

A four-component, 32-bit unsigned normalized integer format that supports 10 bits for each color and 2 bits for alpha.

R10G10B10_Xr_Bias_A2_UNorm = 89

A four-component, 32-bit format consisting of 10 bits for each of the red, green, and blue channels encoded as 2.8-biased fixed-point numbers and 2-bit alpha channel. The XR bias applies a fixed scale and offset to the red channel to better represent HDR luminance. This is useful when tone mapping has already been applied and the image is ready for display.
This format is intended for use as a presentation format, particularly for High Dynamic Range (HDR) content. It is read-only for shaders and not renderable directly. Instead, it is typically converted from a compatible format (like R10G10B10A2_UNorm).

R11G11B10_Float = 26

A three-component, 32-bit partial-precision floating-point format that supports 11 bits for the red and green channels and 10 bits for the blue channel.
It uses a variant of s10e5 (sign bit, 10-bit mantissa, and 5-bit biased (15) exponent), but there are no sign bits, and there is a 5-bit biased (15) exponent for each channel, 6-bit mantissa for R and G, and a 5-bit mantissa for B.

R16G16B16A16_Float = 10

A four-component, 64-bit floating-point format that supports 16 bits per channel including alpha.

R16G16B16A16_SInt = 14

A four-component, 64-bit signed integer format that supports 16 bits per channel including alpha.

R16G16B16A16_SNorm = 13

A four-component, 64-bit signed normalized integer format that supports 16 bits per channel including alpha.

R16G16B16A16_Typeless = 9

A four-component, 64-bit format that supports 16 bits per channel including alpha.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R16G16B16A16_UInt = 12

A four-component, 64-bit unsigned integer format that supports 16 bits per channel including alpha.

R16G16B16A16_UNorm = 11

A four-component, 64-bit unsigned normalized integer format that supports 16 bits per channel including alpha.

R16G16_Float = 34

A two-component, 32-bit floating-point format that supports 16 bits for the red channel and 16 bits for the green channel.

R16G16_SInt = 38

A two-component, 32-bit signed integer format that supports 16 bits for the red channel and 16 bits for the green channel.

R16G16_SNorm = 37

A two-component, 32-bit signed normalized integer format that supports 16 bits for the red channel and 16 bits for the green channel.

R16G16_Typeless = 33

A two-component, 32-bit format that supports 16 bits for the red channel and 16 bits for the green channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R16G16_UInt = 36

A two-component, 32-bit unsigned integer format that supports 16 bits for the red channel and 16 bits for the green channel.

R16G16_UNorm = 35

A two-component, 32-bit unsigned normalized integer format that supports 16 bits for the red channel and 16 bits for the green channel.

R16_Float = 54

A single-component, 16-bit floating-point format that supports 16 bits for the red channel.

R16_SInt = 59

A single-component, 16-bit signed integer format that supports 16 bits for the red channel.

R16_SNorm = 58

A single-component, 16-bit signed normalized integer format that supports 16 bits for the red channel.

R16_Typeless = 53

A single-component, 16-bit format that supports 16 bits for the red channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R16_UInt = 57

A single-component, 16-bit unsigned integer format that supports 16 bits for the red channel.

R16_UNorm = 56

A single-component, 16-bit unsigned normalized integer format that supports 16 bits for the red channel.

R1_UNorm = 66

A single-component, 1-bit unsigned normalized integer format that supports 1 bit for the red channel.

R24G8_Typeless = 44

A two-component, 32-bit format that supports 24 bits for the red channel and 8 bits for the green channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R24_UNorm_X8_Typeless = 46

A two-component, 32-bit format consisting of a 24-bit unsigned normalized integer red component and a 8-bit typeless component.
This format has a typeless component, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32G32B32A32_Float = 2

A four-component, 128-bit floating-point format that supports 32 bits per channel including alpha.

R32G32B32A32_SInt = 4

A four-component, 128-bit signed integer format that supports 32 bits per channel including alpha.

R32G32B32A32_Typeless = 1

A four-component, 128-bit format that supports 32 bits per channel including alpha.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32G32B32A32_UInt = 3

A four-component, 128-bit unsigned integer format that supports 32 bits per channel including alpha.

R32G32B32_Float = 6

A three-component, 96-bit floating-point format that supports 32 bits per channel.

R32G32B32_SInt = 8

A three-component, 96-bit signed integer format that supports 32 bits per channel.

R32G32B32_Typeless = 5

A three-component, 96-bit format that supports 32 bits per channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32G32B32_UInt = 7

A three-component, 96-bit unsigned integer format that supports 32 bits per channel.

R32G32_Float = 16

A two-component, 64-bit floating-point format that supports 32 bits for the red channel and 32 bits for the green channel.

R32G32_SInt = 18

A two-component, 64-bit signed integer format that supports 32 bits for the red channel and 32 bits for the green channel.

R32G32_Typeless = 15

A two-component, 64-bit format that supports 32 bits for the red channel and 32 bits for the green channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32G32_UInt = 17

A two-component, 64-bit unsigned integer format that supports 32 bits for the red channel and 32 bits for the green channel.

R32G8X24_Typeless = 19

A two-component, 64-bit format that supports 32 bits for the red channel, 8 bits for the green channel, and 24 bits are unused.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32_Float = 41

A single-component, 32-bit floating-point format that supports 32 bits for the red channel.

R32_Float_X8X24_Typeless = 21

A composite format consisting of a 32-bit floating-point component for the red channel, and two typeless components (8-bit and 24-bit respectively) in an additional 32-bit part.
This is commonly used to create Views for Depth-Stencil Buffers where a shader needs to access the depth.
This format has typeless components, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32_SInt = 43

A single-component, 32-bit signed integer format that supports 32 bits for the red channel.

R32_Typeless = 39

A single-component, 32-bit format that supports 32 bits for the red channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R32_UInt = 42

A single-component, 32-bit unsigned integer format that supports 32 bits for the red channel.

R8G8B8A8_SInt = 32

A four-component, 32-bit signed integer format that supports 8 bits per channel including alpha.

R8G8B8A8_SNorm = 31

A four-component, 32-bit signed normalized integer format that supports 8 bits per channel including alpha.

R8G8B8A8_Typeless = 27

A four-component, 32-bit format that supports 8 bits per channel including alpha.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R8G8B8A8_UInt = 30

A four-component, 32-bit unsigned integer format that supports 8 bits per channel including alpha.

R8G8B8A8_UNorm = 28

A four-component, 32-bit unsigned normalized integer format that supports 8 bits per channel including alpha.

R8G8B8A8_UNorm_SRgb = 29

A four-component, 32-bit unsigned normalized integer format that supports 8 bits per channel including alpha, where the data is stored in sRGB color space, and the GPU will automatically convert it to linear space when sampling in a shader.

R8G8_B8G8_UNorm = 68

A four-component, 32-bit unsigned normalized integer format packed in a form analogous to the UYVY format. Each 32-bit block describes a pair of pixels (RGB, RGB) with 8-bit RGB components where the R/B values are repeated, and the G values are unique to each pixel.

R8G8_SInt = 52

A two-component, 16-bit signed integer format that supports 8 bits for the red channel and 8 bits for the green channel.

R8G8_SNorm = 51

A two-component, 16-bit signed normalized integer format that supports 8 bits for the red channel and 8 bits for the green channel.

R8G8_Typeless = 48

A two-component, 16-bit format that supports 8 bits for the red channel and 8 bits for the green channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R8G8_UInt = 50

A two-component, 16-bit unsigned integer format that supports 8 bits for the red channel and 8 bits for the green channel.

R8G8_UNorm = 49

A two-component, 16-bit unsigned normalized integer format that supports 8 bits for the red channel and 8 bits for the green channel.

R8_SInt = 64

A single-component, 8-bit signed integer format that supports 8 bits for the red channel.

R8_SNorm = 63

A single-component, 8-bit signed normalized integer format that supports 8 bits for the red channel.

R8_Typeless = 60

A single-component, 8-bit format that supports 8 bits for the red channel.
This format is typeless, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

R8_UInt = 62

A single-component, 8-bit unsigned integer format that supports 8 bits for the red channel.

R8_UNorm = 61

A single-component, 8-bit unsigned normalized integer format that supports 8 bits for the red channel.

R9G9B9E5_Sharedexp = 67

A three-component, 32-bit partial-precision floating-point format that supports 9 bits per channel with the same 5-bit shared exponent.
It uses a variant of s10e5 (sign bit, 10-bit mantissa, and 5-bit biased (15) exponent), but there are no sign bits, and the exponent is shared.

X24_Typeless_G8_UInt = 47

A two-component, 32-bit format consisting of a 24-bit typeless component and a 8-bit unsigned integer green component.
This format has a typeless component, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

X32_Typeless_G8X24_UInt = 22

A composite format consisting of an unused 32-bit typeless component, plus an 8-bit unsigned-integer component in an additional 32-bit part where the last 24 bits are unused (for padding).
This is commonly used to create Views for Depth-Stencil Buffers where a shader needs to access the stencil values.
This format has typeless components, i.e. it just specifies the memory layout, but can be used for different types of data, such as floating-point, unsigned-integer, or signed-integer.

Remarks

Pixel formats describe the layout and type of data stored in a pixel, including the number of channels, bits per channel, and whether the data is normalized or typeless.

The suffixes in the names indicate the type of data:

UNorm (Unsigned Normalized) Values are stored as unsigned integers, but interpreted as floating-point values between 0.0 and 1.0. For example, R8G8B8A8_UNorm stores 8-bit values per channel, where 0 maps to 0.0 and 255 maps to 1.0.
Common for color Textures and Render Targets.
SNorm (Signed Normalized) Values are stored as signed integers, but interpreted as floating-point values between -1.0 and 1.0. For example, R8G8_SNorm stores 8-bit values per channel, where -128 to -1.0 and 127 to ~1.0.
Useful for storing normals or vectors.
Typeless The format is not fully defined —it’s just a memory layout.
Multiple Views (e.g., Shader Resource Views, Render Target Views) can be created over a Graphics Resource with a typeless format with different interpretations. For example, R8G8B8A8_Typeless can be viewed as UNorm, UNorm_SRgb, or UInt, depending on how the resource is bound.
Great for flexibility, like rendering in linear space and sampling in sRGB.
UInt / SInt Unsigned (UInt) or signed (SInt) integer values. No normalization —values are used as-is.
Often used for IDs, masks, or counters.
Float Stores values as IEEE floating-point numbers.
Used when precision and range are important, like Depth Buffers or HDR color.
SRgb Stores color data in the sRGB color space. When sampling, the GPU automatically converts it to linear space, and when writing the data, it converts it back to sRGB (applies gamma correction).
It is typically used for textures that represent colors.
Edit this page