Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
RenderingServer
继承： Object
任何可见的东西的服务器。
描述
渲染服务器是所有可见内容的 API 后端。整个场景系统都挂载在它上面来显示。渲染服务器是完全不透明的：内部实现完全取决于具体的实现，无法进行访问。
使用渲染服务器可以完全绕过场景和 Node 系统。如果场景系统是瓶颈所在，那么这样做就可以提升性能，否则无法提升性能（例如已经完全利用 GPU 的情况）。
资源是使用 *_create 函数创建的。这些函数返回的 RID 并不是对对象本身的引用，而是指向这些对象的不透明指针。
所有对象都会被绘制到视口中。你可以使用附加到 SceneTree 的 Viewport，或者也可以使用 viewport_create() 自行创建。使用自定义场景或画布时，需要使用 viewport_set_scenario() 或 viewport_attach_canvas() 将场景或画布附加到视口。
场景：在 3D 中，所有可视对象都必须与一个场景（Scenario）相关联。场景是世界的可视化表示。如果要从正在运行的游戏中访问渲染服务器，那么就可以使用 Node3D.get_world_3d() 从任何 Node3D 节点的场景树访问该场景。此外，也可以使用 scenario_create() 创建场景。
在 2D 中也是类似的，需要一个画布（Canvas）来绘制所有的画布项。
3D：在 3D 中，所有可视对象都由资源（Resource）和实例（Instance）组成。资源可以是网格、粒子系统、灯光或任何其他 3D 对象。为了使资源可见，必须使用 instance_set_base() 将其附加到一个实例。该实例还必须使用 instance_set_scenario() 附加到场景中才可见。不带前缀的 RenderingServer 方法通常都是针对 3D 的（但也有例外）。
2D：在 2D 中，所有可见对象都是某种形式的画布项（Canvas Item）。为了使画布项可见，就需要让它成为附加到视口的画布的子项，或者需要让它成为其他画布项的子项，但这些画布项最终也需要是画布的子项。针对 2D 的 RenderingServer 方法一般都以 canvas_* 开头。
无头模式：使用 --headless 命令行参数启动引擎将禁用所有渲染和窗口管理功能。在这种情况下，RenderingServer 中的大多数函数将返回虚设值。
教程
属性
方法
信号
frame_post_draw() 🔗
在该帧的结尾发出，此时 RenderingServer 刚刚完成对所有 Viewport 的更新。
frame_pre_draw() 🔗
在该帧的开头发出，此后 RenderingServer 会更新所有 Viewport。
枚举
enum TextureType: 🔗
TextureType TEXTURE_TYPE_2D = 0
2D 纹理。
TextureType TEXTURE_TYPE_LAYERED = 1
分层纹理。
TextureType TEXTURE_TYPE_3D = 2
3D 纹理。
enum TextureLayeredType: 🔗
TextureLayeredType TEXTURE_LAYERED_2D_ARRAY = 0
二维纹理数组（见 Texture2DArray）。
TextureLayeredType TEXTURE_LAYERED_CUBEMAP = 1
立方体贴图纹理（见 Cubemap）。
TextureLayeredType TEXTURE_LAYERED_CUBEMAP_ARRAY = 2
立方体贴图纹理数组（见 CubemapArray）。
enum CubeMapLayer: 🔗
CubeMapLayer CUBEMAP_LAYER_LEFT = 0
Cubemap 的左面。
CubeMapLayer CUBEMAP_LAYER_RIGHT = 1
Cubemap 的右面。
CubeMapLayer CUBEMAP_LAYER_BOTTOM = 2
Cubemap 的底面。
CubeMapLayer CUBEMAP_LAYER_TOP = 3
Cubemap 的顶面。
CubeMapLayer CUBEMAP_LAYER_FRONT = 4
Cubemap 的正面。
CubeMapLayer CUBEMAP_LAYER_BACK = 5
Cubemap 的背面。
enum ShaderMode: 🔗
ShaderMode SHADER_SPATIAL = 0
着色器是 3D 着色器。
ShaderMode SHADER_CANVAS_ITEM = 1
着色器是 2D 着色器。
ShaderMode SHADER_PARTICLES = 2
着色器是粒子着色器（2D 和 3D 均可使用）。
ShaderMode SHADER_SKY = 3
着色器是 3D 天空着色器。
ShaderMode SHADER_FOG = 4
着色器是 3D 雾着色器。
ShaderMode SHADER_MAX = 5
代表 ShaderMode 枚举的大小。
enum ArrayType: 🔗
ArrayType ARRAY_VERTEX = 0
数组是顶点位置数组。
ArrayType ARRAY_NORMAL = 1
数组是法线数组。
ArrayType ARRAY_TANGENT = 2
数组是切线数组。
ArrayType ARRAY_COLOR = 3
数组是顶点颜色数组。
ArrayType ARRAY_TEX_UV = 4
数组是 UV 坐标数组。
ArrayType ARRAY_TEX_UV2 = 5
数组是第二组 UV 坐标的 UV 坐标数组。
ArrayType ARRAY_CUSTOM0 = 6
数组是第一组自定义数据的自定义数据数组。
ArrayType ARRAY_CUSTOM1 = 7
数组是第二组自定义数据的自定义数据数组。
ArrayType ARRAY_CUSTOM2 = 8
数组是第三组自定义数据的自定义数据数组。
ArrayType ARRAY_CUSTOM3 = 9
数组是第四组自定义数据的自定义数据数组。
ArrayType ARRAY_BONES = 10
数组包含骨骼信息。
ArrayType ARRAY_WEIGHTS = 11
数组是重量信息。
ArrayType ARRAY_INDEX = 12
数组是索引数组。
ArrayType ARRAY_MAX = 13
代表 ArrayType 枚举的大小。
enum ArrayCustomFormat: 🔗
ArrayCustomFormat ARRAY_CUSTOM_RGBA8_UNORM = 0
自定义数据数组包含的是每通道 8 位的红、绿、蓝、Alpha 颜色数据。元素经过归一化，是 [0.0, 1.0] 范围内的无符号浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RGBA8_SNORM = 1
自定义数据数组包含的是每通道 8 位的红、绿、蓝、Alpha 颜色数据。元素经过归一化，是 [0.0, 1.0] 范围内的带符号浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RG_HALF = 2
自定义数据数组包含的是每通道 16 位的红、绿、蓝颜色数据。元素为半精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RGBA_HALF = 3
自定义数据数组包含的是每通道 16 位的红、绿、蓝、Alpha 颜色数据。元素为半精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_R_FLOAT = 4
自定义数据数组包含的是每通道 32 位的红色数据。元素为单精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RG_FLOAT = 5
自定义数据数组包含的是每通道 32 位的红、绿颜色数据。元素为单精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RGB_FLOAT = 6
自定义数据数组包含的是每通道 32 位的红、绿、蓝颜色数据。元素为单精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_RGBA_FLOAT = 7
自定义数据数组包含的是每通道 32 位的红、绿、蓝、Alpha 颜色数据。元素为单精度浮点数。
ArrayCustomFormat ARRAY_CUSTOM_MAX = 8
代表 ArrayCustomFormat 枚举的大小。
flags ArrayFormat: 🔗
ArrayFormat ARRAY_FORMAT_VERTEX = 1
用于标记顶点位置数组的标志。
ArrayFormat ARRAY_FORMAT_NORMAL = 2
用于标记法线数组的标志。
ArrayFormat ARRAY_FORMAT_TANGENT = 4
用于标记切线数组的标志。
ArrayFormat ARRAY_FORMAT_COLOR = 8
用于标记顶点颜色数组的标志。
ArrayFormat ARRAY_FORMAT_TEX_UV = 16
用于标记 UV 坐标数组的标志。
ArrayFormat ARRAY_FORMAT_TEX_UV2 = 32
用于标记第二个 UV 坐标的 UV 坐标数组的标志。
ArrayFormat ARRAY_FORMAT_CUSTOM0 = 64
用于标记第一组自定义数据的自定义顶点数据数组的标志。
ArrayFormat ARRAY_FORMAT_CUSTOM1 = 128
用于标记第二组自定义数据的自定义顶点数据数组的标志。
ArrayFormat ARRAY_FORMAT_CUSTOM2 = 256
用于标记第三组自定义数据的自定义顶点数据数组的标志。
ArrayFormat ARRAY_FORMAT_CUSTOM3 = 512
用于标记第四组自定义数据的自定义顶点数据数组的标志。
ArrayFormat ARRAY_FORMAT_BONES = 1024
用来标记骨骼信息数组的标志。
ArrayFormat ARRAY_FORMAT_WEIGHTS = 2048
用于标记重量数组的标记。
ArrayFormat ARRAY_FORMAT_INDEX = 4096
用于标记索引数组的标志。
ArrayFormat ARRAY_FORMAT_BLEND_SHAPE_MASK = 7
混合形状中允许使用的网格通道的掩码。
ArrayFormat ARRAY_FORMAT_CUSTOM_BASE = 13
第一个自定义通道的移位量。
ArrayFormat ARRAY_FORMAT_CUSTOM_BITS = 3
每个自定义通道的格式位数。请参阅 ArrayCustomFormat。
ArrayFormat ARRAY_FORMAT_CUSTOM0_SHIFT = 13
自定义通道索引 0 需要对 ArrayCustomFormat 进行的按位移动量。
ArrayFormat ARRAY_FORMAT_CUSTOM1_SHIFT = 16
自定义通道索引 1 需要对 ArrayCustomFormat 进行的按位移动量。
ArrayFormat ARRAY_FORMAT_CUSTOM2_SHIFT = 19
自定义通道索引 2 需要对 ArrayCustomFormat 进行的按位移动量。
ArrayFormat ARRAY_FORMAT_CUSTOM3_SHIFT = 22
自定义通道索引 3 需要对 ArrayCustomFormat 进行的按位移动量。
ArrayFormat ARRAY_FORMAT_CUSTOM_MASK = 7
每个自定义通道的自定义格式位掩码。必须按 SHIFT 常量之一进行移位。请参阅 ArrayCustomFormat。
ArrayFormat ARRAY_COMPRESS_FLAGS_BASE = 25
第一个压缩标志的移位。压缩标志应该被传递给 ArrayMesh.add_surface_from_arrays() 和 SurfaceTool.commit()。
ArrayFormat ARRAY_FLAG_USE_2D_VERTICES = 33554432
用于标记包含 2D 顶点的数组的标志。
ArrayFormat ARRAY_FLAG_USE_DYNAMIC_UPDATE = 67108864
网格数据将在 GLES 上使用 GL_DYNAMIC_DRAW 的标记索引。在 Vulkan 上未被使用。
ArrayFormat ARRAY_FLAG_USE_8_BONE_WEIGHTS = 134217728
用于标记数组使用 8 个骨骼权重而不是 4 个的标志。
ArrayFormat ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY = 268435456
用于标记网格没有顶点数组，而是使用索引和其他信息推断着色器中的顶点位置的标志。
ArrayFormat ARRAY_FLAG_COMPRESS_ATTRIBUTES = 536870912
用于标记网格正在使用的压缩的属性（顶点、法线、切线、UV）的标志。启用这种形式的压缩后，顶点位置将被打包到 RGBA16UNORM 属性中，并在顶点着色器中进行缩放。法线和切线将被打包到表示一个轴的 RG16UNORM 中，并在顶点的 A 通道中存储一个 16 位浮点数。UV 将使用 16 位标准化浮点数而不是完整的 32 位有符号浮点数。使用该压缩模式时，必须使用顶点、法线和切线或仅使用顶点。你无法使用没有切线的法线。如果可以的话，导入器将自动启用这种压缩。
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_BASE = 35
用于标记被用于存储网格版本的位的起始的标志。
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_SHIFT = 35
用于移动网格格式 int，以将版本带入最低位的标志。
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_1 = 0
用于记录版本引入之前先前网格版本所使用的格式的标志。
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_2 = 34359738368
用于记录第二次迭代的网格版本标志的标志。该版本与 ARRAY_FLAG_FORMAT_VERSION_1 之间的主要区别在于，该版本支持 ARRAY_FLAG_COMPRESS_ATTRIBUTES，并且在该版本中，顶点位置与法线和切线去交错。
ArrayFormat ARRAY_FLAG_FORMAT_CURRENT_VERSION = 34359738368
用于记录引擎期望的当前版本的标志。目前这与 ARRAY_FLAG_FORMAT_VERSION_2 相同。
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_MASK = 255
使用 ARRAY_FLAG_FORMAT_VERSION_SHIFT 将用于网格版本的位转移到位后，用于隔离这些位的标志。
enum PrimitiveType: 🔗
PrimitiveType PRIMITIVE_POINTS = 0
绘制的图元由点组成。
PrimitiveType PRIMITIVE_LINES = 1
绘制的图元由线组成。
PrimitiveType PRIMITIVE_LINE_STRIP = 2
绘制的图元由单条线带组成。
PrimitiveType PRIMITIVE_TRIANGLES = 3
绘制的图元由三角形组成。
PrimitiveType PRIMITIVE_TRIANGLE_STRIP = 4
绘制的图元由单条三角形带组成（最后 3 个顶点总是会构成三角形）。
PrimitiveType PRIMITIVE_MAX = 5
代表 PrimitiveType 枚举的大小。
enum BlendShapeMode: 🔗
BlendShapeMode BLEND_SHAPE_MODE_NORMALIZED = 0
混合形状是被归一化了的。
BlendShapeMode BLEND_SHAPE_MODE_RELATIVE = 1
混合形状是相对于基础的权重。
enum MultimeshTransformFormat: 🔗
MultimeshTransformFormat MULTIMESH_TRANSFORM_2D = 0
使用 Transform2D 存储 MultiMesh 变换。
MultimeshTransformFormat MULTIMESH_TRANSFORM_3D = 1
使用 Transform3D 存储 MultiMesh 变换。
enum MultimeshPhysicsInterpolationQuality: 🔗
MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_FAST = 0
MultiMesh 的物理插值优先考虑速度，然后才是质量。
MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_HIGH = 1
MultiMesh 的物理插值优先考虑质量，然后才是速度。
enum LightProjectorFilter: 🔗
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST = 0
光线投射器的最近邻过滤（用于像素风光线投射器）。渲染时不使用 mipmap，这意味着较远处的光线投射器看上去会很锐利，但会有颗粒状的图案。与使用 mipmap 的性能开销大致相同。
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR = 1
光线投射器的线性过滤（用于非像素风光线投射器）。渲染时不使用 mipmap，这意味着较远处的光线投射器看上去会很平滑，但会有模糊的效果。与使用 mipmap 的性能开销大致相同。
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS = 2
光线投射器的最近邻过滤（用于像素风光线投射器）。渲染时使用各向同性的 mipmap，这意味着较远处的光线投射器看上去会很平滑，但会有模糊的效果。与不使用 mipmap 的性能开销大致相同。
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS = 3
光线投射器的线性过滤（用于非像素风光线投射器）。渲染时使用各向同性的 mipmap，这意味着较远处的光线投射器看上去会很平滑，但会有模糊的效果。与不使用 mipmap 的性能开销大致相同。
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4
光线投射器的最近邻过滤（用于像素风光线投射器）。渲染时使用各向异性的 mipmap，这意味着光线投射器从斜角度观察会既平滑又锐利。比各向同性的 mipmap 更好看，但也更慢。各向异性的级别由 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 定义。
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5
光线投射器的线性过滤（用于非像素风光线投射器）。渲染时使用各向异性的 mipmap，这意味着光线投射器从斜角度观察会既平滑又锐利。比各向同性的 mipmap 更好看，但也更慢。各向异性的级别由 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 定义。
enum LightType: 🔗
LightType LIGHT_DIRECTIONAL = 0
方向（太阳/月亮）灯（见 DirectionalLight3D）。
LightType LIGHT_OMNI = 1
全向灯（见 OmniLight3D）。
LightType LIGHT_SPOT = 2
聚光灯（见 SpotLight3D）。
enum LightParam: 🔗
LightParam LIGHT_PARAM_ENERGY = 0
该灯光的能量倍数。
LightParam LIGHT_PARAM_INDIRECT_ENERGY = 1
该灯光的间接能量倍数（最终的间接能量为 LIGHT_PARAM_ENERGY * LIGHT_PARAM_INDIRECT_ENERGY）。
LightParam LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY = 2
该灯光的体积雾能量倍数（最终的体积雾能量为 LIGHT_PARAM_ENERGY * LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY）。
LightParam LIGHT_PARAM_SPECULAR = 3
灯光对镜面反射的影响。
LightParam LIGHT_PARAM_RANGE = 4
灯光的范围。
LightParam LIGHT_PARAM_SIZE = 5
使用聚光灯或全向灯时的灯光大小。使用定向光时是光的角度大小。
LightParam LIGHT_PARAM_ATTENUATION = 6
光线的衰减。
LightParam LIGHT_PARAM_SPOT_ANGLE = 7
聚光灯的角度。
LightParam LIGHT_PARAM_SPOT_ATTENUATION = 8
聚光灯的衰减。
LightParam LIGHT_PARAM_SHADOW_MAX_DISTANCE = 9
阴影分割的最大距离。将这个值增大会让定向阴影在更远处可见，代价是整体的阴影细节降低和性能（因为渲染定向阴影时需要包含更多的物体）。
LightParam LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET = 10
第一次拆分所占据的阴影图集的比例。
LightParam LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET = 11
第二次拆分所占用的阴影图集的比例。
LightParam LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET = 12
第三次拆分所占用的阴影图集的比例。第四个拆分占据了其余部分。
LightParam LIGHT_PARAM_SHADOW_FADE_START = 13
阴影将开始淡出的阴影最大距离的比例。
LightParam LIGHT_PARAM_SHADOW_NORMAL_BIAS = 14
法线偏置，用于抵消物体法线的阴影查找。可以用来修复自阴影的伪影。
LightParam LIGHT_PARAM_SHADOW_BIAS = 15
对阴影查找进行偏置，以修复自我阴影的假象。
LightParam LIGHT_PARAM_SHADOW_PANCAKE_SIZE = 16
设置定向阴影压平区域的大小。压平区域会偏移阴影相机视锥体的起点，为阴影提供更高的有效深度分辨率。但是，较大的压平区大小会导致靠近视锥体边缘的大型物体的阴影出现伪影。减少压平区大小会有所帮助。将大小设置为 0 会关闭该压平效果。
LightParam LIGHT_PARAM_SHADOW_OPACITY = 17
灯光的阴影不透明度。低于 1.0 的值会使光线透过阴影出现。这可以用于以较低的性能成本伪造全局照明。
LightParam LIGHT_PARAM_SHADOW_BLUR = 18
模糊阴影的边缘。可用于隐藏低分辨率阴影贴图中的像素伪影。较高的值会使阴影显得粗糙，并可能导致其他不需要的伪影。尽量保持接近默认值。
LightParam LIGHT_PARAM_TRANSMITTANCE_BIAS = 19
该枚举目前没有描述，请帮我们贡献一个吧！
LightParam LIGHT_PARAM_INTENSITY = 20
代表灯光强度的常量，SpotLight3D 和 OmniLight3D 的单位为流明，DirectionalLight3D 的单位为勒克斯。仅在 ProjectSettings.rendering/lights_and_shadows/use_physical_light_units 为 true 时使用。
LightParam LIGHT_PARAM_MAX = 21
代表 LightParam 枚举的大小。
enum LightBakeMode: 🔗
LightBakeMode LIGHT_BAKE_DISABLED = 0
烘焙时灯光将被忽略。这是最快的模式，但是在烘焙全局照明时仍会考虑该灯光。该模式通常应用于快速变化的动态灯光，因为全局照明的效果在这些灯光上不太明显。
LightBakeMode LIGHT_BAKE_STATIC = 1
在静态烘焙（VoxelGI、LightmapGI、SDFGI（Environment.sdfgi_enabled））时，考虑了灯光。灯光可以四处移动或修改，但其全局照明不会实时更新。这适用于细微的变化（例如闪烁的手电筒），但通常不适用于大的变化，例如打开和关闭灯光。
LightBakeMode LIGHT_BAKE_DYNAMIC = 2
动态烘焙时考虑灯光（仅 VoxelGI 和 SDFGI（Environment.sdfgi_enabled））。灯光可以四处移动或修改，全局照明会实时更新。灯光的全局照明效果与 LIGHT_BAKE_STATIC 略有不同。性能开销比 LIGHT_BAKE_STATIC 更大。使用 SDFGI 时，动态灯光的更新速度受 ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights 的影响。
enum LightOmniShadowMode: 🔗
LightOmniShadowMode LIGHT_OMNI_SHADOW_DUAL_PARABOLOID = 0
对全向光使用双抛物面阴影贴图。
LightOmniShadowMode LIGHT_OMNI_SHADOW_CUBE = 1
对全向光使用立方体贴图阴影贴图。比双抛物面更慢但质量更好。
enum LightDirectionalShadowMode: 🔗
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL = 0
对平行光使用正交阴影投影。
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS = 1
使用平行光时，使用 2 个分割进行阴影投影。
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS = 2
使用平行光时，使用 4 个分割进行阴影投影。
enum LightDirectionalSkyMode: 🔗
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_AND_SKY = 0
在天空渲染和场景照明中都使用 DirectionalLight3D。
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_ONLY = 1
仅在场景照明中使用 DirectionalLight3D。
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_SKY_ONLY = 2
仅在天空渲染中使用 DirectionalLight3D。
enum ShadowQuality: 🔗
ShadowQuality SHADOW_QUALITY_HARD = 0
最低的阴影过滤质量（最快）。使用这种质量设置时，软阴影不可用，这意味着如果 Light3D.light_size 和 Light3D.light_angular_distance 为 0.0，则会忽略 Light3D.shadow_blur 属性。
注意：使用硬阴影过滤时，由 Light3D.light_size 和 Light3D.light_angular_distance 执行的可变阴影模糊仍然有效。在这种情况下会考虑 Light3D.shadow_blur。但是不会对结果进行模糊处理，而是将模糊量视为半影的最大半径。
ShadowQuality SHADOW_QUALITY_SOFT_VERY_LOW = 1
非常低的阴影过滤质量（更快）。使用该质量设置时，Light3D.shadow_blur 会自动乘以 0.75 倍以避免引入过多的噪点。该划分仅适用于 Light3D.light_size 或 Light3D.light_angular_distance 为 0.0 的灯光。
ShadowQuality SHADOW_QUALITY_SOFT_LOW = 2
低阴影过滤质量（快速）。
ShadowQuality SHADOW_QUALITY_SOFT_MEDIUM = 3
中低阴影过滤质量（平均）。
ShadowQuality SHADOW_QUALITY_SOFT_HIGH = 4
高低阴影过滤质量（慢）。使用该质量设置时，Light3D.shadow_blur 会自动乘以 1.5 倍以更好地利用高样本数。这种增加的模糊还提高了动态对象阴影的稳定性。该乘数仅适用于 Light3D.light_size 或 Light3D.light_angular_distance 为 0.0 的灯光。
ShadowQuality SHADOW_QUALITY_SOFT_ULTRA = 5
最高的低阴影过滤质量（最慢）。使用该质量设置时，Light3D.shadow_blur 会自动乘以 2 倍以更好地利用高样本数。这种增加的模糊还提高了动态对象阴影的稳定性。该乘数仅适用于 Light3D.light_size 或 Light3D.light_angular_distance 为 0.0 的灯光。
ShadowQuality SHADOW_QUALITY_MAX = 6
代表 ShadowQuality 枚举的大小。
enum ReflectionProbeUpdateMode: 🔗
ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ONCE = 0
反射探针将更新一次反射，然后停止。
ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ALWAYS = 1
反射探针将每帧更新。这种模式对于捕捉移动物体是必要的。
enum ReflectionProbeAmbientMode: 🔗
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_DISABLED = 0
不要在反射探针的区域内应用任何环境光，区域由探针的大小决定。
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_ENVIRONMENT = 1
在反射探针的区域内应用自动来源的环境光照，区域由探针的大小决定。
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_COLOR = 2
在反射探针的区域内应用自定义环境光，区域由探针的大小决定。见 reflection_probe_set_ambient_color() 和 reflection_probe_set_ambient_energy()。
enum DecalTexture: 🔗
DecalTexture DECAL_TEXTURE_ALBEDO = 0
贴花中的反照率纹理（Decal.texture_albedo）。
DecalTexture DECAL_TEXTURE_NORMAL = 1
贴花中的法线贴图纹理（Decal.texture_normal）。
DecalTexture DECAL_TEXTURE_ORM = 2
贴花中的遮蔽/粗糙度/金属性纹理（Decal.texture_orm）。
DecalTexture DECAL_TEXTURE_EMISSION = 3
贴花中的自发光纹理（Decal.texture_orm）。
DecalTexture DECAL_TEXTURE_MAX = 4
代表 DecalTexture 枚举的大小。
enum DecalFilter: 🔗
DecalFilter DECAL_FILTER_NEAREST = 0
贴花的最近邻过滤（用于像素风贴花）。渲染时不使用 mipmap，这意味着较远处的贴花看上去会很锐利，但会有颗粒状的图案。与使用 mipmap 的性能开销大致相同。
DecalFilter DECAL_FILTER_LINEAR = 1
贴花的线性过滤（用于非像素风贴花）。渲染时不使用 mipmap，这意味着较远处的贴花看上去会很平滑，但会有模糊的效果。与使用 mipmap 的性能开销大致相同。
DecalFilter DECAL_FILTER_NEAREST_MIPMAPS = 2
贴花的最近邻过滤（用于像素风贴花）。渲染时使用各向同性的 mipmap，这意味着较远处的贴花看上去会很平滑，但会有模糊的效果。与不使用 mipmap 的性能开销大致相同。
DecalFilter DECAL_FILTER_LINEAR_MIPMAPS = 3
贴花的线性过滤（用于非像素风贴花）。渲染时使用各向同性的 mipmap，这意味着较远处的贴花看上去会很平滑，但会有模糊的效果。与不使用 mipmap 的性能开销大致相同。
DecalFilter DECAL_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4
贴花的最近邻过滤（用于像素风贴花）。渲染时使用各向异性的 mipmap，这意味着贴花从斜角度观察会既平滑又锐利。比各向同性的 mipmap 更好看，但也更慢。各向异性的级别由 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 定义。
DecalFilter DECAL_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5
贴花的线性过滤（用于非像素风贴花）。渲染时使用各向异性的 mipmap，这意味着贴花从斜角度观察会既平滑又锐利。比各向同性的 mipmap 更好看，但也更慢。各向异性的级别由 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 定义。
enum VoxelGIQuality: 🔗
VoxelGIQuality VOXEL_GI_QUALITY_LOW = 0
VoxelGI 较低渲染质量，使用 4 个锥体。
VoxelGIQuality VOXEL_GI_QUALITY_HIGH = 1
VoxelGI 较高渲染质量，使用 6 个锥体。
enum ParticlesMode: 🔗
ParticlesMode PARTICLES_MODE_2D = 0
2D 粒子。
ParticlesMode PARTICLES_MODE_3D = 1
3D 粒子。
enum ParticlesTransformAlign: 🔗
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_DISABLED = 0
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD = 1
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY = 2
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY = 3
该枚举目前没有描述，请帮我们贡献一个吧！
enum ParticlesDrawOrder: 🔗
ParticlesDrawOrder PARTICLES_DRAW_ORDER_INDEX = 0
按照粒子数组中出现的顺序绘制粒子。
ParticlesDrawOrder PARTICLES_DRAW_ORDER_LIFETIME = 1
根据粒子的寿命对其进行排序。换句话说，寿命最长的粒子被绘制在前面。
ParticlesDrawOrder PARTICLES_DRAW_ORDER_REVERSE_LIFETIME = 2
根据粒子寿命的倒数对粒子进行排序。换句话说，寿命最短的粒子被绘制在前面。
ParticlesDrawOrder PARTICLES_DRAW_ORDER_VIEW_DEPTH = 3
根据粒子与相机的距离对其进行排序。
enum ParticlesCollisionType: 🔗
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_ATTRACT = 0
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_ATTRACT = 1
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_VECTOR_FIELD_ATTRACT = 2
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_COLLIDE = 3
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_COLLIDE = 4
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SDF_COLLIDE = 5
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionType PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE = 6
该枚举目前没有描述，请帮我们贡献一个吧！
enum ParticlesCollisionHeightfieldResolution: 🔗
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_256 = 0
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_512 = 1
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_1024 = 2
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_2048 = 3
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_4096 = 4
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_8192 = 5
该枚举目前没有描述，请帮我们贡献一个吧！
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_MAX = 6
代表 ParticlesCollisionHeightfieldResolution 枚举的大小。
enum FogVolumeShape: 🔗
FogVolumeShape FOG_VOLUME_SHAPE_ELLIPSOID = 0
FogVolume 的形状类似于一个椭球体（拉伸的球体）。
FogVolumeShape FOG_VOLUME_SHAPE_CONE = 1
FogVolume 的形状像一个向上的圆锥体（在局部坐标中）。圆锥体的角度会自动被设置以填充大小。锥体将被调整以适合大小。旋转 FogVolume 节点以重新定向圆锥体。不支持通过大小进行非均匀缩放（改为缩放 FogVolume 节点）。
FogVolumeShape FOG_VOLUME_SHAPE_CYLINDER = 2
FogVolume 的形状将像一个直立的圆柱体（在局部坐标中）。旋转 FogVolume 节点以重新定向圆柱体。圆柱体将被调整以适合大小。不支持通过大小进行非均匀缩放（改为缩放 FogVolume 节点）。
FogVolumeShape FOG_VOLUME_SHAPE_BOX = 3
FogVolume 的形状会像一个盒子。
FogVolumeShape FOG_VOLUME_SHAPE_WORLD = 4
FogVolume 将没有形状，将覆盖整个世界并且不会被剔除。
FogVolumeShape FOG_VOLUME_SHAPE_MAX = 5
代表 FogVolumeShape 枚举的大小。
enum ViewportScaling3DMode: 🔗
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_BILINEAR = 0
对视口的 3D 缓冲区使用双线性缩放。可以使用 Viewport.scaling_3d_scale 设置缩放量。小于 1.0 的值将导致欠采样，而大于 1.0 的值将导致超采样。1.0 的值将禁用缩放。
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR = 1
对视口的 3D 缓冲区使用 AMD FidelityFX 超分辨率 1.0 放大。可以使用 Viewport.scaling_3d_scale 设置缩放量。小于 1.0 的值将导致使用 FSR 放大视口。不支持大于 1.0 的值，将改用双线性降采样。1.0 的值将禁用缩放。
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR2 = 2
对视口的 3D 缓冲区使用 AMD FidelityFX 超分辨率 2.2 放大。可以使用 Viewport.scaling_3d_scale 设置缩放量。小于 1.0 的值将导致使用 FSR2 放大视口。不支持大于 1.0 的值，将改用双线性降采样。1.0 的值将使用原生分辨率下的 FSR2 作为 TAA 解决方案。
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_SPATIAL = 3
对视口的 3D 缓冲区使用 MetalFX 空间放大。可以使用 Viewport.scaling_3d_scale 设置缩放量。小于 1.0 的值将导致使用 MetalFX 放大视口。不支持大于 1.0 的值，将改用双线性降采样。1.0 的值将禁用缩放。
注意：仅在使用 Metal 渲染驱动时支持该缩放模式，因此该模式仅限于 macOS 和 iOS。
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_TEMPORAL = 4
对视口的 3D 缓冲区使用 MetalFX 时间放大。可以使用 Viewport.scaling_3d_scale 设置缩放量。小于 1.0 的值将导致使用 MetalFX 放大视口。不支持大于 1.0 的值，将改用双线性降采样。1.0 的值将以原生分辨率使用 MetalFX 作为 TAA 解决方案。
注意：仅在使用 Metal 渲染驱动时支持该缩放模式，因此该模式仅限于 macOS 和 iOS。
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_MAX = 5
代表 ViewportScaling3DMode 枚举的大小。
enum ViewportUpdateMode: 🔗
ViewportUpdateMode VIEWPORT_UPDATE_DISABLED = 0
不要更新视口的渲染目标。
ViewportUpdateMode VIEWPORT_UPDATE_ONCE = 1
更新一次视口的渲染目标，然后切换到 VIEWPORT_UPDATE_DISABLED。
ViewportUpdateMode VIEWPORT_UPDATE_WHEN_VISIBLE = 2
仅在渲染目标可见时更新视口的渲染目标。这是默认值。
ViewportUpdateMode VIEWPORT_UPDATE_WHEN_PARENT_VISIBLE = 3
仅在其父级可见时更新视口的渲染目标。
ViewportUpdateMode VIEWPORT_UPDATE_ALWAYS = 4
始终更新视口的渲染目标。
enum ViewportClearMode: 🔗
ViewportClearMode VIEWPORT_CLEAR_ALWAYS = 0
绘制前始终清除视口的渲染目标。
ViewportClearMode VIEWPORT_CLEAR_NEVER = 1
永不清除视口的渲染目标。
ViewportClearMode VIEWPORT_CLEAR_ONLY_NEXT_FRAME = 2
在下一帧清除视口的渲染目标，然后切换到 VIEWPORT_CLEAR_NEVER。
enum ViewportEnvironmentMode: 🔗
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_DISABLED = 0
禁用在 2D 画布上渲染 3D 环境。
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_ENABLED = 1
启用在 2D 画布上渲染 3D 环境。
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_INHERIT = 2
从父级继承启用/禁用值。如果最顶层的父级也被设置为 VIEWPORT_ENVIRONMENT_INHERIT，那么与 VIEWPORT_ENVIRONMENT_ENABLED 的行为相同。
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_MAX = 3
代表 ViewportEnvironmentMode 枚举的大小。
enum ViewportSDFOversize: 🔗
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_100_PERCENT = 0
不使用过大的 2D 带符号距离场。遮挡器可能在接触视口边缘时消失，GPUParticles3D 碰撞也可能比预期更早地停止工作。对 GPU 的要求最低。
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_120_PERCENT = 1
2D 带符号距离场在每个方向（上、右、下、左）都覆盖超出视口大小 20% 的范围。
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_150_PERCENT = 2
2D 带符号距离场在每个方向（上、右、下、左）都覆盖超出视口大小 50% 的范围。
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_200_PERCENT = 3
2D 带符号距离场在每个方向（上、右、下、左）都覆盖超出视口大小 100% 的范围。对 GPU 的要求最高。
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_MAX = 4
代表 ViewportSDFOversize 枚举的大小。
enum ViewportSDFScale: 🔗
ViewportSDFScale VIEWPORT_SDF_SCALE_100_PERCENT = 0
全分辨率 2D 带符号距离场缩放。对 GPU 的要求最高。
ViewportSDFScale VIEWPORT_SDF_SCALE_50_PERCENT = 1
各轴半分辨率 2D 带符号距离场缩放（视口像素数的 25%）。
ViewportSDFScale VIEWPORT_SDF_SCALE_25_PERCENT = 2
各轴四分之一分辨率 2D 带符号距离场缩放（视口像素数的 6.25%）。对 GPU 的要求最低。
ViewportSDFScale VIEWPORT_SDF_SCALE_MAX = 3
代表 ViewportSDFScale 枚举的大小。
enum ViewportMSAA: 🔗
ViewportMSAA VIEWPORT_MSAA_DISABLED = 0
用于 3D 的多重采样抗锯齿被禁用。这是默认值，也是最快的设置。
ViewportMSAA VIEWPORT_MSAA_2X = 1
用于 3D 的多重采样抗锯齿，使用每个像素 2 个样本。这对性能有中等影响。
ViewportMSAA VIEWPORT_MSAA_4X = 2
用于 3D 的多重采样抗锯齿，使用每个像素 4 个样本。这对性能有较大影响。
ViewportMSAA VIEWPORT_MSAA_8X = 3
用于 3D 的多重采样抗锯齿，使用每个像素 8 个样本。这对性能有非常大的影响。可能在低端和较旧的硬件上不受支持。
ViewportMSAA VIEWPORT_MSAA_MAX = 4
代表 ViewportMSAA 枚举的大小。
enum ViewportAnisotropicFiltering: 🔗
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_DISABLED = 0
各向异性过滤已禁用。
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_2X = 1
使用 2× 各向异性过滤。
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_4X = 2
使用 4× 各向异性过滤。这是默认值。
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_8X = 3
使用 8× 各向异性过滤。
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_16X = 4
使用 16× 各向异性过滤。
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_MAX = 5
代表 ViewportAnisotropicFiltering 枚举的大小。
enum ViewportScreenSpaceAA: 🔗
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_DISABLED = 0
不要在全屏后处理中执行抗锯齿。
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_FXAA = 1
使用快速近似抗锯齿（Fast Approximate Anti-Aliasing）。FXAA 是一种流行的屏幕空间抗锯齿方法，速度很快，但会让图像变模糊，使用较低分辨率时尤为显著。1440p 和 4K 等较高分辨率下效果仍然不错。
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_MAX = 2
代表 ViewportScreenSpaceAA 枚举的大小。
enum ViewportOcclusionCullingBuildQuality: 🔗
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_LOW = 0
较低的遮挡剔除 BVH 构建质量（由 Embree 定义）。CPU 占用最低，但剔除效率最低。
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_MEDIUM = 1
中等的遮挡剔除 BVH 构建质量（由 Embree 定义）。
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_HIGH = 2
较高的遮挡剔除 BVH 构建质量（由 Embree 定义）。CPU 占用最高，但剔除效率最高。
enum ViewportRenderInfo: 🔗
ViewportRenderInfo VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME = 0
在单帧中绘制的对象的数量。
ViewportRenderInfo VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME = 1
在单帧中绘制的点、线、三角形的数量。
ViewportRenderInfo VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME = 2
此帧期间的绘制调用数。
ViewportRenderInfo VIEWPORT_RENDER_INFO_MAX = 3
代表 ViewportRenderInfo 枚举的大小。
enum ViewportRenderInfoType: 🔗
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_VISIBLE = 0
可见渲染阶段（不含阴影）。
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_SHADOW = 1
阴影渲染阶段。根据开启了阴影的灯光数以及方向阴影的拆分数，同一个对象可能会渲染多次。
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_CANVAS = 2
画布项渲染。包括所有 2D 渲染。
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_MAX = 3
代表 ViewportRenderInfoType 枚举的大小。
enum ViewportDebugDraw: 🔗
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLED = 0
调试绘制被禁用。默认设置。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_UNSHADED = 1
显示的对象没有光照信息。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_LIGHTING = 2
仅使用光照信息显示对象。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OVERDRAW = 3
对象通过加法混合显示为半透明，因此可以看到它们在彼此之上绘制的位置。更高的过度绘制（由更亮的颜色表示）意味着在绘制隐藏在其他像素后面的像素时浪费了性能。
注意：使用该调试绘制模式时，自定义着色器将被忽略。这意味着顶点置换不再可见。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_WIREFRAME = 4
调试绘制以线框形式绘制对象。
注意：使用 Compatibility 渲染器时，必须在加载任何网格之前调用 set_debug_generate_wireframes() 线框才可见。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER = 5
绘制法线缓冲区而不是常规场景，因此可以看到将由后处理效果使用的每像素法线。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_ALBEDO = 6
仅使用来自 VoxelGI 的反照率值显示对象。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_LIGHTING = 7
仅使用来自 VoxelGI 的照明值显示对象。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_EMISSION = 8
仅使用来自 VoxelGI 的自发光颜色显示对象。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS = 9
在 Viewport 的左上象限中绘制存储来自 OmniLight3D 和 SpotLight3D 的阴影的阴影图集。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS = 10
绘制阴影图集，该阴影图集存储 Viewport 左上象限中 DirectionalLight3D 的阴影。
与阴影贴图级联相关的相机视锥体切片被叠加以可视化覆盖范围。每个切片的颜色与 VIEWPORT_DEBUG_DRAW_PSSM_SPLITS 使用的颜色匹配。当混合阴影级联时，绘制视锥体切片时会考虑重叠。
最后一个级联显示了所有视锥体切片，以说明所有切片的覆盖范围。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE = 11
绘制估计的场景亮度。这是一个 1×1 的纹理，启用自动曝光时生成，用于控制场景的曝光。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSAO = 12
绘制屏幕空间环境光遮蔽纹理而不是场景，以便可以清楚地看到它是如何影响对象的。为了使这种显示模式起作用，必须在 WorldEnvironment 中设置 Environment.ssao_enabled。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSIL = 13
绘制屏幕空间间接照明纹理而不是场景，以便可以清楚地看到它是如何影响对象的。为了使这种显示模式起作用，必须在 WorldEnvironment 中设置 Environment.ssil_enabled。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_PSSM_SPLITS = 14
为场景中的 DirectionalLight3D 的每个 PSSM 分割着色不同的颜色，以便可以看到分割的位置。它们将按顺序被着色为红色、绿色、蓝色、黄色。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DECAL_ATLAS = 15
绘制贴花图集，图集中保存的是各个 Decal 中的贴花纹理。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI = 16
绘制 SDFGI 级联数据。这是用于反弹灯光、创建反射的数据结构。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI_PROBES = 17
绘制 SDFGI 探针数据。这是用于为场景中移动的动态对象提供间接光照的数据结构。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_GI_BUFFER = 18
绘制全局光照缓冲（VoxelGI 或 SDFGI）。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLE_LOD = 19
禁用网格 LOD。所有网格都会使用完整细节绘制，可以用来比较性能。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS = 20
绘制 OmniLight3D 集群。集群决定屏幕空间中灯光的放置位置，能够让引擎在进行光照时仅对屏幕的部分区域进行处理。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS = 21
绘制 SpotLight3D 集群。集群决定屏幕空间中灯光的放置位置，能够让引擎在进行光照时仅对屏幕的部分区域进行处理。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_DECALS = 22
绘制 Decal 集群。集群决定屏幕空间中贴花的放置位置，能够让引擎在进行贴花时仅对屏幕的部分区域进行处理。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES = 23
绘制 ReflectionProbe 集群。集群决定屏幕空间中反射探针的放置位置，能够让引擎在处理反射探针时仅对屏幕的部分区域进行处理。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OCCLUDERS = 24
绘制遮挡剔除缓冲。这个低分辨率遮挡剔除缓冲在 CPU 栅格化，可用于检查实例是否被其他对象遮挡。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_MOTION_VECTORS = 25
绘制运动向量缓冲。由时间抗锯齿使用，能够修正在游戏过程中发生的运动。
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_INTERNAL_BUFFER = 26
绘制内部缓冲区而不是常规场景，因此可以看到将被后处理效果使用的每像素输出。
enum ViewportVRSMode: 🔗
ViewportVRSMode VIEWPORT_VRS_DISABLED = 0
可变速率着色已禁用。
ViewportVRSMode VIEWPORT_VRS_TEXTURE = 1
可变速率着色使用纹理。请注意，对于立体视觉，请使用为每个视图提供纹理的纹理图集。
ViewportVRSMode VIEWPORT_VRS_XR = 2
可变速率着色纹理由主 XRInterface 提供。请注意，这可能会覆盖更新模式。
ViewportVRSMode VIEWPORT_VRS_MAX = 3
代表 ViewportVRSMode 枚举的大小。
enum ViewportVRSUpdateMode: 🔗
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_DISABLED = 0
可变速率着色的输入纹理将不会被处理。
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ONCE = 1
可变速率着色的输入纹理将被处理一次。
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ALWAYS = 2
可变速率着色的输入纹理将每帧进行处理。
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_MAX = 3
代表 ViewportVRSUpdateMode 枚举的大小。
enum SkyMode: 🔗
SkyMode SKY_MODE_AUTOMATIC = 0
根据天空着色器自动选择合适的处理模式。如果着色器使用 TIME 或 POSITION，则会使用 SKY_MODE_REALTIME。如果着色器使用任何 LIGHT_* 变量或任何自定义 uniform，则会使用 SKY_MODE_INCREMENTAL。否则默认为 SKY_MODE_QUALITY。
SkyMode SKY_MODE_QUALITY = 1
使用高质量重要性采样处理辐射率贴图。得到的结果通常比 SKY_MODE_REALTIME 的质量更高，但需要花费更多的时间来生成。如果你计划在运行时修改天空，则不应使用。如果你发现反射不够模糊，出现了火花或者萤火虫，请尝试增大 ProjectSettings.rendering/reflections/sky_reflections/ggx_samples。
SkyMode SKY_MODE_INCREMENTAL = 2
使用与 SKY_MODE_QUALITY 相同的高质量重要性采样来处理辐射率贴图，但更新会占用若干帧。帧数由 ProjectSettings.rendering/reflections/sky_reflections/roughness_layers 决定。当需要最高质量的辐射率贴图，但天空更新缓慢时，请使用该选项。
SkyMode SKY_MODE_REALTIME = 3
使用快速过滤算法处理辐射率贴图。一般来说，这会导致质量降低，但运行时间会大大加快。如果需要更好的质量，但仍需要每帧更新天空，请考虑开启 ProjectSettings.rendering/reflections/sky_reflections/fast_filter_high_quality。
注意：快速过滤算法被限制为 256x256 立方体贴图，因此 sky_set_radiance_size() 必须被设置为 256。否则会打印警告并忽略对辐射率大小的覆盖。
enum CompositorEffectFlags: 🔗
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_COLOR = 1
启用 MSAA 时，渲染效果需要解析颜色缓冲。
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_DEPTH = 2
启用 MSAA 时，渲染效果需要解析深度缓冲。
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_MOTION_VECTORS = 4
渲染效果需要生成运动向量。
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_ROUGHNESS = 8
渲染效果需要生成法线和粗糙度 G 缓冲（仅适用于 Forward+）。
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_SEPARATE_SPECULAR = 16
渲染效果需要单独的镜面反射数据（仅适用于 Forward+）。
enum CompositorEffectCallbackType: 🔗
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_OPAQUE = 0
回调在不透明渲染阶段之前调用，但在深度前置阶段之后（如果适用）。
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_OPAQUE = 1
回调在不透明渲染阶段之后调用，但在渲染天空之前。
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_SKY = 2
回调在渲染天空之后调用，但在创建后台缓冲之前（如果启用，则在次表面散射和/或屏幕空间反射之前）。
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT = 3
回调在透明渲染阶段之前调用，但在渲染天空和创建后台缓冲区之后。
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_TRANSPARENT = 4
回调在透明渲染阶段之后调用，但在内置后期效果和输出到渲染目标之前。
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_ANY = -1
该枚举目前没有描述，请帮我们贡献一个吧！
enum EnvironmentBG: 🔗
EnvironmentBG ENV_BG_CLEAR_COLOR = 0
用透明的颜色作为背景。
EnvironmentBG ENV_BG_COLOR = 1
使用指定的颜色作为背景。
EnvironmentBG ENV_BG_SKY = 2
使用天空资源作为背景。
EnvironmentBG ENV_BG_CANVAS = 3
使用一个指定的画布层作为背景。这对在 3D 世界中实例化一个 2D 场景很有用。
EnvironmentBG ENV_BG_KEEP = 4
不要清除背景，使用上一帧渲染的东西作为背景。
EnvironmentBG ENV_BG_CAMERA_FEED = 5
在背景中显示相机源。
EnvironmentBG ENV_BG_MAX = 6
代表 EnvironmentBG 枚举的大小。
enum EnvironmentAmbientSource: 🔗
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_BG = 0
从指定为背景的任何来源收集环境光。
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_DISABLED = 1
禁用环境光。
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_COLOR = 2
为环境光指定特定的 Color。
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_SKY = 3
无论背景如何，都从 Sky 收集环境光。
enum EnvironmentReflectionSource: 🔗
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_BG = 0
使用背景进行反射。
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_DISABLED = 1
禁用反射。
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_SKY = 2
无论背景如何，都使用 Sky 进行反射。
enum EnvironmentGlowBlendMode: 🔗
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_ADDITIVE = 0
添加辉光混合模式。主要用于粒子、辉光（泛光）、镜头眩光、亮源。
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SCREEN = 1
滤色辉光混合模式。增加亮度，经常与泛光一起使用。
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SOFTLIGHT = 2
柔光辉光混合模式。修改对比度，曝光阴影和高光（高质量泛光）。
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_REPLACE = 3
替换辉光混合模式。用辉光值替换所有像素的颜色。这可以通过调整辉光参数来模拟全屏模糊效果，使其与原始图像的亮度相匹配。
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_MIX = 4
将辉光与底层颜色混合，以避免在保持辉光效果的同时，尽可能多地增加亮度。
enum EnvironmentFogMode: 🔗
EnvironmentFogMode ENV_FOG_MODE_EXPONENTIAL = 0
使用主要由雾密度定义的基于物理的雾模型。
EnvironmentFogMode ENV_FOG_MODE_DEPTH = 1
使用由开始位置和结束位置以及自定义曲线定义的简单雾模型。虽然在物理上并不准确，但当你需要更多的艺术控制时，该模型可能会很有用。
enum EnvironmentToneMapper: 🔗
EnvironmentToneMapper ENV_TONE_MAPPER_LINEAR = 0
不修改颜色数据，得到线性的色调映射曲线，裁剪较亮的值时不自然，明亮的光照会过曝。这是最简单快速的色调映射器。
EnvironmentToneMapper ENV_TONE_MAPPER_REINHARD = 1
一种简单的色调映射曲线，会通过降低亮度值来防止发生裁剪。这会导致图像看起来平淡并且对比度低。比 ENV_TONE_MAPPER_LINEAR 更慢。
注意：当 Environment.tonemap_white 保持默认值 1.0 时，ENV_TONE_MAPPER_REINHARD 生成的图像与 ENV_TONE_MAPPER_LINEAR 相同。
EnvironmentToneMapper ENV_TONE_MAPPER_FILMIC = 2
使用类似胶卷的色调映射曲线来防止裁剪亮度值，提供比 ENV_TONE_MAPPER_REINHARD 更好的对比度。比 ENV_TONE_MAPPER_REINHARD 稍慢。
EnvironmentToneMapper ENV_TONE_MAPPER_ACES = 3
使用高对比度的类似胶卷的色调映射曲线并对亮度值进行去饱和处理，从而获得更真实的外观。比 ENV_TONE_MAPPER_FILMIC 稍慢。
注意：在 Godot 3.x 中将该色调映射运算称为“ACES Fitted”。
EnvironmentToneMapper ENV_TONE_MAPPER_AGX = 4
使用类似胶卷的色调映射曲线并对亮度值进行去饱和处理，从而获得更真实的外观。相比其他色调映射器，在颜色变亮时能够更好地保持色调。这是最慢的色调映射选项。
注意：Environment.tonemap_white 固定在 16.29，因此 ENV_TONE_MAPPER_AGX 不适合移动渲染方法。
enum EnvironmentSSRRoughnessQuality: 🔗
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_DISABLED = 0
用于屏幕空间反射的最低质量粗糙度过滤。与光滑（非粗糙）材质相比，粗糙材质不会有更模糊的屏幕空间反射。这是最快的选项。
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_LOW = 1
屏幕空间反射的较低质量粗糙度过滤器。
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_MEDIUM = 2
屏幕空间反射的中等质量粗糙度过滤器。
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_HIGH = 3
屏幕空间反射的较高质量粗糙度过滤器。这是最慢的选项。
enum EnvironmentSSAOQuality: 🔗
EnvironmentSSAOQuality ENV_SSAO_QUALITY_VERY_LOW = 0
最低质量的屏幕空间环境光遮蔽。
EnvironmentSSAOQuality ENV_SSAO_QUALITY_LOW = 1
低质量的屏幕空间环境光遮蔽。
EnvironmentSSAOQuality ENV_SSAO_QUALITY_MEDIUM = 2
中等质量的屏幕空间环境光遮蔽。
EnvironmentSSAOQuality ENV_SSAO_QUALITY_HIGH = 3
高质量的屏幕空间环境光遮蔽。
EnvironmentSSAOQuality ENV_SSAO_QUALITY_ULTRA = 4
最高质量的屏幕空间环境光遮蔽。使用可动态调整的自适应目标设置，以平滑地平衡性能和视觉质量。
enum EnvironmentSSILQuality: 🔗
EnvironmentSSILQuality ENV_SSIL_QUALITY_VERY_LOW = 0
最低质量的屏幕空间间接光照。
EnvironmentSSILQuality ENV_SSIL_QUALITY_LOW = 1
较低质量的屏幕空间间接光照。
EnvironmentSSILQuality ENV_SSIL_QUALITY_MEDIUM = 2
较高质量的屏幕空间间接光照。
EnvironmentSSILQuality ENV_SSIL_QUALITY_HIGH = 3
较高质量的屏幕空间间接光照。
EnvironmentSSILQuality ENV_SSIL_QUALITY_ULTRA = 4
最高质量的屏幕空间间接光照。使用可动态调整的自适应目标设置，以平滑地平衡性能和视觉质量。
enum EnvironmentSDFGIYScale: 🔗
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_50_PERCENT = 0
在 Y（垂直）轴上对 SDFGI 使用 50% 的缩放。SDFGI 单元格将比它们的宽度短两倍。这允许提供更多的 GI 细节，并减少薄地板和天花板的漏光。这通常是垂直度不高的场景的最佳选择。
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_75_PERCENT = 1
在 Y（垂直）轴上为 SDFGI 使用 75% 的缩放。这是 50% 和 100% SDFGI Y 缩放之间的平衡。
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_100_PERCENT = 2
在 Y（垂直）轴上为 SDFGI 使用 100% 的缩放。SDFGI 单元格将与宽度一样高。这通常是高度垂直场景的最佳选择。不利之处在于，薄地板和天花板可能会导致漏光更加明显。
enum EnvironmentSDFGIRayCount: 🔗
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_4 = 0
聚合 SDFGI 时每帧发出 4 条光线。对 GPU 的要求最低，但结果中噪点最多。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_8 = 1
聚合 SDFGI 时每帧发出 8 条光线。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_16 = 2
聚合 SDFGI 时每帧发出 16 条光线。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_32 = 3
聚合 SDFGI 时每帧发出 32 条光线。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_64 = 4
聚合 SDFGI 时每帧发出 64 条光线。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_96 = 5
聚合 SDFGI 时每帧发出 96 条光线。对 GPU 的要求较高。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_128 = 6
聚合 SDFGI 时每帧发出 128 条光线。对 GPU 的要求非常高，但结果中噪点最少。
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_MAX = 7
代表 EnvironmentSDFGIRayCount 枚举的大小。
enum EnvironmentSDFGIFramesToConverge: 🔗
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_5_FRAMES = 0
通过 5 帧聚合 SDFGI。响应最快，但光线数量一定时，结果中噪点最多。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_10_FRAMES = 1
让 SDFGI 通过 10 帧完成聚合。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_15_FRAMES = 2
让 SDFGI 通过 15 帧完成聚合。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_20_FRAMES = 3
让 SDFGI 通过 20 帧完成聚合。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_25_FRAMES = 4
让 SDFGI 通过 25 帧完成聚合。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_30_FRAMES = 5
让 SDFGI 通过 30 帧完成聚合。响应最慢，但光线数量一定时，结果中噪点最少。
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_MAX = 6
代表 EnvironmentSDFGIFramesToConverge 枚举的大小。
enum EnvironmentSDFGIFramesToUpdateLight: 🔗
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_1_FRAME = 0
通过 1 帧更新 SDFGI 中动态灯光的间接光照。响应最快，但对 GPU 的要求最高。
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_2_FRAMES = 1
通过 2 帧更新 SDFGI 中动态灯光的间接光照。
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_4_FRAMES = 2
通过 4 帧更新 SDFGI 中动态灯光的间接光照。
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_8_FRAMES = 3
通过 8 帧更新 SDFGI 中动态灯光的间接光照。
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_16_FRAMES = 4
通过 16 帧更新 SDFGI 中动态灯光的间接光照。响应最慢，但对 GPU 的要求最低。
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_MAX = 5
代表 EnvironmentSDFGIFramesToUpdateLight 枚举的大小。
enum SubSurfaceScatteringQuality: 🔗
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_DISABLED = 0
完全禁用次表面散射，即便材质的 BaseMaterial3D.subsurf_scatter_enabled 为 true。对 GPU 的要求最低。
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_LOW = 1
较低质量的次表面散射。
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_MEDIUM = 2
中等质量的次表面散射。
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_HIGH = 3
较高质量的次表面散射。对 GPU 的要求最高。
enum DOFBokehShape: 🔗
DOFBokehShape DOF_BOKEH_BOX = 0
使用一个盒式过滤计算 DOF 模糊。最快的选项，但会在模糊图案中产生明显的线条。
DOFBokehShape DOF_BOKEH_HEXAGON = 1
使用一个六边形过滤计算 DOF 模糊。
DOFBokehShape DOF_BOKEH_CIRCLE = 2
使用一个圆形过滤计算 DOF 模糊。最好的质量和最真实的，但最慢的。仅用于可以将大量性能专用于后期处理的区域（例如过场动画）。
enum DOFBlurQuality: 🔗
DOFBlurQuality DOF_BLUR_QUALITY_VERY_LOW = 0
最低质量的 DOF 模糊。这是最快的设置，但你可能会看到不自然的过滤。
DOFBlurQuality DOF_BLUR_QUALITY_LOW = 1
较低质量的 DOF 模糊。
DOFBlurQuality DOF_BLUR_QUALITY_MEDIUM = 2
中等质量的 DOF 模糊。
DOFBlurQuality DOF_BLUR_QUALITY_HIGH = 3
最高质量的 DOF 模糊。通过采集最多的样本，产生最平滑的模糊效果，但速度也明显变慢。
enum InstanceType: 🔗
InstanceType INSTANCE_NONE = 0
实例没有类型。
InstanceType INSTANCE_MESH = 1
该实例是网格。
InstanceType INSTANCE_MULTIMESH = 2
该实例是一个 multimesh。
InstanceType INSTANCE_PARTICLES = 3
该实例是粒子发射器。
InstanceType INSTANCE_PARTICLES_COLLISION = 4
该实例是 GPUParticles 碰撞形状。
InstanceType INSTANCE_LIGHT = 5
该实例是灯。
InstanceType INSTANCE_REFLECTION_PROBE = 6
该实例是反射探针。
InstanceType INSTANCE_DECAL = 7
该实例是贴花。
InstanceType INSTANCE_VOXEL_GI = 8
该实例是 VoxelGI。
InstanceType INSTANCE_LIGHTMAP = 9
该实例是光照贴图。
InstanceType INSTANCE_OCCLUDER = 10
该实例是遮挡剔除遮挡器。
InstanceType INSTANCE_VISIBLITY_NOTIFIER = 11
该实例是屏幕可见通知器。
InstanceType INSTANCE_FOG_VOLUME = 12
该实例是雾体积。
InstanceType INSTANCE_MAX = 13
代表 InstanceType 枚举的大小。
InstanceType INSTANCE_GEOMETRY_MASK = 14
几何体实例（网格、多网格、即时和粒子）的标志的组合。
enum InstanceFlags: 🔗
InstanceFlags INSTANCE_FLAG_USE_BAKED_LIGHT = 0
允许在烘焙照明中使用实例。
InstanceFlags INSTANCE_FLAG_USE_DYNAMIC_GI = 1
允许在动态全局光照中使用该实例。
InstanceFlags INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 2
当设置时，手动请求在下一帧绘制几何图形。
InstanceFlags INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING = 3
始终绘制，即便实例能够被遮挡剔除剔除。不影响视锥剔除。
InstanceFlags INSTANCE_FLAG_MAX = 4
代表 InstanceFlags 枚举的大小。
enum ShadowCastingSetting: 🔗
ShadowCastingSetting SHADOW_CASTING_SETTING_OFF = 0
禁用这个实例的阴影。
ShadowCastingSetting SHADOW_CASTING_SETTING_ON = 1
从此实例投下阴影。
ShadowCastingSetting SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2
在渲染对象的阴影时禁用背面剔除。这会稍微慢一些，但可能会产生更正确的阴影。
ShadowCastingSetting SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3
仅渲染对象的阴影。对象本身不会被绘制。
enum VisibilityRangeFadeMode: 🔗
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DISABLED = 0
禁用给定实例的可见性范围淡出。
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_SELF = 1
当给定实例接近其可见范围限制时淡出该给定实例。
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DEPENDENCIES = 2
当达到其可见性范围限制时淡入给定实例的依赖项。
enum BakeChannels: 🔗
BakeChannels BAKE_CHANNEL_ALBEDO_ALPHA = 0
bake_render_uv2() 返回的 Image 数组中 Image 的索引。图像使用 Image.FORMAT_RGBA8 格式，并在 .rgb 通道中包含反照率颜色，在 .a 通道中包含 Alpha。
BakeChannels BAKE_CHANNEL_NORMAL = 1
bake_render_uv2() 返回的 Image 数组中 Image 的索引。图像使用 Image.FORMAT_RGBA8 格式，并在 .rgb 通道中包含该对象的每像素法线，在 .a 通道中不包含任何内容。每像素法线被编码为 normal * 0.5 + 0.5。
BakeChannels BAKE_CHANNEL_ORM = 2
bake_render_uv2() 返回的 Image 数组中 Image 的索引。图像使用 Image.FORMAT_RGBA8 格式，并在 .r 通道中包含环境光遮挡（仅来自材质和贴花），在 .g 通道中包含粗糙度，在 .b 通道中包含金属度，并且中 .a 通道中包含次表面散射量。
BakeChannels BAKE_CHANNEL_EMISSION = 3
bake_render_uv2() 返回的 Image 数组中 Image 的索引。图像使用 Image.FORMAT_RGBAH 格式，并在 .rgb 通道中包含自发光颜色，在 .a 通道中不包含任何内容。
enum CanvasTextureChannel: 🔗
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_DIFFUSE = 0
漫反射画布纹理（CanvasTexture.diffuse_texture）。
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_NORMAL = 1
法线贴图画布纹理（CanvasTexture.normal_texture）。
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_SPECULAR = 2
高光贴图画布纹理（CanvasTexture.specular_texture）。
enum NinePatchAxisMode: 🔗
NinePatchAxisMode NINE_PATCH_STRETCH = 0
九宫格在需要的地方被拉伸。
NinePatchAxisMode NINE_PATCH_TILE = 1
九宫格在需要的地方填充图块。
NinePatchAxisMode NINE_PATCH_TILE_FIT = 2
九宫格在需要的地方填充图块，并在需要时将它们拉伸一点。
enum CanvasItemTextureFilter: 🔗
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_DEFAULT = 0
为 Viewport 使用默认过滤模式。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST = 1
纹理过滤仅从最近的像素读取。这使得纹理从近距离看是像素化的，从远处看是颗粒状的（由于多级渐远纹理没有被采样）。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR = 2
纹理过滤在最近的 4 个像素之间进行混合。这使得纹理从近处看起来很平滑，从远处看起来却有颗粒感（由于多级渐远纹理没有被采样）。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 3
纹理过滤从最近的像素读取并在最近的 2 个多级渐远纹理之间进行混合（或者如果 ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter 为 true，则使用最近的多级渐远纹理）。这使得纹理从近处看起来像素化，从远处看起来平滑。
将此用于可能以低缩放查看的非像素艺术纹理（例如，由于 Camera2D 缩放或精灵缩放），因为多级渐远纹理对于平滑小于屏幕像素的像素很重要。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 4
纹理过滤在最近的 4 个像素和最近的 2 个多级渐远纹理之间进行混合（或者如果 ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter 为 true，则使用最近的多级渐远纹理）。这使得纹理从近处看起来平滑，从远处看起来也平滑。
将此用于可能以低缩放查看的非像素艺术纹理（例如，由于 Camera2D 缩放或精灵缩放），因为多级渐远纹理对于平滑小于屏幕像素的像素很重要。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 5
纹理过滤从最近的像素读取并根据表面和相机视图之间的角度在 2 个多级渐远纹理之间进行混合（或者如果 ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter 为 true，则使用最近的多级渐远纹理）。这使得纹理从近处看起来像素化，从远处看起来平滑。各向异性过滤提高了几乎与相机位于一条线的表面上的纹理质量，但速度稍慢。各向异性过滤级别可以通过调整 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 来改变。
注意：该纹理过滤在 2D 项目中很少有用。CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS 在这种情况下通常更合适。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 6
纹理过滤在最近的 4 个像素之间进行混合，并基于表面与相机视图之间的角度在 2 个多级渐远纹理之间进行混合（或者如果 ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter 为 true，则使用最近的多级渐远纹理）。这使得纹理从近处看起来平滑，从远处看起来也平滑。各向异性过滤提高了几乎与相机位于一条线的表面上的纹理质量，但速度稍慢。各向异性过滤级别可以通过调整 ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level 来改变。
注意：该纹理过滤在 2D 项目中很少有用。CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS 在这种情况下通常更合适。
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_MAX = 7
CanvasItemTextureFilter 枚举的最大值。
enum CanvasItemTextureRepeat: 🔗
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT = 0
为 Viewport 使用默认重复模式。
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DISABLED = 1
禁用纹理重复。相反，当读取 0-1 范围之外的 UV 时，该值将被钳制在纹理的边缘，从而导致纹理的边界看起来被拉长。
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_ENABLED = 2
当 UV 坐标超出 0-1 范围时，使纹理能够重复。如果使用其中一种线性过滤模式，则当采样器过滤纹理边缘时，这可能会导致纹理边缘出现伪影。
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MIRROR = 3
重复时翻转该纹理，使边缘对齐而不是突然改变。
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MAX = 4
CanvasItemTextureRepeat 枚举的最大值。
enum CanvasGroupMode: 🔗
CanvasGroupMode CANVAS_GROUP_MODE_DISABLED = 0
子级绘制在父级之上，不会被裁剪。
CanvasGroupMode CANVAS_GROUP_MODE_CLIP_ONLY = 1
父级仅用于裁剪目的。子级被裁剪到父级的可见区域，不绘制父级。
CanvasGroupMode CANVAS_GROUP_MODE_CLIP_AND_DRAW = 2
父级用于裁剪子级，但在将子级剪裁到其可见区域之前，父级也像往常一样绘制在子级下方。
CanvasGroupMode CANVAS_GROUP_MODE_TRANSPARENT = 3
该枚举目前没有描述，请帮我们贡献一个吧！
enum CanvasLightMode: 🔗
CanvasLightMode CANVAS_LIGHT_MODE_POINT = 0
2D 点光（见 PointLight2D）。
CanvasLightMode CANVAS_LIGHT_MODE_DIRECTIONAL = 1
2D 方向（日月）光（见 DirectionalLight2D）。
enum CanvasLightBlendMode: 🔗
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_ADD = 0
向画布添加浅色。
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_SUB = 1
从画布中减去浅色。
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_MIX = 2
灯光根据透明度增加颜色。
enum CanvasLightShadowFilter: 🔗
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_NONE = 0
不要对画布上的光影应用滤镜。
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF5 = 1
使用 PCF5 过滤法来过滤画布的光影。
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF13 = 2
使用 PCF13 过滤法来过滤画布的光影。
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_MAX = 3
CanvasLightShadowFilter 枚举的最大值。
enum CanvasOccluderPolygonCullMode: 🔗
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_DISABLED = 0
禁用画布遮挡物的剔除。
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE = 1
画布遮挡器的剔除是顺时针的。
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE = 2
画布遮挡物的剔除是逆时针的。
enum GlobalShaderParameterType: 🔗
GlobalShaderParameterType GLOBAL_VAR_TYPE_BOOL = 0
布尔型全局着色器参数（global uniform bool ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC2 = 1
二维布尔向量全局着色器参数（global uniform bvec2 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC3 = 2
三维布尔向量全局着色器参数（global uniform bvec3 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC4 = 3
四维布尔向量全局着色器参数（global uniform bvec4 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_INT = 4
整数全局着色器参数（global uniform int ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC2 = 5
二维整数向量全局着色器参数（global uniform ivec2 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC3 = 6
三维整数向量全局着色器参数（global uniform ivec3 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC4 = 7
四维整数向量全局着色器参数（global uniform ivec4 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2I = 8
二维整数矩形全局着色器参数（global uniform ivec4 ...）。等价于着色器代码中的 GLOBAL_VAR_TYPE_IVEC4，但在编辑器 UI 中以 Rect2i 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_UINT = 9
无符号整数全局着色器参数（global uniform uint ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC2 = 10
二维无符号整数向量全局着色器参数（global uniform uvec2 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC3 = 11
三维无符号整数向量全局着色器参数（global uniform uvec3 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC4 = 12
四维无符号整数向量全局着色器参数（global uniform uvec4 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_FLOAT = 13
单精度浮点数全局着色器参数（global uniform float ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC2 = 14
二维单精度浮点数向量全局着色器参数（global uniform vec2 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC3 = 15
三维单精度浮点数向量全局着色器参数（global uniform vec3 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC4 = 16
四维单精度浮点数向量全局着色器参数（global uniform vec4 ...）。
GlobalShaderParameterType GLOBAL_VAR_TYPE_COLOR = 17
颜色全局着色器参数（global uniform vec4 ...）。等价于着色器代码中的 GLOBAL_VAR_TYPE_VEC4，但在编辑器 UI 中以 Color 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2 = 18
二维浮点数矩形全局着色器参数（global uniform vec4 ...）。等价于着色器代码中的 GLOBAL_VAR_TYPE_VEC4，但在编辑器 UI 中以 Rect2 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT2 = 19
2×2 矩阵全局着色器参数（global uniform mat2 ...）。编辑器 UI 中以 PackedInt32Array 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT3 = 20
3×3 矩阵全局着色器参数（global uniform mat3 ...）。编辑器 UI 中以 Basis 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT4 = 21
4×4 矩阵全局着色器参数（global uniform mat4 ...）。编辑器 UI 中以 Projection 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM_2D = 22
二维变换全局着色器参数（global uniform mat2x3 ...）。编辑器 UI 中以 Transform2D 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM = 23
三维变换全局着色器参数（global uniform mat3x4 ...）。编辑器 UI 中以 Transform3D 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2D = 24
2D 采样器全局着色器参数（global uniform sampler2D ...）。编辑器 UI 中以 Texture2D 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2DARRAY = 25
2D 采样器数组全局着色器参数（global uniform sampler2DArray ...）。编辑器 UI 中以 Texture2DArray 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER3D = 26
3D 采样器全局着色器参数（global uniform sampler3D ...）。编辑器 UI 中以 Texture3D 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLERCUBE = 27
立方体贴图全局着色器参数（global uniform samplerCube ...）。编辑器 UI 中以 Cubemap 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLEREXT = 28
外部采样器全局着色器参数（global uniform samplerExternalOES ...）。编辑器 UI 中以 ExternalTexture 的形式暴露。
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAX = 29
代表 GlobalShaderParameterType 枚举的大小。
enum RenderingInfo: 🔗
RenderingInfo RENDERING_INFO_TOTAL_OBJECTS_IN_FRAME = 0
在当前 3D 场景中渲染的对象数。会根据相机的位置和旋转的不同而不同。
RenderingInfo RENDERING_INFO_TOTAL_PRIMITIVES_IN_FRAME = 1
在当前 3D 场景中渲染的点、线、三角的数量。会根据相机的位置和旋转的不同而不同。
RenderingInfo RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME = 2
在当前 3D 场景中渲染执行的绘制调用的数量。会根据相机的位置和旋转的不同而不同。
RenderingInfo RENDERING_INFO_TEXTURE_MEM_USED = 3
纹理内存的使用量（单位为字节）。
RenderingInfo RENDERING_INFO_BUFFER_MEM_USED = 4
缓冲内存的使用量（单位为字节）。包括顶点数据、uniform 缓冲以及内部使用的各种不同缓冲类型。
RenderingInfo RENDERING_INFO_VIDEO_MEM_USED = 5
显存的使用量（单位为字节）。使用 Forward+ 或移动渲染器时，始终比 RENDERING_INFO_TEXTURE_MEM_USED 与 RENDERING_INFO_BUFFER_MEM_USED 的总和要大，因为这两项之外还有一些杂项数据。使用 Compatibility 渲染器时，等于 RENDERING_INFO_TEXTURE_MEM_USED 与 RENDERING_INFO_BUFFER_MEM_USED 之和。
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_CANVAS = 6
由 2D 画布渲染器触发的管线编译次数。
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_MESH = 7
因加载网格而触发的管线编译次数。用户首次运行游戏且需要该管线时，这些编译会导致加载时间变长。
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SURFACE = 8
因渲染场景前构建表面缓存而触发的管线编译次数。用户首次运行游戏且需要该管线时，这些编译会导致加载场景时的卡顿。
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_DRAW = 9
因绘制场景而触发的管线编译次数。用户首次运行游戏且需要该管线时，这些编译会导致游戏过程中的卡顿。
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SPECIALIZATION = 10
因优化当前场景而触发的管线编译次数。这些编译是在后台进行的，不会导致任何卡顿。
enum PipelineSource: 🔗
PipelineSource PIPELINE_SOURCE_CANVAS = 0
由 2D 画布渲染器触发的管线编译。
PipelineSource PIPELINE_SOURCE_MESH = 1
因加载网格而触发的管线编译。
PipelineSource PIPELINE_SOURCE_SURFACE = 2
因渲染场景前构建表面缓存而触发的管线编译。
PipelineSource PIPELINE_SOURCE_DRAW = 3
因绘制场景而触发的管线编译。
PipelineSource PIPELINE_SOURCE_SPECIALIZATION = 4
因优化当前场景而触发的管线编译。
PipelineSource PIPELINE_SOURCE_MAX = 5
代表 PipelineSource 枚举的大小。
enum Features: 🔗
Features FEATURE_SHADERS = 0
已弃用： This constant has not been used since Godot 3.0.
Features FEATURE_MULTITHREADED = 1
已弃用： This constant has not been used since Godot 3.0.
常量
NO_INDEX_ARRAY = -1 🔗
标记一个错误，表明索引数组为空。
ARRAY_WEIGHTS_SIZE = 4 🔗
每个顶点的权重/骨骼数。
CANVAS_ITEM_Z_MIN = -4096 🔗
画布项目的最小 Z 层。
CANVAS_ITEM_Z_MAX = 4096 🔗
画布项目的最大 Z 层。
MAX_GLOW_LEVELS = 7 🔗
辉光后期处理效果使用的最大辉光级别数。
MAX_CURSORS = 8 🔗
已弃用： This constant is not used by the engine.
MAX_2D_DIRECTIONAL_LIGHTS = 8 🔗
2D 中同一时间能够渲染的最大方向光的数量。
MAX_MESH_SURFACES = 256 🔗
网格可拥有的最大表面数。
MATERIAL_RENDER_PRIORITY_MIN = -128 🔗
所有材质的最小渲染优先级。
MATERIAL_RENDER_PRIORITY_MAX = 127 🔗
所有材质的最大渲染优先级。
ARRAY_CUSTOM_COUNT = 4 🔗
可用自定义数据数组的数量（ARRAY_CUSTOM0、ARRAY_CUSTOM1、ARRAY_CUSTOM2、ARRAY_CUSTOM3）。
PARTICLES_EMIT_FLAG_POSITION = 1 🔗
该常量目前没有描述，请帮我们贡献一个吧！
PARTICLES_EMIT_FLAG_ROTATION_SCALE = 2 🔗
该常量目前没有描述，请帮我们贡献一个吧！
PARTICLES_EMIT_FLAG_VELOCITY = 4 🔗
该常量目前没有描述，请帮我们贡献一个吧！
PARTICLES_EMIT_FLAG_COLOR = 8 🔗
该常量目前没有描述，请帮我们贡献一个吧！
PARTICLES_EMIT_FLAG_CUSTOM = 16 🔗
该常量目前没有描述，请帮我们贡献一个吧！
属性说明
如果为 false，则完全禁用渲染，但引擎逻辑仍在处理中。即使禁用渲染，你也可以调用 force_draw() 来绘制帧。
方法说明
Array[Image] bake_render_uv2(base: RID, material_overrides: Array[RID], image_size: Vector2i) 🔗
使用可选的 material_overrides，将 base 参数中传递的 Mesh 的材质数据，烘焙为一组大小为 image_size 的 Image。返回包含 BakeChannels 中指定的材质属性的 Image 数组。
void call_on_render_thread(callable: Callable) 🔗
由于 RenderingServer 实际逻辑可能在单独的线程上运行，因此从主（或任何其他）线程访问其内部将导致错误。为了更轻松地运行可以安全访问渲染内部的代码（例如 RenderingDevice 和类似的 RD 类），请通过该函数推送一个可调用对象，以便它将在渲染线程上执行。
RID camera_attributes_create() 🔗
创建相机属性对象并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 camera_attributes_ RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 CameraAttributes。
void camera_attributes_set_auto_exposure(camera_attributes: RID, enable: bool, min_sensitivity: float, max_sensitivity: float, speed: float, scale: float) 🔗
设置用于自动曝光效果的参数。这些参数与 CameraAttributes 和 CameraAttributesPractical 中的对应参数具有相同的含义。
void camera_attributes_set_dof_blur(camera_attributes: RID, far_enable: bool, far_distance: float, far_transition: float, near_enable: bool, near_distance: float, near_transition: float, amount: float) 🔗
设置用于 DOF 模糊效果的参数。这些参数与 CameraAttributesPractical 中的对应参数具有相同的含义。
void camera_attributes_set_dof_blur_bokeh_shape(shape: DOFBokehShape) 🔗
设置 DOF 散景图案的形状。可以使用不同的形状来达到艺术效果，或达到性能目标。有关可用选项的更多详细信息，请参阅 DOFBokehShape。
void camera_attributes_set_dof_blur_quality(quality: DOFBlurQuality, use_jitter: bool) 🔗
将 DOF 模糊效果的质量级别设置为 DOFBlurQuality 中的选项之一。use_jitter 可用于抖动模糊过程中采集的样本，以隐藏伪影，代价是看起来更模糊。
void camera_attributes_set_exposure(camera_attributes: RID, multiplier: float, normalization: float) 🔗
设置渲染器所使用的曝光值。归一化量用于将给定的曝光值（Exposure Value，EV）烘焙进渲染计算，从而降低场景的动态范围。
可以用如下方法根据曝光值（EV100）来计算归一化系数：
func get_exposure_normalization(ev100: float):
return 1.0 / (pow(2.0, ev100) * 1.2)
可以使用如下方法根据光圈（单位为 F 值）、快门速度（单位为秒）、感光度（单位为 ISO）来计算曝光值：
func get_exposure(aperture: float, shutter_speed: float, sensitivity: float):
return log((aperture * aperture) / shutter_speed * (100.0 / sensitivity)) / log(2)
创建 3D 相机并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 camera_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 Camera3D。
void camera_set_camera_attributes(camera: RID, effects: RID) 🔗
将使用 camera_attributes_create() 创建的 camera_attributes 设置给给定的相机。
void camera_set_compositor(camera: RID, compositor: RID) 🔗
设置该相机使用的合成器。相当于 Camera3D.compositor。
void camera_set_cull_mask(camera: RID, layers: int) 🔗
设置与该相机关联的剔除掩码。剔除掩码描述了该相机渲染了哪些 3D 图层。相当于 Camera3D.cull_mask。
void camera_set_environment(camera: RID, env: RID) 🔗
设置该相机使用的环境。相当于 Camera3D.environment。
void camera_set_frustum(camera: RID, size: float, offset: Vector2, z_near: float, z_far: float) 🔗
将相机设置为使用视锥投影。该模式允许调整 offset 参数以创建“倾斜视锥”效果。
void camera_set_orthogonal(camera: RID, size: float, z_near: float, z_far: float) 🔗
将相机设置为使用正交投影，也称为正射投影。物体在屏幕上保持相同的尺寸，无论它们有多远。
void camera_set_perspective(camera: RID, fovy_degrees: float, z_near: float, z_far: float) 🔗
将相机设置为使用透视投影。屏幕上的物体在远处时变得更小。
void camera_set_transform(camera: RID, transform: Transform3D) 🔗
设置相机的 Transform3D。
void camera_set_use_vertical_aspect(camera: RID, enable: bool) 🔗
如果为 true，则保留水平长宽比，相当于 Camera3D.KEEP_WIDTH。如果为 false，则保留垂直长宽比，相当于 Camera3D.KEEP_HEIGHT。
创建画布并返回分配的 RID。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
void canvas_item_add_animation_slice(item: RID, animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0) 🔗
后续的绘制命令将被忽略，除非它们位于指定的动画切片内。这是实现在背景上循环而不是不断重绘的动画的更快方法。
void canvas_item_add_circle(item: RID, pos: Vector2, radius: float, color: Color, antialiased: bool = false) 🔗
在 item RID 指向的 CanvasItem 上绘制一个圆圈。另见 CanvasItem.draw_circle()。
void canvas_item_add_clip_ignore(item: RID, ignore: bool) 🔗
如果 ignore 为 true，则使用该画布项绘制的项目会忽略裁剪，直到将 ignore 设置为 false 再次调用。
void canvas_item_add_lcd_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color) 🔗
另见 CanvasItem.draw_lcd_texture_rect_region()。
void canvas_item_add_line(item: RID, from: Vector2, to: Vector2, color: Color, width: float = -1.0, antialiased: bool = false) 🔗
在 item RID 指向的 CanvasItem 上画一条线。另见 CanvasItem.draw_line()。
void canvas_item_add_mesh(item: RID, mesh: RID, transform: Transform2D = Transform2D(1, 0, 0, 1, 0, 0), modulate: Color = Color(1, 1, 1, 1), texture: RID = RID()) 🔗
使用给定的 transform、modulate 颜色和 texture 绘制使用 mesh_create() 创建的网格。这由 MeshInstance2D 内部使用。
void canvas_item_add_msdf_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), outline_size: int = 0, px_range: float = 1.0, scale: float = 1.0) 🔗
另见 CanvasItem.draw_msdf_texture_rect_region()。
void canvas_item_add_multiline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗
在 item RID 指向的 CanvasItem 上，绘制一个 2D 多线。另见 CanvasItem.draw_multiline() 和 CanvasItem.draw_multiline_colors()。
void canvas_item_add_multimesh(item: RID, mesh: RID, texture: RID = RID()) 🔗
在 item RID 指向的 CanvasItem 上，绘制一个 2D MultiMesh。另见 CanvasItem.draw_multimesh()。
void canvas_item_add_nine_patch(item: RID, rect: Rect2, source: Rect2, texture: RID, topleft: Vector2, bottomright: Vector2, x_axis_mode: NinePatchAxisMode = 0, y_axis_mode: NinePatchAxisMode = 0, draw_center: bool = true, modulate: Color = Color(1, 1, 1, 1)) 🔗
在 item RID 指向的 CanvasItem 上，绘制一个九宫格矩形。
void canvas_item_add_particles(item: RID, particles: RID, texture: RID) 🔗
在 item RID 指向的 CanvasItem 上绘制粒子。
void canvas_item_add_polygon(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: RID = RID()) 🔗
在 item RID 指向的 CanvasItem 上绘制一个 2D 多边形。如果需要更高的灵活度（例如能够用到骨骼），请改用 canvas_item_add_triangle_array()。另见 CanvasItem.draw_polygon()。
注意：如果你需要频繁重绘同样的多边形，包含大量顶点，请考虑预先使用 Geometry2D.triangulate_polygon() 进行三角剖分计算，并使用 CanvasItem.draw_mesh()、CanvasItem.draw_multimesh() 或 canvas_item_add_triangle_array()。
void canvas_item_add_polyline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗
在 item RID 指向的 CanvasItem 上，绘制一个 2D 折线。另见 CanvasItem.draw_polyline() 和 CanvasItem.draw_polyline_colors()。
void canvas_item_add_primitive(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: RID) 🔗
在 item RID 指向的 CanvasItem 上绘制一个 2D 图元。另见 CanvasItem.draw_primitive()。
void canvas_item_add_rect(item: RID, rect: Rect2, color: Color, antialiased: bool = false) 🔗
在 item RID 指向的 CanvasItem 上绘制一个矩形。另见 CanvasItem.draw_rect()。
void canvas_item_add_set_transform(item: RID, transform: Transform2D) 🔗
设置将被用于变换后续画布项命令的 Transform2D。
void canvas_item_add_texture_rect(item: RID, rect: Rect2, texture: RID, tile: bool = false, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false) 🔗
在 item RID 指向的 CanvasItem 上绘制一个有纹理的 2D 矩形。另见 CanvasItem.draw_texture_rect() 和 Texture2D.draw_rect()。
void canvas_item_add_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false, clip_uv: bool = true) 🔗
在 item RID 指向的 CanvasItem 上绘制一个有纹理 2D 矩形的特定区域。另见 CanvasItem.draw_texture_rect_region() 和 Texture2D.draw_rect_region()。
void canvas_item_add_triangle_array(item: RID, indices: PackedInt32Array, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), bones: PackedInt32Array = PackedInt32Array(), weights: PackedFloat32Array = PackedFloat32Array(), texture: RID = RID(), count: int = -1) 🔗
在 item RID 指向的 CanvasItem 上绘制一个三角形数组。渲染 Line2D 和 StyleBoxFlat 时内部使用。canvas_item_add_triangle_array() 非常灵活，但用起来要比 canvas_item_add_polygon() 复杂。
注意：count 未使用，可以不指定。
void canvas_item_attach_skeleton(item: RID, skeleton: RID) 🔗
将骨架附加到 CanvasItem 上。会移除之前骨架。
void canvas_item_clear(item: RID) 🔗
清空 CanvasItem 并删除其中的所有命令。
新建 CanvasItem 实例并返回其 RID。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_item_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 CanvasItem。
Variant canvas_item_get_instance_shader_parameter(instance: RID, parameter: StringName) const 🔗
返回指定画布项实例的单实例着色器 uniform 取值。等价于 CanvasItem.get_instance_shader_parameter()。
Variant canvas_item_get_instance_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗
返回指定画布项实例的单实例着色器 uniform 默认取值。等价于 CanvasItem.get_instance_shader_parameter()。
Array[Dictionary] canvas_item_get_instance_shader_parameter_list(instance: RID) const 🔗
返回指定画布项实例的单实例着色器 uniform 名称的字典。
返回的字典使用 PropertyInfo 格式，包含 name、class_name、type、hint、hint_string 以及 usage 等字段。
void canvas_item_reset_physics_interpolation(item: RID) 🔗
防止当前物理刻度的物理插值。
这在将画布项移动到新位置时很有用，可以产生瞬时变化，而不是从先前位置进行插值。
void canvas_item_set_canvas_group_mode(item: RID, mode: CanvasGroupMode, clear_margin: float = 5.0, fit_empty: bool = false, fit_margin: float = 0.0, blur_mipmaps: bool = false) 🔗
设置对画布项进行 2D 渲染时使用的画布分组模式，画布项由 item RID 指定。要使用更快速但局限性更大的裁剪，请改用 canvas_item_set_clip()。
注意：等价的节点功能可以在 CanvasGroup 和 CanvasItem.clip_children 中找到。
void canvas_item_set_clip(item: RID, clip: bool) 🔗
如果 clip 为 true，则画布项不会在其矩形坐标之外绘制内容，画布项由 item RID 指定。这种裁剪很快，但只能用于轴对齐的矩形。也就是说裁剪矩形会忽略旋转。更高阶的裁剪形状请改用 canvas_item_set_canvas_group_mode()。
注意：等价的节点功能可以在 Label.clip_text、RichTextLabel（始终启用）等处找到。
void canvas_item_set_copy_to_backbuffer(item: RID, enabled: bool, rect: Rect2) 🔗
设置 CanvasItem 以将矩形复制到后台缓冲区。
void canvas_item_set_custom_rect(item: RID, use_custom_rect: bool, rect: Rect2 = Rect2(0, 0, 0, 0)) 🔗
如果 use_custom_rect 为 true，则将画布项 item 的自定义可见性框设置为 rect（用于剔除）。设置自定义可见性框能够在绘制大量 2D 实例时降低 CPU 负载。如果 use_custom_rect 为 false，则会根据画布项的绘制命令自动计算可见性框。
void canvas_item_set_default_texture_filter(item: RID, filter: CanvasItemTextureFilter) 🔗
设置 RID 为 item 的画布项的默认纹理过滤模式。等价于 CanvasItem.texture_filter。
void canvas_item_set_default_texture_repeat(item: RID, repeat: CanvasItemTextureRepeat) 🔗
设置 RID 为 item 的画布项的默认纹理重复模式。等价于 CanvasItem.texture_repeat。
void canvas_item_set_distance_field_mode(item: RID, enabled: bool) 🔗
如果 enabled 为 true，则为 RID 为 item 的画布项启用多通道带符号距离场渲染模式。旨在用于字体渲染，或针对使用 msdfgen 生成的图像。
void canvas_item_set_draw_behind_parent(item: RID, enabled: bool) 🔗
如果 enabled 为 true，则为 RID 为 item 的画布项绘制在父级之后。等价于 CanvasItem.show_behind_parent。
void canvas_item_set_draw_index(item: RID, index: int) 🔗
设置 CanvasItem 的索引。
void canvas_item_set_instance_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗
设置指定画布项实例的单实例着色器 uniform。等价于 CanvasItem.set_instance_shader_parameter()。
void canvas_item_set_interpolated(item: RID, interpolated: bool) 🔗
如果 interpolated 为 true，则为该画布项打开物理插值。
void canvas_item_set_light_mask(item: RID, mask: int) 🔗
设置 RID 为 item 的画布项的灯光掩码 mask。等价于 CanvasItem.light_mask。
void canvas_item_set_material(item: RID, material: RID) 🔗
设置 RID 为 item 的画布项的新材质 material。等价于 CanvasItem.material。
void canvas_item_set_modulate(item: RID, color: Color) 🔗
将 RID 为 item 的画布项的颜色与其相乘，子项也受影响。另见 canvas_item_set_self_modulate()。等价于 CanvasItem.modulate。
void canvas_item_set_parent(item: RID, parent: RID) 🔗
为 CanvasItem 设置父级 CanvasItem。该项目会从父级继承变换、调制、可见性，和场景树中的 CanvasItem 节点一样。
void canvas_item_set_self_modulate(item: RID, color: Color) 🔗
将 RID 为 item 的画布项的颜色与其相乘，子项不受影响。另见 canvas_item_set_modulate()。等价于 CanvasItem.self_modulate。
void canvas_item_set_sort_children_by_y(item: RID, enabled: bool) 🔗
如果 enabled 为 true，则会在绘制 Y 位置最低的子节点之后再绘制 Y 位置较高的子节点。Y 排序仅影响继承自该画布项的子级，不影响画布项自身，该画布项由 item RID 指定。等价于 CanvasItem.y_sort_enabled。
void canvas_item_set_transform(item: RID, transform: Transform2D) 🔗
将 RID 为 item 的画布项的变换设置为 transform。会影响该画布项绘制的位置和方法。子级画布项的变换会与父级变换相乘。等价于 Node2D.transform。
void canvas_item_set_use_parent_material(item: RID, enabled: bool) 🔗
设置 CanvasItem 是否使用其父级的材质。
void canvas_item_set_visibility_layer(item: RID, visibility_layer: int) 🔗
设置与这个 CanvasItem 关联的渲染可见性层。只有渲染掩码与此匹配的 Viewport 节点才会渲染这个 CanvasItem。
void canvas_item_set_visibility_notifier(item: RID, enable: bool, area: Rect2, enter_callable: Callable, exit_callable: Callable) 🔗
将给定的 CanvasItem 设置为可见性通知器。area 定义可见性检查的区域。CanvasItem 进入屏幕时会调用 enter_callable，CanvasItem 退出屏幕时会调用 exit_callable。如果 enable 为 false，则该项目将不再作为通知器。
这个方法可用于手动模仿 VisibleOnScreenNotifier2D。
void canvas_item_set_visible(item: RID, visible: bool) 🔗
设置 CanvasItem 的可见性。
void canvas_item_set_z_as_relative_to_parent(item: RID, enabled: bool) 🔗
如果启用此选项，则父项的 Z 索引将添加到子项的 Z 索引中。
void canvas_item_set_z_index(item: RID, z_index: int) 🔗
设置 CanvasItem 的 Z 索引，即它的绘制顺序（首先绘制数值较低的索引）。
void canvas_item_transform_physics_interpolation(item: RID, transform: Transform2D) 🔗
同时变换画布项的当前变换和之前存储的变换。
这允许变换画布项而不会在插值中产生“卡顿”，这对于利用原点移位的大型世界特别有用。
void canvas_light_attach_to_canvas(light: RID, canvas: RID) 🔗
将画布灯连接到画布上，并将其从以前的画布中取出。
创建画布灯光并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_light_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 Light2D。
void canvas_light_occluder_attach_to_canvas(occluder: RID, canvas: RID) 🔗
将光遮挡物添加到画布上,并将其从之前的画布中移除。
RID canvas_light_occluder_create() 🔗
创建光线遮挡器并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_light_occluder_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 LightOccluder2D。
void canvas_light_occluder_reset_physics_interpolation(occluder: RID) 🔗
阻止当前物理周期的物理插值。
适用于将遮挡器移动至新位置的情况，这样修改就是即时的，不会从原有位置进行插值。
void canvas_light_occluder_set_as_sdf_collision(occluder: RID, enable: bool) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void canvas_light_occluder_set_enabled(occluder: RID, enabled: bool) 🔗
启用或禁用遮光器。
void canvas_light_occluder_set_interpolated(occluder: RID, interpolated: bool) 🔗
如果 interpolated 为 true，则为该灯光遮挡器打开物理插值。
void canvas_light_occluder_set_light_mask(occluder: RID, mask: int) 🔗
光线遮罩。详见 LightOccluder2D。
void canvas_light_occluder_set_polygon(occluder: RID, polygon: RID) 🔗
设置光遮挡物的多边形。
void canvas_light_occluder_set_transform(occluder: RID, transform: Transform2D) 🔗
设置光遮挡物的 Transform2D。
void canvas_light_occluder_transform_physics_interpolation(occluder: RID, transform: Transform2D) 🔗
同时变换光遮挡器的当前变换和之前存储的变换。
这允许变换遮挡器而不会在插值中产生“卡顿”，这对于利用原点移位的大型世界特别有用。
void canvas_light_reset_physics_interpolation(light: RID) 🔗
防止当前物理刻度的物理插值。
这在将画布项移动到新位置时很有用，可以产生瞬时变化，而不是从先前位置进行插值。
void canvas_light_set_blend_mode(light: RID, mode: CanvasLightBlendMode) 🔗
设置给定画布灯光的混合模式。选项见 CanvasLightBlendMode。等价于 Light2D.blend_mode。
void canvas_light_set_color(light: RID, color: Color) 🔗
设置灯光的颜色。
void canvas_light_set_enabled(light: RID, enabled: bool) 🔗
启用或禁用画布灯。
void canvas_light_set_energy(light: RID, energy: float) 🔗
设置画布灯的能量。
void canvas_light_set_height(light: RID, height: float) 🔗
设置画布灯的高度。
void canvas_light_set_interpolated(light: RID, interpolated: bool) 🔗
如果 interpolated 为 true，则为该画布灯光打开物理插值。
void canvas_light_set_item_cull_mask(light: RID, mask: int) 🔗
光线遮罩。详见 LightOccluder2D。
void canvas_light_set_item_shadow_cull_mask(light: RID, mask: int) 🔗
用于确定此画布灯光阴影影响哪些图层的二进制蒙版。有关光遮罩的更多信息，请参阅 LightOccluder2D。
void canvas_light_set_layer_range(light: RID, min_layer: int, max_layer: int) 🔗
使用此灯光渲染的图层范围。
void canvas_light_set_mode(light: RID, mode: CanvasLightMode) 🔗
光的模式，详见CanvasLightMode。
void canvas_light_set_shadow_color(light: RID, color: Color) 🔗
设置画布灯的阴影颜色。
void canvas_light_set_shadow_enabled(light: RID, enabled: bool) 🔗
启用或禁用画布灯的阴影。
void canvas_light_set_shadow_filter(light: RID, filter: CanvasLightShadowFilter) 🔗
设置画布灯的阴影过滤器，详见 CanvasLightShadowFilter 。
void canvas_light_set_shadow_smooth(light: RID, smooth: float) 🔗
使阴影变得平滑。数值越低越光滑。
void canvas_light_set_texture(light: RID, texture: RID) 🔗
设置 PointLight2D 所使用的纹理。相当于 PointLight2D.texture。
void canvas_light_set_texture_offset(light: RID, offset: Vector2) 🔗
设置 PointLight2D 纹理的偏移量。相当于 PointLight2D.offset。
void canvas_light_set_texture_scale(light: RID, scale: float) 🔗
设置 PointLight2D 纹理的缩放系数。相当于 PointLight2D.texture_scale。
void canvas_light_set_transform(light: RID, transform: Transform2D) 🔗
设置画布灯的 Transform2D。
void canvas_light_set_z_range(light: RID, min_z: int, max_z: int) 🔗
设置将受此光影响的对象的 Z 范围。相当于 Light2D.range_z_min 和 Light2D.range_z_max。
void canvas_light_transform_physics_interpolation(light: RID, transform: Transform2D) 🔗
同时变换画布灯光的当前变换和之前存储的变换。
这样插值就可以在变换灯光的同时不产生“突变”，对于利用原点移位的大型世界特别有用。
RID canvas_occluder_polygon_create() 🔗
新建光线遮挡多边形并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_occluder_polygon_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 OccluderPolygon2D。
void canvas_occluder_polygon_set_cull_mode(occluder_polygon: RID, mode: CanvasOccluderPolygonCullMode) 🔗
设置遮挡多边形剔除模式。详见 CanvasOccluderPolygonCullMode 。
void canvas_occluder_polygon_set_shape(occluder_polygon: RID, shape: PackedVector2Array, closed: bool) 🔗
设置遮挡多边形的形状。
void canvas_set_disable_scale(disable: bool) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void canvas_set_item_mirroring(canvas: RID, item: RID, mirroring: Vector2) 🔗
使用局部偏移量 mirroring 绘制画布项的副本。
注意：等价于使用类似 canvas_set_item_repeat(item, mirroring, 1) 的代码调用 canvas_set_item_repeat()，会进行额外的检查，确保 canvas 是 item 的父级。
void canvas_set_item_repeat(item: RID, repeat_size: Vector2, repeat_times: int) 🔗
将使用 repeat_size 的局部偏移量和 repeat_times 的次数来绘制画布项目的副本。随着 repeat_times 的增加，副本将从原始纹理蔓延开来。
void canvas_set_modulate(canvas: RID, color: Color) 🔗
调制给定画布中的所有颜色。
void canvas_set_shadow_texture_size(size: int) 🔗
设置 Light2D 阴影渲染时使用的 ProjectSettings.rendering/2d/shadow_atlas/size（单位为像素）。该值会向上取整到最接近的 2 的幂。
创建画布纹理并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 canvas_texture_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。另见 texture_2d_create()。
注意：等价资源为 CanvasTexture，应该仅用于 2D 渲染，不用于 3D。
void canvas_texture_set_channel(canvas_texture: RID, channel: CanvasTextureChannel, texture: RID) 🔗
为画布纹理设置 channel 通道的纹理 texture，该画布纹理由 RID canvas_texture 指定。等价于 CanvasTexture.diffuse_texture、CanvasTexture.normal_texture 和 CanvasTexture.specular_texture。
void canvas_texture_set_shading_parameters(canvas_texture: RID, base_color: Color, shininess: float) 🔗
为画布纹理设置 base_color 和 shininess，该画布纹理由 RID canvas_texture 指定。等价于 CanvasTexture.specular_color 和 CanvasTexture.specular_shininess。
void canvas_texture_set_texture_filter(canvas_texture: RID, filter: CanvasItemTextureFilter) 🔗
为画布纹理设置纹理过滤模式 filter，该画布纹理由 RID canvas_texture 指定。
void canvas_texture_set_texture_repeat(canvas_texture: RID, repeat: CanvasItemTextureRepeat) 🔗
为画布纹理设置纹理重复模式 repeat，该画布纹理由 RID canvas_texture 指定。
创建一个新的合成器并将其添加到 RenderingServer。可以使用返回的 RID 来访问它。
RID 使用完后，你将需要使用 RenderingServer 的 free_rid() 方法释放该 RID。
RID compositor_effect_create() 🔗
创建新的渲染效果并将其添加到 RenderingServer。可以使用返回的 RID 来访问它。
RID 使用完后，你将需要使用 RenderingServer 的 free_rid() 方法释放该 RID。
void compositor_effect_set_callback(effect: RID, callback_type: CompositorEffectCallbackType, callback: Callable) 🔗
设置该渲染效果的回调类型（callback_type）和回调方法（callback）。
void compositor_effect_set_enabled(effect: RID, enabled: bool) 🔗
启用/禁用该渲染效果。
void compositor_effect_set_flag(effect: RID, flag: CompositorEffectFlags, set: bool) 🔗
将该渲染效果的标志（flag）设置为 true 或 false（set）。
void compositor_set_compositor_effects(compositor: RID, effects: Array[RID]) 🔗
设置指定合成器 RID 的合成器效果。effects 应该是一个包含使用 compositor_effect_create() 创建的 RID 的数组。
RenderingDevice create_local_rendering_device() const 🔗
创建一个 RenderingDevice，可以用来在单独的线程上进行绘制和计算操作。不能绘制到屏幕上，也不能与全局的 RenderingDevice 共享数据。
注意：使用 OpenGL 渲染驱动或在无头模式下运行时，这个函数始终返回 null 。
Rect2 debug_canvas_item_get_rect(item: RID) 🔗
返回渲染器计算出的局部空间中画布项的边界矩形。该边界在内部用于剔除。
警告：该函数用于在编辑器中进行调试，并且将在导出的项目中跳过并返回零 Rect2。
创建贴花并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 decal_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个贴花放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：等价节点为 Decal。
void decal_set_albedo_mix(decal: RID, albedo_mix: float) 🔗
为贴花设置 albedo_mix，该贴花由 RID decal 指定。等价于 Decal.albedo_mix。
void decal_set_cull_mask(decal: RID, mask: int) 🔗
为贴花设置剔除掩码 mask，该贴花由 RID decal 指定。等价于 Decal.cull_mask。
void decal_set_distance_fade(decal: RID, enabled: bool, begin: float, length: float) 🔗
为贴花设置距离淡出参数，该贴花由 RID decal 指定。等价于 Decal.distance_fade_enabled、Decal.distance_fade_begin 和 Decal.distance_fade_length。
void decal_set_emission_energy(decal: RID, energy: float) 🔗
为贴花设置自发光能量 energy，该贴花由 RID decal 指定。等价于 Decal.emission_energy。
void decal_set_fade(decal: RID, above: float, below: float) 🔗
为贴花设置上侧淡出（above）和下侧淡出（below），该贴花由 RID decal 指定。等价于 Decal.upper_fade 和 Decal.lower_fade。
void decal_set_modulate(decal: RID, color: Color) 🔗
将贴花的颜色乘数设置为 color，该贴花由 RID decal 指定。等价于 Decal.modulate。
void decal_set_normal_fade(decal: RID, fade: float) 🔗
设置 RID 为 decal 的贴花的法线淡出 fade。等价于 Decal.normal_fade。
void decal_set_size(decal: RID, size: Vector3) 🔗
设置 RID 为 decal 的贴花的大小 size。等价于 Decal.size。
void decal_set_texture(decal: RID, type: DecalTexture, texture: RID) 🔗
设置指定贴花中给定纹理类型插槽 type 的纹理 texture。等价于 Decal.set_texture()。
void decals_set_filter(filter: DecalFilter) 🔗
设置渲染贴花时所使用的纹理过滤模式 filter。这个参数是全局的，无法针对某个贴花单独设置。
RID directional_light_create() 🔗
创建平行光并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在大多数 light_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个平行光放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：等价节点为 DirectionalLight3D。
void directional_shadow_atlas_set_size(size: int, is_16bits: bool) 🔗
设置 3D 方向灯光的阴影大小 size。另见 ProjectSettings.rendering/lights_and_shadows/directional_shadow/size。这个参数是全局的，无法针对某个视口单独设置。
void directional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗
设置 3D 方向灯光的阴影过滤质量 quality。另见 ProjectSettings.rendering/lights_and_shadows/directional_shadow/soft_shadow_filter_quality。这个参数是全局的，无法针对某个视口单独设置。
Image environment_bake_panorama(environment: RID, bake_irradiance: bool, size: Vector2i) 🔗
生成并返回包含 environment RID 中的天空的辐射率贴图的 Image。支持内置天空材质和自定义天空着色器。如果 bake_irradiance 为 true，则保存的是辐照度贴图，而不是辐射率贴图。辐射率贴图用于渲染反射光，而辐照度贴图用于渲染环境光。另见 sky_bake_panorama()。
注意：图像使用线性色彩空间保存，未执行任何色调映射，也就是说如果在图像编辑器中查看会显得太暗。
注意：要让生成的全景图拥有正方形的像素，size 的长宽比应该为 2:1。辐射率贴图的高度超过 Sky.radiance_size 没有意义，不会增加细节。辐照度仅包含低频数据，保存时超过 128×64 像素通常没有意义。
创建环境并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 environment_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 Environment。
void environment_glow_set_use_bicubic_upscale(enable: bool) 🔗
如果 enable 为 true，则会为辉光启用双三次插值，能够牺牲性能、提升质量。等价于 ProjectSettings.rendering/environment/glow/upscale_mode。
void environment_set_adjustment(env: RID, enable: bool, brightness: float, contrast: float, saturation: float, use_1d_color_correction: bool, color_correction: RID) 🔗
设置用于“调整”后期处理效果的数值。详见 Environment。
void environment_set_ambient_light(env: RID, color: Color, ambient: EnvironmentAmbientSource = 0, energy: float = 1.0, sky_contribution: float = 0.0, reflection_source: EnvironmentReflectionSource = 0) 🔗
设置用于环境光渲染的数值。详见 Environment。
void environment_set_background(env: RID, bg: EnvironmentBG) 🔗
设置环境的背景模式。等价于 Environment.background_mode。
void environment_set_bg_color(env: RID, color: Color) 🔗
场景中清屏区域的颜色。仅在使用 ENV_BG_COLOR 背景模式时有效。
void environment_set_bg_energy(env: RID, multiplier: float, exposure_value: float) 🔗
设置背景颜色的强度。
void environment_set_camera_id(env: RID, id: int) 🔗
设置用作环境背景的相机 ID。
void environment_set_canvas_max_layer(env: RID, max_layer: int) 🔗
如果使用画布背景模式，设置要使用的最大层数。
void environment_set_fog(env: RID, enable: bool, light_color: Color, light_energy: float, sun_scatter: float, density: float, height: float, height_density: float, aerial_perspective: float, sky_affect: float, fog_mode: EnvironmentFogMode = 0) 🔗
为指定的环境 RID 配置雾。详见 Environment 中的 fog_* 属性。
void environment_set_glow(env: RID, enable: bool, levels: PackedFloat32Array, intensity: float, strength: float, mix: float, bloom_threshold: float, blend_mode: EnvironmentGlowBlendMode, hdr_bleed_threshold: float, hdr_bleed_scale: float, hdr_luminance_cap: float, glow_map_strength: float, glow_map: RID) 🔗
为指定的环境 RID 配置辉光。详见 Environment 中的 glow_* 属性。
void environment_set_sdfgi(env: RID, enable: bool, cascades: int, min_cell_size: float, y_scale: EnvironmentSDFGIYScale, use_occlusion: bool, bounce_feedback: float, read_sky: bool, energy: float, normal_bias: float, probe_bias: float) 🔗
为指定的环境 RID 配置带符号距离场全局光照。详见 Environment 中的 sdfgi_* 属性。
void environment_set_sdfgi_frames_to_converge(frames: EnvironmentSDFGIFramesToConverge) 🔗
设置用于聚合带符号距离场全局光照的帧数。等价于 ProjectSettings.rendering/global_illumination/sdfgi/frames_to_converge。
void environment_set_sdfgi_frames_to_update_light(frames: EnvironmentSDFGIFramesToUpdateLight) 🔗
设置计算带符号距离场全局光照时动态灯光间接光照的更新速度。等价于 ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights。
void environment_set_sdfgi_ray_count(ray_count: EnvironmentSDFGIRayCount) 🔗
设置计算带符号距离场全局光照时每帧射出的光线数。等价于 ProjectSettings.rendering/global_illumination/sdfgi/probe_ray_count。
void environment_set_sky(env: RID, sky: RID) 🔗
设置当使用 BGMode 天空时被用作环境背景的 Sky。相当于 Environment.sky。
void environment_set_sky_custom_fov(env: RID, scale: float) 🔗
为背景 Sky 设置自定义视野。相当于 Environment.sky_custom_fov。
void environment_set_sky_orientation(env: RID, orientation: Basis) 🔗
设置被表示为 Basis 的背景 Sky 的旋转。相当于 Environment.sky_rotation，其中旋转向量用于构建该 Basis。
void environment_set_ssao(env: RID, enable: bool, radius: float, intensity: float, power: float, detail: float, horizon: float, sharpness: float, light_affect: float, ao_channel_affect: float) 🔗
设置屏幕空间环境光遮蔽（SSAO）后期处理效果所使用的变量。详见 Environment。
void environment_set_ssao_quality(quality: EnvironmentSSAOQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗
设置屏幕空间环境光遮蔽（SSAO）后期处理效果的质量级别。详见 Environment。
void environment_set_ssil_quality(quality: EnvironmentSSILQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗
设置屏幕空间间接照明（SSIL）后期处理效果的质量级别。详见 Environment。
void environment_set_ssr(env: RID, enable: bool, max_steps: int, fade_in: float, fade_out: float, depth_tolerance: float) 🔗
设置屏幕空间反射（SSR）后期处理效果所使用的变量。详见 Environment。
void environment_set_ssr_roughness_quality(quality: EnvironmentSSRRoughnessQuality) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void environment_set_tonemap(env: RID, tone_mapper: EnvironmentToneMapper, exposure: float, white: float) 🔗
设置“色调映射”后期处理效果所使用的变量。详见 Environment。
void environment_set_volumetric_fog(env: RID, enable: bool, density: float, albedo: Color, emission: Color, emission_energy: float, anisotropy: float, length: float, p_detail_spread: float, gi_inject: float, temporal_reprojection: bool, temporal_reprojection_amount: float, ambient_inject: float, sky_affect: float) 🔗
设置体积雾后期处理效果所使用的变量。详见 Environment。
void environment_set_volumetric_fog_filter_active(active: bool) 🔗
启用体积雾散射缓冲区的过滤。这会产生更平滑的体积，并且几乎没有欠采样伪影。
void environment_set_volumetric_fog_volume_size(size: int, depth: int) 🔗
设置体积雾的片段体素缓冲区分辨率。size 会被屏幕的纵横比修改，用于设置缓冲区的宽度和高度。depth 则用于设置缓冲区的深度。
新建雾体积并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 fog_volume_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 FogVolume。
void fog_volume_set_material(fog_volume: RID, material: RID) 🔗
设置该雾体积的 Material。可以是 FogMaterial，也可以是自定义的 ShaderMaterial。
void fog_volume_set_shape(fog_volume: RID, shape: FogVolumeShape) 🔗
将雾体积的形状设置为 FOG_VOLUME_SHAPE_ELLIPSOID、FOG_VOLUME_SHAPE_CONE、FOG_VOLUME_SHAPE_CYLINDER、FOG_VOLUME_SHAPE_BOX 或 FOG_VOLUME_SHAPE_WORLD。
void fog_volume_set_size(fog_volume: RID, size: Vector3) 🔗
设置形状为 FOG_VOLUME_SHAPE_ELLIPSOID、FOG_VOLUME_SHAPE_CONE、FOG_VOLUME_SHAPE_CYLINDER 或 FOG_VOLUME_SHAPE_BOX 时，雾体积的大小。
void force_draw(swap_buffers: bool = true, frame_step: float = 0.0) 🔗
强制立即重绘所有视口。必须从主线程调用。
void force_sync() 🔗
强制在 CPU 和 GPU 之间进行同步，某些情况下是必须的。请只在需要时调用，因为 CPU-GPU 同步对性能有影响。
尝试释放 RenderingServer 中的某个对象。为了避免内存泄漏，应该在使用完对象后调用，因为直接使用 RenderingServer 时不会自动进行内存管理。
String get_current_rendering_driver_name() const 🔗
返回当前渲染驱动的名称，可以是 vulkan、d3d12、metal、opengl3、opengl3_es 或 opengl3_angle。另见 get_current_rendering_method().
渲染方法由 ProjectSettings.rendering/rendering_device/driver 决定，--rendering-driver 命令行参数会覆盖该项目设置，还会根据硬件应用自动回退。
String get_current_rendering_method() const 🔗
返回当前渲染方法的名称，可以是 forward_plus、mobile 或 gl_compatibility。另见 get_current_rendering_driver_name().
渲染方法由 ProjectSettings.rendering/renderer/rendering_method 决定，--rendering-method 命令行参数会覆盖该项目设置，还会根据硬件应用自动回退。
Color get_default_clear_color() 🔗
返回默认清屏颜色，会在没有选择特定的清屏颜色时使用。另见 set_default_clear_color()。
float get_frame_setup_time_cpu() const 🔗
返回在 CPU 上设置渲染所消耗的时间，单位为毫秒。这个值是所有视口共享的，不需要在查询的视口上启用 viewport_set_measure_render_time()。另见 viewport_get_measured_render_time_cpu()。
RenderingDevice get_rendering_device() const 🔗
返回全局的 RenderingDevice。
注意：当使用 OpenGL 渲染驱动或在无头模式下运行时，这个函数始终返回 null。
int get_rendering_info(info: RenderingInfo) 🔗
返回关于渲染引擎的统计信息，能够用于性能分析。能够查询的值的列表见 RenderingInfo。另见 viewport_get_render_info()，返回的是某个视口的相关信息。
注意：部分值目前仅考虑 3D 渲染，例如绘制调用的数量。
注意：引擎渲染至少 2 帧后渲染信息才可用。渲染信息不可用时 get_rendering_info() 返回 0。要在 _ready() 中成功输出渲染信息，请使用如下代码：
func _ready():
for _i in 2:
await get_tree().process_frame
print(RenderingServer.get_rendering_info(RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME))
Array[Dictionary] get_shader_parameter_list(shader: RID) const 🔗
返回着色器的参数。
返回测试立方体的 RID。首次调用 get_test_cube() 时会创建并返回该网格，然后为后续调用缓存。另见 make_sphere_mesh()。
返回带有测试图案的 256×256 纹理（格式为 Image.FORMAT_RGB8）。首次调用 get_test_texture() 时会创建并返回该纹理，然后为后续调用缓存。另见 get_white_texture()。
示例：获取测试纹理并将其应用至 Sprite2D 节点：
var texture_rid = RenderingServer.get_test_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture
String get_video_adapter_api_version() const 🔗
返回当前使用的图形视频适配器的版本（例如，Vulkan 为“1.2.189”，OpenGL 为“3.3.0 NVIDIA 510.60.02”）。该版本可能与硬件支持的实际最新版本不同，因为 Godot 可能并不总是要求最新版本。另见 OS.get_video_adapter_driver_info()。
注意：当运行无头或服务器可执行文件时，该函数返回一个空字符串。
String get_video_adapter_name() const 🔗
返回视频适配器的名称（例如“GeForce GTX 1080/PCIe/SSE2”）。
注意：运行无头或服务器二进制文件时，该函数返回空字符串。
注意：在 web 平台上，某些浏览器（例如 Firefox）可能会报告不同的固定 GPU 名称，例如“GeForce GTX 980”（无论用户的实际 GPU 型号如何）。这样做是为了使指纹识别更加困难。
DeviceType get_video_adapter_type() const 🔗
返回视频适配器的类型。由于给定代的专用显卡通常明显快于同一代制造的集成显卡，因此设备类型可用作自动图形设置调整的基础。然而，这并不总是正确的，因此请确保为用户提供一种手动覆盖图形设置的方法。
注意：当使用 OpenGL 渲染驱动或在无头模式下运行时，该函数始终返回 RenderingDevice.DEVICE_TYPE_OTHER。
String get_video_adapter_vendor() const 🔗
返回视频适配器的供应商（例如 "NVIDIA Corporation"）。
注意：当运行精简或服务器可执行文件时，该函数返回一个空字符串。
返回 4×4 的白色纹理（格式为 Image.FORMAT_RGB8）。首次调用 get_white_texture() 时会创建并返回该纹理，然后为后续调用缓存。另见 get_test_texture()。
示例：获取测试纹理并将其应用至 Sprite2D 节点：
var texture_rid = RenderingServer.get_white_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture
void gi_set_use_half_resolution(half_resolution: bool) 🔗
如果 half_resolution 为 true，则每个轴上都会使用一半的分辨率渲染 VoxelGI 和 SDFGI（Environment.sdfgi_enabled）缓冲区（例如视口大小为 1920×1080 时使用 960×540）。启用 VoxelGI 或 SDFGI 时，这样做能够显著提升性能，但代价是多边形边缘可能产生显示问题。视口分辨率越高，越不容易注意到质量的损失。LightmapGI 的渲染不受这个设置的影响。等价于 ProjectSettings.rendering/global_illumination/gi/use_half_resolution。
void global_shader_parameter_add(name: StringName, type: GlobalShaderParameterType, default_value: Variant) 🔗
新建全局着色器 uniform。
注意：全局着色器参数名称是大小写敏感的。
Variant global_shader_parameter_get(name: StringName) const 🔗
返回名称为 name 的全局着色器 uniform 的值。
注意：global_shader_parameter_get() 存在较大的性能损耗，因为渲染线程需要与调用线程同步，这个过程比较慢。为了避免卡顿，请勿在游戏过程中使用这个方法。如果你需要在设置后在脚本中读取，请考虑创建一个自动加载，在设置全局参数的同时保存一份你需要查询的值。
Array[StringName] global_shader_parameter_get_list() const 🔗
返回全局着色器 uniform 名称的列表。
注意：global_shader_parameter_get() 存在较大的性能损耗，因为渲染线程需要与调用线程同步，这个过程比较慢。为了避免卡顿，请勿在游戏过程中使用这个方法。如果你需要在设置后在脚本中读取，请考虑创建一个自动加载，在设置全局参数的同时保存一份你需要查询的值。
GlobalShaderParameterType global_shader_parameter_get_type(name: StringName) const 🔗
返回与名称为 name 的全局着色器 uniform 相关联的类型。
注意：global_shader_parameter_get() 存在较大的性能损耗，因为渲染线程需要与调用线程同步，这个过程比较慢。为了避免卡顿，请勿在游戏过程中使用这个方法。如果你需要在设置后在脚本中读取，请考虑创建一个自动加载，在设置全局参数的同时保存一份你需要查询的值。
void global_shader_parameter_remove(name: StringName) 🔗
移除名称为 name 的全局着色器 Uniform。
void global_shader_parameter_set(name: StringName, value: Variant) 🔗
将名称为 name 的全局着色器 Uniform 设置为 value。
void global_shader_parameter_set_override(name: StringName, value: Variant) 🔗
使用 value 覆盖名称为 name 的全局着色器 Uniform。等价于 ShaderGlobalsOverride 节点。
如果对 RenderingServer 的数据进行了更改，则返回 true。如果发生这种情况，通常会调用 force_draw()。
bool has_feature(feature: Features) const 🔗
已弃用： This method has not been used since Godot 3.0.
该方法不执行任何操作，并且始终返回 false。
bool has_os_feature(feature: String) const 🔗
如果操作系统支持某个特性 feature，则返回 true。特性可以是 s3tc、etc、etc2。
void instance_attach_object_instance_id(instance: RID, id: int) 🔗
将唯一的对象 ID 附加到实例上。必须将对象 ID 附加到实例上，以便通过 instances_cull_aabb()、instances_cull_convex() 和 instances_cull_ray() 进行正确的筛除。
void instance_attach_skeleton(instance: RID, skeleton: RID) 🔗
将骨架附加到实例。并从实例中移除之前骨架。
创建可视实例并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 instance_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
实例可以将 3D 对象放置到场景中。粒子、网格、反射探针、贴花等对象都需要使用 instance_set_base() 与实例关联，才能显示在场景中。
注意：等价节点为 VisualInstance3D。
RID instance_create2(base: RID, scenario: RID) 🔗
创建可视实例并将其添加到 RenderingServer、设置基础和场景。可以通过返回的 RID 进行访问。这个 RID 会在大多数 instance_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。这是使用 instance_create() 并手动设置基础和场景的快捷方式。
Variant instance_geometry_get_shader_parameter(instance: RID, parameter: StringName) const 🔗
返回指定 3D 几何体实例的单实例着色器 uniform 的值。等价于 GeometryInstance3D.get_instance_shader_parameter()。
注意：单实例着色器参数的名称是大小写敏感的。
Variant instance_geometry_get_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗
返回指定 3D 几何体实例的单实例着色器 uniform 的默认值。等价于 GeometryInstance3D.get_instance_shader_parameter()。
Array[Dictionary] instance_geometry_get_shader_parameter_list(instance: RID) const 🔗
返回指定 3D 几何体实例的单实例着色器名称字典。返回的字典使用 PropertyInfo 格式，包含 name、class_name、type、hint、hint_string 以及 usage 等键。等价于 GeometryInstance3D.get_instance_shader_parameter()。
void instance_geometry_set_cast_shadows_setting(instance: RID, shadow_casting_setting: ShadowCastingSetting) 🔗
将阴影的投射设置设置为 ShadowCastingSetting 之一。相当于 GeometryInstance3D.cast_shadow。
void instance_geometry_set_flag(instance: RID, flag: InstanceFlags, enabled: bool) 🔗
设置给定的 InstanceFlags 标志。更多细节请参阅 InstanceFlags。
void instance_geometry_set_lightmap(instance: RID, lightmap: RID, lightmap_uv_scale: Rect2, lightmap_slice: int) 🔗
为指定的 3D 几何体实例设置要使用的光照贴图 GI 实例。必须同时指定该实例的光照贴图 UV 缩放（等价于 GeometryInstance3D.gi_lightmap_scale）和光照贴图图集切片。
void instance_geometry_set_lod_bias(instance: RID, lod_bias: float) 🔗
为指定的 3D 几何体实例设置要使用的细节级别偏置。值越高，距离较远时的细节也会越高。等价于 GeometryInstance3D.lod_bias。
void instance_geometry_set_material_overlay(instance: RID, material: RID) 🔗
设置一个材质，该材质将在与该实例关联的网格的活动材质之上，为所有表面渲染。相当于GeometryInstance3D.material_overlay。
void instance_geometry_set_material_override(instance: RID, material: RID) 🔗
设置一种材质，该材质将覆盖与此实例关联的网格上的所有表面的材质。相当于 GeometryInstance3D.material_override。
void instance_geometry_set_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗
设置指定的 3D 几何体实例的单实例着色器 uniform。等价于 GeometryInstance3D.set_instance_shader_parameter()。
void instance_geometry_set_transparency(instance: RID, transparency: float) 🔗
设置给定几何体实例的透明度。相当于 GeometryInstance3D.transparency。
透明度为 0.0 时完全不透明，为 1.0 时则完全透明。如果值比 0.0 大，则会强制让几何体的材质经过透明管线，渲染起来相对较慢，可能由于错误的透明排序而产生渲染问题。不过，与使用透明材质不同，将 transparency 设置为比 0.0 大的值不会禁用阴影的渲染。
在空间着色器中，内置 ALPHA 的默认值为 1.0 - transparency。
注意：transparency 会被钳制在 0.0 和 1.0 的范围内，所以这个属性无法让透明材质比原来更不透明。
void instance_geometry_set_visibility_range(instance: RID, min: float, max: float, min_margin: float, max_margin: float, fade_mode: VisibilityRangeFadeMode) 🔗
设置给定几何实例的可见性范围值。相当于 GeometryInstance3D.visibility_range_begin 和相关属性。
void instance_reset_physics_interpolation(instance: RID) 🔗
在当前物理周期阻止物理插值。
适用于将实例移动到新位置的场合，可以产生瞬时变化，而不是从先前位置进行插值。
void instance_set_base(instance: RID, base: RID) 🔗
设置实例的基础。基础可以是在 RenderingServer 中创建的任何可以显示的 3D 对象。例如，任何光源类型、网格、多重网格、粒子系统、反射探针、贴花、光照贴图、体素 GI 和可见性通知器都可以设置为实例的基础，以便在场景中显示。
void instance_set_blend_shape_weight(instance: RID, shape: int, weight: float) 🔗
设置与该实例相关的特定混合形状的权重。
void instance_set_custom_aabb(instance: RID, aabb: AABB) 🔗
设置将对象从视锥中剔除时使用的自定义 AABB。相当于设置 GeometryInstance3D.custom_aabb。
void instance_set_extra_visibility_margin(instance: RID, margin: float) 🔗
设置将对象从视锥中剔除时为 AABB 增加的边距大小。这样就可以避免剔除落在视锥外的对象。相当于 GeometryInstance3D.extra_cull_margin。
void instance_set_ignore_culling(instance: RID, enabled: bool) 🔗
如果为 true，则会忽略指定 3D 几何体实例的视锥剔除和遮挡剔除。和 GeometryInstance3D.ignore_occlusion_culling 不同，后者只会忽略遮挡剔除，仍会保留视锥剔除。
void instance_set_interpolated(instance: RID, interpolated: bool) 🔗
开启或关闭实例的物理插值。
void instance_set_layer_mask(instance: RID, mask: int) 🔗
设置这个实例要绘制到的渲染层。相当于 VisualInstance3D.layers。
void instance_set_pivot_data(instance: RID, sorting_offset: float, use_aabb_center: bool) 🔗
设置排序偏移量，并在使用包围框还是实例原点进行深度排序之间进行切换。
void instance_set_scenario(instance: RID, scenario: RID) 🔗
设置实例所在的场景。场景是对象将在其中显示的 3D 世界。
void instance_set_surface_override_material(instance: RID, surface: int, material: RID) 🔗
设置指定表面的覆盖材质。相当于 MeshInstance3D.set_surface_override_material()。
void instance_set_transform(instance: RID, transform: Transform3D) 🔗
设置该实例的世界空间变换。相当于 Node3D.global_transform。
void instance_set_visibility_parent(instance: RID, parent: RID) 🔗
设置给定实例的可见性父级。相当于 Node3D.visibility_parent。
void instance_set_visible(instance: RID, visible: bool) 🔗
设置是否绘制实例。相当于 Node3D.visible。
PackedInt64Array instances_cull_aabb(aabb: AABB, scenario: RID = RID()) const 🔗
返回与提供的 AABB 相交的对象 ID 的数组。仅考虑继承自 VisualInstance3D 的 3D 节点，例如 MeshInstance3D 或 DirectionalLight3D。可使用 @GlobalScope.instance_from_id() 来获取实际节点。必须提供一个场景 RID，且它在要查询的 World3D 中可用。这会强制更新所有已被队列以等待更新的资源。
警告：该函数主要供编辑器使用。对于游戏中的用例，最好是物理碰撞。
PackedInt64Array instances_cull_convex(convex: Array[Plane], scenario: RID = RID()) const 🔗
返回与提供的凸形相交的对象 ID 的数组。仅考虑继承自 VisualInstance3D 的 3D 节点，例如 MeshInstance3D 或 DirectionalLight3D。可使用 @GlobalScope.instance_from_id() 以获取实际节点。必须提供场景 RID，且它在要查询的 World3D 中可用。这会强制更新所有已被队列以等待更新的资源。
警告：该函数主要供编辑器使用。对于游戏中的用例，最好是物理碰撞。
PackedInt64Array instances_cull_ray(from: Vector3, to: Vector3, scenario: RID = RID()) const 🔗
返回与提供的 3D 射线相交的对象 ID 的数组。仅考虑继承自 VisualInstance3D 的 3D 节点，例如 MeshInstance3D 或 DirectionalLight3D。可使用 @GlobalScope.instance_from_id() 以获取实际节点。必须提供场景 RID，且它在你要查询的 World3D 中可用。这会强制更新所有已被队列以等待更新的资源。
警告：该函数主要供编辑器使用。对于游戏中的用例，最好是物理碰撞。
如果我们的代码当前正在渲染线程上执行，则返回 true。
void light_directional_set_blend_splits(light: RID, enable: bool) 🔗
如果为 true，则该平行光将在阴影贴图分割之间混合，从而在它们之间产生更平滑的过渡。相当于 DirectionalLight3D.directional_shadow_blend_splits。
void light_directional_set_shadow_mode(light: RID, mode: LightDirectionalShadowMode) 🔗
设置该平行光的阴影模式。相当于 DirectionalLight3D.directional_shadow_mode。有关选项，请参阅 LightDirectionalShadowMode。
void light_directional_set_sky_mode(light: RID, mode: LightDirectionalSkyMode) 🔗
如果为 true，则该灯光将不会被用于除天空着色器之外的任何内容。将其用于影响天空着色器的灯光，可能希望隐藏这些灯光以免影响场景的其余部分。例如，当天空着色器中的太阳落在地平线以下时，可能希望启用该功能。
void light_omni_set_shadow_mode(light: RID, mode: LightOmniShadowMode) 🔗
设置是使用双抛物面还是立方体贴图作为阴影贴图。双抛物面速度更快，但可能会出现伪影。相当于 OmniLight3D.omni_shadow_mode。
void light_projectors_set_filter(filter: LightProjectorFilter) 🔗
设置渲染光线投射器时使用的纹理过滤模式。这个参数是全局的，不能单独针对某个灯光进行设置。
void light_set_bake_mode(light: RID, bake_mode: LightBakeMode) 🔗
设置指定 3D 灯光所使用的烘焙模式。相当于 Light3D.light_bake_mode。
void light_set_color(light: RID, color: Color) 🔗
设置灯光的颜色。相当于 Light3D.light_color。
void light_set_cull_mask(light: RID, mask: int) 🔗
设置该 3D 灯光的剔除掩码。灯光仅影响选定层中的对象。相当于 Light3D.light_cull_mask。
void light_set_distance_fade(decal: RID, enabled: bool, begin: float, shadow: float, length: float) 🔗
设置该 3D 灯光的淡入淡出距离。这充当了一种多细节层次（LOD）的形式，可用于提高性能。相当于 Light3D.distance_fade_enabled、Light3D.distance_fade_begin、Light3D.distance_fade_shadow 和 Light3D.distance_fade_length。
void light_set_max_sdfgi_cascade(light: RID, cascade: int) 🔗
设置渲染 3D 灯光间接光照时的 SDFGI 最大级联数。较高的值能够让远离相机的灯光在 SDFGI 中渲染。
void light_set_negative(light: RID, enable: bool) 🔗
如果为 true，则该 3D 灯光会扣除光照而不是增加。等价于 Light3D.light_negative。
void light_set_param(light: RID, param: LightParam, value: float) 🔗
设置指定的 3D 灯光参数。选项见 LightParam。等价于 Light3D.set_param()。
void light_set_projector(light: RID, texture: RID) 🔗
设置指定 3D 灯光使用的投射器纹理。等价于 Light3D.light_projector。
void light_set_reverse_cull_face_mode(light: RID, enabled: bool) 🔗
如果为 true，则反转网格的背面剔除。当有一个背后有灯光的平面网格时，这会很有用。如果需要在网格的两侧投射阴影，请使用 instance_geometry_set_cast_shadows_setting()，将网格设置为使用双面阴影。相当于 Light3D.shadow_reverse_cull_face。
void light_set_shadow(light: RID, enabled: bool) 🔗
如果为 true，则灯光会投射阴影。相当于 Light3D.shadow_enabled。
void light_set_shadow_caster_mask(light: RID, mask: int) 🔗
设置该 3D 灯光的阴影投射器掩码。只会使用选定层中的对象投射阴影。等价于 Light3D.shadow_caster_mask。
新建全局光照的光照贴图并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 lightmap_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：与其等价的资源为 LightmapGI。
PackedInt32Array lightmap_get_probe_capture_bsp_tree(lightmap: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedVector3Array lightmap_get_probe_capture_points(lightmap: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedColorArray lightmap_get_probe_capture_sh(lightmap: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedInt32Array lightmap_get_probe_capture_tetrahedra(lightmap: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void lightmap_set_baked_exposure_normalization(lightmap: RID, baked_exposure: float) 🔗
用于通知渲染器在烘焙光照贴图时使用的曝光归一化值。该值将在运行时被使用和被调制，以确保即使场景范围的曝光归一化值在运行时发生变化，光照贴图也能保持一致的曝光水平。有关详细信息，请参阅 camera_attributes_set_exposure()。
void lightmap_set_probe_bounds(lightmap: RID, bounds: AABB) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void lightmap_set_probe_capture_data(lightmap: RID, points: PackedVector3Array, point_sh: PackedColorArray, tetrahedra: PackedInt32Array, bsp_tree: PackedInt32Array) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void lightmap_set_probe_capture_update_speed(speed: float) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void lightmap_set_probe_interior(lightmap: RID, interior: bool) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void lightmap_set_textures(lightmap: RID, light: RID, uses_sh: bool) 🔗
将给定光照贴图 lightmap GI 实例的纹理设置为 light RID 所指向的纹理数组。如果烘焙光照贴图纹理时的 LightmapGI.directional 为 true，则 uses_sh 也必须为 true。
void lightmaps_set_bicubic_filter(enable: bool) 🔗
切换在对光照贴图采样时是否使用双三次插值过滤。开启后能够让外观平滑，但会带来性能开销。
RID make_sphere_mesh(latitudes: int, longitudes: int, radius: float) 🔗
返回球体网格，具有给定数量的水平细分、垂直细分、半径。另见 get_test_cube()。
创建空材质并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 material_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：与其等价的资源为 Material。
Variant material_get_param(material: RID, parameter: StringName) const 🔗
返回特定材质的参数值。
void material_set_next_pass(material: RID, next_material: RID) 🔗
设置对象的下一个材质。
void material_set_param(material: RID, parameter: StringName, value: Variant) 🔗
设置材质的参数。
void material_set_render_priority(material: RID, priority: int) 🔗
设置材质的渲染优先级。
void material_set_shader(shader_material: RID, shader: RID) 🔗
设置着色器材质的着色器。
void mesh_add_surface(mesh: RID, surface: Dictionary) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void mesh_add_surface_from_arrays(mesh: RID, primitive: PrimitiveType, arrays: Array, blend_shapes: Array = [], lods: Dictionary = {}, compress_format: BitField[ArrayFormat] = 0) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
移除网格中的所有表面。
新建网格并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 mesh_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个网格放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：与其等价的资源为 Mesh。
RID mesh_create_from_surfaces(surfaces: Array[Dictionary], blend_shape_count: int = 0) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
int mesh_get_blend_shape_count(mesh: RID) const 🔗
返回一个网格的混合形状数量。
BlendShapeMode mesh_get_blend_shape_mode(mesh: RID) const 🔗
返回网格的混合形状模式。
AABB mesh_get_custom_aabb(mesh: RID) const 🔗
返回网格的自定义 AABB。
Dictionary mesh_get_surface(mesh: RID, surface: int) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
int mesh_get_surface_count(mesh: RID) const 🔗
返回网格的面数。
void mesh_set_blend_shape_mode(mesh: RID, mode: BlendShapeMode) 🔗
设置网格的混合形状模式。
void mesh_set_custom_aabb(mesh: RID, aabb: AABB) 🔗
设置网格的自定义 AABB。
void mesh_set_shadow_mesh(mesh: RID, shadow_mesh: RID) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
Array mesh_surface_get_arrays(mesh: RID, surface: int) const 🔗
返回网格表面的缓冲区数组。
Array[Array] mesh_surface_get_blend_shape_arrays(mesh: RID, surface: int) const 🔗
返回网格表面的混合形状数组。
int mesh_surface_get_format_attribute_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
返回具有给定 format 的网格的属性缓冲区的步幅。
int mesh_surface_get_format_normal_tangent_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
返回具有给定 format 的网格的组合法线和切线的步幅。重要的是请注意，虽然法线和切线位于带有顶点的顶点缓冲区中，但它们仅彼此交错，因此具有与顶点位置不同的步幅。
int mesh_surface_get_format_offset(format: BitField[ArrayFormat], vertex_count: int, array_index: int) const 🔗
返回由 array_index 给定属性在其各自缓冲区开头的偏移量。
int mesh_surface_get_format_skin_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
返回具有给定 format 的网格的皮肤缓冲区的步幅。
int mesh_surface_get_format_vertex_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
返回具有给定 format 的网格的顶点位置的步幅。请注意，重要的是，顶点位置是连续存储的，并且不与顶点缓冲区中的其他属性（法线和切线）交错。
RID mesh_surface_get_material(mesh: RID, surface: int) const 🔗
返回网格表面的材质。
void mesh_surface_remove(mesh: RID, surface: int) 🔗
移除 Mesh 中给定索引处的表面，将索引更大的表面向前移动一位。
void mesh_surface_set_material(mesh: RID, surface: int, material: RID) 🔗
设置网格表面的材质。
void mesh_surface_update_attribute_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void mesh_surface_update_skin_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void mesh_surface_update_vertex_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void multimesh_allocate_data(multimesh: RID, instances: int, transform_format: MultimeshTransformFormat, color_format: bool = false, custom_data_format: bool = false, use_indirect: bool = false) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
新建多网格并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 multimesh_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个多网格放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：与其等价的资源为 MultiMesh。
AABB multimesh_get_aabb(multimesh: RID) const 🔗
计算并返回轴对齐的边界框，该边界框将所有的实例都包含在 multimesh 中。
PackedFloat32Array multimesh_get_buffer(multimesh: RID) const 🔗
返回 MultiMesh 数据（例如实例的变换、颜色等）。有关返回数据的详细信息，请参阅 multimesh_set_buffer()。
注意：如果缓冲位于引擎的内部缓存中，则需要从 GPU 显存获取，并且有可能需要解压。也就是说 multimesh_get_buffer() 可能会比较慢，应该尽可能避免。
RID multimesh_get_buffer_rd_rid(multimesh: RID) const 🔗
返回 MultiMesh 在 RenderingDevice 中的 RID 句柄，可以在 RenderingDevice 上和其他缓冲一样使用。
RID multimesh_get_command_buffer_rd_rid(multimesh: RID) const 🔗
返回 MultiMesh 命令缓冲在 RenderingDevice 中的 RID 句柄。通过 multimesh_allocate_data() 分配数据时，只有将 use_indirect 设为 true，这个 RID 才有效。可以用来通过缓冲直接修改实例的数量。
数据结构依赖于网格包含的表面数量以及是否使用索引，缓冲中有 5 个整数，不使用索引时不会使用最后一个整数。
缓冲中的值对应的选项如下：
使用索引：
0 - indexCount;
1 - instanceCount;
2 - firstIndex;
3 - vertexOffset;
4 - firstInstance;
不使用索引：
0 - vertexCount;
1 - instanceCount;
2 - firstVertex;
3 - firstInstance;
4 - unused;
AABB multimesh_get_custom_aabb(multimesh: RID) const 🔗
返回为该 MultiMesh 资源定义的自定义 AABB。
int multimesh_get_instance_count(multimesh: RID) const 🔗
返回分配给这个 multimesh 的实例的数量。
RID multimesh_get_mesh(multimesh: RID) const 🔗
返回用于绘制此 multimesh 的 RID。
int multimesh_get_visible_instances(multimesh: RID) const 🔗
返回此 multimesh 的可见实例数。
Color multimesh_instance_get_color(multimesh: RID, index: int) const 🔗
返回指定实例将被调制的颜色。
Color multimesh_instance_get_custom_data(multimesh: RID, index: int) const 🔗
返回与指定实例相关的自定义数据。
Transform3D multimesh_instance_get_transform(multimesh: RID, index: int) const 🔗
返回指定实例的 Transform3D。
Transform2D multimesh_instance_get_transform_2d(multimesh: RID, index: int) const 🔗
返回指定实例的 Transform2D。只在 multimesh 设置为使用 2D 变换时使用。
void multimesh_instance_reset_physics_interpolation(multimesh: RID, index: int) 🔗
在当前物理周期中阻止对指定实例进行物理插值。
适用于将实例移动到新位置的场合，可以产生瞬时变化，而不是从先前位置进行插值。
void multimesh_instance_set_color(multimesh: RID, index: int, color: Color) 🔗
设置这个实例的调制颜色。相当于 MultiMesh.set_instance_color()。
void multimesh_instance_set_custom_data(multimesh: RID, index: int, custom_data: Color) 🔗
为这个实例设置自定义数据。自定义数据以 Color 的形式传递，但在着色器中会被解释为 vec4。相当于 MultiMesh.set_instance_custom_data()。
void multimesh_instance_set_transform(multimesh: RID, index: int, transform: Transform3D) 🔗
为此实例设置 Transform3D。相当于 MultiMesh.set_instance_transform()。
void multimesh_instance_set_transform_2d(multimesh: RID, index: int, transform: Transform2D) 🔗
为此实例设置 Transform2D。用于在 2D 中使用 multimesh 时。相当于 MultiMesh.set_instance_transform_2d()。
void multimesh_set_buffer(multimesh: RID, buffer: PackedFloat32Array) 🔗
将用于绘制 multimesh 的全部数据立即写入 buffer（例如实例的变换和颜色）。buffer 的大小必须与实例数和单实例数据大小的乘积匹配（后者取决于启用的 MultiMesh 字段）。否则，会输出错误信息，不渲染任何东西。另见 multimesh_get_buffer()。
单实例数据大小与预期的数据顺序如下：
2D:
- 位置：8 个 float（Transform2D 占 8 个 float）
- 位置 + 顶点颜色：12 个 float（Transform2D 占 8 个 float、颜色占 4 个 float）
- 位置 + 自定义数据：12 个 float（Transform2D 占 8 个 float、自定义数据占 4 个 float）
- 位置 + 顶点颜色 + 自定义数据：16 个 float（Transform2D 占 8 个 float、颜色占 4 个 float、自定义数据占 4 个 float）
3D:
- 位置：12 个 float（Transform3D 占 12 个 float）
- 位置 + 顶点颜色：16 个 float（Transform3D 占 12 个 float、颜色占 4 个 float）
- 位置 + 自定义数据：16 个 float（Transform3D 占 12 个 float、自定义数据占 4 个 float）
- 位置 + 顶点颜色 + 自定义数据：20 个 float（Transform3D 占 12 个 float、颜色占 4 个 float、自定义数据占 4 个 float）
实例变换使用行主序，即：
Transform2D 的 float 顺序为：
(x.x, y.x, padding_float, origin.x, x.y, y.y, padding_float, origin.y)。Transform3D 的 float 顺序为：
(basis.x.x, basis.y.x, basis.z.x, origin.x, basis.x.y, basis.y.y, basis.z.y, origin.y, basis.x.z, basis.y.z, basis.z.z, origin.z)。
void multimesh_set_buffer_interpolated(multimesh: RID, buffer: PackedFloat32Array, buffer_previous: PackedFloat32Array) 🔗
适合物理插值的 multimesh_set_buffer() 版本。
接受当前数据数组以及上一物理周期的数据数组。
void multimesh_set_custom_aabb(multimesh: RID, aabb: AABB) 🔗
为该 MultiMesh 资源设置自定义 AABB。
void multimesh_set_mesh(multimesh: RID, mesh: RID) 🔗
设置 Multimesh 所要绘制的网格。相当于 MultiMesh.mesh。
void multimesh_set_physics_interpolated(multimesh: RID, interpolated: bool) 🔗
为该 MultiMesh 资源打开或关闭物理插值。
void multimesh_set_physics_interpolation_quality(multimesh: RID, quality: MultimeshPhysicsInterpolationQuality) 🔗
设置 MultiMesh 物理插值的质量。
MULTIMESH_INTERP_QUALITY_FAST 较快但插值质量较低，MULTIMESH_INTERP_QUALITY_HIGH 较慢但插值质量较高。
void multimesh_set_visible_instances(multimesh: RID, visible: int) 🔗
设置在给定时间内可见的实例的数量。如果是 -1，所有被分配的实例都会被画出来。相当于 MultiMesh.visible_instance_count。
创建遮挡器实例并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 occluder_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：与其等价的资源为 Occluder3D（请勿与 OccluderInstance3D 节点混淆）。
void occluder_set_mesh(occluder: RID, vertices: PackedVector3Array, indices: PackedInt32Array) 🔗
设置给定遮挡器 RID 的网格数据，控制执行遮挡剔除时的形状。
创建一个新的全向灯并将其添加到 RenderingServer。可以使用返回的 RID 访问它。该 RID 可用于大多数 light_* RenderingServer 函数。
一旦使用 RID 完成操作后，需要使用 RenderingServer 的方法 free_rid() 来释放该 RID。
要放置在场景中，请使用 instance_set_base() 使用该返回的 RID 将该全向灯附加到一个实例。
注意：等价节点为 OmniLight3D。
RID particles_collision_create() 🔗
新建 3D GPU 粒子碰撞或吸引器并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 particles_collision_* RenderingServer 函数中使用。
注意：等价节点为 GPUParticlesCollision3D 和 GPUParticlesAttractor3D。
void particles_collision_height_field_update(particles_collision: RID) 🔗
请求对 3D GPU 粒子碰撞高度图进行更新。3D GPU 粒子碰撞高度图可能会自动调用这个函数，取决于 GPUParticlesCollisionHeightField3D.update_mode。
void particles_collision_set_attractor_attenuation(particles_collision: RID, curve: float) 🔗
为 RID 为 particles_collision 的 3D GPU 粒子吸引器设置衰减曲线 curve。仅用于吸引器，对碰撞体不适用。等价于 GPUParticlesAttractor3D.attenuation。
void particles_collision_set_attractor_directionality(particles_collision: RID, amount: float) 🔗
设置 3D GPU 粒子吸引器的方向量 amount，吸引器由 RID particles_collision 指定。仅用于吸引器，不适用于碰撞体。等价于 GPUParticlesAttractor3D.directionality。
void particles_collision_set_attractor_strength(particles_collision: RID, strength: float) 🔗
设置 3D GPU 粒子吸引器的强度 strength，吸引器由 RID particles_collision 指定。仅用于吸引器，不适用于碰撞体。等价于 GPUParticlesAttractor3D.strength。
void particles_collision_set_box_extents(particles_collision: RID, extents: Vector3) 🔗
设置 3D GPU 粒子吸引器的范围 extents，吸引器由 RID particles_collision 指定。根据 particles_collision 类型的不同，等价于 GPUParticlesCollisionBox3D.size、GPUParticlesCollisionSDF3D.size、GPUParticlesCollisionHeightField3D.size、GPUParticlesAttractorBox3D.size、GPUParticlesAttractorVectorField3D.size。
void particles_collision_set_collision_type(particles_collision: RID, type: ParticlesCollisionType) 🔗
设置 3D GPU 粒子碰撞或吸引器的形状类型 type，碰撞或吸引器由 RID particles_collision 指定。
void particles_collision_set_cull_mask(particles_collision: RID, mask: int) 🔗
设置 3D GPU 粒子碰撞或吸引器的剔除掩码 mask，碰撞或吸引器由 RID particles_collision 指定。根据 particles_collision 类型的不同，等价于 GPUParticlesCollision3D.cull_mask 或 GPUParticlesAttractor3D.cull_mask。
void particles_collision_set_field_texture(particles_collision: RID, texture: RID) 🔗
设置 3D GPU 粒子碰撞的带符号距离场纹理 texture，碰撞由 RID particles_collision 指定。根据 particles_collision 类型的不同，等价于 GPUParticlesCollisionSDF3D.texture 或 GPUParticlesAttractorVectorField3D.texture。
void particles_collision_set_height_field_mask(particles_collision: RID, mask: int) 🔗
设置 3D GPU 粒子高度图碰撞的高度图掩码 mask，碰撞由 RID particles_collision 指定。等价于 GPUParticlesCollisionHeightField3D.heightfield_mask。
void particles_collision_set_height_field_resolution(particles_collision: RID, resolution: ParticlesCollisionHeightfieldResolution) 🔗
设置 3D GPU 粒子高度图碰撞的高度图分辨率 resolution，碰撞由 RID particles_collision 指定。等价于 GPUParticlesCollisionHeightField3D.resolution。
void particles_collision_set_sphere_radius(particles_collision: RID, radius: float) 🔗
设置 3D GPU 粒子球体碰撞或吸引器的半径 radius，碰撞或吸引器由 RID particles_collision 指定。根据 particles_collision 类型的不同，等价于 GPUParticlesCollisionSphere3D.radius 或 GPUParticlesAttractorSphere3D.radius。
创建基于 GPU 的粒子系统并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 particles_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个粒子系统放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：等价节点为 GPUParticles2D 和 GPUParticles3D。
注意：所有 particles_* 方法都仅适用于基于 GPU 的粒子，不适用于基于 CPU 的粒子。RenderingServer 中没有 CPUParticles2D 和 CPUParticles3D 的等价函数，因为这两个节点底层使用的是 MultiMeshInstance2D 和 MultiMeshInstance3D（见 multimesh_* 方法）。
void particles_emit(particles: RID, transform: Transform3D, velocity: Vector3, color: Color, custom: Color, emit_flags: int) 🔗
从 particles 实例中手动发射粒子。
AABB particles_get_current_aabb(particles: RID) 🔗
计算并返回包含所有粒子的轴对齐边界框。相当于 GPUParticles3D.capture_aabb()。
bool particles_get_emitting(particles: RID) 🔗
如果当前粒子被设置发射，则返回 true。
bool particles_is_inactive(particles: RID) 🔗
如果粒子没有发射并且粒子设置为非活动状态，则返回 true。
void particles_request_process(particles: RID) 🔗
将粒子系统添加到需要更新的粒子系统列表中。更新将在下一帧或下一次调用 instances_cull_aabb()、instances_cull_convex() 或 instances_cull_ray() 时进行。
void particles_request_process_time(particles: RID, time: float) 🔗
请求粒子在单一帧中再处理指定的时间。
void particles_restart(particles: RID) 🔗
下次更新时重置粒子。相当于 GPUParticles3D.restart()。
void particles_set_amount(particles: RID, amount: int) 🔗
设置要绘制的粒子的数量，并为其分配内存。相当于 GPUParticles3D.amount。
void particles_set_amount_ratio(particles: RID, ratio: float) 🔗
设置要被发射的粒子的数量比率。相当于 GPUParticles3D.amount_ratio。
void particles_set_collision_base_size(particles: RID, size: float) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void particles_set_custom_aabb(particles: RID, aabb: AABB) 🔗
设置粒子系统的自定义轴对齐边界框。相当于 GPUParticles3D.visibility_aabb。
void particles_set_draw_order(particles: RID, order: ParticlesDrawOrder) 🔗
将粒子的绘制顺序设置为命名枚举 ParticlesDrawOrder。选项见 ParticlesDrawOrder。相当于 GPUParticles3D.draw_order。
void particles_set_draw_pass_mesh(particles: RID, pass: int, mesh: RID) 🔗
设置用于指定绘制阶段的网格。相当于 GPUParticles3D.draw_pass_1、GPUParticles3D.draw_pass_2、GPUParticles3D.draw_pass_3 和 GPUParticles3D.draw_pass_4。
void particles_set_draw_passes(particles: RID, count: int) 🔗
设置要使用的绘制阶段的数量。相当于 GPUParticles3D.draw_passes。
void particles_set_emission_transform(particles: RID, transform: Transform3D) 🔗
设置粒子首次发射时使用的 Transform3D。
void particles_set_emitter_velocity(particles: RID, velocity: Vector3) 🔗
设置粒子节点的速度，将由 ParticleProcessMaterial.inherit_velocity_ratio 使用。
void particles_set_emitting(particles: RID, emitting: bool) 🔗
如果为 true，则粒子将随时间发射。设置为 false 不会重置粒子，只会停止发射。等价于 GPUParticles3D.emitting。
void particles_set_explosiveness_ratio(particles: RID, ratio: float) 🔗
设置爆发比例。相当于 GPUParticles3D.explosiveness。
void particles_set_fixed_fps(particles: RID, fps: int) 🔗
设置粒子系统渲染的固定帧率。相当于 GPUParticles3D.fixed_fps。
void particles_set_fractional_delta(particles: RID, enable: bool) 🔗
如果为 true，则使用分数增量来平滑粒子的运动。相当于 GPUParticles3D.fract_delta。
void particles_set_interp_to_end(particles: RID, factor: float) 🔗
设置通知 ParticleProcessMaterial 将所有粒子冲向其生命周期终点的值。
void particles_set_interpolate(particles: RID, enable: bool) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void particles_set_lifetime(particles: RID, lifetime: float) 🔗
设置系统中每个粒子的生命周期。相当于 GPUParticles3D.lifetime。
void particles_set_mode(particles: RID, mode: ParticlesMode) 🔗
设置由 RID particles 指定的 GPU 粒子是否应该根据 mode 在 2D 或 3D 中渲染。
void particles_set_one_shot(particles: RID, one_shot: bool) 🔗
如果为 true，则粒子将发射一次然后停止。相当于 GPUParticles3D.one_shot。
void particles_set_pre_process_time(particles: RID, time: float) 🔗
设置粒子动画的预处理时间。这样可以让动画延迟到粒子开始发射之后再开始。相当于 GPUParticles3D.preprocess。
void particles_set_process_material(particles: RID, material: RID) 🔗
设置用于处理粒子的材质。
注意：这不是用来绘制材质的材质。相当于 GPUParticles3D.process_material。
void particles_set_randomness_ratio(particles: RID, ratio: float) 🔗
设置发射随机性比例。会随机化该粒子在其相位内的发射。相当于 GPUParticles3D.randomness。
void particles_set_speed_scale(particles: RID, scale: float) 🔗
设置粒子系统的速度缩放。相当于 GPUParticles3D.speed_scale。
void particles_set_subemitter(particles: RID, subemitter_particles: RID) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void particles_set_trail_bind_poses(particles: RID, bind_poses: Array[Transform3D]) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void particles_set_trails(particles: RID, enable: bool, length_sec: float) 🔗
如果 enable 为 true，则会为 particles 启用尾迹，长度为 length_sec 秒。等价于 GPUParticles3D.trail_enabled 和 GPUParticles3D.trail_lifetime。
void particles_set_transform_align(particles: RID, align: ParticlesTransformAlign) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void particles_set_use_local_coordinates(particles: RID, enable: bool) 🔗
如果为 true，则粒子使用局部坐标。如果为 false 则使用全局坐标。相当于 GPUParticles3D.local_coords。
void positional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗
设置 3D 全向灯和聚光灯阴影的过滤质量。另见 ProjectSettings.rendering/lights_and_shadows/positional_shadow/soft_shadow_filter_quality。这个参数是全局的，无法针对单个视口设置。
RID reflection_probe_create() 🔗
创建反射探针并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 reflection_probe_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个反射探针放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
注意：等价节点为 ReflectionProbe。
void reflection_probe_set_ambient_color(probe: RID, color: Color) 🔗
设置反射探针的自定义环境光颜色。等价于 ReflectionProbe.ambient_color。
void reflection_probe_set_ambient_energy(probe: RID, energy: float) 🔗
设置反射探针的自定义环境光能量。等价于 ReflectionProbe.ambient_color_energy。
void reflection_probe_set_ambient_mode(probe: RID, mode: ReflectionProbeAmbientMode) 🔗
设置反射探针的环境光模式。等价于 ReflectionProbe.ambient_mode。
void reflection_probe_set_as_interior(probe: RID, enable: bool) 🔗
如果为 true，则反射将忽略天空的贡献。相当于 ReflectionProbe.interior。
void reflection_probe_set_blend_distance(probe: RID, blend_distance: float) 🔗
设置探针与场景融合的距离，单位为米。
void reflection_probe_set_cull_mask(probe: RID, layers: int) 🔗
设置该反射探针的渲染剔除掩码。只有具有匹配层的实例才会被该探针反射。相当于 ReflectionProbe.cull_mask。
void reflection_probe_set_enable_box_projection(probe: RID, enable: bool) 🔗
如果为 true，则使用箱体投影。这可以使反射在某些情况下看起来更正确。相当于 ReflectionProbe.box_projection。
void reflection_probe_set_enable_shadows(probe: RID, enable: bool) 🔗
如果为 true，计算反射探针中的阴影。这会使得反射的计算速度慢得多。相当于 ReflectionProbe.enable_shadows。
void reflection_probe_set_intensity(probe: RID, intensity: float) 🔗
设置反射探针的强度。强度调节反射的强度。相当于 ReflectionProbe.intensity。
void reflection_probe_set_max_distance(probe: RID, distance: float) 🔗
设置物体在被删除前与探针的最大距离。相当于 ReflectionProbe.max_distance。
void reflection_probe_set_mesh_lod_threshold(probe: RID, pixels: float) 🔗
设置渲染反射探针时所使用的网格细节级别。值越高，生成了 LOD 变体的网格所使用的版本细节就越低，能够提升性能。等价于 ReflectionProbe.mesh_lod_threshold。
void reflection_probe_set_origin_offset(probe: RID, offset: Vector3) 🔗
设置当此反射探针处于框项目模式时要使用的源偏移。相当于 ReflectionProbe.origin_offset。
void reflection_probe_set_reflection_mask(probe: RID, layers: int) 🔗
设置该反射探针的渲染反射掩码。只有具有匹配层的实例才会被该探针应用反射。相当于 ReflectionProbe.reflection_mask。
void reflection_probe_set_resolution(probe: RID, resolution: int) 🔗
设置渲染指定的反射探针时使用的分辨率。resolution 指定的是各个立方体贴图面的分辨率：例如指定 512 时就会分配 6 个 512×512 的面（另外还有粗糙度级别的 mipmap）。
void reflection_probe_set_size(probe: RID, size: Vector3) 🔗
设置反射探针将捕获的区域的大小。相当于 ReflectionProbe.size。
void reflection_probe_set_update_mode(probe: RID, mode: ReflectionProbeUpdateMode) 🔗
设置反射探针的更新频率。可以是一次，也可以是每一帧。参阅 ReflectionProbeUpdateMode 选项。
void request_frame_drawn_callback(callable: Callable) 🔗
安排对给定可调用体的回调，会在一帧绘制完成后回调。
创建场景并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 scenario_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
场景是所有可视实例存在的 3D 世界。
void scenario_set_camera_attributes(scenario: RID, effects: RID) 🔗
设置该场景会使用的相机属性（effects）。另见 CameraAttributes。
void scenario_set_compositor(scenario: RID, compositor: RID) 🔗
设置将被用于该场景的合成器（compositor）。另见 Compositor。
void scenario_set_environment(scenario: RID, environment: RID) 🔗
设置该场景会使用的环境。另见 Environment。
void scenario_set_fallback_environment(scenario: RID, environment: RID) 🔗
设置此方案所使用的后备环境。如果没有设置环境，则使用后备环境。这被编辑器用来提供一个默认环境。
void screen_space_roughness_limiter_set_active(enable: bool, amount: float, limit: float) 🔗
设置屏幕空间粗糙度限制参数，例如是否应该启用以及阈值等。等价于 ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/enabled、ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/amount 和 ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/limit。
void set_boot_image(image: Image, color: Color, scale: bool, use_filter: bool = true) 🔗
设置一个启动图像。颜色定义背景颜色。如果 scale 为 true，则该图像将被缩放以适应屏幕大小。如果 use_filter 为 true，则该图像将使用线性插值的方式进行缩放。如果 use_filter 为 false，则该图像将使用最近邻插值的方式进行缩放。
void set_debug_generate_wireframes(generate: bool) 🔗
如果 generate 为 true，则在使用 Compatibility 渲染器时会为所有加载的网格生成调试线框。默认情况下，引擎在运行时不会生成调试线框，因为这会减慢资产加载速度并占用显存。
注意：使用 Compatibility 渲染器时，必须在加载任何网格之前调用此方法，否则将不会使用线框。
void set_default_clear_color(color: Color) 🔗
设置默认清屏颜色，会在尚未选择特定的清屏颜色时使用。另见 get_default_clear_color()。
创建空的着色器并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 shader_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 Shader。
String shader_get_code(shader: RID) const 🔗
以字符串形式返回着色器的源代码。
RID shader_get_default_texture_parameter(shader: RID, name: StringName, index: int = 0) const 🔗
返回着色器中的默认纹理，根据名称搜索。
注意：如果使用了采样器数组，请使用 index 访问指定的纹理。
Variant shader_get_parameter_default(shader: RID, name: StringName) const 🔗
返回指定着色器 Uniform 的默认值。通常是着色器源代码中编写的值。
void shader_set_code(shader: RID, code: String) 🔗
设置着色器的源代码（更改后会出发重新编译）。
void shader_set_default_texture_parameter(shader: RID, name: StringName, texture: RID, index: int = 0) 🔗
设置着色器的默认纹理。覆盖给定名称的纹理。
注意：使用采样器数组时，使用 index 访问指定的纹理。
void shader_set_path_hint(shader: RID, path: String) 🔗
设置指定着色器路径提示。一般应该与 Shader 资源的 Resource.resource_path 相匹配。
void skeleton_allocate_data(skeleton: RID, bones: int, is_2d_skeleton: bool = false) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
Transform3D skeleton_bone_get_transform(skeleton: RID, bone: int) const 🔗
返回该骨架中指定骨骼的 Transform3D。
Transform2D skeleton_bone_get_transform_2d(skeleton: RID, bone: int) const 🔗
返回该骨架中指定骨骼的 Transform2D。
void skeleton_bone_set_transform(skeleton: RID, bone: int, transform: Transform3D) 🔗
设置该骨架中指定骨骼的 Transform3D。
void skeleton_bone_set_transform_2d(skeleton: RID, bone: int, transform: Transform2D) 🔗
设置该骨架中指定骨骼的 Transform2D。
创建骨架并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 skeleton_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
int skeleton_get_bone_count(skeleton: RID) const 🔗
返回分配给这个骨架的骨骼数量。
void skeleton_set_base_transform_2d(skeleton: RID, base_transform: Transform2D) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
Image sky_bake_panorama(sky: RID, energy: float, bake_irradiance: bool, size: Vector2i) 🔗
生成并返回包含指定 sky RID 的辐射率贴图的 Image。这样就能支持内置天空材质和自定义天空着色器。如果 bake_irradiance 为 true，则会保存辐照度贴图，不保存辐射率贴图。辐射率贴图用于渲染反射光，而辐照度贴图用于渲染环境光。另见 environment_bake_panorama()。
注意：图片保存时使用线性色彩空间，未进行色调映射，因此在图像编辑器中直接查看会感觉太暗。将 energy 设为大于 1.0 能够将得到的图像变亮。
注意：对于生成的全景图，size 应该是 2:1 的比例，才能够得到正方形的像素。对于辐射率贴图，将高度设为大于 Sky.radiance_size 的值没有意义，因为不会增加细节。辐照度贴图仅包含低频数据，因此保存辐照度贴图时通常大小超过 128×64 像素没有意义。
创建空的天空并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 sky_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
void sky_set_material(sky: RID, material: RID) 🔗
设置天空用于渲染背景和反射贴图的材质。
void sky_set_mode(sky: RID, mode: SkyMode) 🔗
设置 RID 为 sky 的天空的处理模式 mode。等价于 Sky.process_mode。
void sky_set_radiance_size(sky: RID, radiance_size: int) 🔗
设置 RID 为 sky 的天空的辐射率大小 radiance_size（单位为像素）。等价于 Sky.radiance_size。
创建聚光灯并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在大多数 light_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个聚光灯放置到场景中，请使用返回的 RID 调用 instance_set_base()，将其附加至某个实例上。
void sub_surface_scattering_set_quality(quality: SubSurfaceScatteringQuality) 🔗
设置渲染启用了次表面散射的材质时使用的 ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_quality。
void sub_surface_scattering_set_scale(scale: float, depth_scale: float) 🔗
设置渲染启用了次表面散射的材质时使用的 ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_scale 和 ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_depth_scale。
RID texture_2d_create(image: Image) 🔗
创建二维纹理并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 texture_2d_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 Texture2D。
注意：请勿与 RenderingDevice.texture_create() 混淆，后者创建的是图形 API 自己的纹理类型，并非 Godot 专属的 Texture2D 资源。
Image texture_2d_get(texture: RID) const 🔗
根据给定的纹理 RID texture 返回 Image 实例。
示例：从 get_test_texture() 获取测试纹理并将其应用至 Sprite2D 节点：
var texture_rid = RenderingServer.get_test_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture
Image texture_2d_layer_get(texture: RID, layer: int) const 🔗
返回给定 texture RID 和 layer 中的 Image 实例。
RID texture_2d_layered_create(layers: Array[Image], layered_type: TextureLayeredType) 🔗
创建二维多层纹理并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 texture_2d_layered_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 TextureLayered。
RID texture_2d_layered_placeholder_create(layered_type: TextureLayeredType) 🔗
创建二维多层纹理的占位符并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 texture_2d_layered_* RenderingServer 函数中使用，但使用时什么都不会发生。另见 texture_2d_placeholder_create()。
注意：等价资源为 PlaceholderTextureLayered。
RID texture_2d_placeholder_create() 🔗
创建二维多层纹理的占位符并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 texture_2d_layered_* RenderingServer 函数中使用，但使用时什么都不会发生。另见 texture_2d_layered_placeholder_create()。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 PlaceholderTexture2D。
void texture_2d_update(texture: RID, image: Image, layer: int) 🔗
使用 image 中的数据更新由纹理 RID texture 指定的纹理。layer 也必须指定，更新单层纹理（Texture2D）时应为 0。
注意：image 的宽度、高度、格式都必须和当前 texture 的数据相同。否则会输出错误，不会修改原始纹理。如果你需要使用不同的宽度、高度或格式，请改用 texture_replace()。
RID texture_3d_create(format: Format, width: int, height: int, depth: int, mipmaps: bool, data: Array[Image]) 🔗
注意：等价的资源是 Texture3D。
Array[Image] texture_3d_get(texture: RID) const 🔗
以 Image 数组的形式返回指定纹理 RID 的 3D 纹理数据。
RID texture_3d_placeholder_create() 🔗
创建三维纹理的占位符并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 texture_3d_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价资源为 PlaceholderTexture3D。
void texture_3d_update(texture: RID, data: Array[Image]) 🔗
使用 data 中的数据更新由纹理 RID texture 指定的纹理。必须同时更新所有纹理层。
注意：texture 的宽度、高度、格式都必须和当前纹理数据相同。否则会输出错误，不会修改原始纹理。如果你需要使用不同的宽度、高度或格式，请改用 texture_replace()。
RID texture_create_from_native_handle(type: TextureType, format: Format, native_handle: int, width: int, height: int, depth: int, layers: int = 1, layered_type: TextureLayeredType = 0) 🔗
根据在 Godot 渲染器外部创建的原生句柄创建纹理。
注意：如果仅使用渲染设备渲染器，建议将 RenderingDevice.texture_create_from_extension() 和 texture_rd_create() 结合使用，不要使用此方法。这样控制纹理格式和使用更加灵活。
Format texture_get_format(texture: RID) const 🔗
返回该纹理的格式。
int texture_get_native_handle(texture: RID, srgb: bool = false) const 🔗
返回该纹理对象的内部图形句柄。主要用于 GDExtension 与第三方 API 通讯。
注意：这个函数返回的是 uint64_t，内部映射到 GLuint（OpenGL）或 VkImage（Vulkan）。
String texture_get_path(texture: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
RID texture_get_rd_texture(texture: RID, srgb: bool = false) const 🔗
返回可用于 RenderingDevice 的纹理 RID。
RID texture_proxy_create(base: RID) 🔗
已弃用： ProxyTexture was removed in Godot 4.
这个方法不起任何作用，始终返回无效的 RID。
void texture_proxy_update(texture: RID, proxy_to: RID) 🔗
已弃用： ProxyTexture was removed in Godot 4.
这个方法什么也不做。
RID texture_rd_create(rd_texture: RID, layer_type: TextureLayeredType = 0) 🔗
基于直接在 RenderingDevice 上创建的纹理创建新的纹理对象。如果该纹理包含图层，则 layer_type 被用于定义图层类型。
void texture_replace(texture: RID, by_texture: RID) 🔗
将 texture 的纹理数据替换为由纹理 RID by_texture 指定的纹理，不会改变 texture 的 RID。
void texture_set_force_redraw_if_visible(texture: RID, enable: bool) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void texture_set_path(texture: RID, path: String) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void texture_set_size_override(texture: RID, width: int, height: int) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void viewport_attach_camera(viewport: RID, camera: RID) 🔗
设置视图的相机。
void viewport_attach_canvas(viewport: RID, canvas: RID) 🔗
设置视口的画布。
void viewport_attach_to_screen(viewport: RID, rect: Rect2 = Rect2(0, 0, 0, 0), screen: int = 0) 🔗
将该视口复制到 rect 指定的屏幕区域。如果 viewport_set_render_direct_to_screen() 为 true，则视口不使用帧缓冲区，视口的内容将直接渲染到屏幕。但是，请注意根视口是最后绘制的，因此它会覆盖屏幕。相应地，必须将根视口的区域设置为不覆盖附加该视口的区域。
例如，可以使用以下代码将根视口设置为完全不渲染：
func _ready():
RenderingServer.viewport_attach_to_screen(get_viewport().get_viewport_rid(), Rect2())
RenderingServer.viewport_attach_to_screen($Viewport.get_viewport_rid(), Rect2(0, 0, 600, 600))
使用它可以带来显著的优化，尤其是在低端设备上。但是，这是以必须手动管理视口为代价的。进一步优化请参见 viewport_set_render_direct_to_screen()。
创建空的视口并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 viewport_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 Viewport。
float viewport_get_measured_render_time_cpu(viewport: RID) const 🔗
返回渲染上一帧所消耗的 CPU 时间，单位为毫秒。只包含渲染相关操作所消耗的时间；读数中不含脚本的 _process 函数及其他引擎子系统。要获取渲染场景所消耗 CPU 时间的完整读数，请将每帧绘制的所有视口的渲染时间以及 get_frame_setup_time_cpu() 相加。与 Engine.get_frames_per_second() 不同，即便帧率受到垂直同步或 Engine.max_fps 的限制，这个方法也会精确反映 CPU 利用率。另见 viewport_get_measured_render_time_gpu()。
注意：需要使用 viewport_set_measure_render_time() 启用 viewport 的测量。否则这个方法会返回 0.0。
float viewport_get_measured_render_time_gpu(viewport: RID) const 🔗
返回渲染上一帧所消耗的 GPU 时间，单位为毫秒。要获取渲染场景所消耗 GPU 时间的完整读数，请将每帧绘制的所有视口的渲染时间相加。与 Engine.get_frames_per_second() 不同，即便帧率受到垂直同步或 Engine.max_fps 的限制，这个方法也会精确反映 GPU 利用率。另见 viewport_get_measured_render_time_cpu()。
注意：需要使用 viewport_set_measure_render_time() 启用 viewport 的测量。否则这个方法会返回 0.0。
注意：GPU 的利用率在一段时间内低到一定程度时，GPU 会降低电源状态（导致内核与内存时钟速度的降低）。这会导致 GPU 在某个帧率下保持较低利用率时，汇报的 GPU 时间增大（相对于 GPU 的最高电源状态而言）。请在使用 viewport_get_measured_render_time_gpu() 进行性能测试时牢记这一点。可以在显卡驱动的设置中改变这种行为，但代价是耗电量增大。
int viewport_get_render_info(viewport: RID, type: ViewportRenderInfoType, info: ViewportRenderInfo) 🔗
返回关于渲染引擎的统计信息，能够用于性能分析。会区分不同的渲染阶段类型 type，每种类型都有相同的可查询信息 info（不同的阶段会返回不同的值）。渲染阶段类型列表见 ViewportRenderInfoType，能够查询的信息列表见 ViewportRenderInfo。
另见 get_rendering_info()，返回的是所有视口的全局信息。
注意：引擎渲染至少 2 帧后渲染信息才可用。渲染信息不可用时 viewport_get_render_info() 返回 0。要在 _ready() 中成功输出渲染信息，请使用如下代码：
func _ready():
for _i in 2:
await get_tree().process_frame
print(
RenderingServer.viewport_get_render_info(get_viewport().get_viewport_rid(),
RenderingServer.VIEWPORT_RENDER_INFO_TYPE_VISIBLE,
RenderingServer.VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME)
)
RID viewport_get_render_target(viewport: RID) const 🔗
返回该视口的渲染目标。
RID viewport_get_texture(viewport: RID) const 🔗
返回视口的最后渲染帧。
ViewportUpdateMode viewport_get_update_mode(viewport: RID) const 🔗
返回视口的更新模式。选项见 ViewportUpdateMode 常量。
警告：在渲染线程之外的线程调用该方法会损害性能。
void viewport_remove_canvas(viewport: RID, canvas: RID) 🔗
从画布分离视口。
void viewport_set_active(viewport: RID, active: bool) 🔗
如果为 true，则将视口设置为活动状态，否则将其设置为非活动状态。
void viewport_set_anisotropic_filtering_level(viewport: RID, anisotropic_filtering_level: ViewportAnisotropicFiltering) 🔗
设置在纹理上使用各向异性过滤时要采用的最大样本数（作为 2 的幂）。更高的采样数将导致倾斜角度的纹理更清晰，但计算成本更高。0 的值会强制禁用各向异性过滤，即使在启用它的材质上也是如此。
如果贴花和投影器被配置为使用各向异性过滤，则各向异性过滤级别也会影响它们。见 ProjectSettings.rendering/textures/decals/filter and ProjectSettings.rendering/textures/light_projectors/filter。
注意：要使该设置在 3D 中生效，请在材质上将 BaseMaterial3D.texture_filter 设置为 BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC 或 BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC。
注意：要使该设置在 2D 中生效，请在显示纹理的 CanvasItem 节点上（或 CanvasTexture 中）将 CanvasItem.texture_filter 设置为 CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC 或 CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC。然而各向异性过滤在 2D 中并不实用，因此在 2D 中只有在它产生有意义的视觉差异时才对纹理启用它。
void viewport_set_canvas_cull_mask(viewport: RID, canvas_cull_mask: int) 🔗
设置与此 Viewport 关联的渲染掩码。渲染可见层与之匹配的 CanvasItem 节点才会被此 Viewport 渲染。
void viewport_set_canvas_stacking(viewport: RID, canvas: RID, layer: int, sublayer: int) 🔗
设置视口画布的堆叠顺序。
layer 是实际的画布层，而 sublayer 指定的是该画布在同一层中的堆叠顺序。
void viewport_set_canvas_transform(viewport: RID, canvas: RID, offset: Transform2D) 🔗
设置视口画布的变换。
void viewport_set_clear_mode(viewport: RID, clear_mode: ViewportClearMode) 🔗
设置视口的清除模式。可选项见 ViewportClearMode。
void viewport_set_debug_draw(viewport: RID, draw: ViewportDebugDraw) 🔗
设置视口的调试绘图模式。可选项见 ViewportDebugDraw。
void viewport_set_default_canvas_item_texture_filter(viewport: RID, filter: CanvasItemTextureFilter) 🔗
设置视口的默认纹理过滤模式，视口由 viewport RID 指定。选项见 CanvasItemTextureFilter。
void viewport_set_default_canvas_item_texture_repeat(viewport: RID, repeat: CanvasItemTextureRepeat) 🔗
设置视口的默认纹理重复模式，视口由 viewport RID 指定。选项见 CanvasItemTextureRepeat。
void viewport_set_disable_2d(viewport: RID, disable: bool) 🔗
如果为 true，则不渲染视口的画布（即 2D 和 GUI 元素）。
void viewport_set_disable_3d(viewport: RID, disable: bool) 🔗
如果为 true，则不渲染视口的 3D 元素。
void viewport_set_environment_mode(viewport: RID, mode: ViewportEnvironmentMode) 🔗
设置视口的环境模式，该模式允许启用或禁用 2D 画布上的 3D 环境渲染。禁用时，2D 将不受环境影响。启用时，如果环境背景模式为 ENV_BG_CANVAS，则 2D 会受到环境的影响。默认行为是从视口的父级继承设置。如果最顶层的父级也被设置为 VIEWPORT_ENVIRONMENT_INHERIT，则该行为将与设置为 VIEWPORT_ENVIRONMENT_ENABLED 时相同。
void viewport_set_fsr_sharpness(viewport: RID, sharpness: float) 🔗
决定使用 FSR 放大模式时放大图像的清晰度。每个整数的锐度减半。值从 0.0（最锐利）到 2.0。高于 2.0 的值不会产生明显的差异。
void viewport_set_global_canvas_transform(viewport: RID, transform: Transform2D) 🔗
设置视口的全局变换矩阵。
void viewport_set_measure_render_time(viewport: RID, enable: bool) 🔗
为给定的 viewport RID（使用 Viewport.get_viewport_rid() 获取）设置是否测量。启用后，使用给定的 viewport 对 viewport_get_measured_render_time_cpu() 和 viewport_get_measured_render_time_gpu() 进行查询返回的就是大于 0.0 的值。
void viewport_set_msaa_2d(viewport: RID, msaa: ViewportMSAA) 🔗
设置 RID 为 viewport 的视口的 2D/画布多重采样抗锯齿模式。选项见 ViewportMSAA。等价于 ProjectSettings.rendering/anti_aliasing/quality/msaa_2d 或 Viewport.msaa_2d。
void viewport_set_msaa_3d(viewport: RID, msaa: ViewportMSAA) 🔗
设置 RID 为 viewport 的视口的 3D 多重采样抗锯齿模式。选项见 ViewportMSAA。等价于 ProjectSettings.rendering/anti_aliasing/quality/msaa_3d 或 Viewport.msaa_3d。
void viewport_set_occlusion_culling_build_quality(quality: ViewportOcclusionCullingBuildQuality) 🔗
设置遮挡剔除的 ProjectSettings.rendering/occlusion_culling/bvh_build_quality。这个参数是全局的，无法针对特定视口设置。
void viewport_set_occlusion_rays_per_thread(rays_per_thread: int) 🔗
设置遮挡剔除的 ProjectSettings.rendering/occlusion_culling/occlusion_rays_per_thread。这个参数是全局的，无法针对特定视口设置。
void viewport_set_parent_viewport(viewport: RID, parent_viewport: RID) 🔗
将该视口的父项设置为 parent_viewport RID 指定的视口。
void viewport_set_positional_shadow_atlas_quadrant_subdivision(viewport: RID, quadrant: int, subdivision: int) 🔗
设置全向灯和聚光灯阴影的指定阴影图集象限 quadrant 的细分次数。另见 Viewport.set_positional_shadow_atlas_quadrant_subdiv()。
void viewport_set_positional_shadow_atlas_size(viewport: RID, size: int, use_16_bits: bool = false) 🔗
设置阴影图集图像的大小（用于全向灯和聚光灯），大小由 size 指定，生效的视口由 viewport RID 指定。该值将向上舍入到最接近的 2 次幂。如果 use_16_bits 为 true，则会使用 16 位的全向灯/聚光灯阴影深度贴图。启用后，阴影的精度会降低，可能造成阴影失真，但能够在部分设备上提升性能。
注意：如果设置为 0，将根本看不到任何阴影。可以通过降低 CPU 和 GPU 负载来显著提升在低端系统上的性能（因为绘制不带阴影的场景需要的绘制调用更少）。
void viewport_set_render_direct_to_screen(viewport: RID, enabled: bool) 🔗
如果为 true，则将视口的内容直接渲染到屏幕。这允许一个低级别的优化，可以跳过将视口绘制到根视口。虽然这种优化可以显著提高速度（尤其是在旧设备上），但它是以可用性为代价的。启用后，无法从视口或 screen_texture 读取。而且还会失去某些窗口设置的好处，例如各种拉伸模式。另一个需要注意的后果是，在 2D 中，渲染是以窗口坐标进行的，所以如果有一个两倍于窗口大小的视口，并且设置了这个属性，那么只会绘制适合窗口的部分， 无法自动缩放，即使游戏场景明显大于窗口大小。
void viewport_set_scaling_3d_mode(viewport: RID, scaling_3d_mode: ViewportScaling3DMode) 🔗
设置 3D 分辨率缩放模式。双线性缩放使用不同的分辨率渲染，能够对视口进行欠采样或超采样。FidelityFX 超分辨率 1.0，缩写为 FSR，是一种放大技术，通过使用空间感知放大算法以快速帧速率生成高质量图像。FSR 比双线性的开销略大，但产生的图像质量明显更高。应尽可能使用 FSR。
void viewport_set_scaling_3d_scale(viewport: RID, scale: float) 🔗
根据视图大小，缩放 3D 渲染缓冲区，使用 ViewportScaling3DMode 中指定的图像过滤器，将输出图像缩放到完整视图大小。低于 1.0 的值，可用于加速 3D 渲染，但会以质量为代价（欠采样）。大于 1.0 的值，仅对双线性模式有效，可用于以较高的性能成本（超级采样），提高 3D 渲染质量。另见 ViewportMSAA 以了解多重采样抗锯齿，这要便宜得多，但只会平滑多边形的边缘。
在使用 FSR 放大时，AMD 建议将以下值，作为预设选项公开给用户：“超质量：0.77”、“质量：0.67”、“平衡：0.59”、“性能：0.5”，而不是公开整个比例。
void viewport_set_scenario(viewport: RID, scenario: RID) 🔗
设置视口的场景。该场景包含环境、反射图集等信息。
void viewport_set_screen_space_aa(viewport: RID, mode: ViewportScreenSpaceAA) 🔗
设置视口的屏幕空间抗锯齿模式。等价于 ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa 和 Viewport.screen_space_aa。
void viewport_set_sdf_oversize_and_scale(viewport: RID, oversize: ViewportSDFOversize, scale: ViewportSDFScale) 🔗
设置视口的 2D 带符号距离场的 ProjectSettings.rendering/2d/sdf/oversize 和 ProjectSettings.rendering/2d/sdf/scale。在 CanvasItem 着色器中对带符号距离场进行采样时会用到，GPUParticles2D 碰撞时也会用到。3D 渲染时的 SDFGI 不会使用。
void viewport_set_size(viewport: RID, width: int, height: int) 🔗
设置视口的宽度和高度，单位为像素。
void viewport_set_snap_2d_transforms_to_pixel(viewport: RID, enabled: bool) 🔗
如果为 true，则画布项的变换（即原点的位置）会在渲染时吸附到整像素。这样外观看上去就会更锐利，但会影响移动的平滑程度，尤其是在启用了 Camera2D 平滑的情况下。等价于 ProjectSettings.rendering/2d/snap/snap_2d_transforms_to_pixel。
void viewport_set_snap_2d_vertices_to_pixel(viewport: RID, enabled: bool) 🔗
如果为 true，则画布项的顶点（即多边形的点）会在渲染时吸附到整像素。这样外观看上去就会更锐利，但会影响移动的平滑程度，尤其是在启用了 Camera2D 平滑的情况下。等价于 ProjectSettings.rendering/2d/snap/snap_2d_vertices_to_pixel。
void viewport_set_texture_mipmap_bias(viewport: RID, mipmap_bias: float) 🔗
读取较低或较高的 mipmap，影响最终纹理的清晰度（也称为“纹理 LOD 偏置”）。负值会让 mipmap 纹理更锐利，但从较远处观察时颗粒更明显，而正值会让 mipmap 纹理更模糊（即便凑近看也一样）。要在不引入太多颗粒感的情况下，在远处获得更锐利的纹理，请将其设置在 -0.75 和 0.0 之间。启用时间抗锯齿（ProjectSettings.rendering/anti_aliasing/quality/use_taa）有助于减少使用负 mipmap 偏置时可见的颗粒度。
注意：当 3D 缩放模式设置为 FSR 1.0 时，会使用该值调整自动 mipmap 偏置，偏置的计算基于缩放系数。其公式为 -log2(1.0 / scale) + mipmap_bias。
void viewport_set_transparent_background(viewport: RID, enabled: bool) 🔗
如果为 true，视口将其背景渲染为透明。
void viewport_set_update_mode(viewport: RID, update_mode: ViewportUpdateMode) 🔗
设置应更新视口的时间。可选项请参阅 ViewportUpdateMode 。
void viewport_set_use_debanding(viewport: RID, enable: bool) 🔗
如果为 true，则在指定的视口上启用去条带。等价于 ProjectSettings.rendering/anti_aliasing/quality/use_debanding 或 Viewport.use_debanding。
void viewport_set_use_hdr_2d(viewport: RID, enabled: bool) 🔗
如果为 true，2D 渲染将使用与 3D 帧缓冲区的位深度匹配的高动态范围（HDR）格式帧缓冲区。当使用 Forward+ 渲染器时，这将是一个 RGBA16 帧缓冲区，而当使用 Mobile 渲染器时，它将是一个 RGB10_A2 帧缓冲区。此外，2D 渲染将在线性色彩空间中进行，并在位块传输到屏幕之前（如果视口被连接到屏幕）立即转换为 sRGB 空间。实际上，这意味着视口的最终结果不会被钳制在 0-1 范围内，并且可以在不进行色彩空间调整的情况下被用于 3D 渲染。这使得 2D 渲染能够利用需要高动态范围的效果（例如 2D 辉光），并显著改善需要高度详细渐变的效果的外观。该设置与 Viewport.use_hdr_2d 效果相同。
注意：使用 Compatibility 渲染器时该设置不起作用，出于性能原因，该渲染器始终在低动态范围内渲染。
void viewport_set_use_occlusion_culling(viewport: RID, enable: bool) 🔗
如果为 true，则在指定的视口上启用遮挡剔除。等价于 ProjectSettings.rendering/occlusion_culling/use_occlusion_culling。
void viewport_set_use_taa(viewport: RID, enable: bool) 🔗
如果为 true，则在指定的视口上启用时间抗锯齿。等价于 ProjectSettings.rendering/anti_aliasing/quality/use_taa 或 Viewport.use_taa。
void viewport_set_use_xr(viewport: RID, use_xr: bool) 🔗
如果为 true，则视口使用增强或虚拟现实技术。参阅 XRInterface。
void viewport_set_vrs_mode(viewport: RID, mode: ViewportVRSMode) 🔗
设置视口的可变速率着色（VRS）模式。如果 GPU 不支持 VRS 则会忽略该属性。等价于 ProjectSettings.rendering/vrs/mode。
void viewport_set_vrs_texture(viewport: RID, texture: RID) 🔗
当 VRS 模式设置为 VIEWPORT_VRS_TEXTURE 时，要使用的纹理。等价于 ProjectSettings.rendering/vrs/texture。
void viewport_set_vrs_update_mode(viewport: RID, mode: ViewportVRSUpdateMode) 🔗
设置视口的可变速率着色（VRS）更新模式。VRS 要求将输入纹理转换为硬件支持的 VRS 方法可用的格式。更新模式定义这种情况发生的频率。如果 GPU 不支持 VRS，或者未启用 VRS，则忽略该属性。
如果设置为 VIEWPORT_VRS_UPDATE_ONCE，则输入纹理将被复制一次，且模式更改为 VIEWPORT_VRS_UPDATE_DISABLED。
RID visibility_notifier_create() 🔗
新建 3D 可见性通知器并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 visibility_notifier_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
如果要将这个网格放置到场景中，请使用返回的 RID 调用 instance_set_base()，将通知器附加至某个实例上。
注意：等价节点为 VisibleOnScreenNotifier3D。
void visibility_notifier_set_aabb(notifier: RID, aabb: AABB) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void visibility_notifier_set_callbacks(notifier: RID, enter_callable: Callable, exit_callable: Callable) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void voxel_gi_allocate_data(voxel_gi: RID, to_cell_xform: Transform3D, aabb: AABB, octree_size: Vector3i, octree_cells: PackedByteArray, data_cells: PackedByteArray, distance_field: PackedByteArray, level_counts: PackedInt32Array) 🔗
该方法目前没有描述，请帮我们贡献一个吧！
新建基于体素的全局光照对象并将其添加到 RenderingServer。可以通过返回的 RID 进行访问。这个 RID 会在所有 voxel_gi_* RenderingServer 函数中使用。
RID 使用结束后，应该使用 RenderingServer 的 free_rid() 方法进行释放。
注意：等价节点为 VoxelGI。
PackedByteArray voxel_gi_get_data_cells(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedByteArray voxel_gi_get_distance_field(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedInt32Array voxel_gi_get_level_counts(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
PackedByteArray voxel_gi_get_octree_cells(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
Vector3i voxel_gi_get_octree_size(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
Transform3D voxel_gi_get_to_cell_xform(voxel_gi: RID) const 🔗
该方法目前没有描述，请帮我们贡献一个吧！
void voxel_gi_set_baked_exposure_normalization(voxel_gi: RID, baked_exposure: float) 🔗
用于通知渲染器烘焙体素 GI 时使用的曝光归一化值。运行时会使用这个值进行调制，确保体素 GI 能够维持恒定的曝光等级，即便场景范围的曝光归一化值在运行时发生改变。更多信息见 camera_attributes_set_exposure()。
void voxel_gi_set_bias(voxel_gi: RID, bias: float) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.bias 值。
void voxel_gi_set_dynamic_range(voxel_gi: RID, range: float) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.dynamic_range 值。
void voxel_gi_set_energy(voxel_gi: RID, energy: float) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.energy 值。
void voxel_gi_set_interior(voxel_gi: RID, enable: bool) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.interior 值。
void voxel_gi_set_normal_bias(voxel_gi: RID, bias: float) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.normal_bias 值。
void voxel_gi_set_propagation(voxel_gi: RID, amount: float) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.propagation 值。
void voxel_gi_set_quality(quality: VoxelGIQuality) 🔗
设置渲染时使用的 ProjectSettings.rendering/global_illumination/voxel_gi/quality 值。这个参数是全局的，无法为单独的 VoxelGI 进行设置。
void voxel_gi_set_use_two_bounces(voxel_gi: RID, enable: bool) 🔗
为 RID 为 voxel_gi 的对象设置 VoxelGIData.use_two_bounces 值。