RenderingDevice

Inherits: Object

Abstraction for working with modern low-level graphics APIs.

Description

RenderingDevice is an abstraction for working with modern low-level graphics APIs such as Vulkan. Compared to RenderingServer (which works with Godot’s own rendering subsystems), RenderingDevice is much lower-level and allows working more directly with the underlying graphics APIs. RenderingDevice is used in Godot to provide support for several modern low-level graphics APIs while reducing the amount of code duplication required. RenderingDevice can also be used in your own projects to perform things that are not exposed by RenderingServer or high-level nodes, such as using compute shaders.

On startup, Godot creates a global RenderingDevice which can be retrieved using RenderingServer.get_rendering_device. This global RenderingDevice performs drawing to the screen.

Local RenderingDevices: Using RenderingServer.create_local_rendering_device, you can create “secondary” rendering devices to perform drawing and GPU compute operations on separate threads.

Note: RenderingDevice assumes intermediate knowledge of modern graphics APIs such as Vulkan, Direct3D 12, Metal or WebGPU. These graphics APIs are lower-level than OpenGL or Direct3D 11, requiring you to perform what was previously done by the graphics driver itself. If you have difficulty understanding the concepts used in this class, follow the Vulkan Tutorial or Vulkan Guide. It’s recommended to have existing modern OpenGL or Direct3D 11 knowledge before attempting to learn a low-level graphics API.

Note: RenderingDevice is not available when running in headless mode or when using the Compatibility rendering method.

Tutorials

• Using compute shaders

Methods

Enumerations

enum DeviceType:

DeviceType DEVICE_TYPE_OTHER = 0

Rendering device type does not match any of the other enum values or is unknown.

DeviceType DEVICE_TYPE_INTEGRATED_GPU = 1

Rendering device is an integrated GPU, which is typically (but not always) slower than dedicated GPUs (DEVICE_TYPE_DISCRETE_GPU). On Android and iOS, the rendering device type is always considered to be DEVICE_TYPE_INTEGRATED_GPU.

DeviceType DEVICE_TYPE_DISCRETE_GPU = 2

Rendering device is a dedicated GPU, which is typically (but not always) faster than integrated GPUs (DEVICE_TYPE_INTEGRATED_GPU).

DeviceType DEVICE_TYPE_VIRTUAL_GPU = 3

Rendering device is an emulated GPU in a virtual environment. This is typically much slower than the host GPU, which means the expected performance level on a dedicated GPU will be roughly equivalent to DEVICE_TYPE_INTEGRATED_GPU. Virtual machine GPU passthrough (such as VFIO) will not report the device type as DEVICE_TYPE_VIRTUAL_GPU. Instead, the host GPU’s device type will be reported as if the GPU was not emulated.

DeviceType DEVICE_TYPE_CPU = 4

Rendering device is provided by software emulation (such as Lavapipe or SwiftShader). This is the slowest kind of rendering device available; it’s typically much slower than DEVICE_TYPE_INTEGRATED_GPU.

DeviceType DEVICE_TYPE_MAX = 5

Represents the size of the DeviceType enum.

enum DriverResource:

DriverResource DRIVER_RESOURCE_VULKAN_DEVICE = 0

Vulkan device driver resource. This is a “global” resource and ignores the RID passed in

DriverResource DRIVER_RESOURCE_VULKAN_PHYSICAL_DEVICE = 1

Physical device (graphics card) driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_INSTANCE = 2

Vulkan instance driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_QUEUE = 3

Vulkan queue driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_QUEUE_FAMILY_INDEX = 4

Vulkan queue family index driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE = 5

Vulkan image driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE_VIEW = 6

Vulkan image view driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE_NATIVE_TEXTURE_FORMAT = 7

Vulkan image native texture format driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_SAMPLER = 8

Vulkan sampler driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_DESCRIPTOR_SET = 9

Vulkan descriptor set driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_BUFFER = 10

Vulkan buffer driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_COMPUTE_PIPELINE = 11

Vulkan compute pipeline driver resource.

DriverResource DRIVER_RESOURCE_VULKAN_RENDER_PIPELINE = 12

Vulkan render pipeline driver resource.

enum DataFormat:

DataFormat DATA_FORMAT_R4G4_UNORM_PACK8 = 0

4-bit-per-channel red/green channel data format, packed into 8 bits. Values are in the [0.0, 1.0] range.

Note: More information on all data formats can be found on the Identification of formats section of the Vulkan specification, as well as the VkFormat enum.

DataFormat DATA_FORMAT_R4G4B4A4_UNORM_PACK16 = 1

4-bit-per-channel red/green/blue/alpha channel data format, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B4G4R4A4_UNORM_PACK16 = 2

4-bit-per-channel blue/green/red/alpha channel data format, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R5G6B5_UNORM_PACK16 = 3

Red/green/blue channel data format with 5 bits of red, 6 bits of green and 5 bits of blue, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B5G6R5_UNORM_PACK16 = 4

Blue/green/red channel data format with 5 bits of blue, 6 bits of green and 5 bits of red, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R5G5B5A1_UNORM_PACK16 = 5

Red/green/blue/alpha channel data format with 5 bits of red, 6 bits of green, 5 bits of blue and 1 bit of alpha, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B5G5R5A1_UNORM_PACK16 = 6

Blue/green/red/alpha channel data format with 5 bits of blue, 6 bits of green, 5 bits of red and 1 bit of alpha, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A1R5G5B5_UNORM_PACK16 = 7

Alpha/red/green/blue channel data format with 1 bit of alpha, 5 bits of red, 6 bits of green and 5 bits of blue, packed into 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8_UNORM = 8

8-bit-per-channel unsigned floating-point red channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8_SNORM = 9

8-bit-per-channel signed floating-point red channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R8_USCALED = 10

8-bit-per-channel unsigned floating-point red channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_R8_SSCALED = 11

8-bit-per-channel signed floating-point red channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_R8_UINT = 12

8-bit-per-channel unsigned integer red channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_R8_SINT = 13

8-bit-per-channel signed integer red channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_R8_SRGB = 14

8-bit-per-channel unsigned floating-point red channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8_UNORM = 15

8-bit-per-channel unsigned floating-point red/green channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8_SNORM = 16

8-bit-per-channel signed floating-point red/green channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8_USCALED = 17

8-bit-per-channel unsigned floating-point red/green channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_R8G8_SSCALED = 18

8-bit-per-channel signed floating-point red/green channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_R8G8_UINT = 19

8-bit-per-channel unsigned integer red/green channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_R8G8_SINT = 20

8-bit-per-channel signed integer red/green channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_R8G8_SRGB = 21

8-bit-per-channel unsigned floating-point red/green channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8_UNORM = 22

8-bit-per-channel unsigned floating-point red/green/blue channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8_SNORM = 23

8-bit-per-channel signed floating-point red/green/blue channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8_USCALED = 24

8-bit-per-channel unsigned floating-point red/green/blue channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_R8G8B8_SSCALED = 25

8-bit-per-channel signed floating-point red/green/blue channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_R8G8B8_UINT = 26

8-bit-per-channel unsigned integer red/green/blue channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_R8G8B8_SINT = 27

8-bit-per-channel signed integer red/green/blue channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_R8G8B8_SRGB = 28

8-bit-per-channel unsigned floating-point red/green/blue/blue channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8_UNORM = 29

8-bit-per-channel unsigned floating-point blue/green/red channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8_SNORM = 30

8-bit-per-channel signed floating-point blue/green/red channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8_USCALED = 31

8-bit-per-channel unsigned floating-point blue/green/red channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_B8G8R8_SSCALED = 32

8-bit-per-channel signed floating-point blue/green/red channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_B8G8R8_UINT = 33

8-bit-per-channel unsigned integer blue/green/red channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_B8G8R8_SINT = 34

8-bit-per-channel signed integer blue/green/red channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_B8G8R8_SRGB = 35

8-bit-per-channel unsigned floating-point blue/green/red data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8A8_UNORM = 36

8-bit-per-channel unsigned floating-point red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8A8_SNORM = 37

8-bit-per-channel signed floating-point red/green/blue/alpha channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R8G8B8A8_USCALED = 38

8-bit-per-channel unsigned floating-point red/green/blue/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_R8G8B8A8_SSCALED = 39

8-bit-per-channel signed floating-point red/green/blue/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_R8G8B8A8_UINT = 40

8-bit-per-channel unsigned integer red/green/blue/alpha channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_R8G8B8A8_SINT = 41

8-bit-per-channel signed integer red/green/blue/alpha channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_R8G8B8A8_SRGB = 42

8-bit-per-channel unsigned floating-point red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8A8_UNORM = 43

8-bit-per-channel unsigned floating-point blue/green/red/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8A8_SNORM = 44

8-bit-per-channel signed floating-point blue/green/red/alpha channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_B8G8R8A8_USCALED = 45

8-bit-per-channel unsigned floating-point blue/green/red/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_B8G8R8A8_SSCALED = 46

8-bit-per-channel signed floating-point blue/green/red/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_B8G8R8A8_UINT = 47

8-bit-per-channel unsigned integer blue/green/red/alpha channel data format. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_B8G8R8A8_SINT = 48

8-bit-per-channel signed integer blue/green/red/alpha channel data format. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_B8G8R8A8_SRGB = 49

8-bit-per-channel unsigned floating-point blue/green/red/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A8B8G8R8_UNORM_PACK32 = 50

8-bit-per-channel unsigned floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A8B8G8R8_SNORM_PACK32 = 51

8-bit-per-channel signed floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_A8B8G8R8_USCALED_PACK32 = 52

8-bit-per-channel unsigned floating-point alpha/red/green/blue channel data format with scaled value (value is converted from integer to float), packed in 32 bits. Values are in the [0.0, 255.0] range.

DataFormat DATA_FORMAT_A8B8G8R8_SSCALED_PACK32 = 53

8-bit-per-channel signed floating-point alpha/red/green/blue channel data format with scaled value (value is converted from integer to float), packed in 32 bits. Values are in the [-127.0, 127.0] range.

DataFormat DATA_FORMAT_A8B8G8R8_UINT_PACK32 = 54

8-bit-per-channel unsigned integer alpha/red/green/blue channel data format, packed in 32 bits. Values are in the [0, 255] range.

DataFormat DATA_FORMAT_A8B8G8R8_SINT_PACK32 = 55

8-bit-per-channel signed integer alpha/red/green/blue channel data format, packed in 32 bits. Values are in the [-127, 127] range.

DataFormat DATA_FORMAT_A8B8G8R8_SRGB_PACK32 = 56

8-bit-per-channel unsigned floating-point alpha/red/green/blue channel data format with normalized value and non-linear sRGB encoding, packed in 32 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A2R10G10B10_UNORM_PACK32 = 57

Unsigned floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A2R10G10B10_SNORM_PACK32 = 58

Signed floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_A2R10G10B10_USCALED_PACK32 = 59

Unsigned floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [0.0, 1023.0] range for red/green/blue and [0.0, 3.0] for alpha.

DataFormat DATA_FORMAT_A2R10G10B10_SSCALED_PACK32 = 60

