RenderingDevice

继承： Object

用于处理现代低阶图形 API 的抽象。

描述

RenderingDevice 是用来使用 Vulkan 等现代低阶图形 API 的抽象。与（适用于 Godot 自有渲染子系统的）RenderingServer 相比，RenderingDevice 所处的层级更低，能够更加直接地使用底层图形 API。Godot 使用 RenderingDevice 来支持部分现代低阶图形 API，能够减少所需的重复代码。你也可以在自己的项目中使用 RenderingDevice，从而执行 RenderingServer 和高阶节点未暴露的功能，例如使用计算着色器。

启动时，Godot 会创建一个全局的 RenderingDevice，可以使用 RenderingServer.get_rendering_device() 获取。这个全局的 RenderingDevice 进行的是屏幕绘图。

局部 RenderingDevice：你可以使用 RenderingServer.create_local_rendering_device() 创建“次级”渲染设备，在单独的线程中进行渲染和 GPU 计算操作。

注意：使用 RenderingDevice 需要对 Vulkan、Direct3D 12、Metal 或 WebGPU 有中等水平的知识。这些图形 API 比 OpenGL 和 Direct3D 所处的层级更低，能够执行原本由图形驱动自己实现的功能。如果这个类中所使用的概念你理解起来有困难，请学习 Vulkan 教程或 Vulkan 指南。在尝试学习低阶图形 API 之前，建议先学习现代 OpenGL 或 Direct3D 11 相关的知识。

注意：使用无头模式运行或使用 Compatibility 渲染方法时，RenderingDevice 不可用。

教程

使用计算着色器

方法

void	barrier(from: BitField[BarrierMask] = 32767, to: BitField[BarrierMask] = 32767)
Error	buffer_clear(buffer: RID, offset: int, size_bytes: int)
Error	buffer_copy(src_buffer: RID, dst_buffer: RID, src_offset: int, dst_offset: int, size: int)
PackedByteArray	buffer_get_data(buffer: RID, offset_bytes: int = 0, size_bytes: int = 0)
Error	buffer_get_data_async(buffer: RID, callback: Callable, offset_bytes: int = 0, size_bytes: int = 0)
int	buffer_get_device_address(buffer: RID)
Error	buffer_update(buffer: RID, offset: int, size_bytes: int, data: PackedByteArray)
void	capture_timestamp(name: String)
void	compute_list_add_barrier(compute_list: int)
int	compute_list_begin()
void	compute_list_bind_compute_pipeline(compute_list: int, compute_pipeline: RID)
void	compute_list_bind_uniform_set(compute_list: int, uniform_set: RID, set_index: int)
void	compute_list_dispatch(compute_list: int, x_groups: int, y_groups: int, z_groups: int)
void	compute_list_dispatch_indirect(compute_list: int, buffer: RID, offset: int)
void	compute_list_end()
void	compute_list_set_push_constant(compute_list: int, buffer: PackedByteArray, size_bytes: int)
RID	compute_pipeline_create(shader: RID, specialization_constants: Array[RDPipelineSpecializationConstant] = [])
bool	compute_pipeline_is_valid(compute_pipeline: RID)
RenderingDevice	create_local_device()
void	draw_command_begin_label(name: String, color: Color)
void	draw_command_end_label()
void	draw_command_insert_label(name: String, color: Color)
int	draw_list_begin(framebuffer: RID, draw_flags: BitField[DrawFlags] = 0, clear_color_values: PackedColorArray = PackedColorArray(), clear_depth_value: float = 1.0, clear_stencil_value: int = 0, region: Rect2 = Rect2(0, 0, 0, 0), breadcrumb: int = 0)
int	draw_list_begin_for_screen(screen: int = 0, clear_color: Color = Color(0, 0, 0, 1))
PackedInt64Array	draw_list_begin_split(framebuffer: RID, splits: int, initial_color_action: InitialAction, final_color_action: FinalAction, initial_depth_action: InitialAction, final_depth_action: FinalAction, clear_color_values: PackedColorArray = PackedColorArray(), clear_depth: float = 1.0, clear_stencil: int = 0, region: Rect2 = Rect2(0, 0, 0, 0), storage_textures: Array[RID] = [])
void	draw_list_bind_index_array(draw_list: int, index_array: RID)
void	draw_list_bind_render_pipeline(draw_list: int, render_pipeline: RID)
void	draw_list_bind_uniform_set(draw_list: int, uniform_set: RID, set_index: int)
void	draw_list_bind_vertex_array(draw_list: int, vertex_array: RID)
void	draw_list_disable_scissor(draw_list: int)
void	draw_list_draw(draw_list: int, use_indices: bool, instances: int, procedural_vertex_count: int = 0)
void	draw_list_draw_indirect(draw_list: int, use_indices: bool, buffer: RID, offset: int = 0, draw_count: int = 1, stride: int = 0)
void	draw_list_enable_scissor(draw_list: int, rect: Rect2 = Rect2(0, 0, 0, 0))
void	draw_list_end()
void	draw_list_set_blend_constants(draw_list: int, color: Color)
void	draw_list_set_push_constant(draw_list: int, buffer: PackedByteArray, size_bytes: int)
int	draw_list_switch_to_next_pass()
PackedInt64Array	draw_list_switch_to_next_pass_split(splits: int)
RID	framebuffer_create(textures: Array[RID], validate_with_format: int = -1, view_count: int = 1)
RID	framebuffer_create_empty(size: Vector2i, samples: TextureSamples = 0, validate_with_format: int = -1)
RID	framebuffer_create_multipass(textures: Array[RID], passes: Array[RDFramebufferPass], validate_with_format: int = -1, view_count: int = 1)
int	framebuffer_format_create(attachments: Array[RDAttachmentFormat], view_count: int = 1)
int	framebuffer_format_create_empty(samples: TextureSamples = 0)
int	framebuffer_format_create_multipass(attachments: Array[RDAttachmentFormat], passes: Array[RDFramebufferPass], view_count: int = 1)
TextureSamples	framebuffer_format_get_texture_samples(format: int, render_pass: int = 0)
int	framebuffer_get_format(framebuffer: RID)
bool	framebuffer_is_valid(framebuffer: RID) const
void	free_rid(rid: RID)
void	full_barrier()
int	get_captured_timestamp_cpu_time(index: int) const
int	get_captured_timestamp_gpu_time(index: int) const
String	get_captured_timestamp_name(index: int) const
int	get_captured_timestamps_count() const
int	get_captured_timestamps_frame() const
int	get_device_allocation_count() const
int	get_device_allocs_by_object_type(type: int) const
int	get_device_memory_by_object_type(type: int) const
String	get_device_name() const
String	get_device_pipeline_cache_uuid() const
int	get_device_total_memory() const
String	get_device_vendor_name() const
int	get_driver_allocation_count() const
int	get_driver_allocs_by_object_type(type: int) const
String	get_driver_and_device_memory_report() const
int	get_driver_memory_by_object_type(type: int) const
int	get_driver_resource(resource: DriverResource, rid: RID, index: int)
int	get_driver_total_memory() const
int	get_frame_delay() const
int	get_memory_usage(type: MemoryType) const
String	get_perf_report() const
String	get_tracked_object_name(type_index: int) const
int	get_tracked_object_type_count() const
bool	has_feature(feature: Features) const
RID	index_array_create(index_buffer: RID, index_offset: int, index_count: int)
RID	index_buffer_create(size_indices: int, format: IndexBufferFormat, data: PackedByteArray = PackedByteArray(), use_restart_indices: bool = false, creation_bits: BitField[BufferCreationBits] = 0)
int	limit_get(limit: Limit) const
RID	render_pipeline_create(shader: RID, framebuffer_format: int, vertex_format: int, primitive: RenderPrimitive, rasterization_state: RDPipelineRasterizationState, multisample_state: RDPipelineMultisampleState, stencil_state: RDPipelineDepthStencilState, color_blend_state: RDPipelineColorBlendState, dynamic_state_flags: BitField[PipelineDynamicStateFlags] = 0, for_render_pass: int = 0, specialization_constants: Array[RDPipelineSpecializationConstant] = [])
bool	render_pipeline_is_valid(render_pipeline: RID)
RID	sampler_create(state: RDSamplerState)
bool	sampler_is_format_supported_for_filter(format: DataFormat, sampler_filter: SamplerFilter) const
int	screen_get_framebuffer_format(screen: int = 0) const
int	screen_get_height(screen: int = 0) const
int	screen_get_width(screen: int = 0) const
void	set_resource_name(id: RID, name: String)
PackedByteArray	shader_compile_binary_from_spirv(spirv_data: RDShaderSPIRV, name: String = "")
RDShaderSPIRV	shader_compile_spirv_from_source(shader_source: RDShaderSource, allow_cache: bool = true)
RID	shader_create_from_bytecode(binary_data: PackedByteArray, placeholder_rid: RID = RID())
RID	shader_create_from_spirv(spirv_data: RDShaderSPIRV, name: String = "")
RID	shader_create_placeholder()
int	shader_get_vertex_input_attribute_mask(shader: RID)
RID	storage_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), usage: BitField[StorageBufferUsage] = 0, creation_bits: BitField[BufferCreationBits] = 0)
void	submit()
void	sync()
RID	texture_buffer_create(size_bytes: int, format: DataFormat, data: PackedByteArray = PackedByteArray())
Error	texture_clear(texture: RID, color: Color, base_mipmap: int, mipmap_count: int, base_layer: int, layer_count: int)
Error	texture_copy(from_texture: RID, to_texture: RID, from_pos: Vector3, to_pos: Vector3, size: Vector3, src_mipmap: int, dst_mipmap: int, src_layer: int, dst_layer: int)
RID	texture_create(format: RDTextureFormat, view: RDTextureView, data: Array[PackedByteArray] = [])
RID	texture_create_from_extension(type: TextureType, format: DataFormat, samples: TextureSamples, usage_flags: BitField[TextureUsageBits], image: int, width: int, height: int, depth: int, layers: int)
RID	texture_create_shared(view: RDTextureView, with_texture: RID)
RID	texture_create_shared_from_slice(view: RDTextureView, with_texture: RID, layer: int, mipmap: int, mipmaps: int = 1, slice_type: TextureSliceType = 0)
PackedByteArray	texture_get_data(texture: RID, layer: int)
Error	texture_get_data_async(texture: RID, layer: int, callback: Callable)
RDTextureFormat	texture_get_format(texture: RID)
int	texture_get_native_handle(texture: RID)
bool	texture_is_discardable(texture: RID)
bool	texture_is_format_supported_for_usage(format: DataFormat, usage_flags: BitField[TextureUsageBits]) const
bool	texture_is_shared(texture: RID)
bool	texture_is_valid(texture: RID)
Error	texture_resolve_multisample(from_texture: RID, to_texture: RID)
void	texture_set_discardable(texture: RID, discardable: bool)
Error	texture_update(texture: RID, layer: int, data: PackedByteArray)
RID	uniform_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), creation_bits: BitField[BufferCreationBits] = 0)
RID	uniform_set_create(uniforms: Array[RDUniform], shader: RID, shader_set: int)
bool	uniform_set_is_valid(uniform_set: RID)
RID	vertex_array_create(vertex_count: int, vertex_format: int, src_buffers: Array[RID], offsets: PackedInt64Array = PackedInt64Array())
RID	vertex_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), creation_bits: BitField[BufferCreationBits] = 0)
int	vertex_format_create(vertex_descriptions: Array[RDVertexAttribute])

枚举

enum DeviceType: 🔗

DeviceType DEVICE_TYPE_OTHER = 0

渲染设备的类型与其他枚举值均不匹配，或者未知。

DeviceType DEVICE_TYPE_INTEGRATED_GPU = 1

渲染设备为集成 GPU，通常（但不一定）比独立 GPU（DEVICE_TYPE_DISCRETE_GPU）要慢。在 Android 和 iOS 上，渲染设备的类型始终为 DEVICE_TYPE_INTEGRATED_GPU。

DeviceType DEVICE_TYPE_DISCRETE_GPU = 2

渲染设备为独立 GPU，通常（但不一定）比集成 GPU（DEVICE_TYPE_INTEGRATED_GPU）要快。

DeviceType DEVICE_TYPE_VIRTUAL_GPU = 3

渲染设备为虚拟环境中的模拟 GPU。通常比主机 GPU 要慢很多，这意味着独立 GPU 的预期性能等级大概与 DEVICE_TYPE_INTEGRATED_GPU 等价。使用虚拟机 GPU 穿透（例如 VFIO）时，设备类型不会被汇报为 DEVICE_TYPE_VIRTUAL_GPU。而是会汇报主机 GPU 的设备类型，就好像使用的不是模拟 GPU 一样。

DeviceType DEVICE_TYPE_CPU = 4

渲染设备由软件模拟提供（例如 Lavapipe 或 SwiftShader）。这是可用的渲染设备中最慢的一种；通常比 DEVICE_TYPE_INTEGRATED_GPU 要慢很多。

DeviceType DEVICE_TYPE_MAX = 5

代表 DeviceType 枚举的大小。

enum DriverResource: 🔗

DriverResource DRIVER_RESOURCE_LOGICAL_DEVICE = 0

基于物理设备的特定设备对象。

Vulkan：Vulkan 设备驱动资源（VkDevice）。（rid 参数不适用。）

DriverResource DRIVER_RESOURCE_PHYSICAL_DEVICE = 1

特定逻辑设备基于的物理设备。

Vulkan：VkDevice。（rid 参数不适用。）

DriverResource DRIVER_RESOURCE_TOPMOST_OBJECT = 2

顶层图形 API 入口对象。

Vulkan：VkInstance。（rid 参数不适用。）

DriverResource DRIVER_RESOURCE_COMMAND_QUEUE = 3

主要图形计算命令队列。

Vulkan：VkQueue。（rid 参数不适用。）

DriverResource DRIVER_RESOURCE_QUEUE_FAMILY = 4

主要队列属于的家族。