Signed floating-point alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [-511.0, 511.0] range for red/green/blue and [-1.0, 1.0] for alpha.

DataFormat DATA_FORMAT_A2R10G10B10_UINT_PACK32 = 61

Unsigned integer alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [0, 1023] range for red/green/blue and [0, 3] for alpha.

DataFormat DATA_FORMAT_A2R10G10B10_SINT_PACK32 = 62

Signed integer alpha/red/green/blue channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of red, 10 bits of green and 10 bits of blue. Values are in the [-511, 511] range for red/green/blue and [-1, 1] for alpha.

DataFormat DATA_FORMAT_A2B10G10R10_UNORM_PACK32 = 63

Unsigned floating-point alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_A2B10G10R10_SNORM_PACK32 = 64

Signed floating-point alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_A2B10G10R10_USCALED_PACK32 = 65

Unsigned floating-point alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [0.0, 1023.0] range for blue/green/red and [0.0, 3.0] for alpha.

DataFormat DATA_FORMAT_A2B10G10R10_SSCALED_PACK32 = 66

Signed floating-point alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [-511.0, 511.0] range for blue/green/red and [-1.0, 1.0] for alpha.

DataFormat DATA_FORMAT_A2B10G10R10_UINT_PACK32 = 67

Unsigned integer alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [0, 1023] range for blue/green/red and [0, 3] for alpha.

DataFormat DATA_FORMAT_A2B10G10R10_SINT_PACK32 = 68

Signed integer alpha/blue/green/red channel data format with normalized value, packed in 32 bits. Format contains 2 bits of alpha, 10 bits of blue, 10 bits of green and 10 bits of red. Values are in the [-511, 511] range for blue/green/red and [-1, 1] for alpha.

DataFormat DATA_FORMAT_R16_UNORM = 69

16-bit-per-channel unsigned floating-point red channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R16_SNORM = 70

16-bit-per-channel signed floating-point red channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R16_USCALED = 71

16-bit-per-channel unsigned floating-point red channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 65535.0] range.

DataFormat DATA_FORMAT_R16_SSCALED = 72

16-bit-per-channel signed floating-point red channel data format with scaled value (value is converted from integer to float). Values are in the [-32767.0, 32767.0] range.

DataFormat DATA_FORMAT_R16_UINT = 73

16-bit-per-channel unsigned integer red channel data format. Values are in the [0.0, 65535] range.

DataFormat DATA_FORMAT_R16_SINT = 74

16-bit-per-channel signed integer red channel data format. Values are in the [-32767, 32767] range.

DataFormat DATA_FORMAT_R16_SFLOAT = 75

16-bit-per-channel signed floating-point red channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R16G16_UNORM = 76

16-bit-per-channel unsigned floating-point red/green channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16_SNORM = 77

16-bit-per-channel signed floating-point red/green channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16_USCALED = 78

16-bit-per-channel unsigned floating-point red/green channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 65535.0] range.

DataFormat DATA_FORMAT_R16G16_SSCALED = 79

16-bit-per-channel signed floating-point red/green channel data format with scaled value (value is converted from integer to float). Values are in the [-32767.0, 32767.0] range.

DataFormat DATA_FORMAT_R16G16_UINT = 80

16-bit-per-channel unsigned integer red/green channel data format. Values are in the [0.0, 65535] range.

DataFormat DATA_FORMAT_R16G16_SINT = 81

16-bit-per-channel signed integer red/green channel data format. Values are in the [-32767, 32767] range.

DataFormat DATA_FORMAT_R16G16_SFLOAT = 82

16-bit-per-channel signed floating-point red/green channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R16G16B16_UNORM = 83

16-bit-per-channel unsigned floating-point red/green/blue channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16B16_SNORM = 84

16-bit-per-channel signed floating-point red/green/blue channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16B16_USCALED = 85

16-bit-per-channel unsigned floating-point red/green/blue channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 65535.0] range.

DataFormat DATA_FORMAT_R16G16B16_SSCALED = 86

16-bit-per-channel signed floating-point red/green/blue channel data format with scaled value (value is converted from integer to float). Values are in the [-32767.0, 32767.0] range.

DataFormat DATA_FORMAT_R16G16B16_UINT = 87

16-bit-per-channel unsigned integer red/green/blue channel data format. Values are in the [0.0, 65535] range.

DataFormat DATA_FORMAT_R16G16B16_SINT = 88

16-bit-per-channel signed integer red/green/blue channel data format. Values are in the [-32767, 32767] range.

DataFormat DATA_FORMAT_R16G16B16_SFLOAT = 89

16-bit-per-channel signed floating-point red/green/blue channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R16G16B16A16_UNORM = 90

16-bit-per-channel unsigned floating-point red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16B16A16_SNORM = 91

16-bit-per-channel signed floating-point red/green/blue/alpha channel data format with normalized value. Values are in the [-1.0, 1.0] range.

DataFormat DATA_FORMAT_R16G16B16A16_USCALED = 92

16-bit-per-channel unsigned floating-point red/green/blue/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [0.0, 65535.0] range.

DataFormat DATA_FORMAT_R16G16B16A16_SSCALED = 93

16-bit-per-channel signed floating-point red/green/blue/alpha channel data format with scaled value (value is converted from integer to float). Values are in the [-32767.0, 32767.0] range.

DataFormat DATA_FORMAT_R16G16B16A16_UINT = 94

16-bit-per-channel unsigned integer red/green/blue/alpha channel data format. Values are in the [0.0, 65535] range.

DataFormat DATA_FORMAT_R16G16B16A16_SINT = 95

16-bit-per-channel signed integer red/green/blue/alpha channel data format. Values are in the [-32767, 32767] range.

DataFormat DATA_FORMAT_R16G16B16A16_SFLOAT = 96

16-bit-per-channel signed floating-point red/green/blue/alpha channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R32_UINT = 97

32-bit-per-channel unsigned integer red channel data format. Values are in the [0, 2^32 - 1] range.

DataFormat DATA_FORMAT_R32_SINT = 98

32-bit-per-channel signed integer red channel data format. Values are in the [2^31 + 1, 2^31 - 1] range.

DataFormat DATA_FORMAT_R32_SFLOAT = 99

32-bit-per-channel signed floating-point red channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R32G32_UINT = 100

32-bit-per-channel unsigned integer red/green channel data format. Values are in the [0, 2^32 - 1] range.

DataFormat DATA_FORMAT_R32G32_SINT = 101

32-bit-per-channel signed integer red/green channel data format. Values are in the [2^31 + 1, 2^31 - 1] range.

DataFormat DATA_FORMAT_R32G32_SFLOAT = 102

32-bit-per-channel signed floating-point red/green channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R32G32B32_UINT = 103

32-bit-per-channel unsigned integer red/green/blue channel data format. Values are in the [0, 2^32 - 1] range.

DataFormat DATA_FORMAT_R32G32B32_SINT = 104

32-bit-per-channel signed integer red/green/blue channel data format. Values are in the [2^31 + 1, 2^31 - 1] range.

DataFormat DATA_FORMAT_R32G32B32_SFLOAT = 105

32-bit-per-channel signed floating-point red/green/blue channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R32G32B32A32_UINT = 106

32-bit-per-channel unsigned integer red/green/blue/alpha channel data format. Values are in the [0, 2^32 - 1] range.

DataFormat DATA_FORMAT_R32G32B32A32_SINT = 107

32-bit-per-channel signed integer red/green/blue/alpha channel data format. Values are in the [2^31 + 1, 2^31 - 1] range.

DataFormat DATA_FORMAT_R32G32B32A32_SFLOAT = 108

32-bit-per-channel signed floating-point red/green/blue/alpha channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R64_UINT = 109

64-bit-per-channel unsigned integer red channel data format. Values are in the [0, 2^64 - 1] range.

DataFormat DATA_FORMAT_R64_SINT = 110

64-bit-per-channel signed integer red channel data format. Values are in the [2^63 + 1, 2^63 - 1] range.

DataFormat DATA_FORMAT_R64_SFLOAT = 111

64-bit-per-channel signed floating-point red channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R64G64_UINT = 112

64-bit-per-channel unsigned integer red/green channel data format. Values are in the [0, 2^64 - 1] range.

DataFormat DATA_FORMAT_R64G64_SINT = 113

64-bit-per-channel signed integer red/green channel data format. Values are in the [2^63 + 1, 2^63 - 1] range.

DataFormat DATA_FORMAT_R64G64_SFLOAT = 114

64-bit-per-channel signed floating-point red/green channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R64G64B64_UINT = 115

64-bit-per-channel unsigned integer red/green/blue channel data format. Values are in the [0, 2^64 - 1] range.

DataFormat DATA_FORMAT_R64G64B64_SINT = 116

64-bit-per-channel signed integer red/green/blue channel data format. Values are in the [2^63 + 1, 2^63 - 1] range.

DataFormat DATA_FORMAT_R64G64B64_SFLOAT = 117

64-bit-per-channel signed floating-point red/green/blue channel data format with the value stored as-is.

DataFormat DATA_FORMAT_R64G64B64A64_UINT = 118

64-bit-per-channel unsigned integer red/green/blue/alpha channel data format. Values are in the [0, 2^64 - 1] range.

DataFormat DATA_FORMAT_R64G64B64A64_SINT = 119

64-bit-per-channel signed integer red/green/blue/alpha channel data format. Values are in the [2^63 + 1, 2^63 - 1] range.

DataFormat DATA_FORMAT_R64G64B64A64_SFLOAT = 120

64-bit-per-channel signed floating-point red/green/blue/alpha channel data format with the value stored as-is.

DataFormat DATA_FORMAT_B10G11R11_UFLOAT_PACK32 = 121

Unsigned floating-point blue/green/red data format with the value stored as-is, packed in 32 bits. The format’s precision is 10 bits of blue channel, 11 bits of green channel and 11 bits of red channel.

DataFormat DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 122

Unsigned floating-point exposure/blue/green/red data format with the value stored as-is, packed in 32 bits. The format’s precision is 5 bits of exposure, 9 bits of blue channel, 9 bits of green channel and 9 bits of red channel.

DataFormat DATA_FORMAT_D16_UNORM = 123

16-bit unsigned floating-point depth data format with normalized value. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_X8_D24_UNORM_PACK32 = 124

24-bit unsigned floating-point depth data format with normalized value, plus 8 unused bits, packed in 32 bits. Values for depth are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_D32_SFLOAT = 125

32-bit signed floating-point depth data format with the value stored as-is.

DataFormat DATA_FORMAT_S8_UINT = 126

8-bit unsigned integer stencil data format.

DataFormat DATA_FORMAT_D16_UNORM_S8_UINT = 127

16-bit unsigned floating-point depth data format with normalized value, plus 8 bits of stencil in unsigned integer format. Values for depth are in the [0.0, 1.0] range. Values for stencil are in the [0, 255] range.

DataFormat DATA_FORMAT_D24_UNORM_S8_UINT = 128

24-bit unsigned floating-point depth data format with normalized value, plus 8 bits of stencil in unsigned integer format. Values for depth are in the [0.0, 1.0] range. Values for stencil are in the [0, 255] range.

DataFormat DATA_FORMAT_D32_SFLOAT_S8_UINT = 129