Vulkan：队列家族索引，是一个 uint32_t。（rid 参数不适用。）

DriverResource DRIVER_RESOURCE_TEXTURE = 5

Vulkan：VkImage。

DriverResource DRIVER_RESOURCE_TEXTURE_VIEW = 6

自有或共享纹理的视图。

Vulkan：VkImageView。

DriverResource DRIVER_RESOURCE_TEXTURE_DATA_FORMAT = 7

纹理数据格式的原生 ID。

Vulkan：VkFormat。

DriverResource DRIVER_RESOURCE_SAMPLER = 8

Vulkan：VkSampler。

DriverResource DRIVER_RESOURCE_UNIFORM_SET = 9

Vulkan：VkDescriptorSet。

DriverResource DRIVER_RESOURCE_BUFFER = 10

任何类型的缓冲（存储缓冲、顶点缓冲等）。

Vulkan：VkBuffer。

DriverResource DRIVER_RESOURCE_COMPUTE_PIPELINE = 11

Vulkan：VkPipeline。

DriverResource DRIVER_RESOURCE_RENDER_PIPELINE = 12

Vulkan：VkPipeline。

DriverResource DRIVER_RESOURCE_VULKAN_DEVICE = 0

已弃用： Use DRIVER_RESOURCE_LOGICAL_DEVICE instead.

DriverResource DRIVER_RESOURCE_VULKAN_PHYSICAL_DEVICE = 1

已弃用： Use DRIVER_RESOURCE_PHYSICAL_DEVICE instead.

DriverResource DRIVER_RESOURCE_VULKAN_INSTANCE = 2

已弃用： Use DRIVER_RESOURCE_TOPMOST_OBJECT instead.

DriverResource DRIVER_RESOURCE_VULKAN_QUEUE = 3

已弃用： Use DRIVER_RESOURCE_COMMAND_QUEUE instead.

DriverResource DRIVER_RESOURCE_VULKAN_QUEUE_FAMILY_INDEX = 4

已弃用： Use DRIVER_RESOURCE_QUEUE_FAMILY instead.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE = 5

已弃用： Use DRIVER_RESOURCE_TEXTURE instead.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE_VIEW = 6

已弃用： Use DRIVER_RESOURCE_TEXTURE_VIEW instead.

DriverResource DRIVER_RESOURCE_VULKAN_IMAGE_NATIVE_TEXTURE_FORMAT = 7

已弃用： Use DRIVER_RESOURCE_TEXTURE_DATA_FORMAT instead.

DriverResource DRIVER_RESOURCE_VULKAN_SAMPLER = 8

已弃用： Use DRIVER_RESOURCE_SAMPLER instead.

DriverResource DRIVER_RESOURCE_VULKAN_DESCRIPTOR_SET = 9

已弃用： Use DRIVER_RESOURCE_UNIFORM_SET instead.

DriverResource DRIVER_RESOURCE_VULKAN_BUFFER = 10

已弃用： Use DRIVER_RESOURCE_BUFFER instead.

DriverResource DRIVER_RESOURCE_VULKAN_COMPUTE_PIPELINE = 11

已弃用： Use DRIVER_RESOURCE_COMPUTE_PIPELINE instead.

DriverResource DRIVER_RESOURCE_VULKAN_RENDER_PIPELINE = 12

已弃用： Use DRIVER_RESOURCE_RENDER_PIPELINE instead.

enum DataFormat: 🔗

DataFormat DATA_FORMAT_R4G4_UNORM_PACK8 = 0

每通道 4 位的红、绿通道数据格式，紧缩在 8 个比特位中。取值均在 [0.0, 1.0] 的范围内。

注意：所有数据格式的更多信息可以在 Vulkan 规格说明的 Identification of formats 章节和 VkFormat 枚举中找到。

DataFormat DATA_FORMAT_R4G4B4A4_UNORM_PACK16 = 1

每通道 4 位的红、绿、蓝、Alpha 通道数据格式，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B4G4R4A4_UNORM_PACK16 = 2

每通道 4 位的蓝、绿、红、Alpha 通道数据格式，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R5G6B5_UNORM_PACK16 = 3

红、绿、蓝通道数据格式，红占 5 位、绿占 6 位、蓝占 5 位，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B5G6R5_UNORM_PACK16 = 4

蓝、绿、红通道数据格式，蓝占 5 位、绿占 6 位、红占 5 位，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R5G5B5A1_UNORM_PACK16 = 5

红、绿、蓝、Alpha 通道数据格式，红占 5 位、绿占 6 位、蓝占 5 位、Alpha 占 1 位，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B5G5R5A1_UNORM_PACK16 = 6

蓝、绿、红、Alpha 通道数据格式，蓝占 5 位、绿占 6 位、红占 5 位、Alpha 占 1 位，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A1R5G5B5_UNORM_PACK16 = 7

Alpha、红、绿、蓝通道数据格式，Alpha 占 1 位、红占 5 位、绿占 6 位、蓝占 5 位，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8_UNORM = 8

每通道 8 位的无符号浮点数红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8_SNORM = 9

每通道 8 位的带符号浮点数红通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8_USCALED = 10

每通道 8 位的无符号浮点数红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_R8_SSCALED = 11

每通道 8 位的带符号浮点数红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_R8_UINT = 12

每通道 8 位的无符号整数红通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_R8_SINT = 13

每通道 8 位的带符号整数红通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_R8_SRGB = 14

每通道 8 位的无符号浮点数红通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8_UNORM = 15

每通道 8 位的无符号浮点数红、绿通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8_SNORM = 16

每通道 8 位的带符号浮点数红、绿通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8_USCALED = 17

每通道 8 位的无符号浮点数红、绿通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_R8G8_SSCALED = 18

每通道 8 位的带符号浮点数红、绿通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_R8G8_UINT = 19

每通道 8 位的无符号整数红、绿通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_R8G8_SINT = 20

每通道 8 位的带符号整数红、绿通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_R8G8_SRGB = 21

每通道 8 位的无符号浮点数红、绿通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_UNORM = 22

每通道 8 位的无符号浮点数红、绿、蓝通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_SNORM = 23

每通道 8 位的带符号浮点数红、绿、蓝通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_USCALED = 24

每通道 8 位的无符号浮点数红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_SSCALED = 25

每通道 8 位的带符号浮点数红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_UINT = 26

每通道 8 位的无符号整数红、绿、蓝通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_SINT = 27

每通道 8 位的带符号整数红、绿、蓝通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_R8G8B8_SRGB = 28

每通道 8 位的无符号浮点数红、绿、蓝通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_UNORM = 29

每通道 8 位的无符号浮点数蓝、绿、红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_SNORM = 30

每通道 8 位的带符号浮点数蓝、绿、红通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_USCALED = 31

每通道 8 位的无符号浮点数蓝、绿、红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_SSCALED = 32

每通道 8 位的带符号浮点数蓝、绿、红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_UINT = 33

每通道 8 位的无符号整数蓝、绿、红通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_SINT = 34

每通道 8 位的带符号整数蓝、绿、红通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_B8G8R8_SRGB = 35

每通道 8 位的无符号浮点数蓝、绿、红通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_UNORM = 36

每通道 8 位的无符号浮点数红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_SNORM = 37

每通道 8 位的带符号浮点数红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_USCALED = 38

每通道 8 位的无符号浮点数红、绿、蓝、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_SSCALED = 39

每通道 8 位的带符号浮点数红、绿、蓝、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_UINT = 40

每通道 8 位的无符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_SINT = 41

每通道 8 位的带符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_R8G8B8A8_SRGB = 42

每通道 8 位的无符号浮点数红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_UNORM = 43

每通道 8 位的无符号浮点数蓝、绿、红、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_SNORM = 44

每通道 8 位的带符号浮点数蓝、绿、红、Alpha 通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_USCALED = 45

每通道 8 位的无符号浮点数蓝、绿、红、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_SSCALED = 46

每通道 8 位的带符号浮点数蓝、绿、红、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_UINT = 47

每通道 8 位的无符号整数蓝、绿、红、Alpha 通道数据格式。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_SINT = 48

每通道 8 位的带符号整数蓝、绿、红、Alpha 通道数据格式。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_B8G8R8A8_SRGB = 49

每通道 8 位的无符号浮点数蓝、绿、红、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_UNORM_PACK32 = 50

每通道 8 位的无符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_SNORM_PACK32 = 51

每通道 8 位的带符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_USCALED_PACK32 = 52

每通道 8 位的无符号浮点数 Alpha、红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数），紧缩在 32 个比特位中。取值均在 [0.0, 255.0] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_SSCALED_PACK32 = 53

每通道 8 位的带符号浮点数 Alpha、红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数），紧缩在 32 个比特位中。取值均在 [-127.0, 127.0] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_UINT_PACK32 = 54

每通道 8 位的无符号整数 Alpha、红、绿、蓝通道数据格式，紧缩在 32 个比特位中。取值均在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_SINT_PACK32 = 55

每通道 8 位的带符号整数 Alpha、红、绿、蓝通道数据格式，紧缩在 32 个比特位中。取值均在 [-127, 127] 的范围内。

DataFormat DATA_FORMAT_A8B8G8R8_SRGB_PACK32 = 56

每通道 8 位的无符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 32 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_UNORM_PACK32 = 57

无符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_SNORM_PACK32 = 58

带符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_USCALED_PACK32 = 59

无符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。红、绿、蓝的取值在 [0.0, 1023.0] 的范围内，Alpha 的取值在 [0.0, 3.0] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_SSCALED_PACK32 = 60

带符号浮点数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。红、绿、蓝的取值在 [-511.0, 511.0] 的范围内，Alpha 的取值在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_UINT_PACK32 = 61

无符号整数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。红、绿、蓝的取值在 [0, 1023] 的范围内，Alpha 的取值在 [0, 3] 的范围内。

DataFormat DATA_FORMAT_A2R10G10B10_SINT_PACK32 = 62

带符号整数 Alpha、红、绿、蓝通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位红、10 位绿、10 位蓝。红、绿、蓝的取值在 [-511, 511] 的范围内，Alpha 的取值在 [-1, 1] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_UNORM_PACK32 = 63

无符号浮点数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_SNORM_PACK32 = 64

带符号浮点数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_USCALED_PACK32 = 65

无符号浮点数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。蓝、绿、红的取值在 [0.0, 1023.0] 的范围内，Alpha 的取值在 [0.0, 3.0] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_SSCALED_PACK32 = 66

带符号浮点数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。蓝、绿、红的取值在 [-511.0, 511.0] 的范围内，Alpha 的取值在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_UINT_PACK32 = 67

无符号整数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。蓝、绿、红的取值在 [0, 1023] 的范围内，Alpha 的取值在 [0, 3] 的范围内。

DataFormat DATA_FORMAT_A2B10G10R10_SINT_PACK32 = 68

带符号整数 Alpha、蓝、绿、红通道数据格式，使用归一化的值，紧缩在 32 个比特位中。格式中包含 2 位 Alpha、10 位蓝、10 位绿、10 位红。蓝、绿、红的取值在 [-511, 511] 的范围内，Alpha 的取值在 [-1, 1] 的范围内。

DataFormat DATA_FORMAT_R16_UNORM = 69

每通道 16 位的无符号浮点数红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16_SNORM = 70

每通道 16 位的带符号浮点数红通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16_USCALED = 71

每通道 16 位的无符号浮点数红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 65535.0] 的范围内。

DataFormat DATA_FORMAT_R16_SSCALED = 72

每通道 16 位的带符号浮点数红通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-32767.0, 32767.0] 的范围内。

DataFormat DATA_FORMAT_R16_UINT = 73

每通道 16 位的无符号整数红通道数据格式。取值均在 [0.0, 65535] 的范围内。

DataFormat DATA_FORMAT_R16_SINT = 74

每通道 16 位的带符号整数红通道数据格式。取值均在 [-32767, 32767] 的范围内。

DataFormat DATA_FORMAT_R16_SFLOAT = 75

每通道 16 位的带符号浮点数红通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R16G16_UNORM = 76

每通道 16 位的无符号浮点数红、绿通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16_SNORM = 77

每通道 16 位的带符号浮点数红、绿通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16_USCALED = 78

每通道 16 位的无符号浮点数红、绿通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 65535.0] 的范围内。

DataFormat DATA_FORMAT_R16G16_SSCALED = 79

每通道 16 位的带符号浮点数红、绿通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-32767.0, 32767.0] 的范围内。

DataFormat DATA_FORMAT_R16G16_UINT = 80

每通道 16 位的无符号整数红、绿通道数据格式。取值均在 [0.0, 65535] 的范围内。

DataFormat DATA_FORMAT_R16G16_SINT = 81

每通道 16 位的带符号整数红、绿通道数据格式。取值均在 [-32767, 32767] 的范围内。

DataFormat DATA_FORMAT_R16G16_SFLOAT = 82

每通道 16 位的带符号浮点数红、绿通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R16G16B16_UNORM = 83

每通道 16 位的无符号浮点数红、绿、蓝通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_SNORM = 84

每通道 16 位的带符号浮点数红、绿、蓝通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_USCALED = 85

每通道 16 位的无符号浮点数红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 65535.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_SSCALED = 86

每通道 16 位的带符号浮点数红、绿、蓝通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-32767.0, 32767.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_UINT = 87

每通道 16 位的无符号整数红、绿、蓝通道数据格式。取值均在 [0.0, 65535] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_SINT = 88

每通道 16 位的带符号整数红、绿、蓝通道数据格式。取值均在 [-32767, 32767] 的范围内。

DataFormat DATA_FORMAT_R16G16B16_SFLOAT = 89

每通道 16 位的带符号浮点数红、绿、蓝通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R16G16B16A16_UNORM = 90

每通道 16 位的无符号浮点数红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_SNORM = 91

每通道 16 位的带符号浮点数红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_USCALED = 92