32-bit signed floating-point depth data format with the value stored as-is, plus 8 bits of stencil in unsigned integer format. Values for stencil are in the [0, 255] range.

DataFormat DATA_FORMAT_BC1_RGB_UNORM_BLOCK = 130

VRAM-compressed unsigned red/green/blue channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel and 5 bits of blue channel. Using BC1 texture compression (also known as S3TC DXT1).

DataFormat DATA_FORMAT_BC1_RGB_SRGB_BLOCK = 131

VRAM-compressed unsigned red/green/blue channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel and 5 bits of blue channel. Using BC1 texture compression (also known as S3TC DXT1).

DataFormat DATA_FORMAT_BC1_RGBA_UNORM_BLOCK = 132

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 1 bit of alpha channel. Using BC1 texture compression (also known as S3TC DXT1).

DataFormat DATA_FORMAT_BC1_RGBA_SRGB_BLOCK = 133

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 1 bit of alpha channel. Using BC1 texture compression (also known as S3TC DXT1).

DataFormat DATA_FORMAT_BC2_UNORM_BLOCK = 134

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 4 bits of alpha channel. Using BC2 texture compression (also known as S3TC DXT3).

DataFormat DATA_FORMAT_BC2_SRGB_BLOCK = 135

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 4 bits of alpha channel. Using BC2 texture compression (also known as S3TC DXT3).

DataFormat DATA_FORMAT_BC3_UNORM_BLOCK = 136

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 8 bits of alpha channel. Using BC3 texture compression (also known as S3TC DXT5).

DataFormat DATA_FORMAT_BC3_SRGB_BLOCK = 137

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. The format’s precision is 5 bits of red channel, 6 bits of green channel, 5 bits of blue channel and 8 bits of alpha channel. Using BC3 texture compression (also known as S3TC DXT5).

DataFormat DATA_FORMAT_BC4_UNORM_BLOCK = 138

VRAM-compressed unsigned red channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 8 bits of red channel. Using BC4 texture compression.

DataFormat DATA_FORMAT_BC4_SNORM_BLOCK = 139

VRAM-compressed signed red channel data format with normalized value. Values are in the [-1.0, 1.0] range. The format’s precision is 8 bits of red channel. Using BC4 texture compression.

DataFormat DATA_FORMAT_BC5_UNORM_BLOCK = 140

VRAM-compressed unsigned red/green channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is 8 bits of red channel and 8 bits of green channel. Using BC5 texture compression (also known as S3TC RGTC).

DataFormat DATA_FORMAT_BC5_SNORM_BLOCK = 141

VRAM-compressed signed red/green channel data format with normalized value. Values are in the [-1.0, 1.0] range. The format’s precision is 8 bits of red channel and 8 bits of green channel. Using BC5 texture compression (also known as S3TC RGTC).

DataFormat DATA_FORMAT_BC6H_UFLOAT_BLOCK = 142

VRAM-compressed unsigned red/green/blue channel data format with the floating-point value stored as-is. The format’s precision is 8 bits of red channel and 8 bits of green channel. Using BC6H texture compression (also known as BPTC HDR).

DataFormat DATA_FORMAT_BC6H_SFLOAT_BLOCK = 143

VRAM-compressed signed red/green/blue channel data format with the floating-point value stored as-is. The format’s precision is between 4 and 7 bits for the red/green/blue channels and between 0 and 8 bits for the alpha channel. Using BC7 texture compression (also known as BPTC HDR).

DataFormat DATA_FORMAT_BC7_UNORM_BLOCK = 144

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. The format’s precision is between 4 and 7 bits for the red/green/blue channels and between 0 and 8 bits for the alpha channel. Also known as BPTC LDR.

DataFormat DATA_FORMAT_BC7_SRGB_BLOCK = 145

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. The format’s precision is between 4 and 7 bits for the red/green/blue channels and between 0 and 8 bits for the alpha channel. Also known as BPTC LDR.

DataFormat DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 146

VRAM-compressed unsigned red/green/blue channel data format with normalized value. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 147

VRAM-compressed unsigned red/green/blue channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 148

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. Red/green/blue use 8 bit of precision each, with alpha using 1 bit of precision. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 149

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. Red/green/blue use 8 bit of precision each, with alpha using 1 bit of precision. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 150

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value. Values are in the [0.0, 1.0] range. Red/green/blue use 8 bits of precision each, with alpha using 8 bits of precision. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 151

VRAM-compressed unsigned red/green/blue/alpha channel data format with normalized value and non-linear sRGB encoding. Values are in the [0.0, 1.0] range. Red/green/blue use 8 bits of precision each, with alpha using 8 bits of precision. Using ETC2 texture compression.

DataFormat DATA_FORMAT_EAC_R11_UNORM_BLOCK = 152

11-bit VRAM-compressed unsigned red channel data format with normalized value. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_EAC_R11_SNORM_BLOCK = 153

11-bit VRAM-compressed signed red channel data format with normalized value. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_EAC_R11G11_UNORM_BLOCK = 154

11-bit VRAM-compressed unsigned red/green channel data format with normalized value. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_EAC_R11G11_SNORM_BLOCK = 155

11-bit VRAM-compressed signed red/green channel data format with normalized value. Values are in the [0.0, 1.0] range. Using ETC2 texture compression.

DataFormat DATA_FORMAT_ASTC_4x4_UNORM_BLOCK = 156

VRAM-compressed unsigned floating-point data format with normalized value, packed in 4×4 blocks (highest quality). Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_4x4_SRGB_BLOCK = 157

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 4×4 blocks (highest quality). Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_5x4_UNORM_BLOCK = 158

VRAM-compressed unsigned floating-point data format with normalized value, packed in 5×4 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_5x4_SRGB_BLOCK = 159

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 5×4 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_5x5_UNORM_BLOCK = 160

VRAM-compressed unsigned floating-point data format with normalized value, packed in 5×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_5x5_SRGB_BLOCK = 161

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 5×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_6x5_UNORM_BLOCK = 162

VRAM-compressed unsigned floating-point data format with normalized value, packed in 6×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_6x5_SRGB_BLOCK = 163

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 6×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_6x6_UNORM_BLOCK = 164

VRAM-compressed unsigned floating-point data format with normalized value, packed in 6×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_6x6_SRGB_BLOCK = 165

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 6×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x5_UNORM_BLOCK = 166

VRAM-compressed unsigned floating-point data format with normalized value, packed in 8×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x5_SRGB_BLOCK = 167

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 8×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x6_UNORM_BLOCK = 168

VRAM-compressed unsigned floating-point data format with normalized value, packed in 8×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x6_SRGB_BLOCK = 169

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 8×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x8_UNORM_BLOCK = 170

VRAM-compressed unsigned floating-point data format with normalized value, packed in 8×8 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_8x8_SRGB_BLOCK = 171

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 8×8 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x5_UNORM_BLOCK = 172

VRAM-compressed unsigned floating-point data format with normalized value, packed in 10×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x5_SRGB_BLOCK = 173

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 10×5 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x6_UNORM_BLOCK = 174

VRAM-compressed unsigned floating-point data format with normalized value, packed in 10×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x6_SRGB_BLOCK = 175

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 10×6 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x8_UNORM_BLOCK = 176

VRAM-compressed unsigned floating-point data format with normalized value, packed in 10×8 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x8_SRGB_BLOCK = 177

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 10×8 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x10_UNORM_BLOCK = 178

VRAM-compressed unsigned floating-point data format with normalized value, packed in 10×10 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_10x10_SRGB_BLOCK = 179

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 10×10 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_12x10_UNORM_BLOCK = 180

VRAM-compressed unsigned floating-point data format with normalized value, packed in 12×10 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_12x10_SRGB_BLOCK = 181

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 12×10 blocks. Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_12x12_UNORM_BLOCK = 182

VRAM-compressed unsigned floating-point data format with normalized value, packed in 12 blocks (lowest quality). Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_ASTC_12x12_SRGB_BLOCK = 183

VRAM-compressed unsigned floating-point data format with normalized value and non-linear sRGB encoding, packed in 12 blocks (lowest quality). Values are in the [0.0, 1.0] range. Using ASTC compression.

DataFormat DATA_FORMAT_G8B8G8R8_422_UNORM = 184

8-bit-per-channel unsigned floating-point green/blue/red channel data format with normalized value. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_B8G8R8G8_422_UNORM = 185

8-bit-per-channel unsigned floating-point blue/green/red channel data format with normalized value. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 186

8-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM = 187

8-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, stored across 2 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 188

8-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, stored across 2 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM = 189

8-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, stored across 2 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 190

8-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, stored across 3 separate planes. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R10X6_UNORM_PACK16 = 191

10-bit-per-channel unsigned floating-point red channel data with normalized value, plus 6 unused bits, packed in 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R10X6G10X6_UNORM_2PACK16 = 192

10-bit-per-channel unsigned floating-point red/green channel data with normalized value, plus 6 unused bits after each channel, packed in 2×16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 193

10-bit-per-channel unsigned floating-point red/green/blue/alpha channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 194

10-bit-per-channel unsigned floating-point green/blue/green/red channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel). The green channel is listed twice, but contains different values to allow it to be represented at full resolution.

DataFormat DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 195

10-bit-per-channel unsigned floating-point blue/green/red/green channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel). The green channel is listed twice, but contains different values to allow it to be represented at full resolution.

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 196

10-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 2 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 197

10-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 2 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 198

10-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 199

10-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 200

10-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R12X4_UNORM_PACK16 = 201

12-bit-per-channel unsigned floating-point red channel data with normalized value, plus 6 unused bits, packed in 16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R12X4G12X4_UNORM_2PACK16 = 202

12-bit-per-channel unsigned floating-point red/green channel data with normalized value, plus 6 unused bits after each channel, packed in 2×16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 203

12-bit-per-channel unsigned floating-point red/green/blue/alpha channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 204

12-bit-per-channel unsigned floating-point green/blue/green/red channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel). The green channel is listed twice, but contains different values to allow it to be represented at full resolution.

DataFormat DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 205

12-bit-per-channel unsigned floating-point blue/green/red/green channel data with normalized value, plus 6 unused bits after each channel, packed in 4×16 bits. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel). The green channel is listed twice, but contains different values to allow it to be represented at full resolution.

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 206

12-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 2 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 207

12-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 2 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 208

12-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 209

12-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 210

12-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Packed in 3×16 bits and stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_G16B16G16R16_422_UNORM = 211

16-bit-per-channel unsigned floating-point green/blue/red channel data format with normalized value. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_B16G16R16G16_422_UNORM = 212

16-bit-per-channel unsigned floating-point blue/green/red channel data format with normalized value. Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 213

16-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Stored across 2 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM = 214

16-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Stored across 2 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal and vertical resolution (i.e. 2×2 adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 215

16-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM = 216

16-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Stored across 3 separate planes (green + blue/red). Values are in the [0.0, 1.0] range. Blue and red channel data is stored at halved horizontal resolution (i.e. 2 horizontally adjacent pixels will share the same value for the blue/red channel).

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 217

16-bit-per-channel unsigned floating-point green/blue/red channel data with normalized value, plus 6 unused bits after each channel. Stored across 3 separate planes (green + blue + red). Values are in the [0.0, 1.0] range.

DataFormat DATA_FORMAT_MAX = 218

Represents the size of the DataFormat enum.

flags BarrierMask:

BarrierMask BARRIER_MASK_VERTEX = 1

Vertex shader barrier mask.

BarrierMask BARRIER_MASK_FRAGMENT = 8

Fragment shader barrier mask.

BarrierMask BARRIER_MASK_COMPUTE = 2

Compute barrier mask.

BarrierMask BARRIER_MASK_TRANSFER = 4

Transfer barrier mask.

BarrierMask BARRIER_MASK_RASTER = 9

Raster barrier mask (vertex and fragment). Equivalent to BARRIER_MASK_VERTEX | BARRIER_MASK_FRAGMENT.

BarrierMask BARRIER_MASK_ALL_BARRIERS = 32767

Barrier mask for all types (vertex, fragment, compute, transfer).

BarrierMask BARRIER_MASK_NO_BARRIER = 32768

No barrier for any type.

enum TextureType:

TextureType TEXTURE_TYPE_1D = 0

1-dimensional texture.

TextureType TEXTURE_TYPE_2D = 1

2-dimensional texture.

TextureType TEXTURE_TYPE_3D = 2

3-dimensional texture.

TextureType TEXTURE_TYPE_CUBE = 3

Cubemap texture.

TextureType TEXTURE_TYPE_1D_ARRAY = 4

Array of 1-dimensional textures.

TextureType TEXTURE_TYPE_2D_ARRAY = 5

Array of 2-dimensional textures.

TextureType TEXTURE_TYPE_CUBE_ARRAY = 6

Array of Cubemap textures.

TextureType TEXTURE_TYPE_MAX = 7

Represents the size of the TextureType enum.

enum TextureSamples:

TextureSamples TEXTURE_SAMPLES_1 = 0

Perform 1 texture sample (this is the fastest but lowest-quality for antialiasing).

TextureSamples TEXTURE_SAMPLES_2 = 1

Perform 2 texture samples.

TextureSamples TEXTURE_SAMPLES_4 = 2

Perform 4 texture samples.

TextureSamples TEXTURE_SAMPLES_8 = 3

Perform 8 texture samples. Not supported on mobile GPUs (including Apple Silicon).

TextureSamples TEXTURE_SAMPLES_16 = 4

Perform 16 texture samples. Not supported on mobile GPUs and many desktop GPUs.

TextureSamples TEXTURE_SAMPLES_32 = 5

Perform 32 texture samples. Not supported on most GPUs.

TextureSamples TEXTURE_SAMPLES_64 = 6

Perform 64 texture samples (this is the slowest but highest-quality for antialiasing). Not supported on most GPUs.

TextureSamples TEXTURE_SAMPLES_MAX = 7

Represents the size of the TextureSamples enum.

flags TextureUsageBits:

TextureUsageBits TEXTURE_USAGE_SAMPLING_BIT = 1

Texture can be sampled.

TextureUsageBits TEXTURE_USAGE_COLOR_ATTACHMENT_BIT = 2

Texture can be used as a color attachment in a framebuffer.

TextureUsageBits TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 4

Texture can be used as a depth/stencil attachment in a framebuffer.

TextureUsageBits TEXTURE_USAGE_STORAGE_BIT = 8

Texture can be used as a storage image.

TextureUsageBits TEXTURE_USAGE_STORAGE_ATOMIC_BIT = 16

Texture can be used as a storage image with support for atomic operations.

TextureUsageBits TEXTURE_USAGE_CPU_READ_BIT = 32

Texture can be read back on the CPU using texture_get_data faster than without this bit, since it is always kept in the system memory.

TextureUsageBits TEXTURE_USAGE_CAN_UPDATE_BIT = 64

Texture can be updated using texture_update.

TextureUsageBits TEXTURE_USAGE_CAN_COPY_FROM_BIT = 128

Texture can be a source for texture_copy.

TextureUsageBits TEXTURE_USAGE_CAN_COPY_TO_BIT = 256

Texture can be a destination for texture_copy.

TextureUsageBits TEXTURE_USAGE_INPUT_ATTACHMENT_BIT = 512

Texture can be used as a input attachment in a framebuffer.

enum TextureSwizzle:

TextureSwizzle TEXTURE_SWIZZLE_IDENTITY = 0

Return the sampled value as-is.

TextureSwizzle TEXTURE_SWIZZLE_ZERO = 1

Always return 0.0 when sampling.

TextureSwizzle TEXTURE_SWIZZLE_ONE = 2

Always return 1.0 when sampling.

TextureSwizzle TEXTURE_SWIZZLE_R = 3

Sample the red color channel.

TextureSwizzle TEXTURE_SWIZZLE_G = 4

Sample the green color channel.

TextureSwizzle TEXTURE_SWIZZLE_B = 5

Sample the blue color channel.

TextureSwizzle TEXTURE_SWIZZLE_A = 6

Sample the alpha channel.

TextureSwizzle TEXTURE_SWIZZLE_MAX = 7

Represents the size of the TextureSwizzle enum.

enum TextureSliceType:

TextureSliceType TEXTURE_SLICE_2D = 0

2-dimensional texture slice.

TextureSliceType TEXTURE_SLICE_CUBEMAP = 1

Cubemap texture slice.

TextureSliceType TEXTURE_SLICE_3D = 2

3-dimensional texture slice.

enum SamplerFilter:

SamplerFilter SAMPLER_FILTER_NEAREST = 0

Nearest-neighbor sampler filtering. Sampling at higher resolutions than the source will result in a pixelated look.

SamplerFilter SAMPLER_FILTER_LINEAR = 1

Bilinear sampler filtering. Sampling at higher resolutions than the source will result in a blurry look.

enum SamplerRepeatMode:

SamplerRepeatMode SAMPLER_REPEAT_MODE_REPEAT = 0

Sample with repeating enabled.

SamplerRepeatMode SAMPLER_REPEAT_MODE_MIRRORED_REPEAT = 1

Sample with mirrored repeating enabled. When sampling outside the [0.0, 1.0] range, return a mirrored version of the sampler. This mirrored version is mirrored again if sampling further away, with the pattern repeating indefinitely.

SamplerRepeatMode SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE = 2

Sample with repeating disabled. When sampling outside the [0.0, 1.0] range, return the color of the last pixel on the edge.

SamplerRepeatMode SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER = 3

Sample with repeating disabled. When sampling outside the [0.0, 1.0] range, return the specified RDSamplerState.border_color.

SamplerRepeatMode SAMPLER_REPEAT_MODE_MIRROR_CLAMP_TO_EDGE = 4

Sample with mirrored repeating enabled, but only once. When sampling in the [-1.0, 0.0] range, return a mirrored version of the sampler. When sampling outside the [-1.0, 1.0] range, return the color of the last pixel on the edge.

SamplerRepeatMode SAMPLER_REPEAT_MODE_MAX = 5

Represents the size of the SamplerRepeatMode enum.

enum SamplerBorderColor:

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0

Return a floating-point transparent black color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1

Return a integer transparent black color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2

Return a floating-point opaque black color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_OPAQUE_BLACK = 3

Return a integer opaque black color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4

Return a floating-point opaque white color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_OPAQUE_WHITE = 5

Return a integer opaque white color when sampling outside the [0.0, 1.0] range. Only effective if the sampler repeat mode is SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER.

SamplerBorderColor SAMPLER_BORDER_COLOR_MAX = 6

Represents the size of the SamplerBorderColor enum.

enum VertexFrequency:

VertexFrequency VERTEX_FREQUENCY_VERTEX = 0

Vertex attribute addressing is a function of the vertex. This is used to specify the rate at which vertex attributes are pulled from buffers.

VertexFrequency VERTEX_FREQUENCY_INSTANCE = 1

Vertex attribute addressing is a function of the instance index. This is used to specify the rate at which vertex attributes are pulled from buffers.

enum IndexBufferFormat:

IndexBufferFormat INDEX_BUFFER_FORMAT_UINT16 = 0

Index buffer in 16-bit unsigned integer format. This limits the maximum index that can be specified to 65535.

IndexBufferFormat INDEX_BUFFER_FORMAT_UINT32 = 1

Index buffer in 32-bit unsigned integer format. This limits the maximum index that can be specified to 4294967295.

flags StorageBufferUsage:

StorageBufferUsage STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT = 1

enum UniformType:

UniformType UNIFORM_TYPE_SAMPLER = 0

Sampler uniform.

UniformType UNIFORM_TYPE_SAMPLER_WITH_TEXTURE = 1

Sampler uniform with a texture.

UniformType UNIFORM_TYPE_TEXTURE = 2

Texture uniform.

UniformType UNIFORM_TYPE_IMAGE = 3

Image uniform.

UniformType UNIFORM_TYPE_TEXTURE_BUFFER = 4

Texture buffer uniform.

UniformType UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER = 5

Sampler uniform with a texture buffer.

UniformType UNIFORM_TYPE_IMAGE_BUFFER = 6

Image buffer uniform.

UniformType UNIFORM_TYPE_UNIFORM_BUFFER = 7

Uniform buffer uniform.

UniformType UNIFORM_TYPE_STORAGE_BUFFER = 8

Storage buffer uniform.

UniformType UNIFORM_TYPE_INPUT_ATTACHMENT = 9

Input attachment uniform.

UniformType UNIFORM_TYPE_MAX = 10

Represents the size of the UniformType enum.

enum RenderPrimitive:

RenderPrimitive RENDER_PRIMITIVE_POINTS = 0

Point rendering primitive (with constant size, regardless of distance from camera).

RenderPrimitive RENDER_PRIMITIVE_LINES = 1

Line list rendering primitive. Lines are drawn separated from each other.

RenderPrimitive RENDER_PRIMITIVE_LINES_WITH_ADJACENCY = 2

Line list rendering primitive with adjacency.

Note: Adjacency is only useful with geometry shaders, which Godot does not expose.

RenderPrimitive RENDER_PRIMITIVE_LINESTRIPS = 3

Line strip rendering primitive. Lines drawn are connected to the previous vertex.

RenderPrimitive RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY = 4

Line strip rendering primitive with adjacency.

Note: Adjacency is only useful with geometry shaders, which Godot does not expose.

RenderPrimitive RENDER_PRIMITIVE_TRIANGLES = 5

Triangle list rendering primitive. Triangles are drawn separated from each other.

RenderPrimitive RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY = 6

Triangle list rendering primitive with adjacency.

Note: Adjacency is only useful with geometry shaders, which Godot does not expose.

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS = 7

Triangle strip rendering primitive. Triangles drawn are connected to the previous triangle.

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY = 8

Triangle strip rendering primitive with adjacency.

Note: Adjacency is only useful with geometry shaders, which Godot does not expose.

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX = 9

Triangle strip rendering primitive with primitive restart enabled. Triangles drawn are connected to the previous triangle, but a primitive restart index can be specified before drawing to create a second triangle strip after the specified index.

Note: Only compatible with indexed draws.

RenderPrimitive RENDER_PRIMITIVE_TESSELATION_PATCH = 10

Tessellation patch rendering primitive. Only useful with tessellation shaders, which can be used to deform these patches.

RenderPrimitive RENDER_PRIMITIVE_MAX = 11

Represents the size of the RenderPrimitive enum.

enum PolygonCullMode:

PolygonCullMode POLYGON_CULL_DISABLED = 0

Do not use polygon front face or backface culling.

PolygonCullMode POLYGON_CULL_FRONT = 1

Use polygon frontface culling (faces pointing towards the camera are hidden).

PolygonCullMode POLYGON_CULL_BACK = 2

Use polygon backface culling (faces pointing away from the camera are hidden).

enum PolygonFrontFace:

PolygonFrontFace POLYGON_FRONT_FACE_CLOCKWISE = 0

Clockwise winding order to determine which face of a polygon is its front face.

PolygonFrontFace POLYGON_FRONT_FACE_COUNTER_CLOCKWISE = 1

Counter-clockwise winding order to determine which face of a polygon is its front face.

enum StencilOperation:

StencilOperation STENCIL_OP_KEEP = 0

Keep the current stencil value.

StencilOperation STENCIL_OP_ZERO = 1

Set the stencil value to 0.

StencilOperation STENCIL_OP_REPLACE = 2

Replace the existing stencil value with the new one.

StencilOperation STENCIL_OP_INCREMENT_AND_CLAMP = 3

Increment the existing stencil value and clamp to the maximum representable unsigned value if reached. Stencil bits are considered as an unsigned integer.

StencilOperation STENCIL_OP_DECREMENT_AND_CLAMP = 4

Decrement the existing stencil value and clamp to the minimum value if reached. Stencil bits are considered as an unsigned integer.

StencilOperation STENCIL_OP_INVERT = 5

Bitwise-invert the existing stencil value.

StencilOperation STENCIL_OP_INCREMENT_AND_WRAP = 6

Increment the stencil value and wrap around to 0 if reaching the maximum representable unsigned. Stencil bits are considered as an unsigned integer.

StencilOperation STENCIL_OP_DECREMENT_AND_WRAP = 7

Decrement the stencil value and wrap around to the maximum representable unsigned if reaching the minimum. Stencil bits are considered as an unsigned integer.

StencilOperation STENCIL_OP_MAX = 8

Represents the size of the StencilOperation enum.

enum CompareOperator:

CompareOperator COMPARE_OP_NEVER = 0

“Never” comparison (opposite of COMPARE_OP_ALWAYS).

CompareOperator COMPARE_OP_LESS = 1

“Less than” comparison.

CompareOperator COMPARE_OP_EQUAL = 2

“Equal” comparison.

CompareOperator COMPARE_OP_LESS_OR_EQUAL = 3

“Less than or equal” comparison.

CompareOperator COMPARE_OP_GREATER = 4

“Greater than” comparison.

CompareOperator COMPARE_OP_NOT_EQUAL = 5

“Not equal” comparison.

CompareOperator COMPARE_OP_GREATER_OR_EQUAL = 6

“Greater than or equal” comparison.

CompareOperator COMPARE_OP_ALWAYS = 7

“Always” comparison (opposite of COMPARE_OP_NEVER).

CompareOperator COMPARE_OP_MAX = 8

Represents the size of the CompareOperator enum.

enum LogicOperation:

LogicOperation LOGIC_OP_CLEAR = 0

Clear logic operation (result is always 0). See also LOGIC_OP_SET.

LogicOperation LOGIC_OP_AND = 1

AND logic operation.

LogicOperation LOGIC_OP_AND_REVERSE = 2

AND logic operation with the destination operand being inverted. See also LOGIC_OP_AND_INVERTED.

LogicOperation LOGIC_OP_COPY = 3

Copy logic operation (keeps the source value as-is). See also LOGIC_OP_COPY_INVERTED and LOGIC_OP_NO_OP.

LogicOperation LOGIC_OP_AND_INVERTED = 4

AND logic operation with the source operand being inverted. See also LOGIC_OP_AND_REVERSE.

LogicOperation LOGIC_OP_NO_OP = 5

No-op logic operation (keeps the destination value as-is). See also LOGIC_OP_COPY.

LogicOperation LOGIC_OP_XOR = 6

Exclusive or (XOR) logic operation.

LogicOperation LOGIC_OP_OR = 7

OR logic operation.

LogicOperation LOGIC_OP_NOR = 8

Not-OR (NOR) logic operation.

LogicOperation LOGIC_OP_EQUIVALENT = 9

Not-XOR (XNOR) logic operation.

LogicOperation LOGIC_OP_INVERT = 10

Invert logic operation.

LogicOperation LOGIC_OP_OR_REVERSE = 11

OR logic operation with the destination operand being inverted. See also LOGIC_OP_OR_REVERSE.

LogicOperation LOGIC_OP_COPY_INVERTED = 12

NOT logic operation (inverts the value). See also LOGIC_OP_COPY.

LogicOperation LOGIC_OP_OR_INVERTED = 13

OR logic operation with the source operand being inverted. See also LOGIC_OP_OR_REVERSE.

LogicOperation LOGIC_OP_NAND = 14

Not-AND (NAND) logic operation.

LogicOperation LOGIC_OP_SET = 15

SET logic operation (result is always 1). See also LOGIC_OP_CLEAR.

LogicOperation LOGIC_OP_MAX = 16

Represents the size of the LogicOperation enum.

enum BlendFactor:

BlendFactor BLEND_FACTOR_ZERO = 0

Constant 0.0 blend factor.

BlendFactor BLEND_FACTOR_ONE = 1

Constant 1.0 blend factor.

BlendFactor BLEND_FACTOR_SRC_COLOR = 2

Color blend factor is source color. Alpha blend factor is source alpha.

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3

Color blend factor is 1.0 - source color. Alpha blend factor is 1.0 - source alpha.

BlendFactor BLEND_FACTOR_DST_COLOR = 4

Color blend factor is destination color. Alpha blend factor is destination alpha.

BlendFactor BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5

Color blend factor is 1.0 - destination color. Alpha blend factor is 1.0 - destination alpha.

BlendFactor BLEND_FACTOR_SRC_ALPHA = 6

Color and alpha blend factor is source alpha.

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7

Color and alpha blend factor is 1.0 - source alpha.

BlendFactor BLEND_FACTOR_DST_ALPHA = 8

Color and alpha blend factor is destination alpha.

BlendFactor BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9

Color and alpha blend factor is 1.0 - destination alpha.

BlendFactor BLEND_FACTOR_CONSTANT_COLOR = 10

Color blend factor is blend constant color. Alpha blend factor is blend constant alpha (see draw_list_set_blend_constants).

BlendFactor BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11

Color blend factor is 1.0 - blend constant color. Alpha blend factor is 1.0 - blend constant alpha (see draw_list_set_blend_constants).

BlendFactor BLEND_FACTOR_CONSTANT_ALPHA = 12

Color and alpha blend factor is blend constant alpha (see draw_list_set_blend_constants).

BlendFactor BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13

Color and alpha blend factor is 1.0 - blend constant alpha (see draw_list_set_blend_constants).

BlendFactor BLEND_FACTOR_SRC_ALPHA_SATURATE = 14

Color blend factor is min(source alpha, 1.0 - destination alpha). Alpha blend factor is 1.0.

BlendFactor BLEND_FACTOR_SRC1_COLOR = 15

Color blend factor is second source color. Alpha blend factor is second source alpha. Only relevant for dual-source blending.

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16

Color blend factor is 1.0 - second source color. Alpha blend factor is 1.0 - second source alpha. Only relevant for dual-source blending.

BlendFactor BLEND_FACTOR_SRC1_ALPHA = 17

Color and alpha blend factor is second source alpha. Only relevant for dual-source blending.

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18

Color and alpha blend factor is 1.0 - second source alpha. Only relevant for dual-source blending.

BlendFactor BLEND_FACTOR_MAX = 19

Represents the size of the BlendFactor enum.

enum BlendOperation:

BlendOperation BLEND_OP_ADD = 0

Additive blending operation (source + destination).

BlendOperation BLEND_OP_SUBTRACT = 1

Subtractive blending operation (source - destination).

BlendOperation BLEND_OP_REVERSE_SUBTRACT = 2

Reverse subtractive blending operation (destination - source).

BlendOperation BLEND_OP_MINIMUM = 3

Minimum blending operation (keep the lowest value of the two).

BlendOperation BLEND_OP_MAXIMUM = 4

Maximum blending operation (keep the highest value of the two).

BlendOperation BLEND_OP_MAX = 5

Represents the size of the BlendOperation enum.

flags PipelineDynamicStateFlags:

PipelineDynamicStateFlags DYNAMIC_STATE_LINE_WIDTH = 1

PipelineDynamicStateFlags DYNAMIC_STATE_DEPTH_BIAS = 2

PipelineDynamicStateFlags DYNAMIC_STATE_BLEND_CONSTANTS = 4

PipelineDynamicStateFlags DYNAMIC_STATE_DEPTH_BOUNDS = 8

PipelineDynamicStateFlags DYNAMIC_STATE_STENCIL_COMPARE_MASK = 16

PipelineDynamicStateFlags DYNAMIC_STATE_STENCIL_WRITE_MASK = 32

PipelineDynamicStateFlags DYNAMIC_STATE_STENCIL_REFERENCE = 64

enum InitialAction:

InitialAction INITIAL_ACTION_CLEAR = 0

Start rendering and clear the whole framebuffer.

InitialAction INITIAL_ACTION_CLEAR_REGION = 1

Start rendering and clear the framebuffer in the specified region.

InitialAction INITIAL_ACTION_CLEAR_REGION_CONTINUE = 2

Continue rendering and clear the framebuffer in the specified region. Framebuffer must have been left in FINAL_ACTION_CONTINUE state as the final action previously.

InitialAction INITIAL_ACTION_KEEP = 3

Start rendering, but keep attached color texture contents. If the framebuffer was previously used to read in a shader, this will automatically insert a layout transition.

InitialAction INITIAL_ACTION_DROP = 4

Start rendering, ignore what is there; write above it. In general, this is the fastest option when you will be writing every single pixel and you don’t need a clear color.

InitialAction INITIAL_ACTION_CONTINUE = 5

Continue rendering. Framebuffer must have been left in FINAL_ACTION_CONTINUE state as the final action previously.

InitialAction INITIAL_ACTION_MAX = 6

Represents the size of the InitialAction enum.

enum FinalAction:

FinalAction FINAL_ACTION_READ = 0

Store the texture for reading and make it read-only if it has the TEXTURE_USAGE_SAMPLING_BIT bit (only applies to color, depth and stencil attachments).

FinalAction FINAL_ACTION_DISCARD = 1

Discard the texture data and make it read-only if it has the TEXTURE_USAGE_SAMPLING_BIT bit (only applies to color, depth and stencil attachments).

FinalAction FINAL_ACTION_CONTINUE = 2

Store the texture and continue for further processing. Similar to FINAL_ACTION_READ, but does not make the texture read-only if it has the TEXTURE_USAGE_SAMPLING_BIT bit.

FinalAction FINAL_ACTION_MAX = 3

Represents the size of the FinalAction enum.

enum ShaderStage:

ShaderStage SHADER_STAGE_VERTEX = 0

Vertex shader stage. This can be used to manipulate vertices from a shader (but not create new vertices).

ShaderStage SHADER_STAGE_FRAGMENT = 1

Fragment shader stage (called “pixel shader” in Direct3D). This can be used to manipulate pixels from a shader.

ShaderStage SHADER_STAGE_TESSELATION_CONTROL = 2

Tessellation control shader stage. This can be used to create additional geometry from a shader.

ShaderStage SHADER_STAGE_TESSELATION_EVALUATION = 3

Tessellation evaluation shader stage. This can be used to create additional geometry from a shader.

ShaderStage SHADER_STAGE_COMPUTE = 4

Compute shader stage. This can be used to run arbitrary computing tasks in a shader, performing them on the GPU instead of the CPU.

ShaderStage SHADER_STAGE_MAX = 5

Represents the size of the ShaderStage enum.

ShaderStage SHADER_STAGE_VERTEX_BIT = 1

Vertex shader stage bit (see also SHADER_STAGE_VERTEX).

ShaderStage SHADER_STAGE_FRAGMENT_BIT = 2

Fragment shader stage bit (see also SHADER_STAGE_FRAGMENT).

ShaderStage SHADER_STAGE_TESSELATION_CONTROL_BIT = 4

Tessellation control shader stage bit (see also SHADER_STAGE_TESSELATION_CONTROL).

ShaderStage SHADER_STAGE_TESSELATION_EVALUATION_BIT = 8

Tessellation evaluation shader stage bit (see also SHADER_STAGE_TESSELATION_EVALUATION).

ShaderStage SHADER_STAGE_COMPUTE_BIT = 16

Compute shader stage bit (see also SHADER_STAGE_COMPUTE).

enum ShaderLanguage:

ShaderLanguage SHADER_LANGUAGE_GLSL = 0

Khronos’ GLSL shading language (used natively by OpenGL and Vulkan). This is the language used for core Godot shaders.

ShaderLanguage SHADER_LANGUAGE_HLSL = 1

Microsoft’s High-Level Shading Language (used natively by Direct3D, but can also be used in Vulkan).

enum PipelineSpecializationConstantType:

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL = 0

Boolean specialization constant.

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT = 1

Integer specialization constant.

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT = 2

Floating-point specialization constant.

enum Limit:

Limit LIMIT_MAX_BOUND_UNIFORM_SETS = 0

Maximum number of uniform sets that can be bound at a given time.

Limit LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS = 1

Maximum number of color framebuffer attachments that can be used at a given time.

Limit LIMIT_MAX_TEXTURES_PER_UNIFORM_SET = 2

Maximum number of textures that can be used per uniform set.

Limit LIMIT_MAX_SAMPLERS_PER_UNIFORM_SET = 3

Maximum number of samplers that can be used per uniform set.

Limit LIMIT_MAX_STORAGE_BUFFERS_PER_UNIFORM_SET = 4

Maximum number of storage buffers per uniform set.

Limit LIMIT_MAX_STORAGE_IMAGES_PER_UNIFORM_SET = 5

Maximum number of storage images per uniform set.

Limit LIMIT_MAX_UNIFORM_BUFFERS_PER_UNIFORM_SET = 6

Maximum number of uniform buffers per uniform set.

Limit LIMIT_MAX_DRAW_INDEXED_INDEX = 7

Maximum index for an indexed draw command.

Limit LIMIT_MAX_FRAMEBUFFER_HEIGHT = 8

Maximum height of a framebuffer (in pixels).

Limit LIMIT_MAX_FRAMEBUFFER_WIDTH = 9

Maximum width of a framebuffer (in pixels).

Limit LIMIT_MAX_TEXTURE_ARRAY_LAYERS = 10

Maximum number of texture array layers.

Limit LIMIT_MAX_TEXTURE_SIZE_1D = 11

Maximum supported 1-dimensional texture size (in pixels on a single axis).

Limit LIMIT_MAX_TEXTURE_SIZE_2D = 12

Maximum supported 2-dimensional texture size (in pixels on a single axis).

Limit LIMIT_MAX_TEXTURE_SIZE_3D = 13

Maximum supported 3-dimensional texture size (in pixels on a single axis).

Limit LIMIT_MAX_TEXTURE_SIZE_CUBE = 14

Maximum supported cubemap texture size (in pixels on a single axis of a single face).

Limit LIMIT_MAX_TEXTURES_PER_SHADER_STAGE = 15

Maximum number of textures per shader stage.

Limit LIMIT_MAX_SAMPLERS_PER_SHADER_STAGE = 16

Maximum number of samplers per shader stage.

Limit LIMIT_MAX_STORAGE_BUFFERS_PER_SHADER_STAGE = 17

Maximum number of storage buffers per shader stage.

Limit LIMIT_MAX_STORAGE_IMAGES_PER_SHADER_STAGE = 18

Maximum number of storage images per shader stage.

Limit LIMIT_MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE = 19

Maximum number of uniform buffers per uniform set.

Limit LIMIT_MAX_PUSH_CONSTANT_SIZE = 20

Maximum size of a push constant. A lot of devices are limited to 128 bytes, so try to avoid exceeding 128 bytes in push constants to ensure compatibility even if your GPU is reporting a higher value.

Limit LIMIT_MAX_UNIFORM_BUFFER_SIZE = 21

Maximum size of a uniform buffer.

Limit LIMIT_MAX_VERTEX_INPUT_ATTRIBUTE_OFFSET = 22

Maximum vertex input attribute offset.

Limit LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES = 23

Maximum number of vertex input attributes.

Limit LIMIT_MAX_VERTEX_INPUT_BINDINGS = 24

Maximum number of vertex input bindings.

Limit LIMIT_MAX_VERTEX_INPUT_BINDING_STRIDE = 25

Maximum vertex input binding stride.

Limit LIMIT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 26

Minimum uniform buffer offset alignment.

Limit LIMIT_MAX_COMPUTE_SHARED_MEMORY_SIZE = 27

Maximum shared memory size for compute shaders.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X = 28

Maximum number of workgroups for compute shaders on the X axis.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y = 29

Maximum number of workgroups for compute shaders on the Y axis.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z = 30

Maximum number of workgroups for compute shaders on the Z axis.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_INVOCATIONS = 31

Maximum number of workgroup invocations for compute shaders.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X = 32

Maximum workgroup size for compute shaders on the X axis.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y = 33

Maximum workgroup size for compute shaders on the Y axis.

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z = 34

Maximum workgroup size for compute shaders on the Z axis.

Limit LIMIT_MAX_VIEWPORT_DIMENSIONS_X = 35

Maximum viewport width (in pixels).

Limit LIMIT_MAX_VIEWPORT_DIMENSIONS_Y = 36

Maximum viewport height (in pixels).

enum MemoryType:

MemoryType MEMORY_TEXTURES = 0

Memory taken by textures.

MemoryType MEMORY_BUFFERS = 1

Memory taken by buffers.

MemoryType MEMORY_TOTAL = 2

Total memory taken. This is greater than the sum of MEMORY_TEXTURES and MEMORY_BUFFERS, as it also includes miscellaneous memory usage.

Constants

INVALID_ID = -1

Returned by functions that return an ID if a value is invalid.

INVALID_FORMAT_ID = -1

Returned by functions that return a format ID if a value is invalid.

Method Descriptions

void barrier ( BitField<BarrierMask> from=32767, BitField<BarrierMask> to=32767 )

Puts a memory barrier in place. This is used for synchronization to avoid data races. See also full_barrier, which may be useful for debugging.

Error buffer_clear ( RID buffer, int offset, int size_bytes, BitField<BarrierMask> post_barrier=32767 )

Clears the contents of the buffer, clearing size_bytes bytes, starting at offset. Always raises a memory barrier.

Prints an error if:

• the size isn’t a multiple of four

• the region specified by offset + size_bytes exceeds the buffer

• a draw list is currently active (created by draw_list_begin)

• a compute list is currently active (created by compute_list_begin)

PackedByteArray buffer_get_data ( RID buffer, int offset_bytes=0, int size_bytes=0 )

Returns a copy of the data of the specified buffer, optionally offset_bytes and size_bytes can be set to copy only a portion of the buffer.

Error buffer_update ( RID buffer, int offset, int size_bytes, PackedByteArray data, BitField<BarrierMask> post_barrier=32767 )

Updates a region of size_bytes bytes, starting at offset, in the buffer, with the specified data. Raises a memory barrier except when post_barrier is set to BARRIER_MASK_NO_BARRIER.

Prints an error if:

• the region specified by offset + size_bytes exceeds the buffer

• a draw list is currently active (created by draw_list_begin)

• a compute list is currently active (created by compute_list_begin)

void capture_timestamp ( String name )

Creates a timestamp marker with the specified name. This is used for performance reporting with the get_captured_timestamp_cpu_time, get_captured_timestamp_gpu_time and get_captured_timestamp_name methods.

void compute_list_add_barrier ( int compute_list )

Raises a Vulkan compute barrier in the specified compute_list.

int compute_list_begin ( bool allow_draw_overlap=false )

Starts a list of compute commands created with the compute_* methods. The returned value should be passed to other compute_list_* functions.

If allow_draw_overlap is true, you may have one draw list running at the same time as one compute list. Multiple compute lists cannot be created at the same time; you must finish the previous compute list first using compute_list_end.

A simple compute operation might look like this (code is not a complete example):

var rd = RenderingDevice.new()
var compute_list = rd.compute_list_begin()
rd.compute_list_bind_compute_pipeline(compute_list, compute_shader_dilate_pipeline)
rd.compute_list_bind_uniform_set(compute_list, compute_base_uniform_set, 0)
rd.compute_list_bind_uniform_set(compute_list, dilate_uniform_set, 1)
for i in atlas_slices:
    rd.compute_list_set_push_constant(compute_list, push_constant, push_constant.size())
    rd.compute_list_dispatch(compute_list, group_size.x, group_size.y, group_size.z)
    # No barrier, let them run all together.
rd.compute_list_end()

void compute_list_bind_compute_pipeline ( int compute_list, RID compute_pipeline )

Tells the GPU what compute pipeline to use when processing the compute list. If the shader has changed since the last time this function was called, Godot will unbind all descriptor sets and will re-bind them inside compute_list_dispatch.

void compute_list_bind_uniform_set ( int compute_list, RID uniform_set, int set_index )

Binds the uniform_set to this compute_list. Godot ensures that all textures in the uniform set have the correct Vulkan access masks. If Godot had to change access masks of textures, it will raise a Vulkan image memory barrier.

void compute_list_dispatch ( int compute_list, int x_groups, int y_groups, int z_groups )

Submits the compute list for processing on the GPU. This is the compute equivalent to draw_list_draw.

void compute_list_end ( BitField<BarrierMask> post_barrier=32767 )

Finishes a list of compute commands created with the compute_* methods.

void compute_list_set_push_constant ( int compute_list, PackedByteArray buffer, int size_bytes )

Sets the push constant data to buffer for the specified compute_list. The shader determines how this binary data is used. The buffer’s size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

RID compute_pipeline_create ( RID shader, RDPipelineSpecializationConstant[] specialization_constants=[] )

Creates a new compute pipeline. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

bool compute_pipeline_is_valid ( RID compute_pipeline )

Returns true if the compute pipeline specified by the compute_pipeline RID is valid, false otherwise.

RenderingDevice create_local_device ( )

Create a new local RenderingDevice. This is most useful for performing compute operations on the GPU independently from the rest of the engine.

void draw_command_begin_label ( String name, Color color )

Create a command buffer debug label region that can be displayed in third-party tools such as RenderDoc. All regions must be ended with a draw_command_end_label call. When viewed from the linear series of submissions to a single queue, calls to draw_command_begin_label and draw_command_end_label must be matched and balanced.

The VK_EXT_DEBUG_UTILS_EXTENSION_NAME Vulkan extension must be available and enabled for command buffer debug label region to work. See also draw_command_insert_label and draw_command_end_label.

void draw_command_end_label ( )

Ends the command buffer debug label region started by a draw_command_begin_label call.

void draw_command_insert_label ( String name, Color color )

Inserts a command buffer debug label region in the current command buffer. Unlike draw_command_begin_label, this region should not be ended with a draw_command_end_label call.

int draw_list_begin ( RID framebuffer, InitialAction initial_color_action, FinalAction final_color_action, InitialAction initial_depth_action, FinalAction final_depth_action, PackedColorArray clear_color_values=PackedColorArray(), float clear_depth=1.0, int clear_stencil=0, Rect2 region=Rect2(0, 0, 0, 0), RID[] storage_textures=[] )

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions.

Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using draw_list_end.

A simple drawing operation might look like this (code is not a complete example):

var rd = RenderingDevice.new()
var clear_colors = PackedColorArray([Color(0, 0, 0, 0), Color(0, 0, 0, 0), Color(0, 0, 0, 0)]
var draw_list = rd.draw_list_begin(framebuffers[i], RenderingDevice.INITIAL_ACTION_CLEAR, RenderingDevice.FINAL_ACTION_READ, RenderingDevice.INITIAL_ACTION_CLEAR, RenderingDevice.FINAL_ACTION_DISCARD, clear_colors)
# Draw opaque.
rd.draw_list_bind_render_pipeline(draw_list, raster_pipeline)
rd.draw_list_bind_uniform_set(draw_list, raster_base_uniform, 0)
rd.draw_list_set_push_constant(draw_list, raster_push_constant, raster_push_constant.size())
rd.draw_list_draw(draw_list, false, 1, slice_triangle_count[i] * 3)
# Draw wire.
rd.draw_list_bind_render_pipeline(draw_list, raster_pipeline_wire)
rd.draw_list_bind_uniform_set(draw_list, raster_base_uniform, 0)
rd.draw_list_set_push_constant(draw_list, raster_push_constant, raster_push_constant.size())
rd.draw_list_draw(draw_list, false, 1, slice_triangle_count[i] * 3)
rd.draw_list_end()

int draw_list_begin_for_screen ( int screen=0, Color clear_color=Color(0, 0, 0, 1) )

High-level variant of draw_list_begin, with the parameters automatically being adjusted for drawing onto the window specified by the screen ID.

Note: Cannot be used with local RenderingDevices, as these don’t have a screen. If called on a local RenderingDevice, draw_list_begin_for_screen returns INVALID_ID.

PackedInt64Array draw_list_begin_split ( RID framebuffer, int splits, InitialAction initial_color_action, FinalAction final_color_action, InitialAction initial_depth_action, FinalAction final_depth_action, PackedColorArray clear_color_values=PackedColorArray(), float clear_depth=1.0, int clear_stencil=0, Rect2 region=Rect2(0, 0, 0, 0), RID[] storage_textures=[] )

Variant of draw_list_begin with support for multiple splits. The splits parameter determines how many splits are created.

void draw_list_bind_index_array ( int draw_list, RID index_array )

Binds index_array to the specified draw_list.

void draw_list_bind_render_pipeline ( int draw_list, RID render_pipeline )

Binds render_pipeline to the specified draw_list.

void draw_list_bind_uniform_set ( int draw_list, RID uniform_set, int set_index )

Binds uniform_set to the specified draw_list. A set_index must also be specified, which is an identifier starting from 0 that must match the one expected by the draw list.

void draw_list_bind_vertex_array ( int draw_list, RID vertex_array )

Binds vertex_array to the specified draw_list.

void draw_list_disable_scissor ( int draw_list )

Removes and disables the scissor rectangle for the specified draw_list. See also draw_list_enable_scissor.

void draw_list_draw ( int draw_list, bool use_indices, int instances, int procedural_vertex_count=0 )

Submits draw_list for rendering on the GPU. This is the raster equivalent to compute_list_dispatch.

void draw_list_enable_scissor ( int draw_list, Rect2 rect=Rect2(0, 0, 0, 0) )

Creates a scissor rectangle and enables it for the specified draw_list. Scissor rectangles are used for clipping by discarding fragments that fall outside a specified rectangular portion of the screen. See also draw_list_disable_scissor.

Note: The specified rect is automatically intersected with the screen’s dimensions, which means it cannot exceed the screen’s dimensions.

void draw_list_end ( BitField<BarrierMask> post_barrier=32767 )

Finishes a list of raster drawing commands created with the draw_* methods.

void draw_list_set_blend_constants ( int draw_list, Color color )

Sets blend constants for the specified draw_list to color. Blend constants are used only if the graphics pipeline is created with DYNAMIC_STATE_BLEND_CONSTANTS flag set.

void draw_list_set_push_constant ( int draw_list, PackedByteArray buffer, int size_bytes )

Sets the push constant data to buffer for the specified draw_list. The shader determines how this binary data is used. The buffer’s size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

int draw_list_switch_to_next_pass ( )

Switches to the next draw pass and returns the split’s ID. Equivalent to draw_list_switch_to_next_pass_split with splits set to 1.

PackedInt64Array draw_list_switch_to_next_pass_split ( int splits )

Switches to the next draw pass, with the number of splits allocated specified in splits. The return value is an array containing the ID of each split. For single-split usage, see draw_list_switch_to_next_pass.

RID framebuffer_create ( RID[] textures, int validate_with_format=-1, int view_count=1 )

Creates a new framebuffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

RID framebuffer_create_empty ( Vector2i size, TextureSamples samples=0, int validate_with_format=-1 )

Creates a new empty framebuffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

RID framebuffer_create_multipass ( RID[] textures, RDFramebufferPass[] passes, int validate_with_format=-1, int view_count=1 )

Creates a new multipass framebuffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

int framebuffer_format_create ( RDAttachmentFormat[] attachments, int view_count=1 )

Creates a new framebuffer format with the specified attachments and view_count. Returns the new framebuffer’s unique framebuffer format ID.

If view_count is greater than or equal to 2, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.

int framebuffer_format_create_empty ( TextureSamples samples=0 )

Creates a new empty framebuffer format with the specified number of samples and returns its ID.

int framebuffer_format_create_multipass ( RDAttachmentFormat[] attachments, RDFramebufferPass[] passes, int view_count=1 )

Creates a multipass framebuffer format with the specified attachments, passes and view_count and returns its ID. If view_count is greater than or equal to 2, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.

TextureSamples framebuffer_format_get_texture_samples ( int format, int render_pass=0 )

Returns the number of texture samples used for the given framebuffer format ID (returned by framebuffer_get_format).

int framebuffer_get_format ( RID framebuffer )

Returns the format ID of the framebuffer specified by the framebuffer RID. This ID is guaranteed to be unique for the same formats and does not need to be freed.

bool framebuffer_is_valid ( RID framebuffer ) const

Returns true if the framebuffer specified by the framebuffer RID is valid, false otherwise.

void free_rid ( RID rid )

Tries to free an object in the RenderingDevice. To avoid memory leaks, this should be called after using an object as memory management does not occur automatically when using RenderingDevice directly.

void full_barrier ( )

Puts a full memory barrier in place. This is a memory barrier with all flags enabled. full_barrier it should only be used for debugging as it can severely impact performance.

int get_captured_timestamp_cpu_time ( int index ) const

Returns the timestamp in CPU time for the rendering step specified by index (in microseconds since the engine started). See also get_captured_timestamp_gpu_time and capture_timestamp.

int get_captured_timestamp_gpu_time ( int index ) const

Returns the timestamp in GPU time for the rendering step specified by index (in microseconds since the engine started). See also get_captured_timestamp_cpu_time and capture_timestamp.

String get_captured_timestamp_name ( int index ) const

Returns the timestamp’s name for the rendering step specified by index. See also capture_timestamp.

int get_captured_timestamps_count ( ) const

Returns the total number of timestamps (rendering steps) available for profiling.

int get_captured_timestamps_frame ( ) const

Returns the index of the last frame rendered that has rendering timestamps available for querying.

String get_device_name ( ) const

Returns the name of the video adapter (e.g. “GeForce GTX 1080/PCIe/SSE2”). Equivalent to RenderingServer.get_video_adapter_name. See also get_device_vendor_name.

String get_device_pipeline_cache_uuid ( ) const

Returns the universally unique identifier for the pipeline cache. This is used to cache shader files on disk, which avoids shader recompilations on subsequent engine runs. This UUID varies depending on the graphics card model, but also the driver version. Therefore, updating graphics drivers will invalidate the shader cache.

String get_device_vendor_name ( ) const

Returns the vendor of the video adapter (e.g. “NVIDIA Corporation”). Equivalent to RenderingServer.get_video_adapter_vendor. See also get_device_name.

int get_driver_resource ( DriverResource resource, RID rid, int index )

Returns the unique identifier of the driver resource for the specified rid. Some driver resource types ignore the specified rid (see DriverResource descriptions). index is always ignored but must be specified anyway.

int get_frame_delay ( ) const

Returns the frame count kept by the graphics API. Higher values result in higher input lag, but with more consistent throughput. For the main RenderingDevice, frames are cycled (usually 3 with triple-buffered V-Sync enabled). However, local RenderingDevices only have 1 frame.

int get_memory_usage ( MemoryType type ) const

Returns the memory usage in bytes corresponding to the given type. When using Vulkan, these statistics are calculated by Vulkan Memory Allocator.

RID index_array_create ( RID index_buffer, int index_offset, int index_count )

Creates a new index array. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

RID index_buffer_create ( int size_indices, IndexBufferFormat format, PackedByteArray data=PackedByteArray(), bool use_restart_indices=false )

Creates a new index buffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

int limit_get ( Limit limit ) const

Returns the value of the specified limit. This limit varies depending on the current graphics hardware (and sometimes the driver version). If the given limit is exceeded, rendering errors will occur.

Limits for various graphics hardware can be found in the Vulkan Hardware Database.

RID render_pipeline_create ( RID shader, int framebuffer_format, int vertex_format, RenderPrimitive primitive, RDPipelineRasterizationState rasterization_state, RDPipelineMultisampleState multisample_state, RDPipelineDepthStencilState stencil_state, RDPipelineColorBlendState color_blend_state, BitField<PipelineDynamicStateFlags> dynamic_state_flags=0, int for_render_pass=0, RDPipelineSpecializationConstant[] specialization_constants=[] )

Creates a new render pipeline. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

bool render_pipeline_is_valid ( RID render_pipeline )

Returns true if the render pipeline specified by the render_pipeline RID is valid, false otherwise.

RID sampler_create ( RDSamplerState state )

Creates a new sampler. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

bool sampler_is_format_supported_for_filter ( DataFormat format, SamplerFilter sampler_filter ) const

Returns true if implementation supports using a texture of format with the given sampler_filter.

int screen_get_framebuffer_format ( ) const

Returns the screen’s framebuffer format.

Note: Only the main RenderingDevice returned by RenderingServer.get_rendering_device has a format. If called on a local RenderingDevice, this method prints an error and returns INVALID_ID.

int screen_get_height ( int screen=0 ) const

Returns the window height matching the graphics API context for the given window ID (in pixels). Despite the parameter being named screen, this returns the window size. See also screen_get_width.

Note: Only the main RenderingDevice returned by RenderingServer.get_rendering_device has a height. If called on a local RenderingDevice, this method prints an error and returns INVALID_ID.

int screen_get_width ( int screen=0 ) const

Returns the window width matching the graphics API context for the given window ID (in pixels). Despite the parameter being named screen, this returns the window size. See also screen_get_height.

Note: Only the main RenderingDevice returned by RenderingServer.get_rendering_device has a width. If called on a local RenderingDevice, this method prints an error and returns INVALID_ID.

void set_resource_name ( RID id, String name )

Sets the resource name for id to name. This is used for debugging with third-party tools such as RenderDoc.

The following types of resources can be named: texture, sampler, vertex buffer, index buffer, uniform buffer, texture buffer, storage buffer, uniform set buffer, shader, render pipeline and compute pipeline. Framebuffers cannot be named. Attempting to name an incompatible resource type will print an error.

Note: Resource names are only set when the engine runs in verbose mode (OS.is_stdout_verbose = true), or when using an engine build compiled with the dev_mode=yes SCons option. The graphics driver must also support the VK_EXT_DEBUG_UTILS_EXTENSION_NAME Vulkan extension for named resources to work.

PackedByteArray shader_compile_binary_from_spirv ( RDShaderSPIRV spirv_data, String name=”” )

Compiles a binary shader from spirv_data and returns the compiled binary data as a PackedByteArray. This compiled shader is specific to the GPU model and driver version used; it will not work on different GPU models or even different driver versions. See also shader_compile_spirv_from_source.

name is an optional human-readable name that can be given to the compiled shader for organizational purposes.

RDShaderSPIRV shader_compile_spirv_from_source ( RDShaderSource shader_source, bool allow_cache=true )

Compiles a SPIR-V from the shader source code in shader_source and returns the SPIR-V as a RDShaderSPIRV. This intermediate language shader is portable across different GPU models and driver versions, but cannot be run directly by GPUs until compiled into a binary shader using shader_compile_binary_from_spirv.

If allow_cache is true, make use of the shader cache generated by Godot. This avoids a potentially lengthy shader compilation step if the shader is already in cache. If allow_cache is false, Godot’s shader cache is ignored and the shader will always be recompiled.

RID shader_create_from_bytecode ( PackedByteArray binary_data, RID placeholder_rid=RID() )

Creates a new shader instance from a binary compiled shader. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method. See also shader_compile_binary_from_spirv and shader_create_from_spirv.

RID shader_create_from_spirv ( RDShaderSPIRV spirv_data, String name=”” )

Creates a new shader instance from SPIR-V intermediate code. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method. See also shader_compile_spirv_from_source and shader_create_from_bytecode.

RID shader_create_placeholder ( )

Create a placeholder RID by allocating an RID without initializing it for use in shader_create_from_bytecode. This allows you to create an RID for a shader and pass it around, but defer compiling the shader to a later time.

int shader_get_vertex_input_attribute_mask ( RID shader )

Returns the internal vertex input mask. Internally, the vertex input mask is an unsigned integer consisting of the locations (specified in GLSL via. layout(location = ...)) of the input variables (specified in GLSL by the in keyword).

RID storage_buffer_create ( int size_bytes, PackedByteArray data=PackedByteArray(), BitField<StorageBufferUsage> usage=0 )

Creates a storage buffer with the specified data and usage. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

void submit ( )

Pushes the frame setup and draw command buffers then marks the local device as currently processing (which allows calling sync).

Note: Only available in local RenderingDevices.

void sync ( )

Forces a synchronization between the CPU and GPU, which may be required in certain cases. Only call this when needed, as CPU-GPU synchronization has a performance cost.

Note: Only available in local RenderingDevices.

Note: sync can only be called after a submit.

RID texture_buffer_create ( int size_bytes, DataFormat format, PackedByteArray data=PackedByteArray() )

Creates a new texture buffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

Error texture_clear ( RID texture, Color color, int base_mipmap, int mipmap_count, int base_layer, int layer_count, BitField<BarrierMask> post_barrier=32767 )

Clears the specified texture by replacing all of its pixels with the specified color. base_mipmap and mipmap_count determine which mipmaps of the texture are affected by this clear operation, while base_layer and layer_count determine which layers of a 3D texture (or texture array) are affected by this clear operation. For 2D textures (which only have one layer by design), base_layer must be 0 and layer_count must be 1.

Note: texture can’t be cleared while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to clear this texture.

Error texture_copy ( RID from_texture, RID to_texture, Vector3 from_pos, Vector3 to_pos, Vector3 size, int src_mipmap, int dst_mipmap, int src_layer, int dst_layer, BitField<BarrierMask> post_barrier=32767 )

Copies the from_texture to to_texture with the specified from_pos, to_pos and size coordinates. The Z axis of the from_pos, to_pos and size must be 0 for 2-dimensional textures. Source and destination mipmaps/layers must also be specified, with these parameters being 0 for textures without mipmaps or single-layer textures. Returns @GlobalScope.OK if the texture copy was successful or @GlobalScope.ERR_INVALID_PARAMETER otherwise.

Note: from_texture texture can’t be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to copy this texture.

Note: from_texture texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT to be retrieved.

Note: to_texture can’t be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to copy this texture.

Note: to_texture requires the TEXTURE_USAGE_CAN_COPY_TO_BIT to be retrieved.

Note: from_texture and to_texture must be of the same type (color or depth).

RID texture_create ( RDTextureFormat format, RDTextureView view, PackedByteArray[] data=[] )

Creates a new texture. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

Note: Not to be confused with RenderingServer.texture_2d_create, which creates the Godot-specific Texture2D resource as opposed to the graphics API’s own texture type.

RID texture_create_from_extension ( TextureType type, DataFormat format, TextureSamples samples, BitField<TextureUsageBits> usage_flags, int image, int width, int height, int depth, int layers )

Returns an RID for an existing image (VkImage) with the given type, format, samples, usage_flags, width, height, depth, and layers. This can be used to allow Godot to render onto foreign images.

RID texture_create_shared ( RDTextureView view, RID with_texture )

Creates a shared texture using the specified view and the texture information from with_texture.

RID texture_create_shared_from_slice ( RDTextureView view, RID with_texture, int layer, int mipmap, int mipmaps=1, TextureSliceType slice_type=0 )

Creates a shared texture using the specified view and the texture information from with_texture‘s layer and mipmap. The number of included mipmaps from the original texture can be controlled using the mipmaps parameter. Only relevant for textures with multiple layers, such as 3D textures, texture arrays and cubemaps. For single-layer textures, use texture_create_shared

For 2D textures (which only have one layer), layer must be 0.

Note: Layer slicing is only supported for 2D texture arrays, not 3D textures or cubemaps.

PackedByteArray texture_get_data ( RID texture, int layer )

Returns the texture data for the specified layer as raw binary data. For 2D textures (which only have one layer), layer must be 0.

Note: texture can’t be retrieved while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to retrieve this texture. Otherwise, an error is printed and a empty PackedByteArray is returned.

Note: texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT to be retrieved. Otherwise, an error is printed and a empty PackedByteArray is returned.

RDTextureFormat texture_get_format ( RID texture )

Returns the data format used to create this texture.

int texture_get_native_handle ( RID texture )

Returns the internal graphics handle for this texture object. For use when communicating with third-party APIs mostly with GDExtension.

Note: This function returns a uint64_t which internally maps to a GLuint (OpenGL) or VkImage (Vulkan).

bool texture_is_format_supported_for_usage ( DataFormat format, BitField<TextureUsageBits> usage_flags ) const

Returns true if the specified format is supported for the given usage_flags, false otherwise.

bool texture_is_shared ( RID texture )

Returns true if the texture is shared, false otherwise. See RDTextureView.

bool texture_is_valid ( RID texture )

Returns true if the texture is valid, false otherwise.

Error texture_resolve_multisample ( RID from_texture, RID to_texture, BitField<BarrierMask> post_barrier=32767 )

Resolves the from_texture texture onto to_texture with multisample antialiasing enabled. This must be used when rendering a framebuffer for MSAA to work. Returns @GlobalScope.OK if successful, @GlobalScope.ERR_INVALID_PARAMETER otherwise.

Note: from_texture and to_texture textures must have the same dimension, format and type (color or depth).

Note: from_texture can’t be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to resolve this texture.

Note: from_texture requires the TEXTURE_USAGE_CAN_COPY_FROM_BIT to be retrieved.

Note: from_texture must be multisampled and must also be 2D (or a slice of a 3D/cubemap texture).

Note: to_texture can’t be copied while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to resolve this texture.

Note: to_texture texture requires the TEXTURE_USAGE_CAN_COPY_TO_BIT to be retrieved.

Note: to_texture texture must not be multisampled and must also be 2D (or a slice of a 3D/cubemap texture).

Error texture_update ( RID texture, int layer, PackedByteArray data, BitField<BarrierMask> post_barrier=32767 )

Updates texture data with new data, replacing the previous data in place. The updated texture data must have the same dimensions and format. For 2D textures (which only have one layer), layer must be 0. Returns @GlobalScope.OK if the update was successful, @GlobalScope.ERR_INVALID_PARAMETER otherwise.

Note: Updating textures is forbidden during creation of a draw or compute list.

Note: The existing texture can’t be updated while a draw list that uses it as part of a framebuffer is being created. Ensure the draw list is finalized (and that the color/depth texture using it is not set to FINAL_ACTION_CONTINUE) to update this texture.

Note: The existing texture requires the TEXTURE_USAGE_CAN_UPDATE_BIT to be updatable.

RID uniform_buffer_create ( int size_bytes, PackedByteArray data=PackedByteArray() )

Creates a new uniform buffer. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

RID uniform_set_create ( RDUniform[] uniforms, RID shader, int shader_set )

Creates a new uniform set. It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

bool uniform_set_is_valid ( RID uniform_set )

Checks if the uniform_set is valid, i.e. is owned.

RID vertex_array_create ( int vertex_count, int vertex_format, RID[] src_buffers, PackedInt64Array offsets=PackedInt64Array() )

Creates a vertex array based on the specified buffers. Optionally, offsets (in bytes) may be defined for each buffer.

RID vertex_buffer_create ( int size_bytes, PackedByteArray data=PackedByteArray(), bool use_as_storage=false )

It can be accessed with the RID that is returned.

Once finished with your RID, you will want to free the RID using the RenderingDevice’s free_rid method.

int vertex_format_create ( RDVertexAttribute[] vertex_descriptions )

Creates a new vertex format with the specified vertex_descriptions. Returns a unique vertex format ID corresponding to the newly created vertex format.

Previous Next

© Copyright 2014-present Juan Linietsky, Ariel Manzur and the Godot community (CC BY 3.0). Revision 53e837c6.

Built with Sphinx using a theme provided by Read the Docs.