每通道 16 位的无符号浮点数红、绿、蓝、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [0.0, 65535.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_SSCALED = 93

每通道 16 位的带符号浮点数红、绿、蓝、Alpha 通道数据格式，使用缩放后的值（值从整数转换为浮点数）。取值均在 [-32767.0, 32767.0] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_UINT = 94

每通道 16 位的无符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [0.0, 65535] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_SINT = 95

每通道 16 位的带符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [-32767, 32767] 的范围内。

DataFormat DATA_FORMAT_R16G16B16A16_SFLOAT = 96

每通道 16 位的带符号浮点数红、绿、蓝、Alpha 通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R32_UINT = 97

每通道 32 位的无符号整数红通道数据格式。取值均在 [0, 2^32 - 1] 的范围内。

DataFormat DATA_FORMAT_R32_SINT = 98

每通道 32 位的带符号整数红通道数据格式。取值均在 [2^31 + 1, 2^31 - 1] 的范围内。

DataFormat DATA_FORMAT_R32_SFLOAT = 99

每通道 32 位的带符号整数红通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R32G32_UINT = 100

每通道 32 位的无符号整数红、绿通道数据格式。取值均在 [0, 2^32 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32_SINT = 101

每通道 32 位的带符号整数红、绿通道数据格式。取值均在 [2^31 + 1, 2^31 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32_SFLOAT = 102

每通道 32 位的带符号整数红、绿通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R32G32B32_UINT = 103

每通道 32 位的无符号整数红、绿、蓝通道数据格式。取值均在 [0, 2^32 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32B32_SINT = 104

每通道 32 位的带符号整数红、绿、蓝通道数据格式。取值均在 [2^31 + 1, 2^31 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32B32_SFLOAT = 105

每通道 32 位的带符号整数红、绿、蓝通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R32G32B32A32_UINT = 106

每通道 32 位的无符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [0, 2^32 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32B32A32_SINT = 107

每通道 32 位的带符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [2^31 + 1, 2^31 - 1] 的范围内。

DataFormat DATA_FORMAT_R32G32B32A32_SFLOAT = 108

每通道 32 位的带符号整数红、绿、蓝、Alpha 通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R64_UINT = 109

每通道 64 位的无符号整数红通道数据格式。取值均在 [0, 2^64 - 1] 的范围内。

DataFormat DATA_FORMAT_R64_SINT = 110

每通道 64 位的带符号整数红通道数据格式。取值均在 [2^63 + 1, 2^63 - 1] 的范围内。

DataFormat DATA_FORMAT_R64_SFLOAT = 111

每通道 64 位的带符号整数红通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R64G64_UINT = 112

每通道 64 位的无符号整数红、绿通道数据格式。取值均在 [0, 2^64 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64_SINT = 113

每通道 64 位的带符号整数红、绿通道数据格式。取值均在 [2^63 + 1, 2^63 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64_SFLOAT = 114

每通道 64 位的带符号整数红、绿通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R64G64B64_UINT = 115

每通道 64 位的无符号整数红、绿、蓝通道数据格式。取值均在 [0, 2^64 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64B64_SINT = 116

每通道 64 位的带符号整数红、绿、蓝通道数据格式。取值均在 [2^63 + 1, 2^63 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64B64_SFLOAT = 117

每通道 64 位的带符号整数红、绿、蓝通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_R64G64B64A64_UINT = 118

每通道 64 位的无符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [0, 2^64 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64B64A64_SINT = 119

每通道 64 位的带符号整数红、绿、蓝、Alpha 通道数据格式。取值均在 [2^63 + 1, 2^63 - 1] 的范围内。

DataFormat DATA_FORMAT_R64G64B64A64_SFLOAT = 120

每通道 64 位的带符号整数红、绿、蓝、Alpha 通道数据格式，数值原样存储。

DataFormat DATA_FORMAT_B10G11R11_UFLOAT_PACK32 = 121

无符号浮点数蓝、绿、红数据格式，数值原样存储，紧缩在 32 个比特位中。该格式的精度为蓝通道 10 位、绿通道 11 位、红通道 11 位。

DataFormat DATA_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 122

无符号浮点数曝光、蓝、绿、红数据格式，数值原样存储，紧缩在 32 个比特位中。该格式的精度为曝光 5 位、蓝通道 9 位、绿通道 9 位、红通道 9 位。

DataFormat DATA_FORMAT_D16_UNORM = 123

16 位无符号浮点数深度数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_X8_D24_UNORM_PACK32 = 124

24 位无符号浮点数深度数据格式，使用归一化的值，另有 8 位未使用，紧缩在 32 个比特位中。深度取值在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_D32_SFLOAT = 125

32 位无符号浮点数深度数据格式，数值原样存储。

DataFormat DATA_FORMAT_S8_UINT = 126

8 位无符号整数模板数据格式。

DataFormat DATA_FORMAT_D16_UNORM_S8_UINT = 127

16 位无符号浮点数深度数据格式，使用归一化的值，另有 8 位使用无符号整数格式的模板。深度取值在 [0.0, 1.0] 的范围内。模板取值在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_D24_UNORM_S8_UINT = 128

24 位无符号浮点数深度数据格式，使用归一化的值，另有 8 位使用无符号整数格式的模板。深度取值在 [0.0, 1.0] 的范围内。模板取值在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_D32_SFLOAT_S8_UINT = 129

32 位无符号浮点数深度数据格式，数值原样存储，另有 8 位使用无符号整数格式的模板。模板取值在 [0, 255] 的范围内。

DataFormat DATA_FORMAT_BC1_RGB_UNORM_BLOCK = 130

显存压缩的无符号红、绿、蓝通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位。使用 BC1 纹理压缩（也叫 S3TC DXT1）。

DataFormat DATA_FORMAT_BC1_RGB_SRGB_BLOCK = 131

显存压缩的无符号红、绿、蓝通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位。使用 BC1 纹理压缩（也叫 S3TC DXT1）。

DataFormat DATA_FORMAT_BC1_RGBA_UNORM_BLOCK = 132

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 1 位。使用 BC1 纹理压缩（也叫 S3TC DXT1）。

DataFormat DATA_FORMAT_BC1_RGBA_SRGB_BLOCK = 133

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 1 位。使用 BC1 纹理压缩（也叫 S3TC DXT1）。

DataFormat DATA_FORMAT_BC2_UNORM_BLOCK = 134

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 4 位。使用 BC2 纹理压缩（也叫 S3TC DXT3）。

DataFormat DATA_FORMAT_BC2_SRGB_BLOCK = 135

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 4 位。使用 BC2 纹理压缩（也叫 S3TC DXT3）。

DataFormat DATA_FORMAT_BC3_UNORM_BLOCK = 136

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 8 位。使用 BC3 纹理压缩（也叫 S3TC DXT5）。

DataFormat DATA_FORMAT_BC3_SRGB_BLOCK = 137

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 5 位、绿通道 6 位、蓝通道 5 位、Alpha 通道 8 位。使用 BC3 纹理压缩（也叫 S3TC DXT5）。

DataFormat DATA_FORMAT_BC4_UNORM_BLOCK = 138

显存压缩的无符号红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 8 位。使用 BC4 纹理压缩。

DataFormat DATA_FORMAT_BC4_SNORM_BLOCK = 139

显存压缩的带符号红通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。该格式的精度为红通道 8 位。使用 BC4 纹理压缩。

DataFormat DATA_FORMAT_BC5_UNORM_BLOCK = 140

显存压缩的无符号红、绿通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红通道 8 位、绿通道 8 位。使用 BC5 纹理压缩（也叫 S3TC RGTC）。

DataFormat DATA_FORMAT_BC5_SNORM_BLOCK = 141

显存压缩的带符号红、绿通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。该格式的精度为红通道 8 位、绿通道 8 位。使用 BC5 纹理压缩（也叫 S3TC RGTC）。

DataFormat DATA_FORMAT_BC6H_UFLOAT_BLOCK = 142

显存压缩的无符号红、绿、蓝通道数据格式，浮点数值原样存储。对于红/绿/蓝通道，该格式的精度在 10 到 13 位之间。使用 BC6H 纹理压缩（也称为 BPTC HDR）。

DataFormat DATA_FORMAT_BC6H_SFLOAT_BLOCK = 143

显存压缩的有符号红、绿、蓝通道数据格式，浮点数值原样存储。对于红/绿/蓝通道，该格式的精度在 10 到 13 位之间。使用 BC6H 纹理压缩（也称为 BPTC HDR）。

DataFormat DATA_FORMAT_BC7_UNORM_BLOCK = 144

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红、绿、蓝通道在 4 到 7 位之间，Alpha 通道在 0 到 8 位之间。使用 BC7 纹理压缩。也叫 BPTC HDR。

DataFormat DATA_FORMAT_BC7_SRGB_BLOCK = 145

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。该格式的精度为红、绿、蓝通道在 4 到 7 位之间，Alpha 通道在 0 到 8 位之间。使用 BC7 纹理压缩。也叫 BPTC HDR。

DataFormat DATA_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 146

显存压缩的无符号红、绿、蓝通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 147

显存压缩的无符号红、绿、蓝通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 148

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。红、绿、蓝均使用 8 位精度，Alpha 使用 1 位精度。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 149

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。红、绿、蓝均使用 8 位精度，Alpha 使用 1 位精度。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 150

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。红、绿、蓝均使用 8 位精度，Alpha 使用 8 位精度。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 151

显存压缩的无符号红、绿、蓝、Alpha 通道数据格式，使用归一化的值、非线性 sRGB 编码。取值均在 [0.0, 1.0] 的范围内。红、绿、蓝均使用 8 位精度，Alpha 使用 8 位精度。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_EAC_R11_UNORM_BLOCK = 152

11 位显存压缩的无符号红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_EAC_R11_SNORM_BLOCK = 153

11 位显存压缩的有符号红通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_EAC_R11G11_UNORM_BLOCK = 154

11 位显存压缩的无符号红、绿通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_EAC_R11G11_SNORM_BLOCK = 155

11 位显存压缩的有符号红、绿通道数据格式，使用归一化的值。取值均在 [-1.0, 1.0] 的范围内。使用 ETC2 纹理压缩。

DataFormat DATA_FORMAT_ASTC_4x4_UNORM_BLOCK = 156

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 4x4 的区块内（质量最高）。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_4x4_SRGB_BLOCK = 157

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 4x4 的区块内（质量最高）。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_5x4_UNORM_BLOCK = 158

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 5x4 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_5x4_SRGB_BLOCK = 159

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 5x4 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_5x5_UNORM_BLOCK = 160

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 5x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_5x5_SRGB_BLOCK = 161

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 5x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_6x5_UNORM_BLOCK = 162

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 6x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_6x5_SRGB_BLOCK = 163

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 6x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_6x6_UNORM_BLOCK = 164

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 6x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_6x6_SRGB_BLOCK = 165

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 6x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x5_UNORM_BLOCK = 166

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 8x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x5_SRGB_BLOCK = 167

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 8x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x6_UNORM_BLOCK = 168

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 8x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x6_SRGB_BLOCK = 169

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 8x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x8_UNORM_BLOCK = 170

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 8x8 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_8x8_SRGB_BLOCK = 171

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 8x8 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x5_UNORM_BLOCK = 172

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 10x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x5_SRGB_BLOCK = 173

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 10x5 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x6_UNORM_BLOCK = 174

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 10x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x6_SRGB_BLOCK = 175

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 10x6 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x8_UNORM_BLOCK = 176

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 10x8 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x8_SRGB_BLOCK = 177

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 10x8 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x10_UNORM_BLOCK = 178

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 10x10 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_10x10_SRGB_BLOCK = 179

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 10x10 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_12x10_UNORM_BLOCK = 180

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 12x10 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_12x10_SRGB_BLOCK = 181

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 12x10 的区块内。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_12x12_UNORM_BLOCK = 182

显存压缩的无符号浮点数数据格式，使用归一化的值，紧缩在 12 个区块内（质量最低）。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_ASTC_12x12_SRGB_BLOCK = 183

显存压缩的无符号浮点数数据格式，使用归一化的值、非线性 sRGB 编码，紧缩在 12 个区块内（质量最低）。取值均在 [0.0, 1.0] 的范围内。使用 ASTC 压缩。

DataFormat DATA_FORMAT_G8B8G8R8_422_UNORM = 184

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_B8G8R8G8_422_UNORM = 185

每通道 8 位的无符号浮点数蓝、绿、红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 186

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值，分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G8_B8R8_2PLANE_420_UNORM = 187

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值，分别在两个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 188

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值，分别在两个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G8_B8R8_2PLANE_422_UNORM = 189

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值，分别在两个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 190

每通道 8 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值，分别在三个独立平面存储。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R10X6_UNORM_PACK16 = 191

每通道 10 位的无符号浮点数红通道数据，使用归一化的值，另有 6 位未使用，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R10X6G10X6_UNORM_2PACK16 = 192

每通道 10 位的无符号浮点数红、绿通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 2x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 193

每通道 10 位的无符号浮点数红、绿、蓝、Alpha 通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 194

每通道 10 位的无符号浮点数绿、蓝、绿、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。绿通道出现两次，但包含不同的值，因此能够表示为完整的分辨率。

DataFormat DATA_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 195

每通道 10 位的无符号浮点数蓝、绿、红、绿通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。绿通道出现两次，但包含不同的值，因此能够表示为完整的分辨率。

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 196

每通道 10 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在两个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 197

每通道 10 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在两个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 198

每通道 10 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 199

每通道 10 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 200

每通道 10 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R12X4_UNORM_PACK16 = 201

每通道 12 位的无符号浮点数红通道数据，使用归一化的值，另有 6 位未使用，紧缩在 16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R12X4G12X4_UNORM_2PACK16 = 202

每通道 12 位的无符号浮点数红、绿通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 2x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 203

每通道 12 位的无符号浮点数红、绿、蓝、Alpha 通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 204

每通道 12 位的无符号浮点数绿、蓝、绿、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。绿通道出现两次，但包含不同的值，因此能够表示为完整的分辨率。

DataFormat DATA_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 205

每通道 12 位的无符号浮点数蓝、绿、红、绿通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 4x16 个比特位中。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。绿通道出现两次，但包含不同的值，因此能够表示为完整的分辨率。

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 206

每通道 12 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在两个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 207

每通道 12 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在两个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 208

每通道 12 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 209

每通道 12 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 210

每通道 12 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用，紧缩在 3x16 个比特位中，分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_G16B16G16R16_422_UNORM = 211

每通道 16 位的无符号浮点数绿、蓝、红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_B16G16R16G16_422_UNORM = 212

每通道 16 位的无符号浮点数蓝、绿、红通道数据格式，使用归一化的值。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 213

每通道 16 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用。分别在两个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G16_B16R16_2PLANE_420_UNORM = 214

每通道 16 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用。分别在两个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据纵横半分辨率存储（即 2x2 相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 215

每通道 16 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用。分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G16_B16R16_2PLANE_422_UNORM = 216

每通道 16 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用。分别在三个独立平面存储（绿 + 蓝、红）。取值均在 [0.0, 1.0] 的范围内。蓝、红通道数据横向半分辨率存储（即两个横向相邻的像素共享同一个蓝、红通道数值）。

DataFormat DATA_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 217

每通道 16 位的无符号浮点数绿、蓝、红通道数据，使用归一化的值，每个通道均另有 6 位未使用。分别在三个独立平面存储（绿 + 蓝 + 红）。取值均在 [0.0, 1.0] 的范围内。

DataFormat DATA_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 218

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 219

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 220

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 221

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 222

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 223

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 224

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 225

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 226

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 227

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 228

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 229

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 230

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 231

该枚举目前没有描述，请帮我们贡献一个吧！

DataFormat DATA_FORMAT_MAX = 232

代表 DataFormat 枚举的大小。

flags BarrierMask: 🔗

BarrierMask BARRIER_MASK_VERTEX = 1

顶点着色器屏障掩码。

BarrierMask BARRIER_MASK_FRAGMENT = 8

片段着色器屏障掩码。

BarrierMask BARRIER_MASK_COMPUTE = 2

计算屏障掩码。

BarrierMask BARRIER_MASK_TRANSFER = 4

传输屏障掩码。

BarrierMask BARRIER_MASK_RASTER = 9

光栅屏障掩码（顶点及片段）。等价于 BARRIER_MASK_VERTEX | BARRIER_MASK_FRAGMENT。

BarrierMask BARRIER_MASK_ALL_BARRIERS = 32767

所有类型的屏障掩码（顶点、片段、计算、传输）。

BarrierMask BARRIER_MASK_NO_BARRIER = 32768

任何类型都没有屏障。

enum TextureType: 🔗

TextureType TEXTURE_TYPE_1D = 0

一维纹理。

TextureType TEXTURE_TYPE_2D = 1

二维纹理。

TextureType TEXTURE_TYPE_3D = 2

三维纹理。

TextureType TEXTURE_TYPE_CUBE = 3

Cubemap 纹理。

TextureType TEXTURE_TYPE_1D_ARRAY = 4

一维纹理数组。

TextureType TEXTURE_TYPE_2D_ARRAY = 5

二维纹理数组。

TextureType TEXTURE_TYPE_CUBE_ARRAY = 6

Cubemap 纹理数组。

TextureType TEXTURE_TYPE_MAX = 7

代表 TextureType 枚举的大小。

enum TextureSamples: 🔗

TextureSamples TEXTURE_SAMPLES_1 = 0

执行 1 次纹理采样（最快，但抗锯齿质量最低）。

TextureSamples TEXTURE_SAMPLES_2 = 1

执行 2 次纹理采样。

TextureSamples TEXTURE_SAMPLES_4 = 2

执行 4 次纹理采样。

TextureSamples TEXTURE_SAMPLES_8 = 3

执行 8 次纹理采样。移动 GPU 不支持（包括 Apple Silicon）。

TextureSamples TEXTURE_SAMPLES_16 = 4

执行 16 次纹理采样。移动 GPU 及许多桌面 GPU 均不支持。

TextureSamples TEXTURE_SAMPLES_32 = 5

执行 32 次纹理采样。大多数 GPU 均不支持。

TextureSamples TEXTURE_SAMPLES_64 = 6

执行 64 次纹理采样（最慢，但抗锯齿质量最高）。大多数 GPU 均不支持。

TextureSamples TEXTURE_SAMPLES_MAX = 7

代表 TextureSamples 枚举的大小。

flags TextureUsageBits: 🔗

TextureUsageBits TEXTURE_USAGE_SAMPLING_BIT = 1

纹理可以采样。

TextureUsageBits TEXTURE_USAGE_COLOR_ATTACHMENT_BIT = 2

纹理可以用作帧缓冲的颜色附件。

TextureUsageBits TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 4

纹理可以用作帧缓冲的深度/模板附件。

TextureUsageBits TEXTURE_USAGE_STORAGE_BIT = 8

纹理可以用作存储图像。

TextureUsageBits TEXTURE_USAGE_STORAGE_ATOMIC_BIT = 16

纹理可以用作支持原子操作的存储图像。

TextureUsageBits TEXTURE_USAGE_CPU_READ_BIT = 32

纹理可以在 CPU 上使用 texture_get_data() 读取，比不设置这一位要快，因为会始终在系统内存中保留。

TextureUsageBits TEXTURE_USAGE_CAN_UPDATE_BIT = 64

纹理可以使用 texture_update() 更新。

TextureUsageBits TEXTURE_USAGE_CAN_COPY_FROM_BIT = 128

纹理可以作为 texture_copy() 的来源。

TextureUsageBits TEXTURE_USAGE_CAN_COPY_TO_BIT = 256

纹理可以作为 texture_copy() 的目标。

TextureUsageBits TEXTURE_USAGE_INPUT_ATTACHMENT_BIT = 512

纹理可以用作帧缓冲的输入附件。

enum TextureSwizzle: 🔗

TextureSwizzle TEXTURE_SWIZZLE_IDENTITY = 0

原样返回采样数值。

TextureSwizzle TEXTURE_SWIZZLE_ZERO = 1

采样时使用返回 0.0。

TextureSwizzle TEXTURE_SWIZZLE_ONE = 2

采样时使用返回 1.0。

TextureSwizzle TEXTURE_SWIZZLE_R = 3

对红色通道进行采样。

TextureSwizzle TEXTURE_SWIZZLE_G = 4

对绿色通道进行采样。

TextureSwizzle TEXTURE_SWIZZLE_B = 5

对蓝色通道进行采样。

TextureSwizzle TEXTURE_SWIZZLE_A = 6

对 Alpha 通道进行采样。

TextureSwizzle TEXTURE_SWIZZLE_MAX = 7

代表 TextureSwizzle 枚举的大小。

enum TextureSliceType: 🔗

TextureSliceType TEXTURE_SLICE_2D = 0

二维纹理切片。

TextureSliceType TEXTURE_SLICE_CUBEMAP = 1

立方体贴图纹理切片。

TextureSliceType TEXTURE_SLICE_3D = 2

三维纹理切片。

enum SamplerFilter: 🔗

SamplerFilter SAMPLER_FILTER_NEAREST = 0

最近邻采样器过滤。按照比源更高分辨率采样时，会产生像素化的效果。

SamplerFilter SAMPLER_FILTER_LINEAR = 1

双线性采样器过滤。按照比源更高分辨率采样时，会产生模糊的效果。

enum SamplerRepeatMode: 🔗

SamplerRepeatMode SAMPLER_REPEAT_MODE_REPEAT = 0

启用重复采样。

SamplerRepeatMode SAMPLER_REPEAT_MODE_MIRRORED_REPEAT = 1

启用镜像重复采样。对 [0.0, 1.0] 范围外进行采样时，返回采样器的镜像版本。如果采样的是更远的位置，则会对镜像版本再次镜像，并按照这样的规律无限重复下去。

SamplerRepeatMode SAMPLER_REPEAT_MODE_CLAMP_TO_EDGE = 2

禁用重复采样。对 [0.0, 1.0] 范围外进行采样时，返回边缘上最后一个像素的颜色。

SamplerRepeatMode SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER = 3

禁用重复采样。对 [0.0, 1.0] 范围外进行采样时，返回指定的边框颜色 RDSamplerState.border_color。

SamplerRepeatMode SAMPLER_REPEAT_MODE_MIRROR_CLAMP_TO_EDGE = 4

启用单次镜像重复采样。对 [-1.0, 0.0] 范围进行采样时，返回采样器的镜像版本。对 [-1.0, 1.0] 范围外进行采样时，返回边缘上最后一个像素的颜色。

SamplerRepeatMode SAMPLER_REPEAT_MODE_MAX = 5

代表 SamplerRepeatMode 枚举的大小。

enum SamplerBorderColor: 🔗

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0

对 [0.0, 1.0] 范围外进行采样时，返回浮点型的透明黑色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1

对 [0.0, 1.0] 范围外进行采样时，返回整型的透明黑色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2

对 [0.0, 1.0] 范围外进行采样时，返回浮点型的不透明黑色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_OPAQUE_BLACK = 3

对 [0.0, 1.0] 范围外进行采样时，返回整型的不透明黑色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4

对 [0.0, 1.0] 范围外进行采样时，返回浮点型的不透明白色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_INT_OPAQUE_WHITE = 5

对 [0.0, 1.0] 范围外进行采样时，返回整型的不透明白色。仅在采样器的重复模式为 SAMPLER_REPEAT_MODE_CLAMP_TO_BORDER 时有效。

SamplerBorderColor SAMPLER_BORDER_COLOR_MAX = 6

代表 SamplerBorderColor 枚举的大小。

enum VertexFrequency: 🔗

VertexFrequency VERTEX_FREQUENCY_VERTEX = 0

顶点属性寻址是顶点的功能。用于指定从缓冲中拉取顶点属性的频率。

VertexFrequency VERTEX_FREQUENCY_INSTANCE = 1

顶点属性寻址是实例索引的功能。用于指定从缓冲中拉取顶点属性的频率。

enum IndexBufferFormat: 🔗

IndexBufferFormat INDEX_BUFFER_FORMAT_UINT16 = 0

16 位无符号整数格式的索引缓冲。对可指定索引最大值的限制为 65535。

IndexBufferFormat INDEX_BUFFER_FORMAT_UINT32 = 1

32 位无符号整数格式的索引缓冲。对可指定索引最大值的限制为 4294967295。

flags StorageBufferUsage: 🔗

StorageBufferUsage STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT = 1

该枚举目前没有描述，请帮我们贡献一个吧！

flags BufferCreationBits: 🔗

BufferCreationBits BUFFER_CREATION_DEVICE_ADDRESS_BIT = 1

如果希望使用 buffer_get_device_address() 功能，则可以选择设置该标志。必须先检查 GPU 是否支持该功能：

rd = RenderingServer.get_rendering_device()

if rd.has_feature(RenderingDevice.SUPPORTS_BUFFER_DEVICE_ADDRESS):
      storage_buffer = rd.storage_buffer_create(bytes.size(), bytes, RenderingDevice.STORAGE_BUFFER_USAGE_SHADER_DEVICE_ADDRESS):
      storage_buffer_address = rd.buffer_get_device_address(storage_buffer)

BufferCreationBits BUFFER_CREATION_AS_STORAGE_BIT = 2

设置该标志可以将其创建为存储。适用于计算着色器需要访问（读取或写入）缓冲区的场合，例如在计算着色器中处理骨骼动画，这些着色器需要访问顶点缓冲区，以便后续在顶点着色器中使用，这是常规光栅化管线的一部分。

enum UniformType: 🔗

UniformType UNIFORM_TYPE_SAMPLER = 0

采样器 uniform。

UniformType UNIFORM_TYPE_SAMPLER_WITH_TEXTURE = 1

带有纹理的采样器 uniform。

UniformType UNIFORM_TYPE_TEXTURE = 2

纹理 uniform。

UniformType UNIFORM_TYPE_IMAGE = 3

图像 uniform。

UniformType UNIFORM_TYPE_TEXTURE_BUFFER = 4

纹理缓冲 uniform。

UniformType UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER = 5

带有纹理缓冲的采样器 uniform。

UniformType UNIFORM_TYPE_IMAGE_BUFFER = 6

图像缓冲 uniform。

UniformType UNIFORM_TYPE_UNIFORM_BUFFER = 7

Uniform 缓冲区 uniform。

UniformType UNIFORM_TYPE_STORAGE_BUFFER = 8

存储缓冲区 uniform。

UniformType UNIFORM_TYPE_INPUT_ATTACHMENT = 9

输入附件 uniform。

UniformType UNIFORM_TYPE_MAX = 10

表示 UniformType 枚举的大小。

enum RenderPrimitive: 🔗

RenderPrimitive RENDER_PRIMITIVE_POINTS = 0

渲染点的图元（大小为常量，和与相机之间的距离无关）。

RenderPrimitive RENDER_PRIMITIVE_LINES = 1

渲染线段列表的图元。线段在绘制时是彼此独立的。

RenderPrimitive RENDER_PRIMITIVE_LINES_WITH_ADJACENCY = 2

渲染线段列表的图元，提供邻接数据。

注意：邻接数据仅在几何着色器中有用，但 Godot 并没有暴露。

RenderPrimitive RENDER_PRIMITIVE_LINESTRIPS = 3

渲染线段条带的图元。绘制的线段与它的前一个顶点是相连的。

RenderPrimitive RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY = 4

渲染线段条带的图元，提供邻接数据。

注意：邻接数据仅在几何着色器中有用，但 Godot 并没有暴露。

RenderPrimitive RENDER_PRIMITIVE_TRIANGLES = 5

渲染三角形列表的图元。三角形在绘制时是彼此独立的。

RenderPrimitive RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY = 6

渲染三角形列表的图元，提供邻接数据。

注意：邻接数据仅在几何着色器中有用，但 Godot 并没有暴露。

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS = 7

渲染三角形条带的图元。绘制的三角形与它的前一个三角形是相连的。

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY = 8

渲染三角形条带的图元，提供邻接数据。

注意：邻接数据仅在几何着色器中有用，但 Godot 并没有暴露。

RenderPrimitive RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX = 9

渲染三角形条带的图元，启用图元重启。绘制的三角形与它的前一个三角形是相连的，但是在绘制前可以指定图元重启索引，这样在指定索引之后就会再创建一条三角形条带。

注意：仅兼容索引绘图。

RenderPrimitive RENDER_PRIMITIVE_TESSELATION_PATCH = 10

曲面细分面片渲染图元。仅对曲面细分着色器有用，可以将面片变形。

RenderPrimitive RENDER_PRIMITIVE_MAX = 11

代表 RenderPrimitive 枚举的大小。

enum PolygonCullMode: 🔗

PolygonCullMode POLYGON_CULL_DISABLED = 0

不使用多边形的正面和背面剔除。

PolygonCullMode POLYGON_CULL_FRONT = 1

使用多边形的正面剔除（隐藏正对相机的面）。

PolygonCullMode POLYGON_CULL_BACK = 2

使用多边形的背面剔除（隐藏背对相机的面）。

enum PolygonFrontFace: 🔗

PolygonFrontFace POLYGON_FRONT_FACE_CLOCKWISE = 0

决定多边形面为是否为正面时，使用顺时针缠绕顺序。

PolygonFrontFace POLYGON_FRONT_FACE_COUNTER_CLOCKWISE = 1

决定多边形面为是否为正面时，使用逆时针缠绕顺序。

enum StencilOperation: 🔗

StencilOperation STENCIL_OP_KEEP = 0

保留当前的模板值。

StencilOperation STENCIL_OP_ZERO = 1

将模板值设置为 0。

StencilOperation STENCIL_OP_REPLACE = 2

将现有的模板值替换为新值。

StencilOperation STENCIL_OP_INCREMENT_AND_CLAMP = 3

将现有的模板值加一，到达能够表示的最大无符号值之后就不会再增长。会将模板位视作无符号整数。

StencilOperation STENCIL_OP_DECREMENT_AND_CLAMP = 4

将现有的模板值减一，到达最小值之后就不会再降低。会将模板位视作无符号整数。

StencilOperation STENCIL_OP_INVERT = 5

将现有的模板值按位取反。

StencilOperation STENCIL_OP_INCREMENT_AND_WRAP = 6

将现有的模板值加一，到达能够表示的最大无符号值之后环绕至 0。会将模板位视作无符号整数。

StencilOperation STENCIL_OP_DECREMENT_AND_WRAP = 7

将现有的模板值减一，到达最小值之后环绕至能够表示的最大无符号值。会将模板位视作无符号整数。

StencilOperation STENCIL_OP_MAX = 8

代表 StencilOperation 枚举的大小。

enum CompareOperator: 🔗

CompareOperator COMPARE_OP_NEVER = 0

“永不”比较（与 COMPARE_OP_ALWAYS 相对）。

CompareOperator COMPARE_OP_LESS = 1

“小于”比较。

CompareOperator COMPARE_OP_EQUAL = 2

“等于”比较。

CompareOperator COMPARE_OP_LESS_OR_EQUAL = 3

“小于等于”比较。

CompareOperator COMPARE_OP_GREATER = 4

“大于”比较。

CompareOperator COMPARE_OP_NOT_EQUAL = 5

“不等于”比较。

CompareOperator COMPARE_OP_GREATER_OR_EQUAL = 6

“大于等于”比较。

CompareOperator COMPARE_OP_ALWAYS = 7

“始终”比较（与 COMPARE_OP_NEVER 相对）。

CompareOperator COMPARE_OP_MAX = 8

代表 CompareOperator 枚举的大小。

enum LogicOperation: 🔗

LogicOperation LOGIC_OP_CLEAR = 0

逻辑清除运算（结果始终为 0）。另见 LOGIC_OP_SET。

LogicOperation LOGIC_OP_AND = 1

逻辑与（AND）运算。

LogicOperation LOGIC_OP_AND_REVERSE = 2

逻辑与（AND）运算，翻转目标操作数。另见 LOGIC_OP_AND_INVERTED。

LogicOperation LOGIC_OP_COPY = 3

逻辑复制运算（保留来源的值）。另见 LOGIC_OP_COPY_INVERTED 和 LOGIC_OP_NO_OP。

LogicOperation LOGIC_OP_AND_INVERTED = 4

逻辑与（AND）运算，翻转来源操作数。另见 LOGIC_OP_AND_REVERSE。

LogicOperation LOGIC_OP_NO_OP = 5

逻辑空运算（保留目标值）。另见 LOGIC_OP_COPY。

LogicOperation LOGIC_OP_XOR = 6

逻辑异或（XOR）运算。

LogicOperation LOGIC_OP_OR = 7

逻辑或（OR）运算。

LogicOperation LOGIC_OP_NOR = 8

逻辑非或（NOR）运算。

LogicOperation LOGIC_OP_EQUIVALENT = 9

逻辑非异或（XNOR）运算。

LogicOperation LOGIC_OP_INVERT = 10

逻辑翻转运算。

LogicOperation LOGIC_OP_OR_REVERSE = 11

逻辑或（OR）运算，翻转目标操作数。另见 LOGIC_OP_OR_REVERSE。

LogicOperation LOGIC_OP_COPY_INVERTED = 12

逻辑非（NOT）运算（将值翻转）。另见 LOGIC_OP_COPY。

LogicOperation LOGIC_OP_OR_INVERTED = 13

逻辑或（OR）运算，翻转来源操作数。另见 LOGIC_OP_OR_REVERSE。

LogicOperation LOGIC_OP_NAND = 14

逻辑非与（NAND）运算。

LogicOperation LOGIC_OP_SET = 15

逻辑设置运算（结果始终为 1）。另见 LOGIC_OP_CLEAR。

LogicOperation LOGIC_OP_MAX = 16

代表 LogicOperation 枚举的大小。

enum BlendFactor: 🔗

BlendFactor BLEND_FACTOR_ZERO = 0

混合系数常量 0.0。

BlendFactor BLEND_FACTOR_ONE = 1

混合系数常量 1.0。

BlendFactor BLEND_FACTOR_SRC_COLOR = 2

颜色混合系数为 source color。Alpha 混合系数为 source alpha。

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3

颜色混合系数为 1.0 - source color。Alpha 混合系数为 1.0 - source alpha。

BlendFactor BLEND_FACTOR_DST_COLOR = 4

颜色混合系数为 destination color。Alpha 混合系数为 destination alpha。

BlendFactor BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5

颜色混合系数为 1.0 - destination color。Alpha 混合系数为 1.0 - destination alpha。

BlendFactor BLEND_FACTOR_SRC_ALPHA = 6

颜色混合和 Alpha 混合系数为 source alpha。

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7

颜色混合和 Alpha 混合系数为 1.0 - source alpha。

BlendFactor BLEND_FACTOR_DST_ALPHA = 8

颜色混合和 Alpha 混合系数为 destination alpha。

BlendFactor BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9

颜色混合和 Alpha 混合系数为 1.0 - destination alpha。

BlendFactor BLEND_FACTOR_CONSTANT_COLOR = 10

颜色混合系数为 blend constant color。Alpha 混合系数为 blend constant alpha（见 draw_list_set_blend_constants()）。

BlendFactor BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11

颜色混合系数为 1.0 - blend constant color。Alpha 混合系数为 1.0 - blend constant alpha（见 draw_list_set_blend_constants()）。

BlendFactor BLEND_FACTOR_CONSTANT_ALPHA = 12

颜色混合和 Alpha 混合系数为 blend constant alpha（见 draw_list_set_blend_constants()）。

BlendFactor BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13

颜色混合和 Alpha 混合系数为 1.0 - blend constant alpha（见 draw_list_set_blend_constants()）。

BlendFactor BLEND_FACTOR_SRC_ALPHA_SATURATE = 14

颜色混合系数为 min(source alpha, 1.0 - destination alpha)。Alpha 混合系数为 1.0。

BlendFactor BLEND_FACTOR_SRC1_COLOR = 15

颜色混合系数为 second source color。Alpha 混合系数为 second source alpha。仅适用于双源混合。

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16

颜色混合系数为 1.0 - second source color。Alpha 混合系数为 1.0 - second source alpha。仅适用于双源混合。

BlendFactor BLEND_FACTOR_SRC1_ALPHA = 17

颜色混合和 Alpha 混合系数为 second source alpha。仅适用于双源混合。

BlendFactor BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18

颜色混合和 Alpha 混合系数为 1.0 - second source alpha。仅适用于双源混合。

BlendFactor BLEND_FACTOR_MAX = 19

代表 BlendFactor 枚举的大小。

enum BlendOperation: 🔗

BlendOperation BLEND_OP_ADD = 0

加法混合运算（source + destination）。

BlendOperation BLEND_OP_SUBTRACT = 1

减法混合运算（source - destination）。

BlendOperation BLEND_OP_REVERSE_SUBTRACT = 2

逆减法混合运算（destination - source）。

BlendOperation BLEND_OP_MINIMUM = 3

最小混合运算（保留两者之间的较小值）。

BlendOperation BLEND_OP_MAXIMUM = 4

最大混合运算（保留两者之间的较大值）。

BlendOperation BLEND_OP_MAX = 5

代表 BlendOperation 枚举的大小。

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_LOAD = 0

已弃用： Initial actions are solved automatically by RenderingDevice.

加载帧缓冲的先前内容。

InitialAction INITIAL_ACTION_CLEAR = 1

已弃用： Initial actions are solved automatically by RenderingDevice.

清除整个帧缓冲区或其指定区块。

InitialAction INITIAL_ACTION_DISCARD = 2

已弃用： Initial actions are solved automatically by RenderingDevice.

忽略帧缓冲区之前的内容。如果你要覆盖所有像素并且不需要读取任何像素，这是最快的选项。

InitialAction INITIAL_ACTION_MAX = 3

已弃用： Initial actions are solved automatically by RenderingDevice.

代表 InitialAction 枚举的大小。

InitialAction INITIAL_ACTION_CLEAR_REGION = 1

已弃用： Initial actions are solved automatically by RenderingDevice.

InitialAction INITIAL_ACTION_CLEAR_REGION_CONTINUE = 1

已弃用： Initial actions are solved automatically by RenderingDevice.

InitialAction INITIAL_ACTION_KEEP = 0

已弃用： Initial actions are solved automatically by RenderingDevice.

InitialAction INITIAL_ACTION_DROP = 2

已弃用： Initial actions are solved automatically by RenderingDevice.

InitialAction INITIAL_ACTION_CONTINUE = 0

已弃用： Initial actions are solved automatically by RenderingDevice.

enum FinalAction: 🔗

FinalAction FINAL_ACTION_STORE = 0

已弃用： Final actions are solved automatically by RenderingDevice.

将绘制列表的结果存储在帧缓冲区中。这通常是你想要做的。

FinalAction FINAL_ACTION_DISCARD = 1

已弃用： Final actions are solved automatically by RenderingDevice.

丢弃帧缓冲区的内容。如果你不需要使用绘制列表的结果，则这是最快的选项。

FinalAction FINAL_ACTION_MAX = 2

已弃用： Final actions are solved automatically by RenderingDevice.

代表 FinalAction 枚举的大小。

FinalAction FINAL_ACTION_READ = 0

已弃用： Final actions are solved automatically by RenderingDevice.

FinalAction FINAL_ACTION_CONTINUE = 0

已弃用： Final actions are solved automatically by RenderingDevice.

enum ShaderStage: 🔗

ShaderStage SHADER_STAGE_VERTEX = 0

顶点着色器阶段。可用于在着色器中操作顶点（但无法新建顶点）。

ShaderStage SHADER_STAGE_FRAGMENT = 1

片段着色器阶段（Direct3D 中成为“像素着色器”）。可用于在着色器中操作像素。

ShaderStage SHADER_STAGE_TESSELATION_CONTROL = 2

曲面细分控制着色器阶段。可用于在着色器中创建额外的几何体。

ShaderStage SHADER_STAGE_TESSELATION_EVALUATION = 3

曲面细分求值着色器阶段。可用于在着色器中创建额外的几何体。

ShaderStage SHADER_STAGE_COMPUTE = 4

计算着色器阶段。可用于在着色器中执行任意计算任务，在 GPU 而不是 CPU 上进行计算。

ShaderStage SHADER_STAGE_MAX = 5

代表 ShaderStage 枚举的大小。

ShaderStage SHADER_STAGE_VERTEX_BIT = 1

顶点着色器阶段位（另见 SHADER_STAGE_VERTEX）。

ShaderStage SHADER_STAGE_FRAGMENT_BIT = 2

片段着色器阶段位（另见 SHADER_STAGE_FRAGMENT）。

ShaderStage SHADER_STAGE_TESSELATION_CONTROL_BIT = 4

曲面细分控制着色器阶段位（另见 SHADER_STAGE_TESSELATION_CONTROL）。

ShaderStage SHADER_STAGE_TESSELATION_EVALUATION_BIT = 8

曲面细分求值着色器阶段位（另见 SHADER_STAGE_TESSELATION_EVALUATION）。

ShaderStage SHADER_STAGE_COMPUTE_BIT = 16

计算着色器阶段位（另见 SHADER_STAGE_COMPUTE）。

enum ShaderLanguage: 🔗

ShaderLanguage SHADER_LANGUAGE_GLSL = 0

Khronos 的 GLSL 着色语言（OpenGL 和 Vulkan 原生使用）。这是核心 Godot 着色器所使用的语言。

ShaderLanguage SHADER_LANGUAGE_HLSL = 1

Microsoft 的高级着色器语言（Direct3D 原生使用，Vulkan 中也能使用）。

enum PipelineSpecializationConstantType: 🔗

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL = 0

布尔型特化常量。

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT = 1

整型特化常量。

PipelineSpecializationConstantType PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT = 2

浮点型特化常量。

enum Features: 🔗

Features SUPPORTS_BUFFER_DEVICE_ADDRESS = 6

支持缓冲区设备地址扩展的功能。

enum Limit: 🔗

Limit LIMIT_MAX_BOUND_UNIFORM_SETS = 0

能够同时绑定的最大 uniform 集的数量。

Limit LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS = 1

能够同时使用的最大颜色帧缓冲附件的数量。

Limit LIMIT_MAX_TEXTURES_PER_UNIFORM_SET = 2

单个 uniform 集能够使用的最大纹理数量。

Limit LIMIT_MAX_SAMPLERS_PER_UNIFORM_SET = 3

单个 uniform 集能够使用的最大采样器数量。

Limit LIMIT_MAX_STORAGE_BUFFERS_PER_UNIFORM_SET = 4

单个 uniform 集的最大存储缓冲数量。

Limit LIMIT_MAX_STORAGE_IMAGES_PER_UNIFORM_SET = 5

单个 uniform 集的最大存储图像数量。

Limit LIMIT_MAX_UNIFORM_BUFFERS_PER_UNIFORM_SET = 6

单个 uniform 集的最大 uniform 缓冲数量。

Limit LIMIT_MAX_DRAW_INDEXED_INDEX = 7

索引绘图指令的最大索引。

Limit LIMIT_MAX_FRAMEBUFFER_HEIGHT = 8

帧缓冲的最大高度（单位为像素）。

Limit LIMIT_MAX_FRAMEBUFFER_WIDTH = 9

帧缓冲的最大宽度（单位为像素）。

Limit LIMIT_MAX_TEXTURE_ARRAY_LAYERS = 10

纹理数组的最大层数。

Limit LIMIT_MAX_TEXTURE_SIZE_1D = 11

支持的一维纹理的最大尺寸（单轴像素数）。

Limit LIMIT_MAX_TEXTURE_SIZE_2D = 12

支持的二维纹理的最大尺寸（单轴像素数）。

Limit LIMIT_MAX_TEXTURE_SIZE_3D = 13

支持的三维纹理的最大尺寸（单轴像素数）。

Limit LIMIT_MAX_TEXTURE_SIZE_CUBE = 14

支持的立方体贴图纹理的最大尺寸（单轴像素数）。

Limit LIMIT_MAX_TEXTURES_PER_SHADER_STAGE = 15

每个着色器阶段的最大纹理数。

Limit LIMIT_MAX_SAMPLERS_PER_SHADER_STAGE = 16

每个着色器阶段的最大采样器数。

Limit LIMIT_MAX_STORAGE_BUFFERS_PER_SHADER_STAGE = 17

每个着色器阶段的最大存储缓冲数。

Limit LIMIT_MAX_STORAGE_IMAGES_PER_SHADER_STAGE = 18

每个着色器阶段的最大存储图像数。

Limit LIMIT_MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE = 19

单个 uniform 集的最大 uniform 缓冲数量。

Limit LIMIT_MAX_PUSH_CONSTANT_SIZE = 20

推送常量的最大大小。许多设备都有 128 字节的限制，所以即便你的 GPU 汇报的值更大，也请尝试避免让推送常量超过 127 字节，从而确保兼容性。

Limit LIMIT_MAX_UNIFORM_BUFFER_SIZE = 21

Uniform 缓冲的最大大小。

Limit LIMIT_MAX_VERTEX_INPUT_ATTRIBUTE_OFFSET = 22

顶点输入属性的最大偏移。

Limit LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES = 23

顶点输入属性的最大数量。

Limit LIMIT_MAX_VERTEX_INPUT_BINDINGS = 24

顶点输入绑定的最大数量。

Limit LIMIT_MAX_VERTEX_INPUT_BINDING_STRIDE = 25

顶点输入绑定的最大步幅。

Limit LIMIT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 26

Uniform 缓冲的最小偏移对齐。

Limit LIMIT_MAX_COMPUTE_SHARED_MEMORY_SIZE = 27

计算着色器的最大共享内存大小。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X = 28

计算着色器在 X 轴上的最大工作组数量。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y = 29

计算着色器在 Y 轴上的最大工作组数量。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z = 30

计算着色器在 Z 轴上的最大工作组数量。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_INVOCATIONS = 31

计算着色器的最大工作组调用数量。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X = 32

计算着色器在 X 轴上的最大工作组大小。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y = 33

计算着色器在 Y 轴上的最大工作组大小。

Limit LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z = 34

计算着色器在 Z 轴上的最大工作组大小。

Limit LIMIT_MAX_VIEWPORT_DIMENSIONS_X = 35

视口的最大宽度（单位为像素）。

Limit LIMIT_MAX_VIEWPORT_DIMENSIONS_Y = 36

视口的最大高度（单位为像素）。

Limit LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE = 46

返回使用 MetalFX 时间图像放大器时 ProjectSettings.rendering/scaling_3d/scale 的最小值。

注意：返回值已与 1000000 相乘，从而保留了 6 位精度。必须将其除以 1000000.0 转换为浮点数。

Limit LIMIT_METALFX_TEMPORAL_SCALER_MAX_SCALE = 47

返回使用 MetalFX 时间图像放大器时 ProjectSettings.rendering/scaling_3d/scale 的最大值。

注意：返回值已与 1000000 相乘，从而保留了 6 位精度。必须将其除以 1000000.0 转换为浮点数。

enum MemoryType: 🔗

MemoryType MEMORY_TEXTURES = 0

纹理占用的内存。

MemoryType MEMORY_BUFFERS = 1

缓冲区占用的内存。

MemoryType MEMORY_TOTAL = 2

内存中占用。比 MEMORY_TEXTURES 和 MEMORY_BUFFERS 的总和要大，因为还会包含其他杂项内存占用。

enum BreadcrumbMarker: 🔗

BreadcrumbMarker NONE = 0

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker REFLECTION_PROBES = 65536

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker SKY_PASS = 131072

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker LIGHTMAPPER_PASS = 196608

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker SHADOW_PASS_DIRECTIONAL = 262144

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker SHADOW_PASS_CUBE = 327680

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker OPAQUE_PASS = 393216

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker ALPHA_PASS = 458752

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker TRANSPARENT_PASS = 524288

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker POST_PROCESSING_PASS = 589824

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker BLIT_PASS = 655360

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker UI_PASS = 720896

该枚举目前没有描述，请帮我们贡献一个吧！

BreadcrumbMarker DEBUG_PASS = 786432

该枚举目前没有描述，请帮我们贡献一个吧！

flags DrawFlags: 🔗

DrawFlags DRAW_DEFAULT_ALL = 0

不清空和忽略任何附件。

DrawFlags DRAW_CLEAR_COLOR_0 = 1

清空第一个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_1 = 2

清空第二个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_2 = 4

清空第三个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_3 = 8

清空第四个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_4 = 16

清空第五个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_5 = 32

清空第六个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_6 = 64

清空第七个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_7 = 128

清空第八个颜色附件。

DrawFlags DRAW_CLEAR_COLOR_MASK = 255

表示清空所有颜色附件的掩码。

DrawFlags DRAW_CLEAR_COLOR_ALL = 255

清空所有颜色附件。

DrawFlags DRAW_IGNORE_COLOR_0 = 256

忽略第一个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_1 = 512

忽略第二个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_2 = 1024

忽略第三个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_3 = 2048

忽略第四个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_4 = 4096

忽略第五个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_5 = 8192

忽略第六个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_6 = 16384

忽略第七个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_7 = 32768

忽略第八个颜色附件中先前的内容。

DrawFlags DRAW_IGNORE_COLOR_MASK = 65280

表示忽略所有颜色附件中先前内容的掩码。

DrawFlags DRAW_IGNORE_COLOR_ALL = 65280

忽略所有颜色附件中先前的内容。

DrawFlags DRAW_CLEAR_DEPTH = 65536

清空深度附件。

DrawFlags DRAW_IGNORE_DEPTH = 131072

忽略深度附件中先前的内容。

DrawFlags DRAW_CLEAR_STENCIL = 262144

清空模板附件。

DrawFlags DRAW_IGNORE_STENCIL = 524288

忽略模板附件中先前的内容。

DrawFlags DRAW_CLEAR_ALL = 327935

清空所有附件。

DrawFlags DRAW_IGNORE_ALL = 720640

忽略所有附件中先前的内容。

常量

INVALID_ID = -1 🔗

返回 ID 的函数会在值无效时返回此值。

INVALID_FORMAT_ID = -1 🔗

返回格式 ID 的函数会在值无效时返回此值。

方法说明

void barrier(from: BitField[BarrierMask] = 32767, to: BitField[BarrierMask] = 32767) 🔗

已弃用： Barriers are automatically inserted by RenderingDevice.

这个方法什么也不做。

Error buffer_clear(buffer: RID, offset: int, size_bytes: int) 🔗

清除 buffer 的内容，清除的是从 offset 开始的 size_bytes 个字节。

出现以下情况时会输出错误：

大小不是四的倍数
offset + size_bytes 指定的区域超出缓冲区
绘制列表当前处于活动状态（由 draw_list_begin() 创建）
计算列表当前处于活动状态（由 compute_list_begin() 创建）

Error buffer_copy(src_buffer: RID, dst_buffer: RID, src_offset: int, dst_offset: int, size: int) 🔗

将 src_buffer 中从 src_offset 开始的 size 个字节复制到 dst_buffer 中的 dst_offset 位置。

出现以下情况时会输出错误：

size 个字节在 src_buffer 或 dst_buffer 中对应位置上会超出边界
绘制列表当前处于活动状态（由 draw_list_begin() 创建）
计算列表当前处于活动状态（由 compute_list_begin() 创建）

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

返回指定 buffer 中数据的副本，还可以设置 offset_bytes 和 size_bytes，仅复制缓冲区的某一部分。

注意：该方法将在获取到数据前阻塞 GPU 的工作。请参考 buffer_get_data_async()，该方法可以更高效地返回数据。

Error buffer_get_data_async(buffer: RID, callback: Callable, offset_bytes: int = 0, size_bytes: int = 0) 🔗

buffer_get_data() 的异步版本。RenderingDevice 将在一定帧数内调用 callback，提供请求时缓冲中的数据。

注意：目前延迟对应 ProjectSettings.rendering/rendering_device/vsync/frame_queue_size 中指定的帧数。

注意：下载较大的缓冲可能会因硬件带宽限制而对实时性能产生巨大的影响，即便使用异步方法也是如此。在处理大型资源时，你可以调整 ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb 等设置，用额外的内存换取传输速度的提升。

func _buffer_get_data_callback(array):
    value = array.decode_u32(0)

...

rd.buffer_get_data_async(buffer, _buffer_get_data_callback)

int buffer_get_device_address(buffer: RID) 🔗

返回缓冲区 buffer 的地址，该地址可以以任何方式传递给着色器，从而访问底层数据。创建缓冲区时必须启用该功能。

注意：你必须通过调用 has_feature() 并将 SUPPORTS_BUFFER_DEVICE_ADDRESS 作为参数传递来检查 GPU 是否支持此功能。

Error buffer_update(buffer: RID, offset: int, size_bytes: int, data: PackedByteArray) 🔗

使用指定的 data 更新缓冲区中从 offset 开始的 size_bytes 个字节的区块。

出现以下情况时会输出错误：

offset + size_bytes 指定的区块超出缓冲区
绘制列表当前处于活动状态（由 draw_list_begin() 创建）
计算列表当前处于活动状态（由 compute_list_begin() 创建）

void capture_timestamp(name: String) 🔗

使用指定的名称 name 创建时间戳标记。用于 get_captured_timestamp_cpu_time()、get_captured_timestamp_gpu_time()、get_captured_timestamp_name() 等方法的性能汇报。

void compute_list_add_barrier(compute_list: int) 🔗

在指定的 compute_list 中引发 Vulkan 计算屏障。

int compute_list_begin() 🔗

开始由 compute_* 方法创建的计算命令列表。应该将返回值传递给其他 compute_list_* 函数。

无法同时创建多个计算列表；你必须先使用 compute_list_end() 把之前的计算列表完成。

简易的计算操作类似于下面这样（代码不是完整的示例）：

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)
    # 没有屏障，一起执行。

rd.compute_list_end()

void compute_list_bind_compute_pipeline(compute_list: int, compute_pipeline: RID) 🔗

告诉 GPU 在处理计算列表时使用什么计算管道。如果自上次调用该函数以来着色器发生了更改，Godot 将取消绑定所有描述符集，并在 compute_list_dispatch() 中重新绑定它们。

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

将 uniform_set 绑定到该 compute_list。Godot 确保统一集中的所有纹理都具有正确的 Vulkan 访问蒙版。如果 Godot 必须更改纹理的访问蒙版，则会引发 Vulkan 图像内存障碍。

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

将计算列表提交给 GPU 处理。相当于是计算版本的 draw_list_draw()。

void compute_list_dispatch_indirect(compute_list: int, buffer: RID, offset: int) 🔗

提交计算列表以供 GPU 处理，其中给定的组计数存储在 buffer 中的 offset 处。必须使用 STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT 标志创建缓冲区。

void compute_list_end() 🔗

结束由 compute_* 方法创建的计算命令列表。

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

为指定的 compute_list 设置 buffer 的推送常量数据。如何使用这个二进制数据由着色器决定。另外还必须在 size_bytes 中指定缓冲的字节大小（可以通过对 buffer 调用 PackedByteArray.size() 获取）。

RID compute_pipeline_create(shader: RID, specialization_constants: Array[RDPipelineSpecializationConstant] = []) 🔗

新建计算管线。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

bool compute_pipeline_is_valid(compute_pipeline: RID) 🔗

如果由 compute_pipeline RID 指定的计算管线有效，则返回 true，否则返回 false。

RenderingDevice create_local_device() 🔗

新建局部 RenderingDevice。主要用于在 GPU 上执行计算操作，独立于引擎的其他部分。

void draw_command_begin_label(name: String, color: Color) 🔗

创建命令缓冲调试标签区域，能够在 RenderDoc 等第三方工具中显示。所有的区域都应该调用 draw_command_end_label() 结束。观察单个队列的线性提交序列时，draw_command_begin_label() 必须有与之对应的 draw_command_end_label()。

Vulkan 扩展 VK_EXT_DEBUG_UTILS_EXTENSION_NAME 必须可用并启用，这样命令缓冲调试标签区域才能正常工作。另见 draw_command_end_label()。

void draw_command_end_label() 🔗

结束命令缓冲调试标签区域，该区域由 draw_command_begin_label() 调用开启。

void draw_command_insert_label(name: String, color: Color) 🔗

已弃用： Inserting labels no longer applies due to command reordering.

这个方法什么也不做。

int draw_list_begin(framebuffer: RID, draw_flags: BitField[DrawFlags] = 0, clear_color_values: PackedColorArray = PackedColorArray(), clear_depth_value: float = 1.0, clear_stencil_value: int = 0, region: Rect2 = Rect2(0, 0, 0, 0), breadcrumb: int = 0) 🔗

开始栅格绘图命令列表，命令由 draw_* 方法创建。返回值应当传递给其他 draw_list_* 函数。

同一时间无法创建多个绘图列表；必须先使用 draw_list_end() 结束之前的绘图列表。

简易绘图操作类似这样（代码并非完整示例）：

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.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS)

# 实心绘图。
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)
# 线框绘图。
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()

draw_flags 表示应将帧缓冲的纹理附件清空还是忽略。每个独立的附件都只能在这两个标志中二选一。忽略附件就是完全丢弃绘图列表之前已存在的内容，能够降低渲染阶段所使用的内存带宽，但如果没有对像素进行替换就会出现垃圾结果。默认行为能够让引擎判断纹理可丢弃时的正确操作，可以提升性能。见 RDTextureFormat 或 texture_set_discardable()。

面包屑参数 breadcrumb 可以是任意 32 位整数，适用于诊断 GPU 崩溃。如果 Godot 使用开发模式或调试模式构建，GPU 崩溃时 Godot 就会转储崩溃时正在执行的所有着色器，可以使用面包屑来诊断这些着色器分别属于哪个阶段。

该参数不会影响渲染行为，可以设为 0。建议使用 BreadcrumbMarker 枚举保持一致，不过不强制。还可以使用按位操作添加额外的数据。例如：

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

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

draw_list_begin() 的高阶变体，会针对绘制到 screen ID 指定的窗口上自动调整参数。

注意：局部 RenderingDevice 没有屏幕，所以无法使用。如果在局部 RenderingDevice 上调用，draw_list_begin_for_screen() 会返回 INVALID_ID。

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

已弃用： Split draw lists are used automatically by RenderingDevice.

该方法不执行任何操作，并且始终返回空的 PackedInt64Array。

void draw_list_bind_index_array(draw_list: int, index_array: RID) 🔗

将 index_array 绑定到指定的 draw_list。

void draw_list_bind_render_pipeline(draw_list: int, render_pipeline: RID) 🔗

将 render_pipeline 绑定到指定的 draw_list。

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

将 uniform_set 绑定到指定的 draw_list。还必须指定 set_index，这是从 0 开始的标识符，必须与绘制列表中所需要的相匹配。

void draw_list_bind_vertex_array(draw_list: int, vertex_array: RID) 🔗

将 vertex_array 绑定到指定的 draw_list。

void draw_list_disable_scissor(draw_list: int) 🔗

为指定的 draw_list 移除并禁用裁剪矩形。另见 draw_list_enable_scissor()。

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

将 draw_list 提交给 GPU 渲染。相当于是栅格版本的 compute_list_dispatch()。

void draw_list_draw_indirect(draw_list: int, use_indices: bool, buffer: RID, offset: int = 0, draw_count: int = 1, stride: int = 0) 🔗

将 draw_list 提交给 GPU 处理，参数位于缓冲区 buffer 的偏移 offset 处。参数为整数：顶点数、实例数、首个顶点、首个实例。使用索引时则为：索引数、实例数、首个索引、顶点偏移、首个实例。创建缓冲区时必须使用 STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT 标志。

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

创建裁剪矩形并为指定的 draw_list 启用。裁剪矩形可以用来实现裁剪，会丢弃落在屏幕上指定矩形范围之外的片段。另见 draw_list_disable_scissor()。

注意：指定的 rect 会自动与屏幕尺寸求交集，也就是说裁剪矩形无法超出屏幕的范围。

void draw_list_end() 🔗

结束由 draw_* 方法创建的栅格绘图命令列表。

void draw_list_set_blend_constants(draw_list: int, color: Color) 🔗

将指定 draw_list 的混合常量设置为 color。创建图形管线时设置了 DYNAMIC_STATE_BLEND_CONSTANTS 标志时才会使用混合常量。

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

为指定的 draw_list 设置 buffer 的推送常量数据。如何使用这个二进制数据由着色器决定。另外还必须在 size_bytes 中指定缓冲的字节大小（可以通过对 buffer 调用 PackedByteArray.size() 获取）。

int draw_list_switch_to_next_pass() 🔗

切换到下一个绘制阶段。

PackedInt64Array draw_list_switch_to_next_pass_split(splits: int) 🔗

已弃用： Split draw lists are used automatically by RenderingDevice.

该方法不执行任何操作，并且始终返回空的 PackedInt64Array。

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

新建帧缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

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

新建空的帧缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

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

新建多阶段帧缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

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

新建帧缓冲格式，附件为 attachments、视图数为 view_count。返回的是新帧缓冲的唯一帧缓冲格式 ID。

如果 view_count 大于等于 2，则会针对 VR 渲染启用多视图。要求支持 Vulkan 的多视图扩展。

int framebuffer_format_create_empty(samples: TextureSamples = 0) 🔗

新建空的帧缓冲格式并返回其 ID，采样数为 samples。

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

创建多阶段帧缓冲格式并返回其 ID，附件为 attachments、阶段数为 passes、视图数为 view_count。如果 view_count 大于等于 2，则会针对 VR 渲染启用多视图。要求支持 Vulkan 的多视图扩展。

TextureSamples framebuffer_format_get_texture_samples(format: int, render_pass: int = 0) 🔗

返回给定帧缓冲格式 ID format 所使用的纹理采样数量（格式由 framebuffer_get_format() 返回）。

int framebuffer_get_format(framebuffer: RID) 🔗

返回由帧缓冲 RID framebuffer 指定的帧缓冲的格式 ID。相同格式下，这个 ID 一定是唯一的，不需要释放。

bool framebuffer_is_valid(framebuffer: RID) const 🔗

返回由帧缓冲 RID framebuffer 指定的帧缓冲有效，则返回 true，否则返回 false。

void free_rid(rid: RID) 🔗

尝试释放 RenderingDevice 中的某个对象。为了防止内存泄漏，对象使用完后就应该调用这个方法，因为直接使用 RenderingDevice 时并不会自动进行内存管理。

void full_barrier() 🔗

已弃用： Barriers are automatically inserted by RenderingDevice.

这个方法什么也不做。

int get_captured_timestamp_cpu_time(index: int) const 🔗

返回渲染步骤的 CPU 时间戳（引擎启动后经过的毫秒数），渲染步骤由 index 指定。另见 get_captured_timestamp_gpu_time() 和 capture_timestamp()。

int get_captured_timestamp_gpu_time(index: int) const 🔗

返回渲染步骤的 GPU 时间戳（引擎启动后经过的毫秒数），渲染步骤由 index 指定。另见 get_captured_timestamp_cpu_time() 和 capture_timestamp()。

String get_captured_timestamp_name(index: int) const 🔗

返回渲染步骤的时间戳的名称，渲染步骤由 index 指定。另见 capture_timestamp()。

int get_captured_timestamps_count() const 🔗

返回能够进行性能分析的时间戳（渲染步骤）总数。

int get_captured_timestamps_frame() const 🔗

返回能够进行渲染时间戳查询的最后一个渲染帧的索引。

int get_device_allocation_count() const 🔗

返回 GPU 为内部驱动器结构进行了多少次分配。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

int get_device_allocs_by_object_type(type: int) const 🔗

与 get_device_allocation_count() 相同，但是根据给定对象类型进行了过滤。

类型参数必须在 [0; get_tracked_object_type_count - 1] 的范围内。如果 get_tracked_object_type_count() 为 0，则会忽略类型参数并始终返回 0。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

int get_device_memory_by_object_type(type: int) const 🔗

与 get_device_total_memory() 相同，但是根据给定对象类型进行了过滤。

类型参数必须在 [0; get_tracked_object_type_count - 1] 的范围内。如果 get_tracked_object_type_count() 为 0，则会忽略类型参数并始终返回 0。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

String get_device_name() const 🔗

返回视频适配器的名称（例如 "GeForce GTX 1080/PCIe/SSE2"）。等价于 RenderingServer.get_video_adapter_name()。另见 get_device_vendor_name()。

String get_device_pipeline_cache_uuid() const 🔗

返回管线缓存的通用唯一标识符。用于将着色器文件缓存到磁盘，避免后续运行引擎时进行着色器的重新编译。这个 UUID 会根据显卡型号以及驱动版本的不同而不同。因此，更新图形驱动会使着色器缓存失效。

int get_device_total_memory() const 🔗

返回 GPU 使用了多少字节。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

String get_device_vendor_name() const 🔗

返回视频适配器的供应商（例如 "NVIDIA Corporation"）。等价于 RenderingServer.get_video_adapter_vendor()。另见 get_device_name()。

int get_driver_allocation_count() const 🔗

返回 GPU 驱动器为内部驱动器结构进行了多少次分配。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

int get_driver_allocs_by_object_type(type: int) const 🔗

与 get_driver_allocation_count() 相同，但是根据给定对象类型进行了过滤。

类型参数必须在 [0; get_tracked_object_type_count - 1] 的范围内。如果 get_tracked_object_type_count() 为 0，则会忽略类型参数并始终返回 0。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

String get_driver_and_device_memory_report() const 🔗

返回 CSV 格式的报告字符串，使用以下方法：

get_tracked_object_name()
get_tracked_object_type_count()
get_driver_total_memory()
get_driver_allocation_count()
get_driver_memory_by_object_type()
get_driver_allocs_by_object_type()
get_device_total_memory()
get_device_allocation_count()
get_device_memory_by_object_type()
get_device_allocs_by_object_type()

仅在调试构建中由 Vulkan 使用，同时 Godot 必须使用 --extra-gpu-memory-tracking 命令行参数启动。

int get_driver_memory_by_object_type(type: int) const 🔗

与 get_driver_total_memory() 相同，但是根据给定对象类型进行了过滤。

类型参数必须在 [0; get_tracked_object_type_count - 1] 的范围内。如果 get_tracked_object_type_count() 为 0，则会忽略类型参数并始终返回 0。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

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

返回指定 rid 的驱动资源 resource 的唯一标识符。部分驱动资源类型会忽略指定的 rid（说明见 DriverResource）。index 始终会被忽略，但仍然必须指定。

int get_driver_total_memory() const 🔗

返回 GPU 驱动器为内部驱动器结构使用了多少字节。

只有调试构建下的 Vulkan 会用到，未跟踪此信息或信息未知时可能返回 0。

int get_frame_delay() const 🔗

返回图形 API 所记录的帧数。值越高输入延迟就越高，但吞吐量也更一致。对于主 RenderingDevice 而言，帧会进行循环（启用三缓冲垂直同步时通常为 3）。但是局部 RenderingDevice 只有 1 帧。

int get_memory_usage(type: MemoryType) const 🔗

返回与类型 type 对应的内存用量，单位为字节。使用 Vulkan 时，会通过 Vulkan Memory Allocator 计算这些统计信息。

String get_perf_report() const 🔗

返回上一帧的性能报告字符串。每一帧都会更新。

String get_tracked_object_name(type_index: int) const 🔗

返回类索引 type_index 对应的对象类型名称。该值必须在 [0; get_tracked_object_type_count - 1] 范围内。如果 get_tracked_object_type_count() 为 0，则会忽略类型参数，始终返回相同的字符串。

返回值的重要性在于它为传递给 get_driver_memory_by_object_type()、get_driver_allocs_by_object_type()、get_device_memory_by_object_type()、get_device_allocs_by_object_type() 的类型赋予了含义。能够返回的字符串示例（不限于以下示例）：

DEVICE_MEMORY
PIPELINE_CACHE
SWAPCHAIN_KHR
COMMAND_POOL

因此，如果 get_tracked_object_name(5) 返回的是“COMMAND_POOL”，那么 get_device_memory_by_object_type(5) 返回的就是 GPU 为命令池所使用的字节数。

该函数仅在调试构建中由 Vulkan 使用。Godot 也必须使用 --extra-gpu-memory-tracking 命令行参数启动。

int get_tracked_object_type_count() const 🔗

返回可追踪对象的类型数量。

仅在调试构建中由 Vulkan 使用。Godot 也必须使用 --extra-gpu-memory-tracking 命令行参数启动。

bool has_feature(feature: Features) const 🔗

如果 GPU 支持 feature 特性，则返回 true。

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

新建索引数组。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

RID index_buffer_create(size_indices: int, format: IndexBufferFormat, data: PackedByteArray = PackedByteArray(), use_restart_indices: bool = false, creation_bits: BitField[BufferCreationBits] = 0) 🔗

新建索引缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

int limit_get(limit: Limit) const 🔗

返回指定 limit 的值。这个极限值取决于当前的图形硬件（有时也和驱动版本有关）。如果超出了给定的极限，则会发生渲染错误。

各种图形硬件的极限可以在 Vulkan 硬件数据库中找到。

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

新建渲染管线。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

bool render_pipeline_is_valid(render_pipeline: RID) 🔗

如果由 render_pipeline RID 指定的渲染管线有效则返回 true，否则返回 false。

RID sampler_create(state: RDSamplerState) 🔗

新建采样器。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

bool sampler_is_format_supported_for_filter(format: DataFormat, sampler_filter: SamplerFilter) const 🔗

如果实现支持使用格式为 format 和 sampler_filter 采样过滤的纹理，则返回 true。

int screen_get_framebuffer_format(screen: int = 0) const 🔗

返回给定屏幕的帧缓冲的格式。

注意：只有 RenderingServer.get_rendering_device() 返回的主 RenderingDevice 有格式。对局部 RenderingDevice 调用时，这个方法会输出错误并返回 INVALID_ID。

int screen_get_height(screen: int = 0) const 🔗

返回与给定窗口 ID 图形 API 上下文相匹配的窗口高度（单位为像素）。虽然参数的名字叫 screen，但返回的是窗口的大小。另见 screen_get_width()。

注意：只有 RenderingServer.get_rendering_device() 返回的主 RenderingDevice 有高度。如果对局部 RenderingDevice 调用，则会输出错误并返回 INVALID_ID。

int screen_get_width(screen: int = 0) const 🔗

返回与给定窗口 ID 图形 API 上下文相匹配的窗口宽度（单位为像素）。虽然参数的名字叫 screen，但返回的是窗口的大小。另见 screen_get_height()。

注意：只有 RenderingServer.get_rendering_device() 返回的主 RenderingDevice 有宽度。如果对局部 RenderingDevice 调用，则会输出错误并返回 INVALID_ID。

void set_resource_name(id: RID, name: String) 🔗

将 ID 为 id 的资源名称设置为 name。用于使用 RenderDoc 等第三方工具进行调试。

可以为以下类型的资源命名：纹理、采样器、顶点缓冲、索引缓冲、uniform 缓冲、纹理缓冲、存储缓冲、uniform 集缓冲、着色器、渲染管线、计算管线。无法为帧缓冲命名。尝试为不兼容的资源类型命名会输出错误。

注意：引擎以详细模式运行时（OS.is_stdout_verbose() = true），或者使用 dev_mode=yes SCons 选项编译引擎构建时，才会设置资源的名称。图形驱动也必须支持 Vulkan 扩展 VK_EXT_DEBUG_UTILS_EXTENSION_NAME 具名资源才能正常工作。

PackedByteArray shader_compile_binary_from_spirv(spirv_data: RDShaderSPIRV, name: String = "") 🔗

从 spirv_data 编译二进制着色器，并将编译得到的二进制数据以 PackedByteArray 的形式返回。编译后的着色器与所使用的 GPU 型号和驱动版本对应；无法在不同的 GPU 型号甚至不同的驱动版本上正常工作。另见 shader_compile_spirv_from_source()。

name 是可选的人类可读名称，会给予编译后的着色器，方便组织。

RDShaderSPIRV shader_compile_spirv_from_source(shader_source: RDShaderSource, allow_cache: bool = true) 🔗

将 shader_source 中的着色器源代码编译为 RDShaderSPIRV 形式的 SPIR-V。这种中间语言的着色器可以在不同 GPU 型号和驱动版本之间移植，但无法直接在 GPU 上运行，需要先使用 shader_compile_binary_from_spirv() 编译为二进制着色器。

如果 allow_cache 为 true，则会使用 Godot 生成的着色器缓存。如果着色器已经在缓存中，这样就可能避免冗长的着色器编译步骤。allow_cache 为 false，则会忽略 Godot 的着色器缓存，始终重新编译着色器。

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

根据二进制的已编译着色器创建新的着色器实例。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingDevice 的 free_rid() 方法进行释放。另见 shader_compile_binary_from_spirv() 和 shader_create_from_spirv()。

RID shader_create_from_spirv(spirv_data: RDShaderSPIRV, name: String = "") 🔗

根据 SPIR-V 中间代码创建新的着色器实例。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingDevice 的 free_rid() 方法进行释放。另见 shader_compile_spirv_from_source() 和 shader_create_from_bytecode()。

RID shader_create_placeholder() 🔗

通过分配 RID 来创建占位符 RID，而不对其进行初始化以供在 shader_create_from_bytecode() 中使用。这允许你为着色器创建 RID 并传递它，但将着色器的编译推迟到以后的时间。

int shader_get_vertex_input_attribute_mask(shader: RID) 🔗

返回内部顶点输入掩码。在内部，顶点输入掩码是一个无符号整数，由输入变量（在 GLSL 中通过 in 关键字指定）的位置（在 GLSL 中通过 layout(location = ...) 指定）组成。

RID storage_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), usage: BitField[StorageBufferUsage] = 0, creation_bits: BitField[BufferCreationBits] = 0) 🔗

创建带有指定数据 data 用法为 usage 的存储缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

void submit() 🔗

推送帧设置与绘图命令缓冲，然后将局部设备标记为当前正在处理（这样就能够调用 sync()）。

注意：仅在局部 RenderingDevice 上可用。

void sync() 🔗

让 CPU 与 GPU 进行强制同步，部分场合可能需要进行这样的操作。请只在需要时调用，因为 CPU 与 GPU 的同步存在性能开销。

注意：仅在局部 RenderingDevice 上可用。

注意：只能在 submit() 后调用 sync()。

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

新建纹理缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

Error texture_clear(texture: RID, color: Color, base_mipmap: int, mipmap_count: int, base_layer: int, layer_count: int) 🔗

将指定的 texture 清屏，将所有像素替换为指定的颜色 color。base_mipmap 和 mipmap_count 决定该清屏操作影响纹理的哪些 mipmap，而 base_layer 和 layer_count 决定该清屏操作影响 3D 纹理（或纹理数组）的哪几层。如果是 2D 纹理（本来就只有一层），则 base_layer 必须为 0，layer_count 必须为 1。

注意：如果使用 texture 的绘图列表是创建的帧缓冲的一部分，则该纹理不能被清屏。确保绘图列表释放后（并且使用它的颜色和深度纹理没有被设为 FINAL_ACTION_CONTINUE）才能对该纹理做清屏操作。

Error texture_copy(from_texture: RID, to_texture: RID, from_pos: Vector3, to_pos: Vector3, size: Vector3, src_mipmap: int, dst_mipmap: int, src_layer: int, dst_layer: int) 🔗

将 from_texture 复制到 to_texture，使用指定的 from_pos、to_pos 和 size 坐标。对于二维纹理，from_pos、to_pos 和 size 的 Z 轴必须为 0。来源和目标的 mipmap/图层也必须指定，对于没有 mipmap 或单层纹理的情况，这些参数应为 0。如果纹理复制成功，则返回 @GlobalScope.OK，否则返回 @GlobalScope.ERR_INVALID_PARAMETER。

注意：如果使用 from_texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法复制。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后再复制纹理。

注意：from_texture 纹理需要获取 TEXTURE_USAGE_CAN_COPY_FROM_BIT。

注意：如果使用 to_texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法复制。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后再复制纹理。

注意：to_texture 纹理需要获取 TEXTURE_USAGE_CAN_COPY_TO_BIT。

注意：from_texture 和 to_texture 的类型必须相同（颜色或深度）。

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

新建纹理。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

注意：请勿与 RenderingServer.texture_2d_create() 混淆，后者创建的是 Godot 专属的 Texture2D 资源，不是图形 API 自己的纹理类型。

RID texture_create_from_extension(type: TextureType, format: DataFormat, samples: TextureSamples, usage_flags: BitField[TextureUsageBits], image: int, width: int, height: int, depth: int, layers: int) 🔗

使用给定的 type、format、samples、usage_flags、width、height、depth 和 layers 返回已有 image（VkImage）的 RID。这可被用于允许 Godot 渲染到外部图像上。

RID texture_create_shared(view: RDTextureView, with_texture: RID) 🔗

使用指定的 view 和 with_texture 中的纹理信息创建共享纹理。

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

使用视图 view 和纹理 with_texture 中 layer 和 mipmap 的信息创建共享纹理。包含的原始纹理中的 mipmap 数可以使用 mipmaps 参数控制。仅适用于 3D 纹理、纹理数组、立方体贴图等多层纹理。单层纹理请使用 texture_create_shared()。

如果是 2D 纹理（只有一层），则 layer 必须为 0。

注意：只有 2D 纹理数组支持层切片，3D 纹理和立方体贴图不支持。

PackedByteArray texture_get_data(texture: RID, layer: int) 🔗

将纹理 texture 中指定层 layer 的纹理数据以原始二进制数据的形式返回。2D 纹理（只有一层）的 layer 必须为 0。

注意：如果使用 texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法获取。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后获取纹理。否则会输出错误并返回空的 PackedByteArray。

注意：texture 纹理需要获取 TEXTURE_USAGE_CAN_COPY_FROM_BIT。否则会输出错误并返回空的 PackedByteArray。

注意：该方法将在获取到数据前阻塞 GPU 的工作。请参考 texture_get_data_async()，该方法可以更高效地返回数据。

Error texture_get_data_async(texture: RID, layer: int, callback: Callable) 🔗

texture_get_data() 的异步版本。RenderingDevice 将在一定帧数内调用 callback，提供请求时纹理中的数据。

注意：目前延迟对应 ProjectSettings.rendering/rendering_device/vsync/frame_queue_size 中指定的帧数。

注意：下载较大的纹理可能会因硬件带宽限制而对实时性能产生巨大的影响，即便使用异步方法也是如此。在处理大型资源时，你可以调整 ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb 等设置，用额外的内存换取传输速度的提升。

func _texture_get_data_callback(array):
    value = array.decode_u32(0)

...

rd.texture_get_data_async(texture, 0, _texture_get_data_callback)

RDTextureFormat texture_get_format(texture: RID) 🔗

返回用于创建该纹理的数据格式。

int texture_get_native_handle(texture: RID) 🔗

已弃用： Use get_driver_resource() with DRIVER_RESOURCE_TEXTURE instead.

返回该纹理对象的内部图形句柄。主要用于 GDExtension 与第三方 API 通讯。

注意：这个函数返回的是 uint64_t，内部映射到 GLuint（OpenGL）或 VkImage（Vulkan）。

bool texture_is_discardable(texture: RID) 🔗

如果 texture 可丢弃，则返回 true，否则返回 false。见 RDTextureFormat 或 texture_set_discardable()。

bool texture_is_format_supported_for_usage(format: DataFormat, usage_flags: BitField[TextureUsageBits]) const 🔗

如果指定的格式 format 支持给定的用途标志 usage_flags，则返回 true，否则返回 false。

bool texture_is_shared(texture: RID) 🔗

如果 texture 是共享纹理，则返回 true，否则返回 false。见 RDTextureView。

bool texture_is_valid(texture: RID) 🔗

如果 texture 有效，则返回 true，否则返回 false。

Error texture_resolve_multisample(from_texture: RID, to_texture: RID) 🔗

启用多重采样抗锯齿，将 from_texture 纹理溶解至 to_texture。启用后才能够正常渲染 MSAA 帧缓冲。成功时返回 @GlobalScope.OK，否则返回 @GlobalScope.ERR_INVALID_PARAMETER。

注意：from_texture 和 to_texture 的尺寸、格式、类型（颜色或深度）都必须相同。

注意：如果使用 from_texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法复制。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后再复制纹理。

注意：from_texture 纹理需要获取 TEXTURE_USAGE_CAN_COPY_FROM_BIT。

注意：from_texture 纹理必须为多重采样，并且必须为 2D 纹理（或者是 3D/立方体贴图纹理的切片）。

注意：如果使用 to_texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法复制。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后再溶解纹理。

注意：to_texture 纹理需要获取 TEXTURE_USAGE_CAN_COPY_TO_BIT。

注意：from_texture 纹理必须不能是多重采样，并且必须为 2D 纹理（或者是 3D/立方体贴图纹理的切片）。

void texture_set_discardable(texture: RID, discardable: bool) 🔗

更新纹理 texture 的可丢弃属性。

如果纹理可丢弃，则其内容不需要在帧与帧之间持久化。纹理用作绘图列表中的目标时，该标志才有意义。

RenderingDevice 会通过该信息判断纹理的内容是否可丢弃，从而消除不必要的内存写操作，提升性能。

Error texture_update(texture: RID, layer: int, data: PackedByteArray) 🔗

使用新的数据更新纹理数据，会原地替换之前的数据。更新后的纹理数据必须和原有尺寸、格式一致。2D 纹理（只有一层）的 layer 必须为 0。如果更新成功则返回 @GlobalScope.OK，否则返回 @GlobalScope.ERR_INVALID_PARAMETER。

注意：精致在创建绘图列表或计算列表时更新纹理。

注意：如果使用 texture 纹理的绘图列表是创建的帧缓冲的一部分，则无法更新。请确保绘图列表已经完成（并且使用它的颜色/深度纹理没有设置为 FINAL_ACTION_CONTINUE），然后再更新纹理。

注意：texture 纹理需要获取 TEXTURE_USAGE_CAN_UPDATE_BIT。

RID uniform_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), creation_bits: BitField[BufferCreationBits] = 0) 🔗

新建 uniform 缓冲。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingDevice 的 free_rid() 方法进行释放。

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

新建 uniform 集。可以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingDevice 的 free_rid() 方法进行释放。

bool uniform_set_is_valid(uniform_set: RID) 🔗

检查 uniform_set 是否有效，即是否有归属。

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

根据给定的缓冲区创建顶点数组。还可以为各个缓冲区定义偏移量 offsets（单位为字节）。

RID vertex_buffer_create(size_bytes: int, data: PackedByteArray = PackedByteArray(), creation_bits: BitField[BufferCreationBits] = 0) 🔗

以通过返回的 RID 进行访问。

RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。

int vertex_format_create(vertex_descriptions: Array[RDVertexAttribute]) 🔗

新建顶点描述为 vertex_descriptions 的顶点格式。返回与新建顶点格式对应的唯一格式 ID。