RenderingServer
Hereda: Object
Servidor para cualquier cosa visible.
Descripción
The rendering server is the API backend for everything visible. The whole scene system mounts on it to display. The rendering server is completely opaque: the internals are entirely implementation-specific and cannot be accessed.
The rendering server can be used to bypass the scene/Node system entirely. This can improve performance in cases where the scene system is the bottleneck, but won't improve performance otherwise (for instance, if the GPU is already fully utilized).
Resources are created using the *_create functions. These functions return RIDs which are not references to the objects themselves, but opaque pointers towards these objects.
All objects are drawn to a viewport. You can use the Viewport attached to the SceneTree or you can create one yourself with viewport_create(). When using a custom scenario or canvas, the scenario or canvas needs to be attached to the viewport using viewport_set_scenario() or viewport_attach_canvas().
Scenarios: In 3D, all visual objects must be associated with a scenario. The scenario is a visual representation of the world. If accessing the rendering server from a running game, the scenario can be accessed from the scene tree from any Node3D node with Node3D.get_world_3d(). Otherwise, a scenario can be created with scenario_create().
Similarly, in 2D, a canvas is needed to draw all canvas items.
3D: In 3D, all visible objects are comprised of a resource and an instance. A resource can be a mesh, a particle system, a light, or any other 3D object. In order to be visible resources must be attached to an instance using instance_set_base(). The instance must also be attached to the scenario using instance_set_scenario() in order to be visible. RenderingServer methods that don't have a prefix are usually 3D-specific (but not always).
2D: In 2D, all visible objects are some form of canvas item. In order to be visible, a canvas item needs to be the child of a canvas attached to a viewport, or it needs to be the child of another canvas item that is eventually attached to the canvas. 2D-specific RenderingServer methods generally start with canvas_*.
Headless mode: Starting the engine with the --headless command line argument disables all rendering and window management functions. Most functions from RenderingServer will return dummy values in this case.
Tutoriales
Propiedades
Métodos
Señales
frame_post_draw() 🔗
Emitted at the end of the frame, after the RenderingServer has finished updating all the Viewports.
frame_pre_draw() 🔗
Emitted at the beginning of the frame, before the RenderingServer updates all the Viewports.
Enumeraciones
enum TextureType: 🔗
TextureType TEXTURE_TYPE_2D = 0
Textura 2D.
TextureType TEXTURE_TYPE_LAYERED = 1
Textura en capas.
TextureType TEXTURE_TYPE_3D = 2
Textura 3D.
enum TextureLayeredType: 🔗
TextureLayeredType TEXTURE_LAYERED_2D_ARRAY = 0
Array de texturas bidimensionales (véase Texture2DArray).
TextureLayeredType TEXTURE_LAYERED_CUBEMAP = 1
La textura del CubeMap (véase Cubemap).
TextureLayeredType TEXTURE_LAYERED_CUBEMAP_ARRAY = 2
Array de texturas de cubemap (véase CubemapArray).
enum CubeMapLayer: 🔗
CubeMapLayer CUBEMAP_LAYER_LEFT = 0
Cara izquierda de un Cubemap.
CubeMapLayer CUBEMAP_LAYER_RIGHT = 1
Cara derecha de un Cubemap.
CubeMapLayer CUBEMAP_LAYER_BOTTOM = 2
Cara inferior de un Cubemap.
CubeMapLayer CUBEMAP_LAYER_TOP = 3
Cara superior de un Cubemap.
CubeMapLayer CUBEMAP_LAYER_FRONT = 4
Cara frontal de un Cubemap.
CubeMapLayer CUBEMAP_LAYER_BACK = 5
Cara trasera de un Cubemap.
enum ShaderMode: 🔗
ShaderMode SHADER_SPATIAL = 0
El shader es un shader 3D.
ShaderMode SHADER_CANVAS_ITEM = 1
El shader es un shader 2D.
ShaderMode SHADER_PARTICLES = 2
El shader es un shader de partículas (se puede utilizar tanto en 2D como en 3D).
ShaderMode SHADER_SKY = 3
El shader es un shader de cielo 3D.
ShaderMode SHADER_FOG = 4
El shader es un shader de niebla 3D.
ShaderMode SHADER_MAX = 5
Representa el tamaño del enum ShaderMode.
enum ArrayType: 🔗
ArrayType ARRAY_VERTEX = 0
Array is a vertex position array.
ArrayType ARRAY_NORMAL = 1
El array es un array normales.
ArrayType ARRAY_TANGENT = 2
El Array es un array de tangentes.
ArrayType ARRAY_COLOR = 3
Array is a vertex color array.
ArrayType ARRAY_TEX_UV = 4
El array es un array de coordenadas UV.
ArrayType ARRAY_TEX_UV2 = 5
El array es un array de coordenadas UV para el segundo conjunto de coordenadas UV.
ArrayType ARRAY_CUSTOM0 = 6
El array es un array de datos personalizados para el primer conjunto de datos personalizados.
ArrayType ARRAY_CUSTOM1 = 7
El array es un array de datos personalizados para el segundo conjunto de datos personalizados.
ArrayType ARRAY_CUSTOM2 = 8
El array es un array de datos personalizados para el tercer conjunto de datos personalizados.
ArrayType ARRAY_CUSTOM3 = 9
El array es un array de datos personalizados para el cuarto conjunto de datos personalizados.
ArrayType ARRAY_BONES = 10
El Array contiene información sobre los huesos.
ArrayType ARRAY_WEIGHTS = 11
El Array contiene la información de pesos.
ArrayType ARRAY_INDEX = 12
El array es un array de índices.
ArrayType ARRAY_MAX = 13
Representa el tamaño del enum ArrayType.
enum ArrayCustomFormat: 🔗
ArrayCustomFormat ARRAY_CUSTOM_RGBA8_UNORM = 0
El array de datos personalizados contiene datos de color rojo/verde/azul/alfa de 8 bits por canal. Los valores son de punto flotante sin signo normalizados en el rango [0.0, 1.0].
ArrayCustomFormat ARRAY_CUSTOM_RGBA8_SNORM = 1
El array de datos personalizados contiene datos de color rojo/verde/azul/alfa de 8 bits por canal. Los valores son de punto flotante con signo normalizados en el rango [-1.0, 1.0].
ArrayCustomFormat ARRAY_CUSTOM_RG_HALF = 2
El array de datos personalizados contiene datos de color rojo/verde de 16 bits por canal. Los valores son de punto flotante de media precisión.
ArrayCustomFormat ARRAY_CUSTOM_RGBA_HALF = 3
El array de datos personalizados contiene datos de color rojo/verde/azul/alfa de 16 bits por canal. Los valores son de punto flotante de media precisión.
ArrayCustomFormat ARRAY_CUSTOM_R_FLOAT = 4
El array de datos personalizados contiene datos de color rojo de 32 bits por canal. Los valores son de punto flotante de precisión simple.
ArrayCustomFormat ARRAY_CUSTOM_RG_FLOAT = 5
El array de datos personalizados contiene datos de color rojo/verde de 32 bits por canal. Los valores son de punto flotante de precisión simple.
ArrayCustomFormat ARRAY_CUSTOM_RGB_FLOAT = 6
El array de datos personalizados contiene datos de color rojo/verde/azul de 32 bits por canal. Los valores son de punto flotante de precisión simple.
ArrayCustomFormat ARRAY_CUSTOM_RGBA_FLOAT = 7
El array de datos personalizados contiene datos de color rojo/verde/azul/alfa de 32 bits por canal. Los valores son de punto flotante de precisión simple.
ArrayCustomFormat ARRAY_CUSTOM_MAX = 8
Representa el tamaño del enum ArrayCustomFormat.
flags ArrayFormat: 🔗
ArrayFormat ARRAY_FORMAT_VERTEX = 1
Bandera usada para marcar un array de posiciones de vértice.
ArrayFormat ARRAY_FORMAT_NORMAL = 2
Bandera usada para marcar un array de normales.
ArrayFormat ARRAY_FORMAT_TANGENT = 4
Bandera usada para marcar un array de tangentes.
ArrayFormat ARRAY_FORMAT_COLOR = 8
Bandera usada para marcar un array de color de vértice.
ArrayFormat ARRAY_FORMAT_TEX_UV = 16
Bandera usada para marcar un array de coordenadas UV.
ArrayFormat ARRAY_FORMAT_TEX_UV2 = 32
Bandera usada para marcar un array de coordenadas UV para las segundas coordenadas UV.
ArrayFormat ARRAY_FORMAT_CUSTOM0 = 64
Bandera usada para marcar un array de datos personalizados por vértice para el primer conjunto de datos personalizados.
ArrayFormat ARRAY_FORMAT_CUSTOM1 = 128
Bandera usada para marcar un array de datos personalizados por vértice para el segundo conjunto de datos personalizados.
ArrayFormat ARRAY_FORMAT_CUSTOM2 = 256
Bandera usada para marcar un array de datos personalizados por vértice para el tercer conjunto de datos personalizados.
ArrayFormat ARRAY_FORMAT_CUSTOM3 = 512
Bandera usada para marcar un array de datos personalizados por vértice para el cuarto conjunto de datos personalizados.
ArrayFormat ARRAY_FORMAT_BONES = 1024
Bandera usada para marcar un array con información de huesos.
ArrayFormat ARRAY_FORMAT_WEIGHTS = 2048
Bandera usada para marcar un array de pesos.
ArrayFormat ARRAY_FORMAT_INDEX = 4096
Bandera usada para marcar un array de índices.
ArrayFormat ARRAY_FORMAT_BLEND_SHAPE_MASK = 7
Máscara de los canales de malla permitidos en las blendshapes.
ArrayFormat ARRAY_FORMAT_CUSTOM_BASE = 13
Desplazamiento del primer canal personalizado.
ArrayFormat ARRAY_FORMAT_CUSTOM_BITS = 3
Número de bits de formato por canal personalizado. Véase ArrayCustomFormat.
ArrayFormat ARRAY_FORMAT_CUSTOM0_SHIFT = 13
Cantidad a desplazar ArrayCustomFormat para el índice de canal personalizado 0.
ArrayFormat ARRAY_FORMAT_CUSTOM1_SHIFT = 16
Cantidad a desplazar ArrayCustomFormat para el índice de canal personalizado 1.
ArrayFormat ARRAY_FORMAT_CUSTOM2_SHIFT = 19
Cantidad a desplazar ArrayCustomFormat para el índice de canal personalizado 2.
ArrayFormat ARRAY_FORMAT_CUSTOM3_SHIFT = 22
Cantidad a desplazar ArrayCustomFormat para el índice de canal personalizado 3.
ArrayFormat ARRAY_FORMAT_CUSTOM_MASK = 7
Máscara de bits de formato personalizado por canal personalizado. Debe ser desplazado por una de las constantes SHIFT. Véase ArrayCustomFormat.
ArrayFormat ARRAY_COMPRESS_FLAGS_BASE = 25
Desplazamiento de la primera bandera de compresión. Las banderas de compresión deben pasarse a ArrayMesh.add_surface_from_arrays() y SurfaceTool.commit().
ArrayFormat ARRAY_FLAG_USE_2D_VERTICES = 33554432
Flag usada para marcar que el array contiene vértices 2D.
ArrayFormat ARRAY_FLAG_USE_DYNAMIC_UPDATE = 67108864
Bandera utilizada para marcar que los datos de la malla usarán GL_DYNAMIC_DRAW en GLES. No se utiliza en Vulkan.
ArrayFormat ARRAY_FLAG_USE_8_BONE_WEIGHTS = 134217728
Bandera usada para marcar que el array usa 8 pesos de hueso en lugar de 4.
ArrayFormat ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY = 268435456
Bandera usada para marcar que la malla no tiene un array de vértices y en su lugar inferirá las posiciones de los vértices en el shader usando índices y otra información.
ArrayFormat ARRAY_FLAG_COMPRESS_ATTRIBUTES = 536870912
Bandera utilizada para marcar que una malla está utilizando atributos comprimidos (vértices, normales, tangentes, UVs). Cuando esta forma de compresión está habilitada, las posiciones de los vértices se empaquetarán en un atributo RGBA16UNORM y se escalarán en el sombreador de vértices. La normal y la tangente se empaquetarán en un RG16UNORM representando un eje, y un float de 16 bits almacenado en el canal A del vértice. Los UVs utilizarán floats normalizados de 16 bits en lugar de floats completos de 32 bits con signo. Cuando utilices este modo de compresión debes usar vértices, normales y tangentes o solo vértices. No puedes usar normales sin tangentes. Los importadores habilitarán automáticamente esta compresión si pueden.
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_BASE = 35
Bandera usada para marcar el inicio de los bits usados para almacenar la versión de la malla.
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_SHIFT = 35
Bandera usada para desplazar un entero de formato de malla para llevar la versión a los dígitos más bajos.
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_1 = 0
Bandera usada para registrar el formato usado por versiones de malla anteriores antes de la introducción de una versión.
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_2 = 34359738368
Bandera usada para registrar la segunda iteración del flag de versión de malla. La diferencia principal entre este y ARRAY_FLAG_FORMAT_VERSION_1 es que esta versión soporta ARRAY_FLAG_COMPRESS_ATTRIBUTES y en esta versión las posiciones de los vértices están desintercaladas de las normales y tangentes.
ArrayFormat ARRAY_FLAG_FORMAT_CURRENT_VERSION = 34359738368
Bandera usada para registrar la versión actual que el motor espera. Actualmente esta es la misma que ARRAY_FLAG_FORMAT_VERSION_2.
ArrayFormat ARRAY_FLAG_FORMAT_VERSION_MASK = 255
Bandera usada para aislar los bits usados para la versión de la malla después de usar ARRAY_FLAG_FORMAT_VERSION_SHIFT para desplazarlos a su lugar.
enum PrimitiveType: 🔗
PrimitiveType PRIMITIVE_POINTS = 0
Primitiva para dibujar vagones de puntos.
PrimitiveType PRIMITIVE_LINES = 1
Primitiva para dibujar vagones de líneas.
PrimitiveType PRIMITIVE_LINE_STRIP = 2
Primitiva para dibujar consiste en una franja de líneas de principio a fin.
PrimitiveType PRIMITIVE_TRIANGLES = 3
Primitiva para dibujar vagones de triángulos.
PrimitiveType PRIMITIVE_TRIANGLE_STRIP = 4
Primitiva para dibujar consiste en una tira de triángulo (los últimos 3 vértices siempre se combinan para formar un triángulo).
PrimitiveType PRIMITIVE_MAX = 5
Representa el tamaño del enum PrimitiveType.
enum BlendShapeMode: 🔗
BlendShapeMode BLEND_SHAPE_MODE_NORMALIZED = 0
Las formas de la mezcla se normalizan.
BlendShapeMode BLEND_SHAPE_MODE_RELATIVE = 1
Las formas de la mezcla son relativas al peso base.
enum MultimeshTransformFormat: 🔗
MultimeshTransformFormat MULTIMESH_TRANSFORM_2D = 0
Use Transform2D para almacenar la transformación de MultiMalla.
MultimeshTransformFormat MULTIMESH_TRANSFORM_3D = 1
Usa Transform3D para almacenar la transformación de MultiMesh.
enum MultimeshPhysicsInterpolationQuality: 🔗
MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_FAST = 0
La interpolación física de MultiMesh favorece la velocidad sobre la calidad.
MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_HIGH = 1
La interpolación física de MultiMesh favorece la calidad sobre la velocidad.
enum LightProjectorFilter: 🔗
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST = 0
Filtro de vecino más cercano para proyectores de luz (úsese para proyectores de luz de pixel art). No se usan mipmaps para el renderizado, lo que significa que los proyectores de luz a distancia se verán nítidos pero granulados. Esto tiene aproximadamente el mismo costo de rendimiento que usar mipmaps.
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR = 1
Filtro lineal para proyectores de luz (úsese para proyectores de luz que no sean de pixel art). No se usan mipmaps para el renderizado, lo que significa que los proyectores de luz a distancia se verán suaves pero borrosos. Esto tiene aproximadamente el mismo costo de rendimiento que usar mipmaps.
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS = 2
Filtro de vecino más cercano para proyectores de luz (úsese para proyectores de luz de pixel art). Se usan mipmaps isotrópicos para el renderizado, lo que significa que los proyectores de luz a distancia se verán suaves pero borrosos. Esto tiene aproximadamente el mismo costo de rendimiento que no usar mipmaps.
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS = 3
Filtro lineal para proyectores de luz (úsese para proyectores de luz que no sean de pixel art). Se usan mipmaps isotrópicos para el renderizado, lo que significa que los proyectores de luz a distancia se verán suaves pero borrosos. Esto tiene aproximadamente el mismo costo de rendimiento que no usar mipmaps.
LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4
Nearest-neighbor filter for light projectors (use for pixel art light projectors). Anisotropic mipmaps are used for rendering, which means light projectors at a distance will look smooth and sharp when viewed from oblique angles. This looks better compared to isotropic mipmaps, but is slower. The level of anisotropic filtering is defined by ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5
Linear filter for light projectors (use for non-pixel art light projectors). Anisotropic mipmaps are used for rendering, which means light projectors at a distance will look smooth and sharp when viewed from oblique angles. This looks better compared to isotropic mipmaps, but is slower. The level of anisotropic filtering is defined by ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
enum LightType: 🔗
LightType LIGHT_DIRECTIONAL = 0
Luz direccional (sol/luna) (véase DirectionalLight3D).
LightType LIGHT_OMNI = 1
Luz omnidireccional (véase OmniLight3D).
LightType LIGHT_SPOT = 2
Luz de foco (véase SpotLight3D).
enum LightParam: 🔗
LightParam LIGHT_PARAM_ENERGY = 0
El multiplicador de energía de la luz.
LightParam LIGHT_PARAM_INDIRECT_ENERGY = 1
El multiplicador de energía indirecta de la luz (la energía indirecta final es LIGHT_PARAM_ENERGY * LIGHT_PARAM_INDIRECT_ENERGY).
LightParam LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY = 2
El multiplicador de energía de niebla volumétrica de la luz (la energía final de la niebla volumétrica es LIGHT_PARAM_ENERGY * LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY).
LightParam LIGHT_PARAM_SPECULAR = 3
La influencia de la luz en la especularidad.
LightParam LIGHT_PARAM_RANGE = 4
El rango de la luz.
LightParam LIGHT_PARAM_SIZE = 5
El tamaño de la luz cuando se usa luz de foco o luz omnidireccional. El tamaño angular de la luz cuando se usa luz direccional.
LightParam LIGHT_PARAM_ATTENUATION = 6
La atenuación de la luz.
LightParam LIGHT_PARAM_SPOT_ANGLE = 7
El ángulo del foco.
LightParam LIGHT_PARAM_SPOT_ATTENUATION = 8
La atenuación del foco.
LightParam LIGHT_PARAM_SHADOW_MAX_DISTANCE = 9
La distancia máxima para las divisiones de sombra. Aumentar este valor hará que las sombras direccionales sean visibles desde más lejos, a costa de un menor detalle general de la sombra y rendimiento (ya que se deben incluir más objetos en la renderización de la sombra direccional).
LightParam LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET = 10
Proporción de atlas de sombras ocupados por la primera división.
LightParam LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET = 11
Proporción del atlas de las sombras ocupado por la segunda división.
LightParam LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET = 12
Proporción del atlas de las sombras ocupado por la tercera división. La cuarta división ocupa el resto.
LightParam LIGHT_PARAM_SHADOW_FADE_START = 13
Proporción de la distancia máxima de la sombra donde la sombra comenzará a desvanecerse.
LightParam LIGHT_PARAM_SHADOW_NORMAL_BIAS = 14
Sesgo normal usado para compensar la búsqueda de sombras por el objeto normal. Puede ser usado para arreglar artefactos de auto-sombra.
LightParam LIGHT_PARAM_SHADOW_BIAS = 15
Sesgo para la búsqueda de sombras para corregir artefactos de sombreado automático.
LightParam LIGHT_PARAM_SHADOW_PANCAKE_SIZE = 16
Sets the size of the directional shadow pancake. The pancake offsets the start of the shadow's camera frustum to provide a higher effective depth resolution for the shadow. However, a high pancake size can cause artifacts in the shadows of large objects that are close to the edge of the frustum. Reducing the pancake size can help. Setting the size to 0 turns off the pancaking effect.
LightParam LIGHT_PARAM_SHADOW_OPACITY = 17
La opacidad de la sombra de la luz. Los valores inferiores a 1.0 hacen que la luz aparezca a través de las sombras. Esto puede usarse para simular iluminación global a un bajo costo de rendimiento.
LightParam LIGHT_PARAM_SHADOW_BLUR = 18
Desenfoca los bordes de la sombra. Se puede utilizar para ocultar artefactos de píxeles en mapas de sombras de baja resolución. Un valor alto puede hacer que las sombras parezcan granuladas y puede causar otros artefactos no deseados. Intenta mantenerlo lo más cerca posible del valor predeterminado.
LightParam LIGHT_PARAM_TRANSMITTANCE_BIAS = 19
There is currently no description for this enum. Please help us by contributing one!
LightParam LIGHT_PARAM_INTENSITY = 20
Constante que representa la intensidad de la luz, medida en Lúmenes cuando se trata de un SpotLight3D o OmniLight3D, o medida en Lux con un DirectionalLight3D. Solo se usa cuando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units es true.
LightParam LIGHT_PARAM_MAX = 21
Representa el tamaño del enum LightParam.
enum LightBakeMode: 🔗
LightBakeMode LIGHT_BAKE_DISABLED = 0
La luz se ignora durante el procesado. Este es el modo más rápido, pero la luz se tendrá en cuenta al procesar la iluminación global. Este modo generalmente debe usarse para luces dinámicas que cambian rápidamente, ya que el efecto de la iluminación global es menos notable en esas luces.
LightBakeMode LIGHT_BAKE_STATIC = 1
La luz se tiene en cuenta en el procesado estático (VoxelGI, LightmapGI, SDFGI (Environment.sdfgi_enabled)). La luz se puede mover o modificar, pero su iluminación global no se actualizará en tiempo real. Esto es adecuado para cambios sutiles (como antorchas parpadeantes), pero generalmente no para cambios grandes como encender y apagar una luz.
LightBakeMode LIGHT_BAKE_DYNAMIC = 2
La luz se tiene en cuenta en el procesado dinámico (solo VoxelGI y SDFGI (Environment.sdfgi_enabled)). La luz se puede mover o modificar con la actualización de la iluminación global en tiempo real. La apariencia de la iluminación global de la luz será ligeramente diferente en comparación con LIGHT_BAKE_STATIC. Esto tiene un mayor costo de rendimiento en comparación con LIGHT_BAKE_STATIC. Al usar SDFGI, la velocidad de actualización de las luces dinámicas se ve afectada por ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.
enum LightOmniShadowMode: 🔗
LightOmniShadowMode LIGHT_OMNI_SHADOW_DUAL_PARABOLOID = 0
Usar un mapa de sombras paraboloide doble para las luces omnidireccionales.
LightOmniShadowMode LIGHT_OMNI_SHADOW_CUBE = 1
Usa un mapa de cubo de sombras para las luces omnidireccionales. Más lento pero de mejor calidad que el paraboloide dual.
enum LightDirectionalShadowMode: 🔗
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL = 0
Usar proyección de sombra ortogonal para la luz direccional.
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS = 1
Use 2 divisiones para la proyección de sombras cuando use luz direccional.
LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS = 2
Use 4 divisiones para la proyección de sombras cuando use luz direccional.
enum LightDirectionalSkyMode: 🔗
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_AND_SKY = 0
Usar DirectionalLight3D tanto en el renderizado del cielo como en la iluminación de la escena.
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_ONLY = 1
Solo usar DirectionalLight3D en la iluminación de la escena.
LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_SKY_ONLY = 2
Only use DirectionalLight3D in sky rendering.
enum ShadowQuality: 🔗
ShadowQuality SHADOW_QUALITY_HARD = 0
Lowest shadow filtering quality (fastest). Soft shadows are not available with this quality setting, which means the Light3D.shadow_blur property is ignored if Light3D.light_size and Light3D.light_angular_distance is 0.0.
Note: The variable shadow blur performed by Light3D.light_size and Light3D.light_angular_distance is still effective when using hard shadow filtering. In this case, Light3D.shadow_blur is taken into account. However, the results will not be blurred, instead the blur amount is treated as a maximum radius for the penumbra.
ShadowQuality SHADOW_QUALITY_SOFT_VERY_LOW = 1
Calidad de filtrado de sombras muy baja (más rápido). Cuando se usa este ajuste de calidad, Light3D.shadow_blur se multiplica automáticamente por 0.75× para evitar introducir demasiado ruido. Esta división solo se aplica a las luces cuyo Light3D.light_size o Light3D.light_angular_distance sea 0.0).
ShadowQuality SHADOW_QUALITY_SOFT_LOW = 2
Filtrado de sombras de baja calidad (rápido).
ShadowQuality SHADOW_QUALITY_SOFT_MEDIUM = 3
Calidad de filtrado de sombras media baja (promedio).
ShadowQuality SHADOW_QUALITY_SOFT_HIGH = 4
Filtrado de sombras de baja calidad (lento). Al usar esta configuración de calidad, Light3D.shadow_blur se multiplica automáticamente por 1.5 para aprovechar mejor el alto número de muestras. Este mayor desenfoque también mejora la estabilidad de las sombras dinámicas de los objetos. Este multiplicador solo se aplica a luces cuyo Light3D.light_size o Light3D.light_angular_distance sea 0.0).
ShadowQuality SHADOW_QUALITY_SOFT_ULTRA = 5
Calidad de filtrado de sombras alta (más lento). Cuando se usa este ajuste de calidad, Light3D.shadow_blur se multiplica automáticamente por 2× para aprovechar mejor el alto número de muestras. Este aumento del desenfoque también mejora la estabilidad de las sombras de los objetos dinámicos. Este multiplicador solo se aplica a las luces cuyo Light3D.light_size o Light3D.light_angular_distance sea 0.0).
ShadowQuality SHADOW_QUALITY_MAX = 6
Representa el tamaño del enum ShadowQuality.
enum ReflectionProbeUpdateMode: 🔗
ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ONCE = 0
La sonda de reflexión actualizará las reflexiones una vez y luego se detendrá.
ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ALWAYS = 1
La sonda de reflexión actualizará cada cuadro. Este modo es necesario para capturar objetos en movimiento.
enum ReflectionProbeAmbientMode: 🔗
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_DISABLED = 0
No aplicar ninguna iluminación ambiental dentro de la caja de la sonda de reflexión definida por su tamaño.
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_ENVIRONMENT = 1
Aplicar iluminación ambiental de origen automático dentro del cuadro de la sonda de reflexión definido por su tamaño.
ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_COLOR = 2
Aplica iluminación ambiental personalizada dentro de la caja de la sonda de reflexión definida por su tamaño. Véase reflection_probe_set_ambient_color() y reflection_probe_set_ambient_energy().
enum DecalTexture: 🔗
DecalTexture DECAL_TEXTURE_ALBEDO = 0
Albedo texture slot in a decal (Decal.texture_albedo).
DecalTexture DECAL_TEXTURE_NORMAL = 1
Normal map texture slot in a decal (Decal.texture_normal).
DecalTexture DECAL_TEXTURE_ORM = 2
Occlusion/Roughness/Metallic texture slot in a decal (Decal.texture_orm).
DecalTexture DECAL_TEXTURE_EMISSION = 3
Emission texture slot in a decal (Decal.texture_emission).
DecalTexture DECAL_TEXTURE_MAX = 4
Representa el tamaño del enum DecalTexture.
enum DecalFilter: 🔗
DecalFilter DECAL_FILTER_NEAREST = 0
Nearest-neighbor filter for decals (use for pixel art decals). No mipmaps are used for rendering, which means decals at a distance will look sharp but grainy. This has roughly the same performance cost as using mipmaps.
DecalFilter DECAL_FILTER_LINEAR = 1
Linear filter for decals (use for non-pixel art decals). No mipmaps are used for rendering, which means decals at a distance will look smooth but blurry. This has roughly the same performance cost as using mipmaps.
DecalFilter DECAL_FILTER_NEAREST_MIPMAPS = 2
Nearest-neighbor filter for decals (use for pixel art decals). Isotropic mipmaps are used for rendering, which means decals at a distance will look smooth but blurry. This has roughly the same performance cost as not using mipmaps.
DecalFilter DECAL_FILTER_LINEAR_MIPMAPS = 3
Linear filter for decals (use for non-pixel art decals). Isotropic mipmaps are used for rendering, which means decals at a distance will look smooth but blurry. This has roughly the same performance cost as not using mipmaps.
DecalFilter DECAL_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4
Nearest-neighbor filter for decals (use for pixel art decals). Anisotropic mipmaps are used for rendering, which means decals at a distance will look smooth and sharp when viewed from oblique angles. This looks better compared to isotropic mipmaps, but is slower. The level of anisotropic filtering is defined by ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
DecalFilter DECAL_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5
Linear filter for decals (use for non-pixel art decals). Anisotropic mipmaps are used for rendering, which means decals at a distance will look smooth and sharp when viewed from oblique angles. This looks better compared to isotropic mipmaps, but is slower. The level of anisotropic filtering is defined by ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
enum VoxelGIQuality: 🔗
VoxelGIQuality VOXEL_GI_QUALITY_LOW = 0
Calidad de renderizado baja de VoxelGI usando 4 conos.
VoxelGIQuality VOXEL_GI_QUALITY_HIGH = 1
Calidad de renderizado alta de VoxelGI usando 6 conos.
enum ParticlesMode: 🔗
ParticlesMode PARTICLES_MODE_2D = 0
Partículas 2D.
ParticlesMode PARTICLES_MODE_3D = 1
Partículas 3D.
enum ParticlesTransformAlign: 🔗
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_DISABLED = 0
There is currently no description for this enum. Please help us by contributing one!
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD = 1
There is currently no description for this enum. Please help us by contributing one!
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY = 2
There is currently no description for this enum. Please help us by contributing one!
ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY = 3
There is currently no description for this enum. Please help us by contributing one!
enum ParticlesDrawOrder: 🔗
ParticlesDrawOrder PARTICLES_DRAW_ORDER_INDEX = 0
Dibuja las partículas en el orden en que aparecen en el array de partículas.
ParticlesDrawOrder PARTICLES_DRAW_ORDER_LIFETIME = 1
Ordena las partículas en función de su tiempo de vida. En otras palabras, la partícula con el mayor tiempo de vida se dibuja al frente.
ParticlesDrawOrder PARTICLES_DRAW_ORDER_REVERSE_LIFETIME = 2
Ordena las partículas en función de la inversa de su tiempo de vida. En otras palabras, la partícula con el menor tiempo de vida se dibuja al frente.
ParticlesDrawOrder PARTICLES_DRAW_ORDER_VIEW_DEPTH = 3
Clasifica las partículas según su distancia a la cámara.
enum ParticlesCollisionType: 🔗
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_ATTRACT = 0
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_ATTRACT = 1
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_VECTOR_FIELD_ATTRACT = 2
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_COLLIDE = 3
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_COLLIDE = 4
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_SDF_COLLIDE = 5
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionType PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE = 6
There is currently no description for this enum. Please help us by contributing one!
enum ParticlesCollisionHeightfieldResolution: 🔗
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_256 = 0
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_512 = 1
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_1024 = 2
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_2048 = 3
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_4096 = 4
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_8192 = 5
There is currently no description for this enum. Please help us by contributing one!
ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_MAX = 6
Representa el tamaño del enum ParticlesCollisionHeightfieldResolution.
enum FogVolumeShape: 🔗
FogVolumeShape FOG_VOLUME_SHAPE_ELLIPSOID = 0
FogVolume tendrá la forma de un elipsoide (esfera estirada).
FogVolumeShape FOG_VOLUME_SHAPE_CONE = 1
FogVolume tendrá la forma de un cono que apunta hacia arriba (en coordenadas locales). El ángulo del cono se ajusta automáticamente para ajustarse al tamaño. El cono se ajustará al tamaño. Gire el nodo FogVolume para reorientarlo. No se admite el escalado no uniforme por tamaño (en su lugar, escale el nodo FogVolume).
FogVolumeShape FOG_VOLUME_SHAPE_CYLINDER = 2
FogVolume tendrá la forma de un cilindro vertical (en coordenadas locales). Gire el nodo FogVolume para reorientar el cilindro. Este se ajustará al tamaño. No se admite el escalado no uniforme por tamaño (en su lugar, escale el nodo FogVolume).
FogVolumeShape FOG_VOLUME_SHAPE_BOX = 3
FogVolume tendrá la forma de una caja.
FogVolumeShape FOG_VOLUME_SHAPE_WORLD = 4
FogVolume no tendrá forma, cubrirá el mundo entero y no será eliminado.
FogVolumeShape FOG_VOLUME_SHAPE_MAX = 5
Representa el tamaño del enum FogVolumeShape.
enum ViewportScaling3DMode: 🔗
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_BILINEAR = 0
Utiliza el escalado bilineal para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando Viewport.scaling_3d_scale. Los valores menores que 1.0 darán como resultado un submuestreo, mientras que los valores mayores que 1.0 darán como resultado un sobremuestreo. Un valor de 1.0 desactiva el escalado.
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR = 1
Utiliza el upscaling AMD FidelityFX Super Resolution 1.0 para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando Viewport.scaling_3d_scale. Los valores menores que 1.0 harán que el viewport se escale utilizando FSR. Los valores mayores que 1.0 no son compatibles y, en su lugar, se utilizará el submuestreo bilineal. Un valor de 1.0 desactiva el escalado.
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR2 = 2
Utiliza el upscaling AMD FidelityFX Super Resolution 2.2 para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando Viewport.scaling_3d_scale. Los valores menores que 1.0 harán que el viewport se escale utilizando FSR2. Los valores mayores que 1.0 no son compatibles y, en su lugar, se utilizará el submuestreo bilineal. Un valor de 1.0 utilizará FSR2 a resolución nativa como una solución TAA.
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_SPATIAL = 3
Utiliza el upscaling espacial MetalFX para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando Viewport.scaling_3d_scale. Los valores menores que 1.0 harán que el viewport se escale utilizando MetalFX. Los valores mayores que 1.0 no son compatibles y, en su lugar, se utilizará el submuestreo bilineal. Un valor de 1.0 desactiva el escalado.
Nota: Solo se admite cuando se utiliza el controlador de renderizado Metal, lo que limita este modo de escalado a macOS e iOS.
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_TEMPORAL = 4
Utiliza el upscaling temporal MetalFX para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando Viewport.scaling_3d_scale. Los valores menores que 1.0 harán que el viewport se escale utilizando MetalFX. Los valores mayores que 1.0 no son compatibles y, en su lugar, se utilizará el submuestreo bilineal. Un valor de 1.0 utilizará MetalFX a resolución nativa como una solución TAA.
Nota: Solo se admite cuando se utiliza el controlador de renderizado Metal, lo que limita este modo de escalado a macOS e iOS.
ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_MAX = 5
Representa el tamaño del enum ViewportScaling3DMode.
enum ViewportUpdateMode: 🔗
ViewportUpdateMode VIEWPORT_UPDATE_DISABLED = 0
No actualizar el objetivo de renderizado del viewport.
ViewportUpdateMode VIEWPORT_UPDATE_ONCE = 1
Actualizar el objetivo de renderizado del viewport una vez, luego cambiar a VIEWPORT_UPDATE_DISABLED.
ViewportUpdateMode VIEWPORT_UPDATE_WHEN_VISIBLE = 2
Actualizar el objetivo de renderizado del viewport solo cuando esté visible. Este es el valor predeterminado.
ViewportUpdateMode VIEWPORT_UPDATE_WHEN_PARENT_VISIBLE = 3
Actualizar el objetivo de renderizado del viewport solo cuando su padre esté visible.
ViewportUpdateMode VIEWPORT_UPDATE_ALWAYS = 4
Siempre actualizar el objetivo de renderizado del viewport.
enum ViewportClearMode: 🔗
ViewportClearMode VIEWPORT_CLEAR_ALWAYS = 0
Siempre limpiar el objetivo de renderizado del viewport antes de dibujar.
ViewportClearMode VIEWPORT_CLEAR_NEVER = 1
Nunca limpiar el objetivo de renderizado del viewport.
ViewportClearMode VIEWPORT_CLEAR_ONLY_NEXT_FRAME = 2
Limpiar el objetivo de renderizado del viewport en el siguiente frame, luego cambiar a VIEWPORT_CLEAR_NEVER.
enum ViewportEnvironmentMode: 🔗
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_DISABLED = 0
Disable rendering of 3D environment over 2D canvas.
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_ENABLED = 1
Enable rendering of 3D environment over 2D canvas.
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_INHERIT = 2
Hereda el valor de habilitación/deshabilitación del padre. Si el padre más alto también está establecido en VIEWPORT_ENVIRONMENT_INHERIT, entonces esto tiene el mismo comportamiento que VIEWPORT_ENVIRONMENT_ENABLED.
ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_MAX = 3
Representa el tamaño del enum ViewportEnvironmentMode.
enum ViewportSDFOversize: 🔗
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_100_PERCENT = 0
No sobredimensionar el campo de distancia firmado 2D. Los oclusores pueden desaparecer al tocar los bordes del viewport, y la colisión de GPUParticles3D puede dejar de funcionar antes de lo previsto. Esto tiene los requisitos de GPU más bajos.
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_120_PERCENT = 1
El campo de distancia firmado 2D cubre el 20% del tamaño del viewport fuera del viewport en cada lado (arriba, derecha, abajo, izquierda).
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_150_PERCENT = 2
El campo de distancia firmado 2D cubre el 50% del tamaño del viewport fuera del viewport en cada lado (arriba, derecha, abajo, izquierda).
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_200_PERCENT = 3
El campo de distancia firmado 2D cubre el 100% del tamaño del viewport fuera del viewport en cada lado (arriba, derecha, abajo, izquierda). Esto tiene los requisitos de GPU más altos.
ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_MAX = 4
Representa el tamaño del enum ViewportSDFOversize.
enum ViewportSDFScale: 🔗
ViewportSDFScale VIEWPORT_SDF_SCALE_100_PERCENT = 0
Escala de campo de distancia firmado 2D de resolución completa. Esto tiene los requisitos de GPU más altos.
ViewportSDFScale VIEWPORT_SDF_SCALE_50_PERCENT = 1
Escala de campo de distancia firmado 2D de media resolución en cada eje (25% del recuento de píxeles del viewport).
ViewportSDFScale VIEWPORT_SDF_SCALE_25_PERCENT = 2
Escala de campo de distancia firmado 2D de un cuarto de resolución en cada eje (6.25% del recuento de píxeles del viewport). Esto tiene los requisitos de GPU más bajos.
ViewportSDFScale VIEWPORT_SDF_SCALE_MAX = 3
Representa el tamaño del enum ViewportSDFScale.
enum ViewportMSAA: 🔗
ViewportMSAA VIEWPORT_MSAA_DISABLED = 0
Multisample antialiasing for 3D is disabled. This is the default value, and also the fastest setting.
ViewportMSAA VIEWPORT_MSAA_2X = 1
Multisample antialiasing uses 2 samples per pixel for 3D. This has a moderate impact on performance.
ViewportMSAA VIEWPORT_MSAA_4X = 2
Multisample antialiasing uses 4 samples per pixel for 3D. This has a high impact on performance.
ViewportMSAA VIEWPORT_MSAA_8X = 3
Multisample antialiasing uses 8 samples per pixel for 3D. This has a very high impact on performance. Likely unsupported on low-end and older hardware.
ViewportMSAA VIEWPORT_MSAA_MAX = 4
Representa el tamaño del enum ViewportMSAA.
enum ViewportAnisotropicFiltering: 🔗
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_DISABLED = 0
El filtrado anisotrópico está desactivado.
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_2X = 1
Usar filtrado anisotrópico 2×.
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_4X = 2
Usar filtrado anisotrópico 4×. Este es el valor predeterminado.
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_8X = 3
Usar filtrado anisotrópico 8×.
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_16X = 4
Usar filtrado anisotrópico 16×.
ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_MAX = 5
Representa el tamaño del enum ViewportAnisotropicFiltering.
enum ViewportScreenSpaceAA: 🔗
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_DISABLED = 0
No realizar ningún antialiasing en el post-procesamiento de pantalla completa.
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_FXAA = 1
Usar antialiasing aproximado rápido. FXAA es un método popular de antialiasing en el espacio de la pantalla, que es rápido pero hará que la imagen se vea borrosa, especialmente en resoluciones más bajas. Aún puede funcionar relativamente bien en resoluciones grandes como 1440p y 4K.
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_SMAA = 2
Usar antialiasing morfológico de subpíxeles. SMAA puede producir resultados más claros que FXAA, pero con un coste de rendimiento ligeramente superior.
ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_MAX = 3
Representa el tamaño del enum ViewportScreenSpaceAA.
enum ViewportOcclusionCullingBuildQuality: 🔗
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_LOW = 0
Calidad de construcción BVH de eliminación de oclusión baja (según lo define Embree). Resulta en el uso de CPU más bajo, pero en la eliminación menos efectiva.
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_MEDIUM = 1
Calidad de construcción BVH de eliminación de oclusión media (según lo define Embree).
ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_HIGH = 2
Calidad de construcción BVH de eliminación de oclusión alta (según lo define Embree). Resulta en el uso de CPU más alto, pero en la eliminación más efectiva.
enum ViewportRenderInfo: 🔗
ViewportRenderInfo VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME = 0
Número de objetos dibujados en un solo fotograma.
ViewportRenderInfo VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME = 1
Número de puntos, líneas o triángulos dibujados en un solo frame.
ViewportRenderInfo VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME = 2
Número de llamadas de dibujo durante este fotograma.
ViewportRenderInfo VIEWPORT_RENDER_INFO_MAX = 3
Representa el tamaño del enum ViewportRenderInfo.
enum ViewportRenderInfoType: 🔗
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_VISIBLE = 0
Pase de renderizado visible (excluidas las sombras).
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_SHADOW = 1
Paso de renderizado de sombras. Los objetos se renderizarán varias veces dependiendo de la cantidad de luces con sombras y el número de divisiones de sombras direccionales.
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_CANVAS = 2
Renderizado de elementos del canvas. Esto incluye todo el renderizado 2D.
ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_MAX = 3
Representa el tamaño del enum ViewportRenderInfoType.
enum ViewportDebugDraw: 🔗
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLED = 0
El dibujado de depuración está desactivado. Configuración predeterminada.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_UNSHADED = 1
Los objetos se muestran sin información de la luz.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_LIGHTING = 2
Los objetos se muestran solo con información de la luz.
Nota: Cuando se utiliza este modo de dibujo de depuración, se ignoran los shaders personalizados, ya que todos los materiales de la escena utilizan temporalmente un material de depuración. Esto significa que el resultado de las funciones de shader personalizadas (como el desplazamiento de vértices) ya no será visible cuando se utilice este modo de dibujo de depuración.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OVERDRAW = 3
Objects are displayed semi-transparent with additive blending so you can see where they are drawing over top of one another. A higher overdraw (represented by brighter colors) means you are wasting performance on drawing pixels that are being hidden behind others.
Note: When using this debug draw mode, custom shaders are ignored since all materials in the scene temporarily use a debug material. This means the result from custom shader functions (such as vertex displacement) won't be visible anymore when using this debug draw mode.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_WIREFRAME = 4
Debug draw draws objects in wireframe.
Note: set_debug_generate_wireframes() must be called before loading any meshes for wireframes to be visible when using the Compatibility renderer.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER = 5
El búfer normal se dibuja en lugar de la escena normal para que puedas ver las normales por píxel que serán utilizadas por los efectos de post-procesamiento.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_ALBEDO = 6
Los objetos se muestran solo con el valor albedo de los VoxelGI. Requiere al menos un nodo VoxelGI visible que haya sido procesado para tener un efecto visible.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_LIGHTING = 7
Los objetos se muestran solo con el valor de iluminación de los VoxelGI. Requiere al menos un nodo VoxelGI visible que haya sido procesado para tener un efecto visible.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_EMISSION = 8
Los objetos se muestran solo con el color de emisión de los VoxelGI. Requiere al menos un nodo VoxelGI visible que haya sido procesado para tener un efecto visible.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS = 9
Dibuja el atlas de sombras que almacena las sombras de las OmniLight3D y SpotLight3D en el cuadrante superior izquierdo del Viewport.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS = 10
Dibuja el atlas de sombras que almacena las sombras de los DirectionalLight3D en el cuadrante superior izquierdo del Viewport.
La porción del frustum de la cámara relacionada con la cascada del mapa de sombras se superpone para visualizar la cobertura. El color de cada porción coincide con los colores utilizados para VIEWPORT_DEBUG_DRAW_PSSM_SPLITS. Cuando las cascadas de sombras se mezclan, la superposición se tiene en cuenta al dibujar las porciones del frustum.
La última cascada muestra todas las porciones del frustum para ilustrar la cobertura de todas las porciones.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE = 11
Dibuja la luminancia estimada de la escena. Esta es una textura de 1×1 que se genera cuando la autoexposición está habilitada para controlar la exposición de la escena.
Nota: Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSAO = 12
Dibuja la textura de oclusión ambiental del espacio de la pantalla en lugar de la escena para que puedas ver claramente cómo está afectando a los objetos. Para que este modo de visualización funcione, debes tener Environment.ssao_enabled establecido en tu WorldEnvironment.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSIL = 13
Dibuja la textura de iluminación indirecta del espacio de la pantalla en lugar de la escena para que puedas ver claramente cómo está afectando a los objetos. Para que este modo de visualización funcione, debes tener Environment.ssil_enabled establecido en tu WorldEnvironment.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_PSSM_SPLITS = 14
Colorea cada división PSSM para los DirectionalLight3D en la escena con un color diferente para que puedas ver dónde están las divisiones. En orden (desde el más cercano al más lejano de la cámara), se colorean de rojo, verde, azul y amarillo.
Nota: Cuando se utiliza este modo de dibujo de depuración, se ignoran los shaders personalizados, ya que todos los materiales de la escena utilizan temporalmente un material de depuración. Esto significa que el resultado de las funciones de shader personalizadas (como el desplazamiento de vértices) ya no será visible cuando se utilice este modo de dibujo de depuración.
Nota: Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DECAL_ATLAS = 15
Dibuja el atlas de decals que almacena las texturas de decals de los Decal.
Nota: Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI = 16
Dibuja los datos de la cascada SDFGI. Esta es la estructura de datos que se utiliza para rebotar la iluminación y crear reflejos.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI_PROBES = 17
Draws SDFGI probe data. This is the data structure that is used to give indirect lighting dynamic objects moving within the scene.
When in the editor, left-clicking a probe will display additional bright dots that show its occlusion information. A white dot means the light is not occluded at all at the dot's position, while a red dot means the light is fully occluded. Intermediate values are possible.
Note: Only supported when using the Forward+ rendering method.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_GI_BUFFER = 18
Dibuja el búfer de iluminación global de VoxelGI o SDFGI. Requiere que VoxelGI (al menos un nodo VoxelGI procesado visible) o SDFGI (Environment.sdfgi_enabled) estén habilitados para tener un efecto visible.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLE_LOD = 19
Deshabilitar el LOD de la malla. Todas las mallas se dibujan con todo detalle, lo que puede utilizarse para comparar el rendimiento.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS = 20
Dibuja el clúster OmniLight3D. La agrupación por clúster determina dónde se colocan las luces en el espacio de la pantalla, lo que permite al motor procesar solo estas porciones de la pantalla para la iluminación.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS = 21
Dibuja el clúster SpotLight3D. La agrupación por clúster determina dónde se colocan las luces en el espacio de la pantalla, lo que permite al motor procesar solo estas porciones de la pantalla para la iluminación.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_DECALS = 22
Dibuja el clúster Decal. La agrupación por clúster determina dónde se colocan los decals en el espacio de la pantalla, lo que permite al motor procesar solo estas porciones de la pantalla para los decals.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES = 23
Dibuja el clúster ReflectionProbe. La agrupación por clúster determina dónde se colocan las sondas de reflexión en el espacio de la pantalla, lo que permite al motor procesar solo estas porciones de la pantalla para las sondas de reflexión.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OCCLUDERS = 24
Dibuja el búfer de eliminación de oclusión. Este búfer de eliminación de oclusión de baja resolución se rasteriza en la CPU y se utiliza para comprobar si las instancias están ocluidas por otros objetos.
Nota: Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_MOTION_VECTORS = 25
Dibuja el búfer de vectores de movimiento. Esto es utilizado por el antialiasing temporal para corregir el movimiento que ocurre durante el juego.
Nota: Solo se admite cuando se utiliza el método de renderizado Forward+.
ViewportDebugDraw VIEWPORT_DEBUG_DRAW_INTERNAL_BUFFER = 26
El búfer interno se dibuja en lugar de la escena normal para que puedas ver la salida por píxel que será utilizada por los efectos de post-procesamiento.
Nota: Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
enum ViewportVRSMode: 🔗
ViewportVRSMode VIEWPORT_VRS_DISABLED = 0
El sombreado de velocidad variable está desactivado.
ViewportVRSMode VIEWPORT_VRS_TEXTURE = 1
El sombreado de velocidad variable utiliza una textura. Nota: para uso estereoscópico, utiliza un atlas de texturas con una textura para cada vista.
ViewportVRSMode VIEWPORT_VRS_XR = 2
La textura de sombreado de velocidad variable es proporcionada por la XRInterface principal. Ten en cuenta que esto puede sobrescribir el modo de actualización.
ViewportVRSMode VIEWPORT_VRS_MAX = 3
Representa el tamaño del enum ViewportVRSMode.
enum ViewportVRSUpdateMode: 🔗
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_DISABLED = 0
La textura de entrada para el sombreado de velocidad variable no se procesará.
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ONCE = 1
La textura de entrada para el sombreado de velocidad variable se procesará una vez.
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ALWAYS = 2
La textura de entrada para el sombreado de velocidad variable se procesará en cada frame.
ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_MAX = 3
Representa el tamaño del enum ViewportVRSUpdateMode.
enum SkyMode: 🔗
SkyMode SKY_MODE_AUTOMATIC = 0
Selecciona automáticamente el modo de proceso apropiado según tu shader de cielo. Si tu shader usa TIME o POSITION, esto usará SKY_MODE_REALTIME. Si tu shader usa cualquiera de las variables LIGHT_* o cualquier uniforme personalizado, esto usa SKY_MODE_INCREMENTAL. De lo contrario, esto regresa por defecto a SKY_MODE_QUALITY.
SkyMode SKY_MODE_QUALITY = 1
Utiliza un muestreo de importancia de alta calidad para procesar el mapa de radiancia. En general, esto resulta en una calidad mucho mayor que SKY_MODE_REALTIME pero tarda mucho más en generarse. Esto no debe usarse si planea cambiar el cielo en tiempo de ejecución. Si encuentra que el reflejo no es lo suficientemente borroso y muestra destellos o luciérnagas, intenta aumentar ProjectSettings.rendering/reflections/sky_reflections/ggx_samples.
SkyMode SKY_MODE_INCREMENTAL = 2
Utiliza el mismo muestreo de importancia de alta calidad para procesar el mapa de radiancia que SKY_MODE_QUALITY, pero se actualiza durante varios fotogramas. El número de fotogramas está determinado por ProjectSettings.rendering/reflections/sky_reflections/roughness_layers. Usa esto cuando necesites mapas de radiancia de la más alta calidad, pero tengas un cielo que se actualice lentamente.
SkyMode SKY_MODE_REALTIME = 3
Utiliza el algoritmo de filtrado rápido para procesar el mapa de radiancia. En general, esto resulta en una menor calidad, pero en tiempos de ejecución sustancialmente más rápidos. Si necesita una mejor calidad, pero aún necesita actualizar el cielo cada fotograma, considera activar ProjectSettings.rendering/reflections/sky_reflections/fast_filter_high_quality.
Nota: El algoritmo de filtrado rápido está limitado a cubemaps de 256×256, por lo que sky_set_radiance_size() debe establecerse en 256. De lo contrario, se imprime una advertencia y se ignora el tamaño de radiancia anulado.
enum CompositorEffectFlags: 🔗
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_COLOR = 1
El efecto de renderizado requiere que se resuelva el búfer de color si MSAA está habilitado.
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_DEPTH = 2
El efecto de renderizado requiere que se resuelva el búfer de profundidad si MSAA está habilitado.
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_MOTION_VECTORS = 4
El efecto de renderizado requiere que se produzcan vectores de movimiento.
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_ROUGHNESS = 8
El efecto de renderizado requiere que se produzcan las normales y el g-búfer de rugosidad (solo Forward+).
CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_SEPARATE_SPECULAR = 16
El efecto de renderizado requiere que los datos especulares se separen (solo Forward+).
enum CompositorEffectCallbackType: 🔗
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_OPAQUE = 0
La callback se llama antes de nuestro pase de renderizado opaco, pero después del pre-pase de profundidad (si corresponde).
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_OPAQUE = 1
La callback se llama después de nuestro pase de renderizado opaco, pero antes de que se renderice nuestro cielo.
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_SKY = 2
La callback se llama después de que se renderice nuestro cielo, pero antes de que se creen nuestros búferes de fondo (y, si está habilitado, antes de la dispersión subsuperficial y/o los reflejos del espacio de pantalla).
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT = 3
La callback se llama antes de nuestro pase de renderizado transparente, pero después de que se renderice nuestro cielo y hayamos creado nuestros búferes de fondo.
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_TRANSPARENT = 4
La callback se llama después de nuestro pase de renderizado transparente, pero antes de cualquier efecto de post-procesamiento incorporado y de la salida a nuestro objetivo de renderizado.
CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_ANY = -1
There is currently no description for this enum. Please help us by contributing one!
enum EnvironmentBG: 🔗
EnvironmentBG ENV_BG_CLEAR_COLOR = 0
Usa el color limpio como fondo.
EnvironmentBG ENV_BG_COLOR = 1
Usar un color específico como fondo.
EnvironmentBG ENV_BG_SKY = 2
Usar un recurso del cielo para el fondo.
EnvironmentBG ENV_BG_CANVAS = 3
Usar una capa de canvas especifica como fondo. Esto puede ser útil para instanciar una escena 2D en un mundo 3D.
EnvironmentBG ENV_BG_KEEP = 4
No despejar el fondo, usar el último fotograma como fondo.
EnvironmentBG ENV_BG_CAMERA_FEED = 5
Muestra un feed de una cámara en el fondo.
EnvironmentBG ENV_BG_MAX = 6
Representa el tamaño del enum EnvironmentBG.
enum EnvironmentAmbientSource: 🔗
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_BG = 0
Recoge la luz ambiental de la fuente que se especifique como fondo.
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_DISABLED = 1
Desactiva la luz ambiental.
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_COLOR = 2
Especifica un Color específico para la luz ambiental.
EnvironmentAmbientSource ENV_AMBIENT_SOURCE_SKY = 3
Recoge la luz ambiental del Sky independientemente de cuál sea el fondo.
enum EnvironmentReflectionSource: 🔗
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_BG = 0
Utilizar el fondo para los reflejos.
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_DISABLED = 1
Desactivar reflejos.
EnvironmentReflectionSource ENV_REFLECTION_SOURCE_SKY = 2
Usa el Sky para los reflejos independientemente de cuál sea el fondo.
enum EnvironmentGlowBlendMode: 🔗
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_ADDITIVE = 0
Modo de mezcla de brillo aditivo. Se utiliza principalmente para partículas, brillos (florecimiento), destellos de lentes, fuentes brillantes.
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SCREEN = 1
Modo de mezcla de brillo de pantalla. Aumenta el brillo, se usa frecuentemente con el bloom.
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SOFTLIGHT = 2
Modo de mezcla de brillo de luz suave. Modifica el contraste, expone sombras y luces (bloom vivo).
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_REPLACE = 3
Reemplazar el modo de mezcla de brillo. Reemplaza el color de todos los píxeles por el valor de brillo. Puede utilizarse para simular un efecto de desenfoque en pantalla completa ajustando los parámetros de brillo para que coincidan con el brillo de la imagen original.
EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_MIX = 4
Mixes the glow with the underlying color to avoid increasing brightness as much while still maintaining a glow effect.
enum EnvironmentFogMode: 🔗
EnvironmentFogMode ENV_FOG_MODE_EXPONENTIAL = 0
Use a physically-based fog model defined primarily by fog density.
EnvironmentFogMode ENV_FOG_MODE_DEPTH = 1
Use a simple fog model defined by start and end positions and a custom curve. While not physically accurate, this model can be useful when you need more artistic control.
enum EnvironmentToneMapper: 🔗
EnvironmentToneMapper ENV_TONE_MAPPER_LINEAR = 0
No modifica los datos de color, lo que resulta en una curva de mapeo tonal lineal que recorta de forma antinatural los valores brillantes, haciendo que la iluminación brillante se vea quemada. El mapeador tonal más simple y rápido.
EnvironmentToneMapper ENV_TONE_MAPPER_REINHARD = 1
Una curva de mapeo de tonos simple que reduce los valores brillantes para evitar el recorte. Esto da como resultado una imagen que puede parecer opaca y de bajo contraste. Más lento que ENV_TONE_MAPPER_LINEAR.
Nota: Cuando Environment.tonemap_white se deja en el valor predeterminado de 1.0, ENV_TONE_MAPPER_REINHARD produce una imagen idéntica a ENV_TONE_MAPPER_LINEAR.
EnvironmentToneMapper ENV_TONE_MAPPER_FILMIC = 2
Utiliza una curva de mapeo de tonos similar a la de una película para evitar el recorte de valores brillantes y proporcionar un mejor contraste que ENV_TONE_MAPPER_REINHARD. Ligeramente más lento que ENV_TONE_MAPPER_REINHARD.
EnvironmentToneMapper ENV_TONE_MAPPER_ACES = 3
Utiliza una curva de mapeo de tonos similar a la de una película de alto contraste y desatura los valores brillantes para una apariencia más realista. Ligeramente más lento que ENV_TONE_MAPPER_FILMIC.
Nota: Este operador de mapeo de tonos se llama "ACES Fitted" en Godot 3.x.
EnvironmentToneMapper ENV_TONE_MAPPER_AGX = 4
Uses an adjustable film-like tonemapping curve and desaturates bright values for a more realistic appearance. Better than other tonemappers at maintaining the hue of colors as they become brighter. The slowest tonemapping option.
enum EnvironmentSSRRoughnessQuality: 🔗
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_DISABLED = 0
La calidad más baja del filtro de rugosidad para los reflejos del espacio de la pantalla. Los materiales rugosos no tendrán reflejos del espacio de la pantalla más borrosos en comparación con los materiales lisos (no rugosos). Esta es la opción más rápida.
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_LOW = 1
Baja calidad del filtro de rugosidad para reflejos en espacio de pantalla.
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_MEDIUM = 2
Calidad media del filtro de rugosidad para reflejos en espacio de pantalla.
EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_HIGH = 3
Alta calidad del filtro de rugosidad para reflejos en espacio de pantalla. Esta es la opción más lenta.
enum EnvironmentSSAOQuality: 🔗
EnvironmentSSAOQuality ENV_SSAO_QUALITY_VERY_LOW = 0
La calidad más baja de la oclusión ambiental del espacio de la pantalla.
EnvironmentSSAOQuality ENV_SSAO_QUALITY_LOW = 1
Oclusión ambiental del espacio de pantalla de baja calidad.
EnvironmentSSAOQuality ENV_SSAO_QUALITY_MEDIUM = 2
Oclusión ambiental del espacio de pantalla de calidad media.
EnvironmentSSAOQuality ENV_SSAO_QUALITY_HIGH = 3
Oclusión ambiental del espacio de pantalla de alta calidad.
EnvironmentSSAOQuality ENV_SSAO_QUALITY_ULTRA = 4
Oclusión ambiental del espacio de pantalla de la máxima calidad. Utiliza el ajuste de objetivo adaptativo que puede ajustarse dinámicamente para equilibrar suavemente el rendimiento y la calidad visual.
enum EnvironmentSSILQuality: 🔗
EnvironmentSSILQuality ENV_SSIL_QUALITY_VERY_LOW = 0
La calidad más baja de iluminación indirecta en espacio de pantalla.
EnvironmentSSILQuality ENV_SSIL_QUALITY_LOW = 1
Iluminación indirecta en espacio de pantalla de baja calidad.
EnvironmentSSILQuality ENV_SSIL_QUALITY_MEDIUM = 2
Iluminación indirecta en espacio de pantalla de alta calidad.
EnvironmentSSILQuality ENV_SSIL_QUALITY_HIGH = 3
Iluminación indirecta en espacio de pantalla de alta calidad.
EnvironmentSSILQuality ENV_SSIL_QUALITY_ULTRA = 4
Iluminación indirecta en espacio de pantalla de la máxima calidad. Utiliza el ajuste de objetivo adaptativo que puede ajustarse dinámicamente para equilibrar suavemente el rendimiento y la calidad visual.
enum EnvironmentSDFGIYScale: 🔗
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_50_PERCENT = 0
Use 50% scale for SDFGI on the Y (vertical) axis. SDFGI cells will be twice as short as they are wide. This allows providing increased GI detail and reduced light leaking with thin floors and ceilings. This is usually the best choice for scenes that don't feature much verticality.
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_75_PERCENT = 1
Use 75% scale for SDFGI on the Y (vertical) axis. This is a balance between the 50% and 100% SDFGI Y scales.
EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_100_PERCENT = 2
Use 100% scale for SDFGI on the Y (vertical) axis. SDFGI cells will be as tall as they are wide. This is usually the best choice for highly vertical scenes. The downside is that light leaking may become more noticeable with thin floors and ceilings.
enum EnvironmentSDFGIRayCount: 🔗
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_4 = 0
Lanza 4 rayos por fotograma al converger SDFGI. Esto tiene los requisitos de GPU más bajos, pero crea el resultado más ruidoso.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_8 = 1
Lanza 8 rayos por fotograma al converger SDFGI.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_16 = 2
Lanza 16 rayos por fotograma al converger SDFGI.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_32 = 3
Lanza 32 rayos por fotograma al converger SDFGI.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_64 = 4
Lanza 64 rayos por fotograma al converger SDFGI.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_96 = 5
Lanza 96 rayos por fotograma al converger SDFGI. Esto tiene altos requisitos de GPU.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_128 = 6
Lanza 128 rayos por fotograma al converger SDFGI. Esto tiene unos requisitos de GPU muy altos, pero crea el resultado menos ruidoso.
EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_MAX = 7
Representa el tamaño del enum EnvironmentSDFGIRayCount.
enum EnvironmentSDFGIFramesToConverge: 🔗
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_5_FRAMES = 0
Converge SDFGI en 5 fotogramas. Esto es lo más sensible, pero crea el resultado más ruidoso con un número de rayos dado.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_10_FRAMES = 1
Configurar SDFGI para que converja completamente en 10 cuadros.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_15_FRAMES = 2
Configurar SDFGI para que converja completamente en 15 cuadros.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_20_FRAMES = 3
Configurar SDFGI para que converja completamente en más de 20 cuadros.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_25_FRAMES = 4
Configurar SDFGI para que converja completamente en 25 cuadros.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_30_FRAMES = 5
Configurar SDFGI para que converja completamente en 30 fotogramas. Esta opción ofrece la menor capacidad de respuesta, pero genera el resultado menos ruidoso con un número de rayos determinado.
EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_MAX = 6
Representa el tamaño del enum EnvironmentSDFGIFramesToConverge.
enum EnvironmentSDFGIFramesToUpdateLight: 🔗
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_1_FRAME = 0
Actualiza la luz indirecta de las luces dinámicas en SDFGI en 1 fotograma. Esto es lo más sensible, pero tiene los requisitos de GPU más altos.
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_2_FRAMES = 1
Actualiza la luz indirecta de las luces dinámicas en SDFGI en 2 fotogramas.
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_4_FRAMES = 2
Actualiza la luz indirecta de las luces dinámicas en SDFGI en 4 fotogramas.
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_8_FRAMES = 3
Actualiza la luz indirecta de las luces dinámicas en SDFGI en 8 fotogramas.
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_16_FRAMES = 4
Actualiza la luz indirecta de las luces dinámicas en SDFGI en 16 fotogramas. Esto es lo menos sensible, pero tiene los requisitos de GPU más bajos.
EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_MAX = 5
Representa el tamaño del enum EnvironmentSDFGIFramesToUpdateLight.
enum SubSurfaceScatteringQuality: 🔗
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_DISABLED = 0
Desactiva por completo la dispersión del subsuelo, incluso en materiales que tienen BaseMaterial3D.subsurf_scatter_enabled establecido en true. Esto tiene los requisitos de GPU más bajos.
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_LOW = 1
Low subsurface scattering quality.
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_MEDIUM = 2
Medium subsurface scattering quality.
SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_HIGH = 3
High subsurface scattering quality. This has the highest GPU requirements.
enum DOFBokehShape: 🔗
DOFBokehShape DOF_BOKEH_BOX = 0
Calcula el desenfoque DOF usando un filtro de caja. Es la opción más rápida, pero da como resultado líneas obvias en el patrón de desenfoque.
DOFBokehShape DOF_BOKEH_HEXAGON = 1
Calcula el desenfoque DOF usando un filtro con forma de hexágono.
DOFBokehShape DOF_BOKEH_CIRCLE = 2
Calcula el desenfoque DOF usando un filtro con forma de círculo. La mejor calidad y la más realista, pero la más lenta. Usar solo para áreas donde se puede dedicar mucho rendimiento al post-procesamiento (por ejemplo, cinemáticas).
enum DOFBlurQuality: 🔗
DOFBlurQuality DOF_BLUR_QUALITY_VERY_LOW = 0
Desenfoque DOF de la calidad más baja. Es el ajuste más rápido, pero es posible que se vean artefactos de filtrado.
DOFBlurQuality DOF_BLUR_QUALITY_LOW = 1
Desenfoque DOF de baja calidad.
DOFBlurQuality DOF_BLUR_QUALITY_MEDIUM = 2
Desenfoque DOF de calidad media.
DOFBlurQuality DOF_BLUR_QUALITY_HIGH = 3
Desenfoque DOF de la más alta calidad. Da como resultado el desenfoque de aspecto más suave al tomar la mayor cantidad de muestras, pero también es significativamente más lento.
enum InstanceType: 🔗
InstanceType INSTANCE_NONE = 0
La instancia no tiene un tipo.
InstanceType INSTANCE_MESH = 1
La instancia es una malla.
InstanceType INSTANCE_MULTIMESH = 2
La instancia es una multimalla.
InstanceType INSTANCE_PARTICLES = 3
El caso es un emisor de partículas.
InstanceType INSTANCE_PARTICLES_COLLISION = 4
La instancia es una forma de colisión de GPUParticles.
InstanceType INSTANCE_LIGHT = 5
La instancia es una luz.
InstanceType INSTANCE_REFLECTION_PROBE = 6
La instancia es una sonda de reflexión.
InstanceType INSTANCE_DECAL = 7
La instancia es una decal.
InstanceType INSTANCE_VOXEL_GI = 8
La instancia es un VoxelGI.
InstanceType INSTANCE_LIGHTMAP = 9
La instancia es un lightmap.
InstanceType INSTANCE_OCCLUDER = 10
La instancia es un oclusor de descarte de oclusión.
InstanceType INSTANCE_VISIBLITY_NOTIFIER = 11
La instancia es un notificador visible en pantalla.
InstanceType INSTANCE_FOG_VOLUME = 12
La instancia es un volumen de niebla.
InstanceType INSTANCE_MAX = 13
Representa el tamaño del enum InstanceType.
InstanceType INSTANCE_GEOMETRY_MASK = 14
Una combinación de las banderas de las instancias de la geometría (malla, multimesh, inmediata y partículas).
enum InstanceFlags: 🔗
InstanceFlags INSTANCE_FLAG_USE_BAKED_LIGHT = 0
Permite que la instancia se utilice en la iluminación del cocinado.
InstanceFlags INSTANCE_FLAG_USE_DYNAMIC_GI = 1
Permite que la instancia se utilice con iluminación global dinámica.
InstanceFlags INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 2
Cuando se establece, pide manualmente dibujar la geometría en el siguiente fotograma.
InstanceFlags INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING = 3
Dibujar siempre, incluso si la instancia fuera descartada por el occlusion culling. No afecta al descarte por frustum de vista.
InstanceFlags INSTANCE_FLAG_MAX = 4
Representa el tamaño del enum InstanceFlags.
enum ShadowCastingSetting: 🔗
ShadowCastingSetting SHADOW_CASTING_SETTING_OFF = 0
Deshabilita sombras de esta instancia.
ShadowCastingSetting SHADOW_CASTING_SETTING_ON = 1
Proyecta sombras de esta instancia.
ShadowCastingSetting SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2
Deshabilitar la selección de la cara posterior cuando se renderice la sombra del objeto. Esto es un poco más lento pero puede resultar en sombras más correctas.
ShadowCastingSetting SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3
Solo se muestran las sombras del objeto. El objeto en sí no será dibujado.
enum VisibilityRangeFadeMode: 🔗
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DISABLED = 0
Deshabilita el desvanecimiento del rango de visibilidad para la instancia dada.
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_SELF = 1
Desvanece la instancia dada cuando se acerca a sus límites de rango de visibilidad.
VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DEPENDENCIES = 2
Muestra gradualmente las dependencias de la instancia dada al alcanzar sus límites del rango de visibilidad.
enum BakeChannels: 🔗
BakeChannels BAKE_CHANNEL_ALBEDO_ALPHA = 0
Índice de Image en el array de Images devuelto por bake_render_uv2(). La imagen usa Image.FORMAT_RGBA8 y contiene el color albedo en los canales .rgb y alfa en el canal .a.
BakeChannels BAKE_CHANNEL_NORMAL = 1
Índice de Image en el array de Images devuelto por bake_render_uv2(). La imagen usa Image.FORMAT_RGBA8 y contiene la normal por píxel del objeto en los canales .rgb y nada en el canal .a. La normal por píxel está codificada como normal * 0.5 + 0.5.
BakeChannels BAKE_CHANNEL_ORM = 2
Índice de Image en el array de Images devuelto por bake_render_uv2(). La imagen utiliza Image.FORMAT_RGBA8 y contiene oclusión ambiental (solo del material y los decals) en el canal .r, rugosidad en el canal .g, metalicidad en el canal .b y la cantidad de dispersión de subsuperficie en el canal .a.
BakeChannels BAKE_CHANNEL_EMISSION = 3
Índice de Image en el array de Images devuelto por bake_render_uv2(). La imagen utiliza Image.FORMAT_RGBAH y contiene el color de emisión en los canales .rgb y nada en el canal .a.
enum CanvasTextureChannel: 🔗
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_DIFFUSE = 0
Textura de lienzo difusa (CanvasTexture.diffuse_texture).
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_NORMAL = 1
Textura de lienzo del mapa de normales (CanvasTexture.normal_texture).
CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_SPECULAR = 2
Textura de lienzo del mapa especular (CanvasTexture.specular_texture).
enum NinePatchAxisMode: 🔗
NinePatchAxisMode NINE_PATCH_STRETCH = 0
El nine patch se estira donde es necesario.
NinePatchAxisMode NINE_PATCH_TILE = 1
El nine patch se llena de tiles donde sea necesario.
NinePatchAxisMode NINE_PATCH_TILE_FIT = 2
El nine patch se llena de tiles donde sea necesario y se estira un poco si es necesario.
enum CanvasItemTextureFilter: 🔗
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_DEFAULT = 0
Usa el modo de filtro por defecto para este Viewport.
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST = 1
The texture filter reads from the nearest pixel only. This makes the texture look pixelated from up close, and grainy from a distance (due to mipmaps not being sampled).
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR = 2
The texture filter blends between the nearest 4 pixels. This makes the texture look smooth from up close, and grainy from a distance (due to mipmaps not being sampled).
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 3
El filtro de textura lee del píxel más cercano y mezcla entre los 2 mipmaps más cercanos (o usa el mipmap más cercano si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter es true). Esto hace que la textura se vea pixelada de cerca y suave de lejos.
Úsalo para texturas que no son de arte de píxeles y que pueden verse a baja escala (por ejemplo, debido al zoom de Camera2D o al escalado de sprites), ya que los mipmaps son importantes para suavizar los píxeles que son más pequeños que los píxeles en pantalla.
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 4
El filtro de textura mezcla entre los 4 píxeles más cercanos y entre los 2 mipmaps más cercanos (o usa el mipmap más cercano si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter es true). Esto hace que la textura se vea suave de cerca y suave de lejos.
Úsalo para texturas que no son de arte de píxeles y que pueden verse a baja escala (por ejemplo, debido al zoom de Camera2D o al escalado de sprites), ya que los mipmaps son importantes para suavizar los píxeles que son más pequeños que los píxeles en pantalla.
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 5
El filtro de textura lee desde el píxel más cercano y se mezcla entre 2 mipmaps (o utiliza el mipmap más cercano si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter es true) según el ángulo entre la superficie y la vista de la cámara. Esto hace que la textura se vea pixelada de cerca y suave desde la distancia. El filtrado anisotrópico mejora la calidad de la textura en superficies que están casi en línea con la cámara, pero es ligeramente más lento. El nivel de filtrado anisotrópico se puede cambiar ajustando ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
Nota: Este filtro de textura rara vez es útil en proyectos 2D. CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS suele ser más apropiado en este caso.
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 6
El filtro de textura se mezcla entre los 4 píxeles más cercanos y se mezcla entre 2 mipmaps (o utiliza el mipmap más cercano si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter es true) según el ángulo entre la superficie y la vista de la cámara. Esto hace que la textura se vea suave de cerca y suave desde la distancia. El filtrado anisotrópico mejora la calidad de la textura en superficies que están casi en línea con la cámara, pero es ligeramente más lento. El nivel de filtrado anisotrópico se puede cambiar ajustando ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.
Nota: Este filtro de textura rara vez es útil en proyectos 2D. CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS suele ser más apropiado en este caso.
CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_MAX = 7
Valor máximo para el enum CanvasItemTextureFilter.
enum CanvasItemTextureRepeat: 🔗
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT = 0
Usa el modo de repetición por defecto para este Viewport.
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DISABLED = 1
Desactiva la repetición de texturas. En su lugar, al leer UVs fuera del rango 0-1, el valor se sujetará al borde de la textura, resultando en un aspecto estirado en los bordes de la textura.
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_ENABLED = 2
Enables the texture to repeat when UV coordinates are outside the 0-1 range. If using one of the linear filtering modes, this can result in artifacts at the edges of a texture when the sampler filters across the edges of the texture.
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MIRROR = 3
Invierte la textura al repetirla para que el borde se alinee en lugar de cambiar bruscamente.
CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MAX = 4
Valor máximo para el enum CanvasItemTextureRepeat.
enum CanvasGroupMode: 🔗
CanvasGroupMode CANVAS_GROUP_MODE_DISABLED = 0
El hijo se dibuja sobre el padre y no se recorta.
CanvasGroupMode CANVAS_GROUP_MODE_CLIP_ONLY = 1
El padre se usa solo para fines de recorte. El hijo se recorta al área visible del padre, el padre no se dibuja.
CanvasGroupMode CANVAS_GROUP_MODE_CLIP_AND_DRAW = 2
El padre se usa para recortar al hijo, pero el padre también se dibuja debajo del hijo de forma normal antes de recortar al hijo a su área visible.
CanvasGroupMode CANVAS_GROUP_MODE_TRANSPARENT = 3
There is currently no description for this enum. Please help us by contributing one!
enum CanvasLightMode: 🔗
CanvasLightMode CANVAS_LIGHT_MODE_POINT = 0
Punto de luz 2D (véase PointLight2D).
CanvasLightMode CANVAS_LIGHT_MODE_DIRECTIONAL = 1
Luz direccional 2D (sol/luna) (véase DirectionalLight2D).
enum CanvasLightBlendMode: 🔗
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_ADD = 0
Añade un aditivo de color claro al canvas.
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_SUB = 1
Añade el color de la luz que se sustrae al canvas.
CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_MIX = 2
La luz añade color dependiendo de la transparencia.
enum CanvasLightShadowFilter: 🔗
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_NONE = 0
No aplique un filtro a las sombras de luz del canvas.
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF5 = 1
Utiliza el filtro PCF5 para filtrar las sombras de luz del canvas.
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF13 = 2
Utiliza el filtro PCF13 para filtrar las sombras de luz del canvas.
CanvasLightShadowFilter CANVAS_LIGHT_FILTER_MAX = 3
Valor máximo del enum CanvasLightShadowFilter.
enum CanvasOccluderPolygonCullMode: 🔗
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_DISABLED = 0
Selección del oclusor del canvas está desactivado.
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE = 1
La selección del oclusor del canvas se hace en el sentido de las agujas del reloj.
CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE = 2
La selección del oclusor del canvas es en sentido contrario a las agujas del reloj.
enum GlobalShaderParameterType: 🔗
GlobalShaderParameterType GLOBAL_VAR_TYPE_BOOL = 0
Parámetro global de shader booleano (global uniform bool ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC2 = 1
Parámetro global de shader de vector booleano de 2 dimensiones (global uniform bvec2 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC3 = 2
Parámetro global de shader de vector booleano de 3 dimensiones (global uniform bvec3 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC4 = 3
Parámetro global de shader de vector booleano de 4 dimensiones (global uniform bvec4 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_INT = 4
Parámetro global de shader de tipo integer (global uniform int ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC2 = 5
Parámetro global de shader de vector de tipo integer de 2 dimensiones (global uniform ivec2 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC3 = 6
Parámetro global de shader de vector de tipo integer de 3 dimensiones (global uniform ivec3 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC4 = 7
Parámetro global de shader de vector de tipo integer de 4 dimensiones (global uniform ivec4 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2I = 8
Parámetro de shader global de rectángulo de tipo integer de 2 dimensiones (global uniform ivec4 ...). Equivalente a GLOBAL_VAR_TYPE_IVEC4 en el código del shader, pero expuesto como un Rect2i en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_UINT = 9
Parámetro de shader global de integer sin signo (global uniform uint ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC2 = 10
Parámetro de shader global de vector de integers sin signo de 2 dimensiones (global uniform uvec2 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC3 = 11
Parámetro de shader global de vector de integers sin signo de 3 dimensiones (global uniform uvec3 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC4 = 12
Parámetro de shader global de vector de integers sin signo de 4 dimensiones (global uniform uvec4 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_FLOAT = 13
Parámetro de shader global de punto flotante de precisión simple (global uniform float ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC2 = 14
Parámetro de shader global de vector de punto flotante de 2 dimensiones (global uniform vec2 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC3 = 15
Parámetro de shader global de vector de punto flotante de 3 dimensiones (global uniform vec3 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC4 = 16
Parámetro de shader global de vector de punto flotante de 4 dimensiones (global uniform vec4 ...).
GlobalShaderParameterType GLOBAL_VAR_TYPE_COLOR = 17
Parámetro de shader global de color (global uniform vec4 ...). Equivalente a GLOBAL_VAR_TYPE_VEC4 en el código del shader, pero expuesto como un Color en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2 = 18
Parámetro de shader global de rectángulo de punto flotante de 2 dimensiones (global uniform vec4 ...). Equivalente a GLOBAL_VAR_TYPE_VEC4 en el código del shader, pero expuesto como un Rect2 en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT2 = 19
Parámetro de shader global de matriz 2×2 (global uniform mat2 ...). Expuesto como un PackedInt32Array en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT3 = 20
Parámetro de shader global de matriz 3×3 (global uniform mat3 ...). Expuesto como una Basis en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT4 = 21
Parámetro de shader global de matriz 4×4 (global uniform mat4 ...). Expuesto como una Projection en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM_2D = 22
Parámetro de shader global de transformación de 2 dimensiones (global uniform mat2x3 ...). Expuesto como un Transform2D en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM = 23
Parámetro de shader global de transformación de 3 dimensiones (global uniform mat3x4 ...). Expuesto como un Transform3D en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2D = 24
Parámetro de shader global de muestreador 2D (global uniform sampler2D ...). Expuesto como un Texture2D en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2DARRAY = 25
Parámetro de shader global de array de muestreador 2D (global uniform sampler2DArray ...). Expuesto como un Texture2DArray en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER3D = 26
Parámetro de shader global de muestreador 3D (global uniform sampler3D ...). Expuesto como un Texture3D en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLERCUBE = 27
Parámetro de shader global de muestreador Cubemap (global uniform samplerCube ...). Expuesto como un Cubemap en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLEREXT = 28
Parámetro de shader global de muestreador externo (global uniform samplerExternalOES ...). Expuesto como una ExternalTexture en la interfaz de usuario del editor.
GlobalShaderParameterType GLOBAL_VAR_TYPE_MAX = 29
Representa el tamaño del enum GlobalShaderParameterType.
enum RenderingInfo: 🔗
RenderingInfo RENDERING_INFO_TOTAL_OBJECTS_IN_FRAME = 0
Número de objetos renderizados en la escena 3D actual. Esto varía dependiendo de la posición y rotación de la cámara.
RenderingInfo RENDERING_INFO_TOTAL_PRIMITIVES_IN_FRAME = 1
Número de puntos, líneas o triángulos renderizados en la escena 3D actual. Esto varía dependiendo de la posición y rotación de la cámara.
RenderingInfo RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME = 2
Número de llamadas de dibujado realizadas para renderizar en la escena 3D actual. Esto varía dependiendo de la posición y rotación de la cámara.
RenderingInfo RENDERING_INFO_TEXTURE_MEM_USED = 3
Memoria de textura utilizada (en bytes).
RenderingInfo RENDERING_INFO_BUFFER_MEM_USED = 4
Memoria de búfer utilizada (en bytes). Esto incluye datos de vértices, búferes uniformes y muchos tipos de búferes misceláneos utilizados internamente.
RenderingInfo RENDERING_INFO_VIDEO_MEM_USED = 5
Memoria de vídeo utilizada (en bytes). Cuando se utilizan los renderizadores Forward+ o Mobile, esta es siempre mayor que la suma de RENDERING_INFO_TEXTURE_MEM_USED y RENDERING_INFO_BUFFER_MEM_USED, ya que hay datos misceláneos no contabilizados por esas dos métricas. Cuando se utiliza el renderizador de Compatibility, es igual a la suma de RENDERING_INFO_TEXTURE_MEM_USED y RENDERING_INFO_BUFFER_MEM_USED.
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_CANVAS = 6
Número de compilaciones de canalización activadas por el renderizador del lienzo 2D.
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_MESH = 7
El número de compilaciones de canalización activadas al cargar mallas. Estas compilaciones se traducirán en tiempos de carga más largos la primera vez que el usuario ejecute el juego y se requiera la canalización.
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SURFACE = 8
Number of pipeline compilations that were triggered by building the surface cache before rendering the scene. These compilations will show up as a stutter when loading a scene the first time a user runs the game and the pipeline is required.
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_DRAW = 9
Number of pipeline compilations that were triggered while drawing the scene. These compilations will show up as stutters during gameplay the first time a user runs the game and the pipeline is required.
RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SPECIALIZATION = 10
Number of pipeline compilations that were triggered to optimize the current scene. These compilations are done in the background and should not cause any stutters whatsoever.
enum PipelineSource: 🔗
PipelineSource PIPELINE_SOURCE_CANVAS = 0
Pipeline compilation that was triggered by the 2D canvas renderer.
PipelineSource PIPELINE_SOURCE_MESH = 1
Pipeline compilation that was triggered by loading a mesh.
PipelineSource PIPELINE_SOURCE_SURFACE = 2
Pipeline compilation that was triggered by building the surface cache before rendering the scene.
PipelineSource PIPELINE_SOURCE_DRAW = 3
Pipeline compilation that was triggered while drawing the scene.
PipelineSource PIPELINE_SOURCE_SPECIALIZATION = 4
Pipeline compilation that was triggered to optimize the current scene.
PipelineSource PIPELINE_SOURCE_MAX = 5
Representa el tamaño del enum PipelineSource.
enum SplashStretchMode: 🔗
SplashStretchMode SPLASH_STRETCH_MODE_DISABLED = 0
No stretching is applied.
SplashStretchMode SPLASH_STRETCH_MODE_KEEP = 1
Stretches image to fullscreen while preserving aspect ratio.
SplashStretchMode SPLASH_STRETCH_MODE_KEEP_WIDTH = 2
Stretches the height of the image based on the width of the screen.
SplashStretchMode SPLASH_STRETCH_MODE_KEEP_HEIGHT = 3
Stretches the width of the image based on the height of the screen.
SplashStretchMode SPLASH_STRETCH_MODE_COVER = 4
Stretches the image to cover the entire screen while preserving aspect ratio.
SplashStretchMode SPLASH_STRETCH_MODE_IGNORE = 5
Stretches the image to cover the entire screen but doesn't preserve aspect ratio.
enum Features: 🔗
Features FEATURE_SHADERS = 0
Obsoleto: This constant has not been used since Godot 3.0.
Features FEATURE_MULTITHREADED = 1
Obsoleto: This constant has not been used since Godot 3.0.
Constantes
NO_INDEX_ARRAY = -1 🔗
Marca un error que muestra que el array de índices está vacío.
ARRAY_WEIGHTS_SIZE = 4 🔗
Número de pesos/huesos por vértice.
CANVAS_ITEM_Z_MIN = -4096 🔗
La capa Z mínima para los objetos del canvas.
CANVAS_ITEM_Z_MAX = 4096 🔗
La máxima capa Z para los objetos del canvas.
CANVAS_LAYER_MIN = -2147483648 🔗
La capa de canvas mínima.
CANVAS_LAYER_MAX = 2147483647 🔗
La capa de canvas máxima.
MAX_GLOW_LEVELS = 7 🔗
El número máximo de niveles de brillo que se pueden utilizar con el efecto de posprocesamiento de brillo.
MAX_CURSORS = 8 🔗
Obsoleto: This constant is not used by the engine.
MAX_2D_DIRECTIONAL_LIGHTS = 8 🔗
El número máximo de luces direccionales que se pueden renderizar en un momento determinado en 2D.
MAX_MESH_SURFACES = 256 🔗
El número máximo de superficies que puede tener una malla.
MATERIAL_RENDER_PRIORITY_MIN = -128 🔗
La prioridad mínima de renderizado de todos los materiales.
MATERIAL_RENDER_PRIORITY_MAX = 127 🔗
La máxima prioridad de renderizado de todos los materiales.
ARRAY_CUSTOM_COUNT = 4 🔗
El número de arrays de datos personalizados disponibles (ARRAY_CUSTOM0, ARRAY_CUSTOM1, ARRAY_CUSTOM2, ARRAY_CUSTOM3).
PARTICLES_EMIT_FLAG_POSITION = 1 🔗
There is currently no description for this constant. Please help us by contributing one!
PARTICLES_EMIT_FLAG_ROTATION_SCALE = 2 🔗
There is currently no description for this constant. Please help us by contributing one!
PARTICLES_EMIT_FLAG_VELOCITY = 4 🔗
There is currently no description for this constant. Please help us by contributing one!
PARTICLES_EMIT_FLAG_COLOR = 8 🔗
There is currently no description for this constant. Please help us by contributing one!
PARTICLES_EMIT_FLAG_CUSTOM = 16 🔗
There is currently no description for this constant. Please help us by contributing one!
Descripciones de Propiedades
Si es false, desactiva el renderizado completamente, pero la lógica del motor sigue siendo procesada. Puedes llamar a force_draw() para dibujar un fotograma incluso con el renderizado desactivada.
Descripciones de Métodos
Array[Image] bake_render_uv2(base: RID, material_overrides: Array[RID], image_size: Vector2i) 🔗
Realiza un procesado de los datos del material de la Mesh pasada en el parámetro base con material_overrides opcionales a un conjunto de Images del tamaño de image_size. Devuelve un array de Images que contienen las propiedades del material tal y como se especifica en BakeChannels.
void call_on_render_thread(callable: Callable) 🔗
Como la lógica real de RenderingServer puede ejecutarse en un hilo separado, acceder a sus elementos internos desde el hilo principal (o cualquier otro) provocará errores. Para que sea más fácil ejecutar código que pueda acceder de forma segura a los elementos internos de renderizado (como RenderingDevice y clases RD similares), envía un elemento invocable a través de esta función para que se ejecute en el hilo de renderizado.
RID camera_attributes_create() 🔗
Crea un objeto de atributos de cámara y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se utilizará en todas las funciones camera_attributes_ de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberarlo utilizando el método free_rid() de RenderingServer.
Nota: El recurso equivalente es CameraAttributes.
void camera_attributes_set_auto_exposure(camera_attributes: RID, enable: bool, min_sensitivity: float, max_sensitivity: float, speed: float, scale: float) 🔗
Establece los parámetros a utilizar con el efecto de autoexposición. Estos parámetros tienen el mismo significado que sus contrapartes en CameraAttributes y 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) 🔗
Establece los parámetros a usar con el efecto de desenfoque DOF. Estos parámetros tienen el mismo significado que sus contrapartes en CameraAttributesPractical.
void camera_attributes_set_dof_blur_bokeh_shape(shape: DOFBokehShape) 🔗
Establece la forma del patrón bokeh DOF a shape. Se pueden usar diferentes formas para lograr un efecto artístico, o para cumplir con los objetivos de rendimiento.
void camera_attributes_set_dof_blur_quality(quality: DOFBlurQuality, use_jitter: bool) 🔗
Establece el nivel de calidad del efecto de desenfoque DOF a quality. use_jitter se puede utilizar para hacer jitter a las muestras tomadas durante el pase de desenfoque para ocultar artefactos a costa de verse más difuso.
void camera_attributes_set_exposure(camera_attributes: RID, multiplier: float, normalization: float) 🔗
Establece los valores de exposición que usarán los renderizadores. La cantidad de normalización se usa para bakear un valor de exposición (EV) dado en los cálculos de renderizado para reducir el rango dinámico de la escena.
El factor de normalización se puede calcular a partir del valor de exposición (EV100) de la siguiente manera:
func get_exposure_normalization(ev100: float):
return 1.0 / (pow(2.0, ev100) * 1.2)
El valor de exposición se puede calcular a partir de la apertura (en pasos f), la velocidad de obturación (en segundos) y la sensibilidad (en ISO) de la siguiente manera:
func get_exposure(aperture: float, shutter_speed: float, sensitivity: float):
return log((aperture * aperture) / shutter_speed * (100.0 / sensitivity)) / log(2)
Crea una cámara 3D y la añade al RenderingServer. Se puede acceder a ella con el RID que se devuelve. Este RID se usará en todas las funciones camera_* de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberarlo utilizando el método free_rid() de RenderingServer.
Nota: El nodo equivalente es Camera3D.
void camera_set_camera_attributes(camera: RID, effects: RID) 🔗
Establece los camera_attributes creados con camera_attributes_create() a la cámara dada.
void camera_set_compositor(camera: RID, compositor: RID) 🔗
Establece el compositor utilizado por esta cámara. Equivalente a Camera3D.compositor.
void camera_set_cull_mask(camera: RID, layers: int) 🔗
Establece la máscara de selección asociada con esta cámara. La máscara de selección describe qué capas 3D son renderizadas por esta cámara. Equivalente a Camera3D.cull_mask.
void camera_set_environment(camera: RID, env: RID) 🔗
Establece el entorno utilizado por esta cámara. Equivalente a Camera3D.environment.
void camera_set_frustum(camera: RID, size: float, offset: Vector2, z_near: float, z_far: float) 🔗
Establece la cámara para usar la proyección de frustum. Este modo permite ajustar el argumento offset para crear efectos de "frustum inclinado".
void camera_set_orthogonal(camera: RID, size: float, z_near: float, z_far: float) 🔗
Establece la cámara para usar la proyección ortogonal, también conocida como proyección ortográfica. Los objetos permanecen del mismo tamaño en la pantalla sin importar lo lejos que estén.
void camera_set_perspective(camera: RID, fovy_degrees: float, z_near: float, z_far: float) 🔗
Establece la cámara para usar la proyección en perspectiva. Los objetos en la pantalla se hacen más pequeños cuando están lejos.
void camera_set_transform(camera: RID, transform: Transform3D) 🔗
Establece la Transform3D de la cámara.
void camera_set_use_vertical_aspect(camera: RID, enable: bool) 🔗
Si es true, conserva la relación de aspecto horizontal, que es equivalente a Camera3D.KEEP_WIDTH. Si es false, preserva la relación de aspecto vertical, que es equivalente a Camera3D.KEEP_HEIGHT.
Crea un canvas y devuelve el RID asignado. Se puede acceder a él con el RID que se devuelve. Este RID se utilizará en todas las funciones canvas_* de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberarlo utilizando el método free_rid() de RenderingServer.
Canvas no tiene un equivalente en Resource o Node.
void canvas_item_add_animation_slice(item: RID, animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0) 🔗
Subsequent drawing commands will be ignored unless they fall within the specified animation slice. This is a faster way to implement animations that loop on background rather than redrawing constantly.
void canvas_item_add_circle(item: RID, pos: Vector2, radius: float, color: Color, antialiased: bool = false) 🔗
Dibuja un círculo en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_circle().
void canvas_item_add_clip_ignore(item: RID, ignore: bool) 🔗
Si ignore es true, ignora el recorte en los elementos dibujados con este elemento de canvas hasta que se vuelva a llamar con ignore establecido en false.
void canvas_item_add_ellipse(item: RID, pos: Vector2, major: float, minor: float, color: Color, antialiased: bool = false) 🔗
Dibuja una elipse con el semieje mayor major y el semieje menor minor en el CanvasItem apuntado por el RID del elemento item. Véase también CanvasItem.draw_ellipse().
void canvas_item_add_lcd_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color) 🔗
Véase también 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) 🔗
Dibuja una línea en el CanvasItem apuntado por el RID de item. Véase también 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()) 🔗
Dibuja una malla creada con mesh_create() con la transform dada, el color modulate y la texture. Esto es usado internamente por 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) 🔗
Véase también CanvasItem.draw_msdf_texture_rect_region().
void canvas_item_add_multiline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗
Dibuja una multilínea 2D en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_multiline() y CanvasItem.draw_multiline_colors().
void canvas_item_add_multimesh(item: RID, mesh: RID, texture: RID = RID()) 🔗
Dibuja un MultiMesh 2D en el CanvasItem apuntado por el RID de item. Véase también 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)) 🔗
Dibuja un rectángulo nine-patch en el CanvasItem apuntado por el RID de item.
void canvas_item_add_particles(item: RID, particles: RID, texture: RID) 🔗
Dibuja partículas en el CanvasItem apuntado por el RID de item.
void canvas_item_add_polygon(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: RID = RID()) 🔗
Dibuja un polígono 2D en el CanvasItem apuntado por el RID de item. Si necesitas más flexibilidad (como poder usar huesos), usa canvas_item_add_triangle_array() en su lugar. Véase también CanvasItem.draw_polygon().
Nota: Si redibujas frecuentemente el mismo polígono con un gran número de vértices, considera pre-calcular la triangulación con Geometry2D.triangulate_polygon() y usar CanvasItem.draw_mesh(), CanvasItem.draw_multimesh() o canvas_item_add_triangle_array().
void canvas_item_add_polyline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗
Dibuja una polilínea 2D en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_polyline() y CanvasItem.draw_polyline_colors().
void canvas_item_add_primitive(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: RID) 🔗
Dibuja una primitiva 2D en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_primitive().
void canvas_item_add_rect(item: RID, rect: Rect2, color: Color, antialiased: bool = false) 🔗
Dibuja un rectángulo en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_rect().
void canvas_item_add_set_transform(item: RID, transform: Transform2D) 🔗
Establece una Transform2D que se utilizará para transformar los siguientes comandos del elemento del canvas.
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) 🔗
Dibuja un rectángulo texturizado 2D en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_texture_rect() y 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) 🔗
Dibuja la región especificada de un rectángulo texturizado 2D en el CanvasItem apuntado por el RID de item. Véase también CanvasItem.draw_texture_rect_region() y 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) 🔗
Dibuja un array de triángulos en el CanvasItem apuntado por el RID de item. Esto es usado internamente por Line2D y StyleBoxFlat para el renderizado. canvas_item_add_triangle_array() es muy flexible, pero más complejo de usar que canvas_item_add_polygon().
Nota: Si count se establece en un valor no negativo, solo se dibujarán los primeros count * 3 índices (correspondientes a count triángulos). De lo contrario, se dibujarán todos los índices.
void canvas_item_attach_skeleton(item: RID, skeleton: RID) 🔗
Attaches a skeleton to the CanvasItem. Removes the previous skeleton.
void canvas_item_clear(item: RID) 🔗
Despeja el CanvasItem y elimina todos los comandos en él.
Crea una nueva instancia de CanvasItem y devuelve su RID. Se puede acceder a ella con el RID que se devuelve. Este RID se utilizará en todas las funciones canvas_item_* de RenderingServer.
Una vez que haya terminado con su RID, querrá liberarlo utilizando el método free_rid() de RenderingServer.
Nota: El nodo equivalente es CanvasItem.
Variant canvas_item_get_instance_shader_parameter(instance: RID, parameter: StringName) const 🔗
Returns the value of the per-instance shader uniform from the specified canvas item instance. Equivalent to CanvasItem.get_instance_shader_parameter().
Variant canvas_item_get_instance_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗
Returns the default value of the per-instance shader uniform from the specified canvas item instance. Equivalent to CanvasItem.get_instance_shader_parameter().
Array[Dictionary] canvas_item_get_instance_shader_parameter_list(instance: RID) const 🔗
Returns a dictionary of per-instance shader uniform names of the per-instance shader uniform from the specified canvas item instance.
The returned dictionary is in PropertyInfo format, with the keys name, class_name, type, hint, hint_string, and usage.
void canvas_item_reset_physics_interpolation(item: RID) 🔗
Prevents physics interpolation for the current physics tick.
This is useful when moving a canvas item to a new location, to give an instantaneous change rather than interpolation from the previous location.
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) 🔗
Establece el modo de grupo de canvas utilizado durante el renderizado 2D para el elemento canvas especificado por el RID item. Para un recorte más rápido pero más limitado, usa canvas_item_set_clip() en su lugar.
Nota: La funcionalidad de nodo equivalente se encuentra en CanvasGroup y CanvasItem.clip_children.
void canvas_item_set_clip(item: RID, clip: bool) 🔗
Si clip es true, hace que el elemento canvas especificado por el RID item no dibuje nada fuera de las coordenadas de su rect. Este recorte es rápido, pero solo funciona con rectángulos alineados con los ejes. Esto significa que la rotación es ignorada por el rectángulo de recorte. Para formas de recorte más avanzadas, usa canvas_item_set_canvas_group_mode() en su lugar.
Nota: La funcionalidad de nodo equivalente se encuentra en Label.clip_text, RichTextLabel (siempre habilitado) y más.
void canvas_item_set_copy_to_backbuffer(item: RID, enabled: bool, rect: Rect2) 🔗
Establece el CanvasItem para copiar un rectángulo al backbuffer.
void canvas_item_set_custom_rect(item: RID, use_custom_rect: bool, rect: Rect2 = Rect2(0, 0, 0, 0)) 🔗
Si use_custom_rect es true, establece el rectángulo de visibilidad personalizado (utilizado para el culling) en rect para el elemento de canvas especificado por item. Establecer un rectángulo de visibilidad personalizado puede reducir la carga de la CPU al dibujar muchas instancias 2D. Si use_custom_rect es false, calcula automáticamente un rectángulo de visibilidad basado en los comandos de dibujo del elemento de canvas.
void canvas_item_set_default_texture_filter(item: RID, filter: CanvasItemTextureFilter) 🔗
Establece el modo de filtro de textura predeterminado para el elemento de canvas especificado por el RID item. Equivalente a CanvasItem.texture_filter.
void canvas_item_set_default_texture_repeat(item: RID, repeat: CanvasItemTextureRepeat) 🔗
Establece el modo de repetición de textura predeterminado para el elemento de canvas especificado por el RID item. Equivalente a CanvasItem.texture_repeat.
void canvas_item_set_distance_field_mode(item: RID, enabled: bool) 🔗
Si enabled es true, habilita el modo de renderizado de campo de distancia con signo multicanal para el elemento de canvas especificado por el RID item. Esto está destinado a ser utilizado para el renderizado de fuentes, o con imágenes especialmente generadas usando msdfgen.
void canvas_item_set_draw_behind_parent(item: RID, enabled: bool) 🔗
Si enabled es true, dibuja el elemento del canvas especificado por el RID item detrás de su padre. Equivalente a CanvasItem.show_behind_parent.
void canvas_item_set_draw_index(item: RID, index: int) 🔗
Establece el índice para el CanvasItem.
void canvas_item_set_instance_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗
Establece la variable uniforme del shader por instancia en la instancia del elemento del canvas especificado. Equivalente a CanvasItem.set_instance_shader_parameter().
void canvas_item_set_interpolated(item: RID, interpolated: bool) 🔗
Si interpolated es true, activa la interpolación de física para el elemento del canvas.
void canvas_item_set_light_mask(item: RID, mask: int) 🔗
Establece la mask de luz para el elemento del canvas especificado por el item RID. Equivalente a CanvasItem.light_mask.
void canvas_item_set_material(item: RID, material: RID) 🔗
Establece un nuevo material al elemento del canvas especificado por el item RID. Equivalente a CanvasItem.material.
void canvas_item_set_modulate(item: RID, color: Color) 🔗
Multiplica el color del item de canvas especificado por el item RID, afectando a sus hijos. Véase también canvas_item_set_self_modulate(). Equivalente a CanvasItem.modulate.
void canvas_item_set_parent(item: RID, parent: RID) 🔗
Establece un CanvasItem padre al CanvasItem. El elemento heredará la transformación, modulación y visibilidad de su padre, como los nodos CanvasItem en el árbol de escenas.
void canvas_item_set_self_modulate(item: RID, color: Color) 🔗
Multiplica el color del elemento de canvas especificado por el item RID, sin afectar a sus hijos. Véase también canvas_item_set_modulate(). Equivalente a CanvasItem.self_modulate.
void canvas_item_set_sort_children_by_y(item: RID, enabled: bool) 🔗
Si enabled es true, los nodos hijos con la posición Y más baja se dibujan antes que aquellos con una posición Y más alta. La ordenación Y solo afecta a los hijos que heredan del item de canvas especificado por el item RID, no al item de canvas en sí mismo. Equivalente a CanvasItem.y_sort_enabled.
void canvas_item_set_transform(item: RID, transform: Transform2D) 🔗
Establece la transform del elemento de canvas especificado por el item RID. Esto afecta dónde y cómo se dibujará el elemento. Las transformaciones de los elementos de canvas hijos se multiplican por la transformación de su padre. Equivalente a Node2D.transform.
void canvas_item_set_use_parent_material(item: RID, enabled: bool) 🔗
Establece si el CanvasItem utiliza el material de su padre.
void canvas_item_set_visibility_layer(item: RID, visibility_layer: int) 🔗
Establece la capa de visibilidad de renderizado asociada con este CanvasItem. Solo los nodos Viewport con una máscara de renderizado coincidente renderizarán este CanvasItem.
void canvas_item_set_visibility_notifier(item: RID, enable: bool, area: Rect2, enter_callable: Callable, exit_callable: Callable) 🔗
Establece el CanvasItem dado como notificador de visibilidad. area define el área para detectar la visibilidad. enter_callable se llama cuando el CanvasItem entra en la pantalla, exit_callable se llama cuando el CanvasItem sale de la pantalla. Si enable es false, el elemento dejará de funcionar como notificador.
Este método se puede usar para imitar manualmente VisibleOnScreenNotifier2D.
void canvas_item_set_visible(item: RID, visible: bool) 🔗
Establece la visibilidad del CanvasItem.
void canvas_item_set_z_as_relative_to_parent(item: RID, enabled: bool) 🔗
Si esto está activado, el índice Z del padre se añadirá al índice Z de los hijos.
void canvas_item_set_z_index(item: RID, z_index: int) 🔗
Establece el índice Z del CanvasItem, es decir, su orden de dibujo (los índices inferiores se dibujan primero).
void canvas_item_transform_physics_interpolation(item: RID, transform: Transform2D) 🔗
Transforma tanto la transformación actual como la anterior almacenada para un elemento de canvas.
Esto permite transformar un elemento de canvas sin crear un "glitch" en la interpolación, lo que es particularmente útil para mundos grandes que utilizan un origen cambiante.
void canvas_light_attach_to_canvas(light: RID, canvas: RID) 🔗
Une la luz del canvas al canvas. Lo quita de su canvas anterior.
Crea una luz de canvas y la añade al RenderingServer. Se puede acceder a ella con el RID que se devuelve. Este RID se usará en todas las funciones canvas_light_* del RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Nota: El nodo equivalente es Light2D.
void canvas_light_occluder_attach_to_canvas(occluder: RID, canvas: RID) 🔗
Adjunta un oclusor de luz al canvas. Lo quita de su canvas anterior.
RID canvas_light_occluder_create() 🔗
Crea un oclusor de luz y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se usará en todas las funciones canvas_light_occluder_* del RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Nota: El nodo equivalente es LightOccluder2D.
void canvas_light_occluder_reset_physics_interpolation(occluder: RID) 🔗
Evita la interpolación física para el tick de física actual.
Esto es útil al mover un oclusor a una nueva ubicación, para dar un cambio instantáneo en lugar de una interpolación desde la ubicación anterior.
void canvas_light_occluder_set_as_sdf_collision(occluder: RID, enable: bool) 🔗
There is currently no description for this method. Please help us by contributing one!
void canvas_light_occluder_set_enabled(occluder: RID, enabled: bool) 🔗
Activa o desactiva el oclusor de luz.
void canvas_light_occluder_set_interpolated(occluder: RID, interpolated: bool) 🔗
Si interpolated es true, activa la interpolación física para el oclusor de luz.
void canvas_light_occluder_set_light_mask(occluder: RID, mask: int) 🔗
La máscara de luz. Véase LightOccluder2D para más información sobre las máscaras de luz.
void canvas_light_occluder_set_polygon(occluder: RID, polygon: RID) 🔗
Establece un polígono de oclusión de luz.
void canvas_light_occluder_set_transform(occluder: RID, transform: Transform2D) 🔗
Establece un oclusor de luz Transform2D.
void canvas_light_occluder_transform_physics_interpolation(occluder: RID, transform: Transform2D) 🔗
Transforma tanto la transformación actual como la anterior almacenada para un oclusor de luz.
Esto permite transformar un oclusor sin crear un "glitch" en la interpolación, lo que es particularmente útil para mundos grandes que utilizan un origen desplazable.
void canvas_light_reset_physics_interpolation(light: RID) 🔗
Prevents physics interpolation for the current physics tick.
This is useful when moving a canvas item to a new location, to give an instantaneous change rather than interpolation from the previous location.
void canvas_light_set_blend_mode(light: RID, mode: CanvasLightBlendMode) 🔗
Establece el modo de mezcla para la luz de canvas especificada a mode. Equivalente a Light2D.blend_mode.
void canvas_light_set_color(light: RID, color: Color) 🔗
Establece el color de la luz.
void canvas_light_set_enabled(light: RID, enabled: bool) 🔗
Habilita o deshabilita una luz de canvas.
void canvas_light_set_energy(light: RID, energy: float) 🔗
Establece la energía de la luz de un canvas.
void canvas_light_set_height(light: RID, height: float) 🔗
Establece la altura de la luz de un canvas.
void canvas_light_set_interpolated(light: RID, interpolated: bool) 🔗
Si interpolated es true, activa la interpolación física para la luz del canvas.
void canvas_light_set_item_cull_mask(light: RID, mask: int) 🔗
La máscara de luz. Véase LightOccluder2D para más información sobre las máscaras de luz.
void canvas_light_set_item_shadow_cull_mask(light: RID, mask: int) 🔗
La máscara binaria utilizada para determinar a qué capas afecta la sombra de la luz del canvas. Véase LightOccluder2D para más información sobre las máscaras de luz.
void canvas_light_set_layer_range(light: RID, min_layer: int, max_layer: int) 🔗
El rango de capas que se renderizan con esta luz.
void canvas_light_set_mode(light: RID, mode: CanvasLightMode) 🔗
Establece el modo de la luz del canvas.
void canvas_light_set_shadow_color(light: RID, color: Color) 🔗
Establece el color de la sombra de la luz del canvas.
void canvas_light_set_shadow_enabled(light: RID, enabled: bool) 🔗
Habilita o deshabilita la sombra de la luz del canvas.
void canvas_light_set_shadow_filter(light: RID, filter: CanvasLightShadowFilter) 🔗
Establece el filtro de la sombra de la luz del canvas.
void canvas_light_set_shadow_smooth(light: RID, smooth: float) 🔗
Suaviza la sombra. Cuanto más baja, más suave.
void canvas_light_set_texture(light: RID, texture: RID) 🔗
Establece la textura a ser usada por una PointLight2D. Equivalente a PointLight2D.texture.
void canvas_light_set_texture_offset(light: RID, offset: Vector2) 🔗
Establece el desplazamiento de la textura de una PointLight2D. Equivalente a PointLight2D.offset.
void canvas_light_set_texture_scale(light: RID, scale: float) 🔗
Establece el factor de escala de la textura de una PointLight2D. Equivalente a PointLight2D.texture_scale.
void canvas_light_set_transform(light: RID, transform: Transform2D) 🔗
Establece la luz del canvas Transform2D.
void canvas_light_set_z_range(light: RID, min_z: int, max_z: int) 🔗
Establece el rango Z de los objetos que serán afectados por esta luz. Equivalente a Light2D.range_z_min y Light2D.range_z_max.
void canvas_light_transform_physics_interpolation(light: RID, transform: Transform2D) 🔗
Transforma tanto la transformación actual como la anterior almacenada para una luz de canvas.
Esto permite transformar una luz sin crear un "glitch" en la interpolación, lo que es particularmente útil para mundos grandes que utilizan un origen desplazable.
RID canvas_occluder_polygon_create() 🔗
Crea un nuevo polígono oclusor de luz y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se usará en todas las funciones canvas_occluder_polygon_* del RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Nota: El recurso equivalente es OccluderPolygon2D.
void canvas_occluder_polygon_set_cull_mode(occluder_polygon: RID, mode: CanvasOccluderPolygonCullMode) 🔗
Establece el modo de descarte de un polígono oclusor.
void canvas_occluder_polygon_set_shape(occluder_polygon: RID, shape: PackedVector2Array, closed: bool) 🔗
Establece la forma del polígono oclusor.
void canvas_set_disable_scale(disable: bool) 🔗
There is currently no description for this method. Please help us by contributing one!
void canvas_set_item_mirroring(canvas: RID, item: RID, mirroring: Vector2) 🔗
Se dibujará una copia del elemento de canvas con un desplazamiento local de mirroring.
Nota: Esto es equivalente a llamar a canvas_set_item_repeat() como canvas_set_item_repeat(item, mirroring, 1), con una comprobación adicional que asegura que canvas es un padre de item.
void canvas_set_item_repeat(item: RID, repeat_size: Vector2, repeat_times: int) 🔗
Se dibujará una copia del elemento de canvas con un desplazamiento local de repeat_size un número de veces igual a repeat_times. A medida que repeat_times aumenta, las copias se alejarán de la textura de origen.
void canvas_set_modulate(canvas: RID, color: Color) 🔗
Modula todos los colores en el canvas dado.
void canvas_set_shadow_texture_size(size: int) 🔗
Establece el ProjectSettings.rendering/2d/shadow_atlas/size a usar para el renderizado de sombras de Light2D (en píxeles). El valor se redondea a la potencia de 2 más cercana.
Crea una textura de lienzo y la añade al RenderingServer. Se puede acceder a ella con el RID que se devuelve. Este RID se usará en todas las funciones canvas_texture_* del RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer. Véase también texture_2d_create().
Nota: El recurso equivalente es CanvasTexture y solo está destinado a ser utilizado en el renderizado 2D, no 3D.
void canvas_texture_set_channel(canvas_texture: RID, channel: CanvasTextureChannel, texture: RID) 🔗
Establece la texture del channel para la textura de canvas especificada por el RID canvas_texture. Equivalente a CanvasTexture.diffuse_texture, CanvasTexture.normal_texture y CanvasTexture.specular_texture.
void canvas_texture_set_shading_parameters(canvas_texture: RID, base_color: Color, shininess: float) 🔗
Establece el base_color y el shininess a usar para la textura de canvas especificada por el RID canvas_texture. Equivalente a CanvasTexture.specular_color y CanvasTexture.specular_shininess.
void canvas_texture_set_texture_filter(canvas_texture: RID, filter: CanvasItemTextureFilter) 🔗
Establece el modo de filtro de textura filter para la textura de canvas especificada por el RID canvas_texture.
void canvas_texture_set_texture_repeat(canvas_texture: RID, repeat: CanvasItemTextureRepeat) 🔗
Establece el modo de repetición de textura repeat para la textura de canvas especificada por el RID canvas_texture.
Crea un nuevo compositor y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve.
Una vez que hayas terminado con tu RID, querrás liberarlo usando el método free_rid() del RenderingServer.
RID compositor_effect_create() 🔗
Crea un nuevo efecto de renderizado y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve.
Una vez que hayas terminado con tu RID, querrás liberarlo usando el método free_rid() del RenderingServer.
void compositor_effect_set_callback(effect: RID, callback_type: CompositorEffectCallbackType, callback: Callable) 🔗
Establece el tipo de callback (callback_type) y el método de callback (callback) para este efecto de renderizado.
void compositor_effect_set_enabled(effect: RID, enabled: bool) 🔗
Habilita/deshabilita este efecto de renderizado.
void compositor_effect_set_flag(effect: RID, flag: CompositorEffectFlags, set: bool) 🔗
Establece la bandera (flag) para este efecto de renderizado a true o false (set).
void compositor_set_compositor_effects(compositor: RID, effects: Array[RID]) 🔗
Establece los efectos de composición para el RID de compositor especificado. effects debe ser un array que contenga RIDs creados con compositor_effect_create().
RenderingDevice create_local_rendering_device() const 🔗
Crea un RenderingDevice que puede ser usado para hacer operaciones de dibujo y computación en un hilo separado. No puede dibujar en la pantalla ni compartir datos con el RenderingDevice global.
Nota: Cuando se usa el controlador de renderizado OpenGL o cuando se ejecuta en modo headless, esta función siempre devuelve null.
Rect2 debug_canvas_item_get_rect(item: RID) 🔗
Devuelve el rectángulo delimitador para un ítem de canvas en el espacio local, tal como lo calcula el renderizador. Este límite se utiliza internamente para la ocultación (culling).
Advertencia: Esta función está pensada para la depuración en el editor, y en los proyectos exportados pasará de largo y devolverá un Rect2 con valor cero.
Crea un decal y la añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se usará en todas las funciones decal_* del RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Para colocarlo en una escena, adjunta este decal a una instancia usando instance_set_base() con el RID devuelto.
Nota: El nodo equivalente es Decal.
void decal_set_albedo_mix(decal: RID, albedo_mix: float) 🔗
Establece el albedo_mix en el decal especificado por el RID decal. Equivalente a Decal.albedo_mix.
void decal_set_cull_mask(decal: RID, mask: int) 🔗
Establece la máscara de ocultación (mask) en el decal especificado por el RID decal. Equivalente a Decal.cull_mask.
void decal_set_distance_fade(decal: RID, enabled: bool, begin: float, length: float) 🔗
Establece los parámetros de desvanecimiento por distancia en el decal especificado por el RID decal. Equivalente a Decal.distance_fade_enabled, Decal.distance_fade_begin y Decal.distance_fade_length.
void decal_set_emission_energy(decal: RID, energy: float) 🔗
Establece la energía de emisión (energy) en el decal especificado por el RID decal. Equivalente a Decal.emission_energy.
void decal_set_fade(decal: RID, above: float, below: float) 🔗
Establece el desvanecimiento superior (above) y el desvanecimiento inferior (below) en el decal especificado por el RID decal. Equivalente a Decal.upper_fade y Decal.lower_fade.
void decal_set_modulate(decal: RID, color: Color) 🔗
Establece el multiplicador de color en el decal especificado por el RID decal a color. Equivalente a Decal.modulate.
void decal_set_normal_fade(decal: RID, fade: float) 🔗
Establece el desvanecimiento normal (fade) en el decal especificado por el RID decal. Equivalente a Decal.normal_fade.
void decal_set_size(decal: RID, size: Vector3) 🔗
Establece el size del decal especificado por el RID decal. Equivalente a Decal.size.
void decal_set_texture(decal: RID, type: DecalTexture, texture: RID) 🔗
Establece la texture en el slot type de textura dado para el decal especificado. Equivalente a Decal.set_texture().
void decals_set_filter(filter: DecalFilter) 🔗
Establece el modo de filter de textura a usar al renderizar decals. Este parámetro es global y no puede establecerse por decal individualmente.
RID directional_light_create() 🔗
Crea una luz direccional y la añade al RenderingServer. Se puede acceder a ella con el RID que se devuelve. Este RID puede ser usado en la mayoría de las funciones de light_* de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Para colocar en una escena, adjunta esta luz direccional a una instancia usando instance_set_base() usando el RID devuelto.
Nota: El nodo equivalente es DirectionalLight3D.
void directional_shadow_atlas_set_size(size: int, is_16bits: bool) 🔗
Establece el size de las sombras de la luz direccional en 3D. Mira también ProjectSettings.rendering/lights_and_shadows/directional_shadow/size. Este parámetro es global y no puede ser establecido por cada viewport.
void directional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗
Establece el filtro quality para las sombras de la luz direccional en 3D. Mira también ProjectSettings.rendering/lights_and_shadows/directional_shadow/soft_shadow_filter_quality. Este parámetro es global y no puede ser establecido por cada viewport.
Image environment_bake_panorama(environment: RID, bake_irradiance: bool, size: Vector2i) 🔗
Genera y devuelve una Image que contiene el mapa de radiancia para el cielo del RID environment especificado. Esto soporta material de cielo incorporado y shaders de cielo personalizados. Si bake_irradiance es true, el mapa de irradiancia se guarda en lugar del mapa de radiancia. El mapa de radiancia se usa para renderizar luz reflejada, mientras que el mapa de irradiancia se usa para renderizar luz ambiental. Véase también sky_bake_panorama().
Nota: La imagen se guarda utilizando codificación lineal sin ningún mapeo de tonos realizado, lo que significa que se verá demasiado oscura si se visualiza directamente en un editor de imágenes.
Nota: size debe tener una relación de aspecto de 2:1 para que el panorama generado tenga píxeles cuadrados. Para los mapas de radiancia, no tiene sentido utilizar una altura mayor que Sky.radiance_size, ya que no aumentará el detalle. Los mapas de irradiancia solo contienen datos de baja frecuencia, por lo que normalmente no tiene sentido ir más allá de un tamaño de 128×64 píxeles al guardar un mapa de irradiancia.
Crea un entorno y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se usará en todas las funciones de RenderingServer de environment_*.
Una vez terminado tu RID, querrás liberarlo usando el método free_rid() del RenderingServer.
Nota: El recurso equivalente es Environment.
void environment_glow_set_use_bicubic_upscale(enable: bool) 🔗
Si enable es true, habilita el escalado bicúbico para el brillo, lo que mejora la calidad a costa del rendimiento. Equivalente a ProjectSettings.rendering/environment/glow/upscale_mode.
Nota: Esta configuración solo es efectiva cuando se utilizan los métodos de renderizado Forward+ o Mobile, ya que Compatibility usa una implementación de brillo diferente.
void environment_set_adjustment(env: RID, enable: bool, brightness: float, contrast: float, saturation: float, use_1d_color_correction: bool, color_correction: RID) 🔗
Establece los valores que se utilizarán con el efecto de post-procesado de "ajustes". Véase Environment para más detalles.
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) 🔗
Establece los valores que se utilizarán para el renderizado de luz ambiental. Véase Environment para más detalles.
void environment_set_background(env: RID, bg: EnvironmentBG) 🔗
Establece el modo de fondo del entorno. Equivalente a Environment.background_mode.
void environment_set_bg_color(env: RID, color: Color) 🔗
Color que se muestra para las zonas despejadas de la escena. Solo es efectivo si se utiliza el modo de fondo ENV_BG_COLOR.
void environment_set_bg_energy(env: RID, multiplier: float, exposure_value: float) 🔗
Establece la intensidad del color de fondo.
void environment_set_camera_id(env: RID, id: int) 🔗
Establece el ID de la cámara que se usará como fondo del entorno.
void environment_set_canvas_max_layer(env: RID, max_layer: int) 🔗
Establece la capa máxima a usar si se utiliza el modo de fondo de canvas.
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) 🔗
Configura la niebla para el RID de entorno especificado. Véanse las propiedades fog_* en Environment para más información.
void environment_set_fog_depth(env: RID, curve: float, begin: float, end: float) 🔗
Configura la profundidad de la niebla para el RID de entorno especificado. Solo tiene efecto cuando el modo de niebla del entorno es ENV_FOG_MODE_DEPTH. Véanse las propiedades fog_depth_* en Environment para más información.
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) 🔗
Configura el brillo (glow) para el RID de entorno especificado. Véanse las propiedades glow_* en Environment para más información.
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) 🔗
Configura la iluminación global de campo de distancia con signo para el RID de entorno especificado. Véanse las propiedades sdfgi_* en Environment para más información.
void environment_set_sdfgi_frames_to_converge(frames: EnvironmentSDFGIFramesToConverge) 🔗
Establece el número de fotogramas a usar para la convergencia de la iluminación global de campo de distancia con signo. Equivalente a ProjectSettings.rendering/global_illumination/sdfgi/frames_to_converge.
void environment_set_sdfgi_frames_to_update_light(frames: EnvironmentSDFGIFramesToUpdateLight) 🔗
Establece la velocidad de actualización para la iluminación indirecta de las luces dinámicas al calcular la iluminación global de campo de distancia con signo. Equivalente a ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.
void environment_set_sdfgi_ray_count(ray_count: EnvironmentSDFGIRayCount) 🔗
Establece el número de rayos a lanzar por fotograma al calcular la iluminación global de campo de distancia con signo. Equivalente a ProjectSettings.rendering/global_illumination/sdfgi/probe_ray_count.
void environment_set_sky(env: RID, sky: RID) 🔗
Establece el Sky para ser usado como fondo del ambiente cuando se usa el BGMode cielo. Equivalente a Environment.sky.
void environment_set_sky_custom_fov(env: RID, scale: float) 🔗
Establece un campo de visión personalizado para el fondo Sky. Equivalente a Environment.sky_custom_fov.
void environment_set_sky_orientation(env: RID, orientation: Basis) 🔗
Establece la rotación del fondo Sky expresada como una Basis. Equivalente a Environment.sky_rotation, donde el vector de rotación se utiliza para construir la 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) 🔗
Establece las variables que se utilizarán con el efecto de post-procesamiento "reflejos del espacio de la pantalla". Véase Environment para más detalles.
void environment_set_ssao_quality(quality: EnvironmentSSAOQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗
Establece el nivel de calidad del efecto de postprocesado de oclusión ambiental en espacio de pantalla (SSAO). Véase Environment para más detalles.
void environment_set_ssil_quality(quality: EnvironmentSSILQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗
Establece el nivel de calidad del efecto de postprocesado de iluminación indirecta en espacio de pantalla (SSIL). Véase Environment para más detalles.
void environment_set_ssr(env: RID, enable: bool, max_steps: int, fade_in: float, fade_out: float, depth_tolerance: float) 🔗
Establece las variables a usar con el efecto de postprocesado de reflejos en espacio de pantalla (SSR). Véase Environment para más detalles.
void environment_set_ssr_half_size(half_size: bool) 🔗
Establece si los reflejos en espacio de pantalla se renderizarán a tamaño completo o a mitad de tamaño. La mitad de tamaño es más rápida, pero puede verse pixelada o causar parpadeos.
void environment_set_ssr_roughness_quality(quality: EnvironmentSSRRoughnessQuality) 🔗
Obsoleto: This option no longer does anything.
void environment_set_tonemap(env: RID, tone_mapper: EnvironmentToneMapper, exposure: float, white: float) 🔗
Establece las variables que se utilizarán con el efecto de post-proceso "tonemap". Véase Environment para más detalles.
void environment_set_tonemap_agx_contrast(env: RID, agx_contrast: float) 🔗
Véase Environment.tonemap_agx_contrast para más detalles.
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) 🔗
Establece las variables que se utilizarán con el efecto de post-procesamiento de niebla volumétrica. Véase Environment para más detalles.
void environment_set_volumetric_fog_filter_active(active: bool) 🔗
Habilita el filtrado del búfer de dispersión de niebla volumétrica. Esto da como resultado volúmenes mucho más suaves con muy pocos artefactos de submuestreo.
void environment_set_volumetric_fog_volume_size(size: int, depth: int) 🔗
Establece la resolución del búfer de froxel de la niebla volumétrica. size es modificado por la relación de aspecto de la pantalla y luego se usa para establecer el ancho y la altura del búfer. Mientras que depth se usa directamente para establecer la profundidad del búfer.
Crea un nuevo volumen de niebla y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se utilizará en todas las funciones fog_volume_* del RenderingServer.
Una vez terminado con tu RID, querrás liberarlo usando el método free_rid() del RenderingServer.
Nota: El nodo equivalente es FogVolume.
void fog_volume_set_material(fog_volume: RID, material: RID) 🔗
Establece el Material del volumen de niebla. Puede ser un FogMaterial o un ShaderMaterial personalizado.
void fog_volume_set_shape(fog_volume: RID, shape: FogVolumeShape) 🔗
Establece la forma del volumen de niebla a FOG_VOLUME_SHAPE_ELLIPSOID, FOG_VOLUME_SHAPE_CONE, FOG_VOLUME_SHAPE_CYLINDER, FOG_VOLUME_SHAPE_BOX o FOG_VOLUME_SHAPE_WORLD.
void fog_volume_set_size(fog_volume: RID, size: Vector3) 🔗
Establece el tamaño del volumen de niebla cuando la forma es FOG_VOLUME_SHAPE_ELLIPSOID, FOG_VOLUME_SHAPE_CONE, FOG_VOLUME_SHAPE_CYLINDER o FOG_VOLUME_SHAPE_BOX.
void force_draw(swap_buffers: bool = true, frame_step: float = 0.0) 🔗
Fuerza el redibujado de todos los viewports a la vez. Debe ser llamado desde el hilo principal.
void force_sync() 🔗
Fuerza una sincronización entre la CPU y la GPU, lo cual puede ser necesario en ciertos casos. Llama a esto solo cuando sea necesario, ya que la sincronización CPU-GPU tiene un coste de rendimiento.
Intenta liberar un objeto en el RenderingServer. Para evitar fugas de memoria, esto debe ser llamado después de usar un objeto, ya que la gestión de memoria no ocurre automáticamente al usar RenderingServer directamente.
String get_current_rendering_driver_name() const 🔗
Devuelve el nombre del controlador de renderizado actual. Puede ser vulkan, d3d12, metal, opengl3, opengl3_es, o opengl3_angle. Véase también get_current_rendering_method().
Cuando ProjectSettings.rendering/renderer/rendering_method es forward_plus o mobile, el controlador de renderizado es determinado por ProjectSettings.rendering/rendering_device/driver.
Cuando ProjectSettings.rendering/renderer/rendering_method es gl_compatibility, el controlador de renderizado es determinado por ProjectSettings.rendering/gl_compatibility/driver.
El controlador de renderizado también es determinado por el argumento de línea de comandos --rendering-driver que anula esta configuración del proyecto, o por una alternativa automática que se aplica dependiendo del hardware.
String get_current_rendering_method() const 🔗
Devuelve el nombre del método de renderizado actual. Puede ser forward_plus, mobile, o gl_compatibility. Véase también get_current_rendering_driver_name().
El método de renderizado es determinado por ProjectSettings.rendering/renderer/rendering_method, el argumento de línea de comandos --rendering-method que anula esta configuración del proyecto, o por una alternativa automática que se aplica dependiendo del hardware.
Color get_default_clear_color() 🔗
Devuelve el color claro predeterminado que se utiliza cuando no se ha seleccionado un color claro específico. Véase también set_default_clear_color().
float get_frame_setup_time_cpu() const 🔗
Devuelve el tiempo que tarda en configurarse el renderizado en la CPU en milisegundos. Este valor se comparte entre todas las viewports y no requiere que viewport_set_measure_render_time() esté habilitado en una viewport para ser consultado. Véase también viewport_get_measured_render_time_cpu().
RenderingDevice get_rendering_device() const 🔗
Returns the global RenderingDevice.
Note: When using the OpenGL rendering driver or when running in headless mode, this function always returns null.
int get_rendering_info(info: RenderingInfo) 🔗
Devuelve una estadística sobre el motor de renderizado que puede utilizarse para la evaluación del rendimiento. Véase también viewport_get_render_info(), que devuelve información específica de una viewport.
Nota: Actualmente, solo el renderizado 3D es tenido en cuenta por algunos de estos valores, como el número de llamadas de dibujo.
Nota: La información de renderizado no está disponible hasta que el motor haya renderizado al menos 2 frames. Si la información de renderizado no está disponible, get_rendering_info() devuelve 0. Para imprimir información de renderizado en _ready() correctamente, utiliza lo siguiente:
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 🔗
Devuelve los parámetros de un shader.
Devuelve el RID del cubo de prueba. Esta malla se creará y devolverá en la primera llamada a get_test_cube(), luego se almacenará en caché para llamadas posteriores. Véase también make_sphere_mesh().
Devuelve el RID de una textura de 256×256 con un patrón de prueba (en formato Image.FORMAT_RGB8). Esta textura se creará y devolverá en la primera llamada a get_test_texture(), luego se almacenará en caché para llamadas posteriores. Ver también get_white_texture().
Ejemplo: Obtener la textura de prueba y aplicarla a un nodo 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 🔗
Devuelve la versión del adaptador de vídeo de gráficos actualmente en uso (p. ej., "1.2.189" para Vulkan, "3.3.0 NVIDIA 510.60.02" para OpenGL). Esta versión puede ser diferente de la versión más reciente real soportada por el hardware, ya que Godot no siempre solicita la versión más reciente. Véase también OS.get_video_adapter_driver_info().
Nota: Cuando se ejecuta un binario sin interfaz gráfica o de servidor, esta función devuelve una string vacía.
String get_video_adapter_name() const 🔗
Devuelve el nombre del adaptador de vídeo (p. ej., "GeForce GTX 1080/PCIe/SSE2").
Nota: Cuando se ejecuta un binario sin interfaz gráfica o de servidor, esta función devuelve una string vacía.
Nota: En la plataforma web, algunos navegadores como Firefox pueden informar de un nombre de GPU diferente y fijo, como "GeForce GTX 980" (independientemente del modelo de GPU real del usuario). Esto se hace para dificultar la toma de huellas dactilares.
DeviceType get_video_adapter_type() const 🔗
Devuelve el tipo del adaptador de vídeo. Dado que las tarjetas gráficas dedicadas de una generación dada normalmente serán significativamente más rápidas que los gráficos integrados hechos en la misma generación, el tipo de dispositivo puede utilizarse como base para el ajuste automático de la configuración de gráficos. Sin embargo, esto no siempre es cierto, así que asegúrate de proporcionar a los usuarios una forma de anular manualmente la configuración de gráficos.
Nota: Cuando se utiliza el controlador de renderizado OpenGL o cuando se ejecuta en modo sin interfaz gráfica, esta función siempre devuelve RenderingDevice.DEVICE_TYPE_OTHER.
String get_video_adapter_vendor() const 🔗
Devuelve el proveedor del adaptador de vídeo (por ejemplo, "NVIDIA Corporation").
Nota: Cuando se ejecuta un binario headless o de servidor, esta función devuelve una string vacía.
Devuelve el ID de una textura blanca de 4x4 (en formato Image.FORMAT_RGB8). Esta textura se creará y se devolverá en la primera llamada a get_white_texture(), luego se almacenará en caché para llamadas subsiguientes. Véase también get_test_texture().
Ejemplo: Obtén la textura blanca y aplícala a un nodo 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) 🔗
Si half_resolution es true, renderiza los búferes de VoxelGI y SDFGI (Environment.sdfgi_enabled) a la mitad de resolución en cada eje (por ejemplo, 960x540 cuando el tamaño del viewport es 1920x1080). Esto mejora significativamente el rendimiento cuando VoxelGI o SDFGI están habilitados, a costa de artefactos que pueden ser visibles en los bordes de los polígonos. La pérdida de calidad se vuelve menos perceptible a medida que aumenta la resolución del viewport. La renderización de LightmapGI no se ve afectada por esta configuración. Equivalente a ProjectSettings.rendering/global_illumination/gi/use_half_resolution.
void global_shader_parameter_add(name: StringName, type: GlobalShaderParameterType, default_value: Variant) 🔗
Crea una nueva variable global uniforme de shader.
Nota: Los nombres de los parámetros de shader globales distinguen entre mayúsculas y minúsculas.
Variant global_shader_parameter_get(name: StringName) const 🔗
Devuelve el valor de la variable uniforme global de shader especificada por name.
Nota: global_shader_parameter_get() tiene una gran penalización de rendimiento ya que el hilo de renderización necesita sincronizarse con el hilo que llama, lo cual es lento. No utilices este método durante el juego para evitar tirones. Si necesitas leer valores en un script después de configurarlos, considera crear un autoload donde almacenes los valores que necesitas consultar al mismo tiempo que los estás configurando como parámetros globales.
Array[StringName] global_shader_parameter_get_list() const 🔗
Devuelve la lista de nombres de uniformes de shader globales.
Nota: global_shader_parameter_get() tiene una gran penalización de rendimiento ya que el hilo de renderizado necesita sincronizarse con el hilo que lo llama, lo cual es lento. No uses este método durante el juego para evitar tirones. Si necesitas leer valores en un script después de configurarlos, considera crear un "autoload" donde almacenes los valores que necesitas consultar al mismo tiempo que los configuras como parámetros globales.
GlobalShaderParameterType global_shader_parameter_get_type(name: StringName) const 🔗
Devuelve el tipo asociado a la variable uniforme de shader global especificado por name.
Nota: global_shader_parameter_get() tiene una gran penalización de rendimiento ya que el hilo de renderizado necesita sincronizarse con el hilo que lo llama, lo cual es lento. No uses este método durante el juego para evitar tirones. Si necesitas leer valores en un script después de configurarlos, considera crear un "autoload" donde almacenes los valores que necesitas consultar al mismo tiempo que los configuras como parámetros globales.
void global_shader_parameter_remove(name: StringName) 🔗
Elimina la variable uniforme global del shader especificada por name.
void global_shader_parameter_set(name: StringName, value: Variant) 🔗
Establece la variable uniforme global del shader name a value.
void global_shader_parameter_set_override(name: StringName, value: Variant) 🔗
Reemplaza la variable uniforme global del shader name con value. Equivalente al nodo ShaderGlobalsOverride.
Devuelve true si se han realizado cambios en los datos del RenderingServer. force_draw() se suele llamar si esto ocurre.
bool has_feature(feature: Features) const 🔗
Obsoleto: This method has not been used since Godot 3.0.
Este método no hace nada y siempre devuelve false.
bool has_os_feature(feature: String) const 🔗
Devuelve true si el sistema operativo soporta una feature determinada. Las características pueden ser s3tc, etc y etc2.
void instance_attach_object_instance_id(instance: RID, id: int) 🔗
Adjunta una identificación de objeto única a la instancia. El ID de objeto debe adjuntarse a la instancia para una correcta selección con instances_cull_aabb(), instances_cull_convex(), y instances_cull_ray().
void instance_attach_skeleton(instance: RID, skeleton: RID) 🔗
Adjunta un esqueleto a una instancia. Elimina el esqueleto anterior de la instancia.
Crea una instancia visual y la añade al RenderingServer. Se puede acceder a ella con el RID que se devuelve. Este RID se usará en todas las funciones de instance_* de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer.
Una instancia es una forma de colocar un objeto 3D en el escenario. Objetos como partículas, mallas, sondas de reflexión y decals necesitan ser asociados a una instancia para ser visibles en el escenario usando instance_set_base().
Nota: El nodo equivalente es VisualInstance3D.
RID instance_create2(base: RID, scenario: RID) 🔗
Crea una instancia visual, la añade al RenderingServer, y establece tanto la base como el escenario. Se puede acceder a ella con el RID que se devuelve. Este RID se usará en todas las funciones de instance_* de RenderingServer.
Una vez que hayas terminado con tu RID, querrás liberar el RID usando el método free_rid() del RenderingServer. Esto es una abreviatura para usar instance_create() y establecer la base y el escenario manualmente.
Variant instance_geometry_get_shader_parameter(instance: RID, parameter: StringName) const 🔗
Devuelve el valor de la variable uniforme de shader por instancia de la instancia de geometría 3D especificada. Equivalente a GeometryInstance3D.get_instance_shader_parameter().
Nota: Los nombres de los parámetros de shader por instancia distinguen entre mayúsculas y minúsculas.
Variant instance_geometry_get_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗
Devuelve el valor predeterminado de la variable uniforme de shader por instancia de la instancia de geometría 3D especificada. Equivalente a GeometryInstance3D.get_instance_shader_parameter().
Array[Dictionary] instance_geometry_get_shader_parameter_list(instance: RID) const 🔗
Devuelve un diccionario con los nombres de los uniformes de shader por instancia de la instancia de geometría 3D especificada. El diccionario devuelto está en formato PropertyInfo, con las claves name, class_name, type, hint, hint_string y usage. Equivalente a GeometryInstance3D.get_instance_shader_parameter().
void instance_geometry_set_cast_shadows_setting(instance: RID, shadow_casting_setting: ShadowCastingSetting) 🔗
Establece la configuración de proyección de sombras. Equivalente a GeometryInstance3D.cast_shadow.
void instance_geometry_set_flag(instance: RID, flag: InstanceFlags, enabled: bool) 🔗
Establece la flag para una instance dada a enabled.
void instance_geometry_set_lightmap(instance: RID, lightmap: RID, lightmap_uv_scale: Rect2, lightmap_slice: int) 🔗
Establece la instancia de GI de mapa de luz a usar para la instancia de geometría 3D especificada. La escala UV del mapa de luz para la instancia especificada (equivalente a GeometryInstance3D.gi_lightmap_scale) y el fragmento del atlas del mapa de luz también deben ser especificados.
void instance_geometry_set_lod_bias(instance: RID, lod_bias: float) 🔗
Establece el sesgo del nivel de detalle a utilizar al renderizar la instancia de geometría 3D especificada. Valores más altos resultan en un mayor detalle desde más lejos. Equivalente a GeometryInstance3D.lod_bias.
void instance_geometry_set_material_overlay(instance: RID, material: RID) 🔗
Establece un material que se renderizará para todas las superficies por encima de los materiales activos para la malla asociada con esta instancia. Equivalente a GeometryInstance3D.material_overlay.
void instance_geometry_set_material_override(instance: RID, material: RID) 🔗
Establece un material que sobreesscribirá el material para todas las superficies de la malla asociada a esta instancia. Equivalente a GeometryInstance3D.material_override.
void instance_geometry_set_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗
Establece la variable uniforme de shader por instancia en la instancia de geometría 3D especificada. Equivalente a GeometryInstance3D.set_instance_shader_parameter().
void instance_geometry_set_transparency(instance: RID, transparency: float) 🔗
Establece la transparencia para la instancia de geometría dada. Equivalente a GeometryInstance3D.transparency.
Una transparencia de 0.0 es totalmente opaca, mientras que 1.0 es totalmente transparente. Los valores mayores que 0.0 (exclusivo) forzarán a los materiales de la geometría a pasar por el pipeline de transparencia, que es más lento de renderizar y puede presentar problemas de renderizado debido a una ordenación incorrecta de la transparencia. Sin embargo, a diferencia de usar un material transparente, establecer transparency a un valor mayor que 0.0 (exclusivo) no desactivará el renderizado de sombras.
En los shaders espaciales, 1.0 - transparency se establece como el valor por defecto del ALPHA incorporado.
Nota: transparency se limita entre 0.0 y 1.0, por lo que esta propiedad no puede usarse para hacer que los materiales transparentes sean más opacos de lo que son originalmente.
void instance_geometry_set_visibility_range(instance: RID, min: float, max: float, min_margin: float, max_margin: float, fade_mode: VisibilityRangeFadeMode) 🔗
Establece los valores del rango de visibilidad para la instancia de geometría dada. Equivalente a GeometryInstance3D.visibility_range_begin y propiedades relacionadas.
void instance_set_base(instance: RID, base: RID) 🔗
Establece la base de la instancia. Una base puede ser cualquiera de los objetos 3D que se crean en el RenderingServer que pueden ser mostrados. Por ejemplo, cualquiera de los tipos de luz, malla, multimalla, sistema de partículas, sonda de reflexión, decal, lightmap, VoxelGI y notificadores de visibilidad son todos tipos que pueden establecerse como base de una instancia para ser mostrada en el escenario.
void instance_set_blend_shape_weight(instance: RID, shape: int, weight: float) 🔗
Establece el peso de una determinada forma de mezcla asociada a este caso.
void instance_set_custom_aabb(instance: RID, aabb: AABB) 🔗
Establece una AABB personalizada para usar al descartar objetos del frustum de la vista. Equivalente a establecer GeometryInstance3D.custom_aabb.
void instance_set_extra_visibility_margin(instance: RID, margin: float) 🔗
Establece un margen para aumentar el tamaño del AABB cuando se seleccionan objetos del frustum de la vista. Esto te permite evitar la selección de objetos que caen fuera del frustum de la vista. Equivalente a GeometryInstance3D.extra_cull_margin.
void instance_set_ignore_culling(instance: RID, enabled: bool) 🔗
Si true, ignora tanto el culling de frustum como el de oclusión en la instancia de geometría 3D especificada. Esto no es lo mismo que GeometryInstance3D.ignore_occlusion_culling, que solo ignora el culling de oclusión y deja el culling de frustum intacto.
void instance_set_layer_mask(instance: RID, mask: int) 🔗
Establece las capas de renderizado a las que se dibujará esta instancia. Equivalente a VisualInstance3D.layers.
void instance_set_pivot_data(instance: RID, sorting_offset: float, use_aabb_center: bool) 🔗
Establece el desplazamiento de ordenación y conmuta entre usar la caja delimitadora o el origen de la instancia para la ordenación por profundidad.
void instance_set_scenario(instance: RID, scenario: RID) 🔗
Establece el escenario en el que se encuentra la instancia. El escenario es el mundo tridimensional en el que se mostrarán los objetos.
void instance_set_surface_override_material(instance: RID, surface: int, material: RID) 🔗
Establece el material de sobrescritura de una superficie específica. Equivalente a MeshInstance3D.set_surface_override_material().
void instance_set_transform(instance: RID, transform: Transform3D) 🔗
Establece la transformación espacial del mundo de la instancia. Equivalente a Node3D.global_transform.
void instance_set_visibility_parent(instance: RID, parent: RID) 🔗
Establece el padre de visibilidad para la instancia dada. Equivalente a Node3D.visibility_parent.
void instance_set_visible(instance: RID, visible: bool) 🔗
Establece si una instancia se dibuja o no. Equivalente a Node3D.visible.
void instance_teleport(instance: RID) 🔗
Reinicia los vectores de movimiento y otros valores interpolados. Utiliza esto después de teletransportar una malla de una posición a otra para evitar artefactos de ghosting.
PackedInt64Array instances_cull_aabb(aabb: AABB, scenario: RID = RID()) const 🔗
Devuelve un array de ID de objetos que se intersecan con el AABB proporcionado. Solo se consideran los nodos 3D que heredan de VisualInstance3D, como MeshInstance3D o DirectionalLight3D. Utiliza @GlobalScope.instance_from_id() para obtener los nodos reales. Se debe proporcionar un RID de escenario, que está disponible en el World3D que deseas consultar. Esto fuerza una actualización para todos los recursos en cola para actualizarse.
Advertencia: Esta función está pensada principalmente para el uso del editor. Para casos de uso en el juego, prefiere la colisión física.
PackedInt64Array instances_cull_convex(convex: Array[Plane], scenario: RID = RID()) const 🔗
Devuelve un array de ID de objetos que se intersecan con la forma convexa proporcionada. Solo se consideran los nodos 3D que heredan de VisualInstance3D, como MeshInstance3D o DirectionalLight3D. Utiliza @GlobalScope.instance_from_id() para obtener los nodos reales. Se debe proporcionar un RID de escenario, que está disponible en el World3D que deseas consultar. Esto fuerza una actualización para todos los recursos en cola para actualizarse.
Advertencia: Esta función está pensada principalmente para el uso del editor. Para casos de uso en el juego, prefiere la colisión física.
PackedInt64Array instances_cull_ray(from: Vector3, to: Vector3, scenario: RID = RID()) const 🔗
Devuelve un array de IDs de objeto que se intersecan con el rayo 3D proporcionado. Solo se consideran los nodos 3D que heredan de VisualInstance3D, como MeshInstance3D o DirectionalLight3D. Utiliza @GlobalScope.instance_from_id() para obtener los nodos reales. Se debe proporcionar un RID de escenario, que está disponible en el World3D que deseas consultar. Esto fuerza una actualización para todos los recursos en cola para actualizarse.
Advertencia: Esta función está pensada principalmente para el uso del editor. Para casos de uso en el juego, prefiere la colisión física.
Devuelve true si nuestro código se está ejecutando actualmente en el hilo de renderizado.
void light_directional_set_blend_splits(light: RID, enable: bool) 🔗
Si es true, esta luz direccional se mezclará entre las divisiones del mapa de sombras, lo que resultará en una transición más suave entre ellas. Equivalente a DirectionalLight3D.directional_shadow_blend_splits.
void light_directional_set_shadow_mode(light: RID, mode: LightDirectionalShadowMode) 🔗
Establece el modo de sombra para esta luz direccional. Equivalente a DirectionalLight3D.directional_shadow_mode. Véase LightDirectionalShadowMode para las opciones.
void light_directional_set_sky_mode(light: RID, mode: LightDirectionalSkyMode) 🔗
Si true, esta luz no se usará para nada excepto para los shaders de cielo. Úsalo para las luces que afectan a tu shader de cielo y que quieras ocultar para que no afecten al resto de la escena. Por ejemplo, puede que quieras activar esto cuando el sol en tu shader de cielo caiga por debajo del horizonte.
void light_omni_set_shadow_mode(light: RID, mode: LightOmniShadowMode) 🔗
Establece si se debe usar un paraboloide dual o un mapa de cubos para el mapa de sombras. El paraboloide dual es más rápido pero puede sufrir de artefactos. Equivalente a OmniLight3D.omni_shadow_mode.
void light_projectors_set_filter(filter: LightProjectorFilter) 🔗
Establece el modo de filtro de textura a usar al renderizar proyectores de luz. Este parámetro es global y no puede establecerse por luz.
void light_set_bake_mode(light: RID, bake_mode: LightBakeMode) 🔗
Establece el modo de horneado a usar para la luz 3D especificada. Equivalente a Light3D.light_bake_mode.
void light_set_color(light: RID, color: Color) 🔗
Establece el color de la luz. Equivalente a Light3D.light_color.
void light_set_cull_mask(light: RID, mask: int) 🔗
Sets the cull mask for this 3D light. Lights only affect objects in the selected layers. Equivalent to Light3D.light_cull_mask.
void light_set_distance_fade(decal: RID, enabled: bool, begin: float, shadow: float, length: float) 🔗
Sets the distance fade for this 3D light. This acts as a form of level of detail (LOD) and can be used to improve performance. Equivalent to Light3D.distance_fade_enabled, Light3D.distance_fade_begin, Light3D.distance_fade_shadow, and Light3D.distance_fade_length.
void light_set_max_sdfgi_cascade(light: RID, cascade: int) 🔗
Sets the maximum SDFGI cascade in which the 3D light's indirect lighting is rendered. Higher values allow the light to be rendered in SDFGI further away from the camera.
void light_set_negative(light: RID, enable: bool) 🔗
If true, the 3D light will subtract light instead of adding light. Equivalent to Light3D.light_negative.
void light_set_param(light: RID, param: LightParam, value: float) 🔗
Sets the specified 3D light parameter. Equivalent to Light3D.set_param().
void light_set_projector(light: RID, texture: RID) 🔗
Sets the projector texture to use for the specified 3D light. Equivalent to Light3D.light_projector.
void light_set_reverse_cull_face_mode(light: RID, enabled: bool) 🔗
If true, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with instance_geometry_set_cast_shadows_setting(). Equivalent to Light3D.shadow_reverse_cull_face.
void light_set_shadow(light: RID, enabled: bool) 🔗
If true, light will cast shadows. Equivalent to Light3D.shadow_enabled.
void light_set_shadow_caster_mask(light: RID, mask: int) 🔗
Sets the shadow caster mask for this 3D light. Shadows will only be cast using objects in the selected layers. Equivalent to Light3D.shadow_caster_mask.
Creates a new lightmap global illumination instance and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all lightmap_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent node is LightmapGI.
PackedInt32Array lightmap_get_probe_capture_bsp_tree(lightmap: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedVector3Array lightmap_get_probe_capture_points(lightmap: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedColorArray lightmap_get_probe_capture_sh(lightmap: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedInt32Array lightmap_get_probe_capture_tetrahedra(lightmap: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
void lightmap_set_baked_exposure_normalization(lightmap: RID, baked_exposure: float) 🔗
Used to inform the renderer what exposure normalization value was used while baking the lightmap. This value will be used and modulated at run time to ensure that the lightmap maintains a consistent level of exposure even if the scene-wide exposure normalization is changed at run time. For more information see camera_attributes_set_exposure().
void lightmap_set_probe_bounds(lightmap: RID, bounds: AABB) 🔗
There is currently no description for this method. Please help us by contributing one!
void lightmap_set_probe_capture_data(lightmap: RID, points: PackedVector3Array, point_sh: PackedColorArray, tetrahedra: PackedInt32Array, bsp_tree: PackedInt32Array) 🔗
There is currently no description for this method. Please help us by contributing one!
void lightmap_set_probe_capture_update_speed(speed: float) 🔗
There is currently no description for this method. Please help us by contributing one!
void lightmap_set_probe_interior(lightmap: RID, interior: bool) 🔗
There is currently no description for this method. Please help us by contributing one!
void lightmap_set_textures(lightmap: RID, light: RID, uses_sh: bool) 🔗
Set the textures on the given lightmap GI instance to the texture array pointed to by the light RID. If the lightmap texture was baked with LightmapGI.directional set to true, then uses_sh must also be true.
void lightmaps_set_bicubic_filter(enable: bool) 🔗
Toggles whether a bicubic filter should be used when lightmaps are sampled. This smoothens their appearance at a performance cost.
RID make_sphere_mesh(latitudes: int, longitudes: int, radius: float) 🔗
Returns a mesh of a sphere with the given number of horizontal subdivisions, vertical subdivisions and radius. See also get_test_cube().
Creates an empty material and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all material_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is Material.
Variant material_get_param(material: RID, parameter: StringName) const 🔗
Devuelve el valor del parámetro de un determinado material.
void material_set_next_pass(material: RID, next_material: RID) 🔗
Establece el próximo material de un objeto.
void material_set_param(material: RID, parameter: StringName, value: Variant) 🔗
Establece el parámetro de un material.
void material_set_render_priority(material: RID, priority: int) 🔗
Establece la prioridad de renderizado de un material.
void material_set_shader(shader_material: RID, shader: RID) 🔗
Establece un shader como el shader de un material.
void material_set_use_debanding(enable: bool) 🔗
When using the Mobile renderer, material_set_use_debanding() can be used to enable or disable the debanding feature of 3D materials (BaseMaterial3D and ShaderMaterial).
material_set_use_debanding() has no effect when using the Compatibility or Forward+ renderer. In Forward+, Viewport debanding can be used instead.
See also ProjectSettings.rendering/anti_aliasing/quality/use_debanding and viewport_set_use_debanding().
void mesh_add_surface(mesh: RID, surface: Dictionary) 🔗
There is currently no description for this method. Please help us by contributing one!
void mesh_add_surface_from_arrays(mesh: RID, primitive: PrimitiveType, arrays: Array, blend_shapes: Array = [], lods: Dictionary = {}, compress_format: BitField[ArrayFormat] = 0) 🔗
There is currently no description for this method. Please help us by contributing one!
Quita todas las superficies de una malla.
Creates a new mesh and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all mesh_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this mesh to an instance using instance_set_base() using the returned RID.
Note: The equivalent resource is Mesh.
RID mesh_create_from_surfaces(surfaces: Array[Dictionary], blend_shape_count: int = 0) 🔗
There is currently no description for this method. Please help us by contributing one!
int mesh_get_blend_shape_count(mesh: RID) const 🔗
Devuelve el recuento de la forma de la malla.
BlendShapeMode mesh_get_blend_shape_mode(mesh: RID) const 🔗
Devuelve el modo de mezcla de una malla.
AABB mesh_get_custom_aabb(mesh: RID) const 🔗
Devuelve el aabb personalizado de una malla.
Dictionary mesh_get_surface(mesh: RID, surface: int) 🔗
There is currently no description for this method. Please help us by contributing one!
int mesh_get_surface_count(mesh: RID) const 🔗
Devuelve el número de superficies de una malla.
void mesh_set_blend_shape_mode(mesh: RID, mode: BlendShapeMode) 🔗
Establece el modo de mezcla de una malla.
void mesh_set_custom_aabb(mesh: RID, aabb: AABB) 🔗
Establece el aabb personalizado de una malla.
void mesh_set_shadow_mesh(mesh: RID, shadow_mesh: RID) 🔗
There is currently no description for this method. Please help us by contributing one!
Array mesh_surface_get_arrays(mesh: RID, surface: int) const 🔗
Devuelve los array de búfer de superficie de una malla.
Array[Array] mesh_surface_get_blend_shape_arrays(mesh: RID, surface: int) const 🔗
Devuelve los arrays de la superficie de una malla para mezclar formas.
int mesh_surface_get_format_attribute_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
Returns the stride of the attribute buffer for a mesh with given format.
int mesh_surface_get_format_index_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
Returns the stride of the index buffer for a mesh with the given format.
int mesh_surface_get_format_normal_tangent_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
Returns the stride of the combined normals and tangents for a mesh with given format. Note importantly that, while normals and tangents are in the vertex buffer with vertices, they are only interleaved with each other and so have a different stride than vertex positions.
int mesh_surface_get_format_offset(format: BitField[ArrayFormat], vertex_count: int, array_index: int) const 🔗
Returns the offset of a given attribute by array_index in the start of its respective buffer.
int mesh_surface_get_format_skin_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
Returns the stride of the skin buffer for a mesh with given format.
int mesh_surface_get_format_vertex_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗
Returns the stride of the vertex positions for a mesh with given format. Note importantly that vertex positions are stored consecutively and are not interleaved with the other attributes in the vertex buffer (normals and tangents).
RID mesh_surface_get_material(mesh: RID, surface: int) const 🔗
Devuelve el material de la superficie de una malla.
void mesh_surface_remove(mesh: RID, surface: int) 🔗
Elimina la superficie en el índice dado de la Mesh, desplazando las superficies con un índice mayor hacia abajo en uno.
void mesh_surface_set_material(mesh: RID, surface: int, material: RID) 🔗
Establece el material de la superficie de una malla.
void mesh_surface_update_attribute_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
There is currently no description for this method. Please help us by contributing one!
void mesh_surface_update_index_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
Updates the index buffer of the mesh surface with the given data. The expected data are 16 or 32-bit unsigned integers, which can be determined with mesh_surface_get_format_index_stride().
void mesh_surface_update_skin_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
There is currently no description for this method. Please help us by contributing one!
void mesh_surface_update_vertex_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗
There is currently no description for this method. Please help us by contributing one!
void multimesh_allocate_data(multimesh: RID, instances: int, transform_format: MultimeshTransformFormat, color_format: bool = false, custom_data_format: bool = false, use_indirect: bool = false) 🔗
There is currently no description for this method. Please help us by contributing one!
Creates a new multimesh on the RenderingServer and returns an RID handle. This RID will be used in all multimesh_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this multimesh to an instance using instance_set_base() using the returned RID.
Note: The equivalent resource is MultiMesh.
AABB multimesh_get_aabb(multimesh: RID) const 🔗
Calcula y devuelve el cuadro delimitador alineado con el eje que encierra todas las instancias dentro de la multimalla.
PackedFloat32Array multimesh_get_buffer(multimesh: RID) const 🔗
Returns the MultiMesh data (such as instance transforms, colors, etc.). See multimesh_set_buffer() for details on the returned data.
Note: If the buffer is in the engine's internal cache, it will have to be fetched from GPU memory and possibly decompressed. This means multimesh_get_buffer() is potentially a slow operation and should be avoided whenever possible.
RID multimesh_get_buffer_rd_rid(multimesh: RID) const 🔗
Returns the RenderingDevice RID handle of the MultiMesh, which can be used as any other buffer on the Rendering Device.
RID multimesh_get_command_buffer_rd_rid(multimesh: RID) const 🔗
Returns the RenderingDevice RID handle of the MultiMesh command buffer. This RID is only valid if use_indirect is set to true when allocating data through multimesh_allocate_data(). It can be used to directly modify the instance count via buffer.
The data structure is dependent on both how many surfaces the mesh contains and whether it is indexed or not, the buffer has 5 integers in it, with the last unused if the mesh is not indexed.
Each of the values in the buffer correspond to these options:
Indexed:
0 - indexCount;
1 - instanceCount;
2 - firstIndex;
3 - vertexOffset;
4 - firstInstance;
Non Indexed:
0 - vertexCount;
1 - instanceCount;
2 - firstVertex;
3 - firstInstance;
4 - unused;
AABB multimesh_get_custom_aabb(multimesh: RID) const 🔗
Returns the custom AABB defined for this MultiMesh resource.
int multimesh_get_instance_count(multimesh: RID) const 🔗
Devuelve el número de instancias asignadas para esta multimalla.
RID multimesh_get_mesh(multimesh: RID) const 🔗
Devuelve el RID de la malla que se usará para dibujar este multimalla.
int multimesh_get_visible_instances(multimesh: RID) const 🔗
Devuelve el número de instancias visibles para este multimalla.
Color multimesh_instance_get_color(multimesh: RID, index: int) const 🔗
Devuelve el color por el cual la instancia especificada será modulada.
Color multimesh_instance_get_custom_data(multimesh: RID, index: int) const 🔗
Devuelve los datos personalizados asociados a la instancia especificada.
Transform3D multimesh_instance_get_transform(multimesh: RID, index: int) const 🔗
Devuelve la Transform3D de la instancia especificada.
Transform2D multimesh_instance_get_transform_2d(multimesh: RID, index: int) const 🔗
Devuelve la Transform2D de la instancia especificada. Para usar cuando el multimalle está configurado para usar transformaciones 2D.
void multimesh_instance_reset_physics_interpolation(multimesh: RID, index: int) 🔗
Prevents physics interpolation for the specified instance during the current physics tick.
This is useful when moving an instance to a new location, to give an instantaneous change rather than interpolation from the previous location.
void multimesh_instance_set_color(multimesh: RID, index: int, color: Color) 🔗
Establece el color por el cual esta instancia será modulada. Equivalente a MultiMesh.set_instance_color().
void multimesh_instance_set_custom_data(multimesh: RID, index: int, custom_data: Color) 🔗
Establece los datos personalizados para este caso. Los datos personalizados se pasan como un Color, pero se interpretan como un vec4 en el shader. Equivalente al MultiMesh.set_instance_custom_data().
void multimesh_instance_set_transform(multimesh: RID, index: int, transform: Transform3D) 🔗
Establece la Transform3D para este caso. Equivalente a MultiMesh.set_instance_transform().
void multimesh_instance_set_transform_2d(multimesh: RID, index: int, transform: Transform2D) 🔗
Establece el Transform2D para este caso. Para su uso cuando se utiliza el multimesh en 2D. Equivalente al MultiMesh.set_instance_transform_2d().
void multimesh_instances_reset_physics_interpolation(multimesh: RID) 🔗
Prevents physics interpolation for all instances during the current physics tick.
This is useful when moving all instances to new locations, to give instantaneous changes rather than interpolation from the previous locations.
void multimesh_set_buffer(multimesh: RID, buffer: PackedFloat32Array) 🔗
Set the entire data to use for drawing the multimesh at once to buffer (such as instance transforms and colors). buffer's size must match the number of instances multiplied by the per-instance data size (which depends on the enabled MultiMesh fields). Otherwise, an error message is printed and nothing is rendered. See also multimesh_get_buffer().
The per-instance data size and expected data order is:
2D:
- Position: 8 floats (8 floats for Transform2D)
- Position + Vertex color: 12 floats (8 floats for Transform2D, 4 floats for Color)
- Position + Custom data: 12 floats (8 floats for Transform2D, 4 floats of custom data)
- Position + Vertex color + Custom data: 16 floats (8 floats for Transform2D, 4 floats for Color, 4 floats of custom data)
3D:
- Position: 12 floats (12 floats for Transform3D)
- Position + Vertex color: 16 floats (12 floats for Transform3D, 4 floats for Color)
- Position + Custom data: 16 floats (12 floats for Transform3D, 4 floats of custom data)
- Position + Vertex color + Custom data: 20 floats (12 floats for Transform3D, 4 floats for Color, 4 floats of custom data)
Instance transforms are in row-major order. Specifically:
For Transform2D the float-order is:
(x.x, y.x, padding_float, origin.x, x.y, y.y, padding_float, origin.y).For Transform3D the float-order is:
(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) 🔗
Alternative version of multimesh_set_buffer() for use with physics interpolation.
Takes both an array of current data and an array of data for the previous physics tick.
void multimesh_set_custom_aabb(multimesh: RID, aabb: AABB) 🔗
Sets the custom AABB for this MultiMesh resource.
void multimesh_set_mesh(multimesh: RID, mesh: RID) 🔗
Establece la malla a ser dibujada por la multimalla. Equivalente a MultiMesh.mesh.
void multimesh_set_physics_interpolated(multimesh: RID, interpolated: bool) 🔗
Turns on and off physics interpolation for this MultiMesh resource.
void multimesh_set_physics_interpolation_quality(multimesh: RID, quality: MultimeshPhysicsInterpolationQuality) 🔗
Sets the physics interpolation quality for the MultiMesh.
A value of MULTIMESH_INTERP_QUALITY_FAST gives fast but low quality interpolation, a value of MULTIMESH_INTERP_QUALITY_HIGH gives slower but higher quality interpolation.
void multimesh_set_visible_instances(multimesh: RID, visible: int) 🔗
Establece el número de instancias visibles en un momento dado. Si es -1, se sortean todas las instancias que han sido asignadas. Equivalente a MultiMesh.visible_instance_count.
Creates an occluder instance and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all occluder_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is Occluder3D (not to be confused with the OccluderInstance3D node).
void occluder_set_mesh(occluder: RID, vertices: PackedVector3Array, indices: PackedInt32Array) 🔗
Sets the mesh data for the given occluder RID, which controls the shape of the occlusion culling that will be performed.
Creates a new omni light and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID can be used in most light_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this omni light to an instance using instance_set_base() using the returned RID.
Note: The equivalent node is OmniLight3D.
RID particles_collision_create() 🔗
Creates a new 3D GPU particle collision or attractor and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID can be used in most particles_collision_* RenderingServer functions.
Note: The equivalent nodes are GPUParticlesCollision3D and GPUParticlesAttractor3D.
void particles_collision_height_field_update(particles_collision: RID) 🔗
Requests an update for the 3D GPU particle collision heightfield. This may be automatically called by the 3D GPU particle collision heightfield depending on its GPUParticlesCollisionHeightField3D.update_mode.
void particles_collision_set_attractor_attenuation(particles_collision: RID, curve: float) 🔗
Sets the attenuation curve for the 3D GPU particles attractor specified by the particles_collision RID. Only used for attractors, not colliders. Equivalent to GPUParticlesAttractor3D.attenuation.
void particles_collision_set_attractor_directionality(particles_collision: RID, amount: float) 🔗
Sets the directionality amount for the 3D GPU particles attractor specified by the particles_collision RID. Only used for attractors, not colliders. Equivalent to GPUParticlesAttractor3D.directionality.
void particles_collision_set_attractor_strength(particles_collision: RID, strength: float) 🔗
Sets the strength for the 3D GPU particles attractor specified by the particles_collision RID. Only used for attractors, not colliders. Equivalent to GPUParticlesAttractor3D.strength.
void particles_collision_set_box_extents(particles_collision: RID, extents: Vector3) 🔗
Sets the extents for the 3D GPU particles collision by the particles_collision RID. Equivalent to GPUParticlesCollisionBox3D.size, GPUParticlesCollisionSDF3D.size, GPUParticlesCollisionHeightField3D.size, GPUParticlesAttractorBox3D.size or GPUParticlesAttractorVectorField3D.size depending on the particles_collision type.
void particles_collision_set_collision_type(particles_collision: RID, type: ParticlesCollisionType) 🔗
Sets the collision or attractor shape type for the 3D GPU particles collision or attractor specified by the particles_collision RID.
void particles_collision_set_cull_mask(particles_collision: RID, mask: int) 🔗
Sets the cull mask for the 3D GPU particles collision or attractor specified by the particles_collision RID. Equivalent to GPUParticlesCollision3D.cull_mask or GPUParticlesAttractor3D.cull_mask depending on the particles_collision type.
void particles_collision_set_field_texture(particles_collision: RID, texture: RID) 🔗
Sets the signed distance field texture for the 3D GPU particles collision specified by the particles_collision RID. Equivalent to GPUParticlesCollisionSDF3D.texture or GPUParticlesAttractorVectorField3D.texture depending on the particles_collision type.
void particles_collision_set_height_field_mask(particles_collision: RID, mask: int) 🔗
Sets the heightfield mask for the 3D GPU particles heightfield collision specified by the particles_collision RID. Equivalent to GPUParticlesCollisionHeightField3D.heightfield_mask.
void particles_collision_set_height_field_resolution(particles_collision: RID, resolution: ParticlesCollisionHeightfieldResolution) 🔗
Sets the heightmap resolution for the 3D GPU particles heightfield collision specified by the particles_collision RID. Equivalent to GPUParticlesCollisionHeightField3D.resolution.
void particles_collision_set_sphere_radius(particles_collision: RID, radius: float) 🔗
Sets the radius for the 3D GPU particles sphere collision or attractor specified by the particles_collision RID. Equivalent to GPUParticlesCollisionSphere3D.radius or GPUParticlesAttractorSphere3D.radius depending on the particles_collision type.
Creates a GPU-based particle system and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all particles_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach these particles to an instance using instance_set_base() using the returned RID.
Note: The equivalent nodes are GPUParticles2D and GPUParticles3D.
Note: All particles_* methods only apply to GPU-based particles, not CPU-based particles. CPUParticles2D and CPUParticles3D do not have equivalent RenderingServer functions available, as these use MultiMeshInstance2D and MultiMeshInstance3D under the hood (see multimesh_* methods).
void particles_emit(particles: RID, transform: Transform3D, velocity: Vector3, color: Color, custom: Color, emit_flags: int) 🔗
Manually emits particles from the particles instance.
AABB particles_get_current_aabb(particles: RID) 🔗
Calculates and returns the axis-aligned bounding box that contains all the particles. Equivalent to GPUParticles3D.capture_aabb().
bool particles_get_emitting(particles: RID) 🔗
Devuelve true si las partículas están actualmente fijadas para emitir.
bool particles_is_inactive(particles: RID) 🔗
Devuelve true si las partículas no están emitiendo y las partículas están inactivas.
void particles_request_process(particles: RID) 🔗
Añade el sistema de partículas a la lista de sistemas de partículas que deben ser actualizados. La actualización tendrá lugar en el siguiente fotograma, o en la siguiente llamada a instances_cull_aabb(), instances_cull_convex(), o instances_cull_ray().
void particles_request_process_time(particles: RID, time: float) 🔗
Requests particles to process for extra process time during a single frame.
void particles_restart(particles: RID) 🔗
Reset the particles on the next update. Equivalent to GPUParticles3D.restart().
void particles_set_amount(particles: RID, amount: int) 🔗
Sets the number of particles to be drawn and allocates the memory for them. Equivalent to GPUParticles3D.amount.
void particles_set_amount_ratio(particles: RID, ratio: float) 🔗
Sets the amount ratio for particles to be emitted. Equivalent to GPUParticles3D.amount_ratio.
void particles_set_collision_base_size(particles: RID, size: float) 🔗
There is currently no description for this method. Please help us by contributing one!
void particles_set_custom_aabb(particles: RID, aabb: AABB) 🔗
Sets a custom axis-aligned bounding box for the particle system. Equivalent to GPUParticles3D.visibility_aabb.
void particles_set_draw_order(particles: RID, order: ParticlesDrawOrder) 🔗
Sets the draw order of the particles. Equivalent to GPUParticles3D.draw_order.
void particles_set_draw_pass_mesh(particles: RID, pass: int, mesh: RID) 🔗
Sets the mesh to be used for the specified draw pass. Equivalent to GPUParticles3D.draw_pass_1, GPUParticles3D.draw_pass_2, GPUParticles3D.draw_pass_3, and GPUParticles3D.draw_pass_4.
void particles_set_draw_passes(particles: RID, count: int) 🔗
Sets the number of draw passes to use. Equivalent to GPUParticles3D.draw_passes.
void particles_set_emission_transform(particles: RID, transform: Transform3D) 🔗
Establece la Transform3D que será utilizada por las partículas cuando emitan por primera vez.
void particles_set_emitter_velocity(particles: RID, velocity: Vector3) 🔗
Establece la velocidad de un nodo de partícula, que será usado por ParticleProcessMaterial.inherit_velocity_ratio.
void particles_set_emitting(particles: RID, emitting: bool) 🔗
If true, particles will emit over time. Setting to false does not reset the particles, but only stops their emission. Equivalent to GPUParticles3D.emitting.
void particles_set_explosiveness_ratio(particles: RID, ratio: float) 🔗
Establece la relación de explosividad. Equivalente a GPUParticles3D.explosiveness.
void particles_set_fixed_fps(particles: RID, fps: int) 🔗
Establece la velocidad de fotogramas a la que se fijará el renderizado del sistema de partículas. Equivalente a GPUParticles3D.fixed_fps.
void particles_set_fractional_delta(particles: RID, enable: bool) 🔗
Si es true, usa delta fraccional que suaviza el movimiento de las partículas. Equivalente a GPUParticles3D.fract_delta.
void particles_set_interp_to_end(particles: RID, factor: float) 🔗
Establece el valor que informa a un ParticleProcessMaterial para que impulse todas las partículas hacia el final de su vida útil.
void particles_set_interpolate(particles: RID, enable: bool) 🔗
There is currently no description for this method. Please help us by contributing one!
void particles_set_lifetime(particles: RID, lifetime: float) 🔗
Establece la vida útil de cada partícula en el sistema. Equivalente a GPUParticles3D.lifetime.
void particles_set_mode(particles: RID, mode: ParticlesMode) 🔗
Establece si las partículas de la GPU especificadas por el RID particles deben renderizarse en 2D o 3D según el mode.
void particles_set_one_shot(particles: RID, one_shot: bool) 🔗
Si es true, las partículas se emitirán una vez y luego se detendrán. Equivalente a GPUParticles3D.one_shot.
void particles_set_pre_process_time(particles: RID, time: float) 🔗
Establece el tiempo de preprocesamiento para la animación de las partículas. Esto te permite retrasar el inicio de una animación hasta después de que las partículas hayan comenzado a emitirse. Equivalente a GPUParticles3D.preprocess.
void particles_set_process_material(particles: RID, material: RID) 🔗
Establece el material para procesar las partículas.
Nota: Este no es el material utilizado para dibujar los materiales. Equivalente a GPUParticles3D.process_material.
void particles_set_randomness_ratio(particles: RID, ratio: float) 🔗
Sets the emission randomness ratio. This randomizes the emission of particles within their phase. Equivalent to GPUParticles3D.randomness.
void particles_set_speed_scale(particles: RID, scale: float) 🔗
Establece la escala de velocidad del sistema de partículas. Equivalente a GPUParticles3D.speed_scale.
void particles_set_subemitter(particles: RID, subemitter_particles: RID) 🔗
There is currently no description for this method. Please help us by contributing one!
void particles_set_trail_bind_poses(particles: RID, bind_poses: Array[Transform3D]) 🔗
There is currently no description for this method. Please help us by contributing one!
void particles_set_trails(particles: RID, enable: bool, length_sec: float) 🔗
If enable is true, enables trails for the particles with the specified length_sec in seconds. Equivalent to GPUParticles3D.trail_enabled and GPUParticles3D.trail_lifetime.
void particles_set_transform_align(particles: RID, align: ParticlesTransformAlign) 🔗
There is currently no description for this method. Please help us by contributing one!
void particles_set_use_local_coordinates(particles: RID, enable: bool) 🔗
If true, particles use local coordinates. If false they use global coordinates. Equivalent to GPUParticles3D.local_coords.
void positional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗
Establece la calidad del filtro para las sombras de luces omnidireccionales y puntuales en 3D. Véase también ProjectSettings.rendering/lights_and_shadows/positional_shadow/soft_shadow_filter_quality. Este parámetro es global y no se puede establecer por viewport.
RID reflection_probe_create() 🔗
Creates a reflection probe and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all reflection_probe_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this reflection probe to an instance using instance_set_base() using the returned RID.
Note: The equivalent node is ReflectionProbe.
void reflection_probe_set_ambient_color(probe: RID, color: Color) 🔗
Establece el color de luz ambiental personalizado de la sonda de reflexión. Equivalente a ReflectionProbe.ambient_color.
void reflection_probe_set_ambient_energy(probe: RID, energy: float) 🔗
Establece la energía de luz ambiental personalizada de la sonda de reflexión. Equivalente a ReflectionProbe.ambient_color_energy.
void reflection_probe_set_ambient_mode(probe: RID, mode: ReflectionProbeAmbientMode) 🔗
Establece el modo de luz ambiental de la sonda de reflexión. Equivalente a ReflectionProbe.ambient_mode.
void reflection_probe_set_as_interior(probe: RID, enable: bool) 🔗
Si es true, las reflexiones ignorarán la contribución del cielo. Equivalente a ReflectionProbe.interior.
void reflection_probe_set_blend_distance(probe: RID, blend_distance: float) 🔗
Establece la distancia en metros sobre la que una sonda se mezcla con la escena.
void reflection_probe_set_cull_mask(probe: RID, layers: int) 🔗
Establece la máscara de selección de renderizado para esta sonda de reflexión. Solo las instancias con una capa coincidente se reflejarán con esta sonda. Equivalente a ReflectionProbe.cull_mask.
void reflection_probe_set_enable_box_projection(probe: RID, enable: bool) 🔗
Si es true, usa la proyección de caja. Esto puede hacer que los reflejos se vean más correctos en ciertas situaciones. Equivalente a ReflectionProbe.box_projection.
void reflection_probe_set_enable_shadows(probe: RID, enable: bool) 🔗
Si es true, calcula las sombras en la sonda de reflexión. Esto hace que el reflejo sea mucho más lento de calcular. Equivalente a ReflectionProbe.enable_shadows.
void reflection_probe_set_intensity(probe: RID, intensity: float) 🔗
Establece la intensidad de la sonda de reflexión. La intensidad modula la fuerza de la reflexión. Equivalente a ReflectionProbe.intensity.
void reflection_probe_set_max_distance(probe: RID, distance: float) 🔗
Establece la máxima distancia de la sonda a la que puede estar un objeto antes de ser seleccionado. Equivalente a ReflectionProbe.max_distance.
void reflection_probe_set_mesh_lod_threshold(probe: RID, pixels: float) 🔗
Establece el nivel de detalle de la malla que se utilizará en el renderizado de la sonda de reflexión. Los valores más altos utilizarán versiones menos detalladas de las mallas que tienen variaciones LOD generadas, lo que puede mejorar el rendimiento. Equivalente a ReflectionProbe.mesh_lod_threshold.
void reflection_probe_set_origin_offset(probe: RID, offset: Vector3) 🔗
Establece el desplazamiento de origen que se utilizará cuando esta sonda de reflexión esté en modo de proyecto de caja. Equivalente a ReflectionProbe.origin_offset.
void reflection_probe_set_reflection_mask(probe: RID, layers: int) 🔗
Establece la máscara de reflexión de renderizado para esta sonda de reflexión. Solo las instancias con una capa coincidente tendrán reflejos aplicados desde esta sonda. Equivalente a ReflectionProbe.reflection_mask.
void reflection_probe_set_resolution(probe: RID, resolution: int) 🔗
Obsoleto: This method has not done anything since Godot 3.
Obsoleto. Este método no hace nada.
void reflection_probe_set_size(probe: RID, size: Vector3) 🔗
Sets the size of the area that the reflection probe will capture. Equivalent to ReflectionProbe.size.
void reflection_probe_set_update_mode(probe: RID, mode: ReflectionProbeUpdateMode) 🔗
Establece la frecuencia con la que se actualiza la sonda de reflexión. Puede ser una vez o en cada fotograma.
void request_frame_drawn_callback(callable: Callable) 🔗
Programa una llamada al objeto invocable dado después de que se haya dibujado un fotograma.
Creates a scenario and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all scenario_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
The scenario is the 3D world that all the visual instances exist in.
void scenario_set_camera_attributes(scenario: RID, effects: RID) 🔗
Establece los atributos de la cámara (effects) que se utilizarán con este escenario. Véase también CameraAttributes.
void scenario_set_compositor(scenario: RID, compositor: RID) 🔗
Establece el compositor (compositor) que se utilizará con este escenario. Véase también Compositor.
void scenario_set_environment(scenario: RID, environment: RID) 🔗
Establece el entorno que se utilizará con este escenario. Véase también Environment.
void scenario_set_fallback_environment(scenario: RID, environment: RID) 🔗
Establece el entorno de reserva que se utilizará en este escenario. El entorno de reserva se utiliza si no se establece ningún entorno. Internamente, es usado por el editor para proporcionar un entorno por defecto.
void screen_space_roughness_limiter_set_active(enable: bool, amount: float, limit: float) 🔗
Sets the screen-space roughness limiter parameters, such as whether it should be enabled and its thresholds. Equivalent to ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/enabled, ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/amount and ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/limit.
void set_boot_image(image: Image, color: Color, scale: bool, use_filter: bool = true) 🔗
Obsoleto: Use set_boot_image_with_stretch() instead.
Sets a boot image. The color defines the background color. The value of scale indicates if the image will be scaled to fit the screen size. If use_filter is true, the image will be scaled with linear interpolation. If use_filter is false, the image will be scaled with nearest-neighbor interpolation.
void set_boot_image_with_stretch(image: Image, color: Color, stretch_mode: SplashStretchMode, use_filter: bool = true) 🔗
Sets a boot image. The color defines the background color. The value of stretch_mode indicates how the image will be stretched (see SplashStretchMode for possible values). If use_filter is true, the image will be scaled with linear interpolation. If use_filter is false, the image will be scaled with nearest-neighbor interpolation.
void set_debug_generate_wireframes(generate: bool) 🔗
If generate is true, generates debug wireframes for all meshes that are loaded when using the Compatibility renderer. By default, the engine does not generate debug wireframes at runtime, since they slow down loading of assets and take up VRAM.
Note: You must call this method before loading any meshes when using the Compatibility renderer, otherwise wireframes will not be used.
void set_default_clear_color(color: Color) 🔗
Establece el color de borrado predeterminado que se utiliza cuando no se ha seleccionado un color de borrado específico. Véase también get_default_clear_color().
Creates an empty shader and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all shader_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is Shader.
String shader_get_code(shader: RID) const 🔗
Devuelve el código fuente de un shader como una string.
RID shader_get_default_texture_parameter(shader: RID, name: StringName, index: int = 0) const 🔗
Devuelve una textura por defecto de un shader buscada por nombre.
Nota: Si se utiliza el array de muestreo, usa index para acceder a la textura especificada.
Variant shader_get_parameter_default(shader: RID, name: StringName) const 🔗
Devuelve el valor por defecto para el shader uniforme especificado. Este es usualmente el valor escrito en el código fuente del shader.
void shader_set_code(shader: RID, code: String) 🔗
Establece el código fuente del shader (lo que desencadena la recompilación después de ser cambiado).
void shader_set_default_texture_parameter(shader: RID, name: StringName, texture: RID, index: int = 0) 🔗
Establece la textura por defecto de un shader. Sobrescribe la textura dada por el nombre.
Nota: Si se utiliza el array de muestreo, utiliza index para acceder a la textura especificada.
void shader_set_path_hint(shader: RID, path: String) 🔗
Establece la pista de ruta para el shader especificado. Esto generalmente debería coincidir con el Resource.resource_path del recurso Shader.
void skeleton_allocate_data(skeleton: RID, bones: int, is_2d_skeleton: bool = false) 🔗
There is currently no description for this method. Please help us by contributing one!
Transform3D skeleton_bone_get_transform(skeleton: RID, bone: int) const 🔗
Devuelve el conjunto Transform3D para un hueso específico de este esqueleto.
Transform2D skeleton_bone_get_transform_2d(skeleton: RID, bone: int) const 🔗
Devuelve el conjunto Transform3D para un hueso específico de este esqueleto.
void skeleton_bone_set_transform(skeleton: RID, bone: int, transform: Transform3D) 🔗
Establece la Transform3D para un hueso específico de este esqueleto.
void skeleton_bone_set_transform_2d(skeleton: RID, bone: int, transform: Transform2D) 🔗
Establece la Transform2D para un hueso específico de este esqueleto.
Crea un esqueleto y lo añade al RenderingServer. Se puede acceder a él con el RID que se devuelve. Este RID se usará en todas las funciones del skeleton_* RenderingServer.
Cuando hayas terminado con tu RID, querrás liberarlo usando el método free_rid() de RenderingServer.
int skeleton_get_bone_count(skeleton: RID) const 🔗
Devuelve el número de huesos asignados a este esqueleto.
void skeleton_set_base_transform_2d(skeleton: RID, base_transform: Transform2D) 🔗
There is currently no description for this method. Please help us by contributing one!
Image sky_bake_panorama(sky: RID, energy: float, bake_irradiance: bool, size: Vector2i) 🔗
Generates and returns an Image containing the radiance map for the specified sky RID. This supports built-in sky material and custom sky shaders. If bake_irradiance is true, the irradiance map is saved instead of the radiance map. The radiance map is used to render reflected light, while the irradiance map is used to render ambient light. See also environment_bake_panorama().
Note: The image is saved using linear encoding without any tonemapping performed, which means it will look too dark if viewed directly in an image editor. energy values above 1.0 can be used to brighten the resulting image.
Note: size should be a 2:1 aspect ratio for the generated panorama to have square pixels. For radiance maps, there is no point in using a height greater than Sky.radiance_size, as it won't increase detail. Irradiance maps only contain low-frequency data, so there is usually no point in going past a size of 128×64 pixels when saving an irradiance map.
Creates an empty sky and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all sky_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
void sky_set_material(sky: RID, material: RID) 🔗
Establece el material que el cielo utiliza para renderizar el fondo, el ambiente y los mapas de reflexión.
void sky_set_mode(sky: RID, mode: SkyMode) 🔗
Establece el mode de proceso del cielo especificado por el RID sky. Equivalente a Sky.process_mode.
void sky_set_radiance_size(sky: RID, radiance_size: int) 🔗
Sets the radiance_size of the sky specified by the sky RID (in pixels). Equivalent to Sky.radiance_size.
Creates a spot light and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID can be used in most light_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this spot light to an instance using instance_set_base() using the returned RID.
void sub_surface_scattering_set_quality(quality: SubSurfaceScatteringQuality) 🔗
Establece ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_quality que se utilizará al renderizar materiales que tengan la dispersión subsuperficial habilitada.
void sub_surface_scattering_set_scale(scale: float, depth_scale: float) 🔗
Establece ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_scale y ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_depth_scale para usarlos al renderizar materiales que tengan la dispersión subsuperficial habilitada.
RID texture_2d_create(image: Image) 🔗
Creates a 2-dimensional texture and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all texture_2d_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is Texture2D.
Note: Not to be confused with RenderingDevice.texture_create(), which creates the graphics API's own texture type as opposed to the Godot-specific Texture2D resource.
Image texture_2d_get(texture: RID) const 🔗
Returns an Image instance from the given texture RID.
Example: Get the test texture from get_test_texture() and apply it to a Sprite2D node:
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 🔗
Devuelve una instancia de Image de la RID de texture dada y layer.
RID texture_2d_layered_create(layers: Array[Image], layered_type: TextureLayeredType) 🔗
Crea una textura en capas bidimensional y la añade al RenderingServer. Se puede acceder a ella con la RID que se devuelve. Esta RID se utilizará en todas las funciones texture_2d_layered_* del RenderingServer.
Cuando hayas terminado con tu RID, querrás liberarla usando el método free_rid() del RenderingServer.
Nota: El recurso equivalente es TextureLayered.
RID texture_2d_layered_placeholder_create(layered_type: TextureLayeredType) 🔗
Creates a placeholder for a 2-dimensional layered texture and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all texture_2d_layered_* RenderingServer functions, although it does nothing when used. See also texture_2d_placeholder_create().
Note: The equivalent resource is PlaceholderTextureLayered.
RID texture_2d_placeholder_create() 🔗
Creates a placeholder for a 2-dimensional layered texture and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all texture_2d_layered_* RenderingServer functions, although it does nothing when used. See also texture_2d_layered_placeholder_create().
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is PlaceholderTexture2D.
void texture_2d_update(texture: RID, image: Image, layer: int) 🔗
Actualiza la textura especificada por la RID texture con los datos de image. También se debe especificar una layer, que debe ser 0 al actualizar una textura de una sola capa (Texture2D).
Nota: La image debe tener el mismo ancho, alto y formato que los datos actuales de texture. De lo contrario, se imprimirá un error y la textura original no se modificará. Si necesitas usar un ancho, alto o formato diferente, usa texture_replace() en su lugar.
RID texture_3d_create(format: Format, width: int, height: int, depth: int, mipmaps: bool, data: Array[Image]) 🔗
Nota: El recurso equivalente es Texture3D.
Array[Image] texture_3d_get(texture: RID) const 🔗
Devuelve datos de textura 3D como un array de Image para la RID de la textura especificada.
RID texture_3d_placeholder_create() 🔗
Creates a placeholder for a 3-dimensional texture and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all texture_3d_* RenderingServer functions, although it does nothing when used.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent resource is PlaceholderTexture3D.
void texture_3d_update(texture: RID, data: Array[Image]) 🔗
Actualiza los datos de la textura especificada por la RID texture con los datos de data. Todas las capas de la textura deben ser reemplazadas a la vez.
Nota: La texture debe tener el mismo ancho, alto, profundidad y formato que los datos actuales de la textura. De lo contrario, se imprimirá un error y la textura original no se modificará. Si necesitas usar un ancho, alto, profundidad o formato diferente, usa texture_replace() en su lugar.
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) 🔗
Creates a texture based on a native handle that was created outside of Godot's renderer.
Note: If using only the rendering device renderer, it's recommend to use RenderingDevice.texture_create_from_extension() together with texture_rd_create(), rather than this method. This way, the texture's format and usage can be controlled more effectively.
Format texture_get_format(texture: RID) const 🔗
Devuelve el formato de la textura.
int texture_get_native_handle(texture: RID, srgb: bool = false) const 🔗
Returns the internal graphics handle for this texture object. For use when communicating with third-party APIs mostly with GDExtension.
srgb should be true when the texture uses nonlinear sRGB encoding and false when the texture uses linear encoding.
Note: This function returns a uint64_t which internally maps to a GLuint (OpenGL) or VkImage (Vulkan).
String texture_get_path(texture: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
RID texture_get_rd_texture(texture: RID, srgb: bool = false) const 🔗
Returns a texture RID that can be used with RenderingDevice.
srgb should be true when the texture uses nonlinear sRGB encoding and false when the texture uses linear encoding.
RID texture_proxy_create(base: RID) 🔗
Obsoleto: ProxyTexture was removed in Godot 4.
Este método no hace nada y siempre devuelve una RID inválida.
void texture_proxy_update(texture: RID, proxy_to: RID) 🔗
Obsoleto: ProxyTexture was removed in Godot 4.
Este método no hace nada.
RID texture_rd_create(rd_texture: RID, layer_type: TextureLayeredType = 0) 🔗
Creates a new texture object based on a texture created directly on the RenderingDevice. If the texture contains layers, layer_type is used to define the layer type.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The RenderingServer's free_rid() won't free the underlying rd_texture, you will want to free the rd_texture using RenderingDevice.free_rid().
void texture_replace(texture: RID, by_texture: RID) 🔗
Reemplaza los datos de la textura de texture por la textura especificada por la RID by_texture, sin cambiar la RID de texture.
void texture_set_force_redraw_if_visible(texture: RID, enable: bool) 🔗
There is currently no description for this method. Please help us by contributing one!
void texture_set_path(texture: RID, path: String) 🔗
There is currently no description for this method. Please help us by contributing one!
void texture_set_size_override(texture: RID, width: int, height: int) 🔗
There is currently no description for this method. Please help us by contributing one!
void viewport_attach_camera(viewport: RID, camera: RID) 🔗
Establece la cámara de un viewport.
void viewport_attach_canvas(viewport: RID, canvas: RID) 🔗
Establece el canvas de un viewport.
void viewport_attach_to_screen(viewport: RID, rect: Rect2 = Rect2(0, 0, 0, 0), screen: int = 0) 🔗
Copies the viewport to a region of the screen specified by rect. If viewport_set_render_direct_to_screen() is true, then the viewport does not use a framebuffer and the contents of the viewport are rendered directly to screen. However, note that the root viewport is drawn last, therefore it will draw over the screen. Accordingly, you must set the root viewport to an area that does not cover the area that you have attached this viewport to.
For example, you can set the root viewport to not render at all with the following code:
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))
Using this can result in significant optimization, especially on lower-end devices. However, it comes at the cost of having to manage your viewports manually. For further optimization, see viewport_set_render_direct_to_screen().
Creates an empty viewport and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all viewport_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent node is Viewport.
float viewport_get_measured_render_time_cpu(viewport: RID) const 🔗
Returns the CPU time taken to render the last frame in milliseconds. This only includes time spent in rendering-related operations; scripts' _process functions and other engine subsystems are not included in this readout. To get a complete readout of CPU time spent to render the scene, sum the render times of all viewports that are drawn every frame plus get_frame_setup_time_cpu(). Unlike Engine.get_frames_per_second(), this method will accurately reflect CPU utilization even if framerate is capped via V-Sync or Engine.max_fps. See also viewport_get_measured_render_time_gpu().
Note: Requires measurements to be enabled on the specified viewport using viewport_set_measure_render_time(). Otherwise, this method returns 0.0.
float viewport_get_measured_render_time_gpu(viewport: RID) const 🔗
Returns the GPU time taken to render the last frame in milliseconds. To get a complete readout of GPU time spent to render the scene, sum the render times of all viewports that are drawn every frame. Unlike Engine.get_frames_per_second(), this method accurately reflects GPU utilization even if framerate is capped via V-Sync or Engine.max_fps. See also viewport_get_measured_render_time_cpu().
Note: Requires measurements to be enabled on the specified viewport using viewport_set_measure_render_time(). Otherwise, this method returns 0.0.
Note: When GPU utilization is low enough during a certain period of time, GPUs will decrease their power state (which in turn decreases core and memory clock speeds). This can cause the reported GPU time to increase if GPU utilization is kept low enough by a framerate cap (compared to what it would be at the GPU's highest power state). Keep this in mind when benchmarking using viewport_get_measured_render_time_gpu(). This behavior can be overridden in the graphics driver settings at the cost of higher power usage.
int viewport_get_render_info(viewport: RID, type: ViewportRenderInfoType, info: ViewportRenderInfo) 🔗
Returns a statistic about the rendering engine which can be used for performance profiling. This is separated into render pass types, each of them having the same infos you can query (different passes will return different values).
See also get_rendering_info(), which returns global information across all viewports.
Note: Viewport rendering information is not available until at least 2 frames have been rendered by the engine. If rendering information is not available, viewport_get_render_info() returns 0. To print rendering information in _ready() successfully, use the following:
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 🔗
Returns the render target for the viewport.
RID viewport_get_texture(viewport: RID) const 🔗
Devuelve el último fotograma renderizado del viewport.
ViewportUpdateMode viewport_get_update_mode(viewport: RID) const 🔗
Returns the viewport's update mode.
Warning: Calling this from any thread other than the rendering thread will be detrimental to performance.
void viewport_remove_canvas(viewport: RID, canvas: RID) 🔗
Detaches a viewport from a canvas.
void viewport_set_active(viewport: RID, active: bool) 🔗
Si es true, activa la ventana de visualización, si no, la desactiva.
void viewport_set_anisotropic_filtering_level(viewport: RID, anisotropic_filtering_level: ViewportAnisotropicFiltering) 🔗
Sets the maximum number of samples to take when using anisotropic filtering on textures (as a power of two). A higher sample count will result in sharper textures at oblique angles, but is more expensive to compute. A value of 0 forcibly disables anisotropic filtering, even on materials where it is enabled.
The anisotropic filtering level also affects decals and light projectors if they are configured to use anisotropic filtering. See ProjectSettings.rendering/textures/decals/filter and ProjectSettings.rendering/textures/light_projectors/filter.
Note: In 3D, for this setting to have an effect, set BaseMaterial3D.texture_filter to BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC or BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC on materials.
Note: In 2D, for this setting to have an effect, set CanvasItem.texture_filter to CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC or CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC on the CanvasItem node displaying the texture (or in CanvasTexture). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference.
void viewport_set_canvas_cull_mask(viewport: RID, canvas_cull_mask: int) 🔗
Sets the rendering mask associated with this Viewport. Only CanvasItem nodes with a matching rendering visibility layer will be rendered by this Viewport.
void viewport_set_canvas_stacking(viewport: RID, canvas: RID, layer: int, sublayer: int) 🔗
Sets the stacking order for a viewport's canvas.
layer is the actual canvas layer, while sublayer specifies the stacking order of the canvas among those in the same layer.
Note: layer should be between CANVAS_LAYER_MIN and CANVAS_LAYER_MAX (inclusive). Any other value will wrap around.
void viewport_set_canvas_transform(viewport: RID, canvas: RID, offset: Transform2D) 🔗
Establece la transformación del canvas de un viewport.
void viewport_set_clear_mode(viewport: RID, clear_mode: ViewportClearMode) 🔗
Sets the clear mode of a viewport.
void viewport_set_debug_draw(viewport: RID, draw: ViewportDebugDraw) 🔗
Sets the debug draw mode of a viewport.
void viewport_set_default_canvas_item_texture_filter(viewport: RID, filter: CanvasItemTextureFilter) 🔗
Establece el modo de filtrado de textura predeterminado para el viewport RID especificado.
void viewport_set_default_canvas_item_texture_repeat(viewport: RID, repeat: CanvasItemTextureRepeat) 🔗
Establece el modo de repetición de textura predeterminado para el viewport RID especificado.
void viewport_set_disable_2d(viewport: RID, disable: bool) 🔗
Si es true, el canvas del viewport (es decir, los elementos 2D y GUI) no se renderiza.
void viewport_set_disable_3d(viewport: RID, disable: bool) 🔗
Si es true, los elementos 3D del viewport no se renderizan.
void viewport_set_environment_mode(viewport: RID, mode: ViewportEnvironmentMode) 🔗
Establece el modo de entorno del viewport, lo que permite activar o desactivar la renderización del entorno 3D sobre el canvas 2D. Cuando está desactivado, el 2D no se verá afectado por el entorno. Cuando está activado, el 2D se verá afectado por el entorno si el modo de fondo del entorno es ENV_BG_CANVAS. El comportamiento predeterminado es heredar el ajuste del padre del viewport. Si el padre superior también está establecido en VIEWPORT_ENVIRONMENT_INHERIT, entonces el comportamiento será el mismo que si estuviera establecido en VIEWPORT_ENVIRONMENT_ENABLED.
void viewport_set_fsr_sharpness(viewport: RID, sharpness: float) 🔗
Determines how sharp the upscaled image will be when using the FSR upscaling mode. Sharpness halves with every whole number. Values go from 0.0 (sharpest) to 2.0. Values above 2.0 won't make a visible difference.
void viewport_set_global_canvas_transform(viewport: RID, transform: Transform2D) 🔗
Establece la matriz de transformación global del Viewport.
void viewport_set_measure_render_time(viewport: RID, enable: bool) 🔗
Establece la medición para el viewport RID dado (obtenido usando Viewport.get_viewport_rid()). Una vez habilitado, viewport_get_measured_render_time_cpu() y viewport_get_measured_render_time_gpu() devolverán valores mayores que 0.0 cuando se consulten con el viewport dado.
void viewport_set_msaa_2d(viewport: RID, msaa: ViewportMSAA) 🔗
Establece el modo de antialiasing multisample para 2D/Canvas en el viewport RID especificado. Equivalente a ProjectSettings.rendering/anti_aliasing/quality/msaa_2d o Viewport.msaa_2d.
void viewport_set_msaa_3d(viewport: RID, msaa: ViewportMSAA) 🔗
Establece el modo de antialiasing multisample para 3D en el viewport RID especificado. Equivalente a ProjectSettings.rendering/anti_aliasing/quality/msaa_3d o Viewport.msaa_3d.
void viewport_set_occlusion_culling_build_quality(quality: ViewportOcclusionCullingBuildQuality) 🔗
Establece el ProjectSettings.rendering/occlusion_culling/bvh_build_quality para usar en el "occlusion culling". Este parámetro es global y no se puede establecer por cada viewport.
void viewport_set_occlusion_rays_per_thread(rays_per_thread: int) 🔗
Establece el ProjectSettings.rendering/occlusion_culling/occlusion_rays_per_thread para usar en el "occlusion culling". Este parámetro es global y no se puede establecer por cada viewport.
void viewport_set_parent_viewport(viewport: RID, parent_viewport: RID) 🔗
Establece el padre del viewport al viewport especificado por el parent_viewport RID.
void viewport_set_positional_shadow_atlas_quadrant_subdivision(viewport: RID, quadrant: int, subdivision: int) 🔗
Establece el número de subdivisiones a utilizar en el atlas de sombras especificado quadrant para sombras omnidireccionales y puntuales. Véase también Viewport.set_positional_shadow_atlas_quadrant_subdiv().
void viewport_set_positional_shadow_atlas_size(viewport: RID, size: int, use_16_bits: bool = false) 🔗
Sets the size of the shadow atlas's images (used for omni and spot lights) on the viewport specified by the viewport RID. The value is rounded up to the nearest power of 2. If use_16_bits is true, use 16 bits for the omni/spot shadow depth map. Enabling this results in shadows having less precision and may result in shadow acne, but can lead to performance improvements on some devices.
Note: If this is set to 0, no positional shadows will be visible at all. This can improve performance significantly on low-end systems by reducing both the CPU and GPU load (as fewer draw calls are needed to draw the scene without shadows).
void viewport_set_render_direct_to_screen(viewport: RID, enabled: bool) 🔗
If true, render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the screen_texture. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size.
void viewport_set_scaling_3d_mode(viewport: RID, scaling_3d_mode: ViewportScaling3DMode) 🔗
Sets the 3D resolution scaling mode. Bilinear scaling renders at different resolution to either undersample or supersample the viewport. FidelityFX Super Resolution 1.0, abbreviated to FSR, is an upscaling technology that produces high quality images at fast framerates by using a spatially aware upscaling algorithm. FSR is slightly more expensive than bilinear, but it produces significantly higher image quality. FSR should be used where possible.
void viewport_set_scaling_3d_scale(viewport: RID, scale: float) 🔗
Scales the 3D render buffer based on the viewport size uses an image filter specified in ViewportScaling3DMode to scale the output image to the full viewport size. Values lower than 1.0 can be used to speed up 3D rendering at the cost of quality (undersampling). Values greater than 1.0 are only valid for bilinear mode and can be used to improve 3D rendering quality at a high performance cost (supersampling). See also ViewportMSAA for multi-sample antialiasing, which is significantly cheaper but only smoothens the edges of polygons.
When using FSR upscaling, AMD recommends exposing the following values as preset options to users "Ultra Quality: 0.77", "Quality: 0.67", "Balanced: 0.59", "Performance: 0.5" instead of exposing the entire scale.
void viewport_set_scenario(viewport: RID, scenario: RID) 🔗
Establece el escenario de un viewport. El escenario contiene información sobre el entorno, el atlas de reflexión, etc.
void viewport_set_screen_space_aa(viewport: RID, mode: ViewportScreenSpaceAA) 🔗
Establece el modo de antialiasing del espacio de pantalla del viewport. Equivalente a ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa o Viewport.screen_space_aa.
void viewport_set_sdf_oversize_and_scale(viewport: RID, oversize: ViewportSDFOversize, scale: ViewportSDFScale) 🔗
Establece el campo de distancia con signo 2D del viewport ProjectSettings.rendering/2d/sdf/oversize y ProjectSettings.rendering/2d/sdf/scale. Esto se utiliza al muestrear el campo de distancia con signo en los shaders de CanvasItem así como la colisión de GPUParticles2D. Esto no es utilizado por SDFGI en el renderizado 3D.
void viewport_set_size(viewport: RID, width: int, height: int) 🔗
Establece el ancho y la altura del viewport en píxeles.
void viewport_set_snap_2d_transforms_to_pixel(viewport: RID, enabled: bool) 🔗
Si es true, las transformaciones de los elementos del canvas (es decir, la posición de origen) se ajustan al píxel más cercano al renderizar. Esto puede llevar a una apariencia más nítida a costa de un movimiento menos suave, especialmente cuando el suavizado de Camera2D está habilitado. Equivalente a ProjectSettings.rendering/2d/snap/snap_2d_transforms_to_pixel.
void viewport_set_snap_2d_vertices_to_pixel(viewport: RID, enabled: bool) 🔗
Si es true, los vértices de los elementos del canvas (es decir, los puntos del polígono) se ajustan al píxel más cercano al renderizar. Esto puede llevar a una apariencia más nítida a costa de un movimiento menos suave, especialmente cuando el suavizado de Camera2D está habilitado. Equivalente a ProjectSettings.rendering/2d/snap/snap_2d_vertices_to_pixel.
void viewport_set_texture_mipmap_bias(viewport: RID, mipmap_bias: float) 🔗
Afecta a la nitidez final de la textura leyendo de un mipmap inferior o superior (también llamado "sesgo LOD de la textura"). Los valores negativos hacen que las texturas mipmapeadas sean más nítidas pero más granuladas cuando se ven a distancia, mientras que los valores positivos hacen que las texturas mipmapeadas se vean más borrosas (incluso de cerca). Para obtener texturas más nítidas a distancia sin introducir demasiada granulosidad, establece este valor entre -0.75 y 0.0. La activación del antialiasing temporal (ProjectSettings.rendering/anti_aliasing/quality/use_taa) puede ayudar a reducir la granulosidad visible cuando se utiliza un sesgo de mipmap negativo.
Nota: Cuando el modo de escalado 3D está establecido en FSR 1.0, este valor se utiliza para ajustar el sesgo automático de mipmap que se calcula internamente basándose en el factor de escala. La fórmula para esto es -log2(1.0 / escala) + mipmap_bias.
void viewport_set_transparent_background(viewport: RID, enabled: bool) 🔗
Si es true, el viewport hace que su fondo sea transparente.
void viewport_set_update_mode(viewport: RID, update_mode: ViewportUpdateMode) 🔗
Establece cuándo debe actualizarse el viewport.
void viewport_set_use_debanding(viewport: RID, enable: bool) 🔗
Equivalent to Viewport.use_debanding. See also ProjectSettings.rendering/anti_aliasing/quality/use_debanding.
void viewport_set_use_hdr_2d(viewport: RID, enabled: bool) 🔗
If true, 2D rendering will use a high dynamic range (HDR) RGBA16 format framebuffer. Additionally, 2D rendering will be performed on linear values and will be converted using the appropriate transfer function immediately before blitting to the screen (if the Viewport is attached to the screen).
Practically speaking, this means that the end result of the Viewport will not be clamped to the 0-1 range and can be used in 3D rendering without color encoding adjustments. This allows 2D rendering to take advantage of effects requiring high dynamic range (e.g. 2D glow) as well as substantially improves the appearance of effects requiring highly detailed gradients. This setting has the same effect as Viewport.use_hdr_2d.
void viewport_set_use_occlusion_culling(viewport: RID, enable: bool) 🔗
If true, enables occlusion culling on the specified viewport. Equivalent to ProjectSettings.rendering/occlusion_culling/use_occlusion_culling.
void viewport_set_use_taa(viewport: RID, enable: bool) 🔗
If true, use temporal antialiasing. Equivalent to ProjectSettings.rendering/anti_aliasing/quality/use_taa or Viewport.use_taa.
void viewport_set_use_xr(viewport: RID, use_xr: bool) 🔗
If true, the viewport uses augmented or virtual reality technologies. See XRInterface.
void viewport_set_vrs_mode(viewport: RID, mode: ViewportVRSMode) 🔗
Sets the Variable Rate Shading (VRS) mode for the viewport. If the GPU does not support VRS, this property is ignored. Equivalent to ProjectSettings.rendering/vrs/mode.
void viewport_set_vrs_texture(viewport: RID, texture: RID) 🔗
The texture to use when the VRS mode is set to VIEWPORT_VRS_TEXTURE. Equivalent to ProjectSettings.rendering/vrs/texture.
void viewport_set_vrs_update_mode(viewport: RID, mode: ViewportVRSUpdateMode) 🔗
Sets the update mode for Variable Rate Shading (VRS) for the viewport. VRS requires the input texture to be converted to the format usable by the VRS method supported by the hardware. The update mode defines how often this happens. If the GPU does not support VRS, or VRS is not enabled, this property is ignored.
If set to VIEWPORT_VRS_UPDATE_ONCE, the input texture is copied once and the mode is changed to VIEWPORT_VRS_UPDATE_DISABLED.
RID visibility_notifier_create() 🔗
Creates a new 3D visibility notifier object and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all visibility_notifier_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
To place in a scene, attach this notifier to an instance using instance_set_base() using the returned RID.
Note: The equivalent node is VisibleOnScreenNotifier3D.
void visibility_notifier_set_aabb(notifier: RID, aabb: AABB) 🔗
There is currently no description for this method. Please help us by contributing one!
void visibility_notifier_set_callbacks(notifier: RID, enter_callable: Callable, exit_callable: Callable) 🔗
There is currently no description for this method. Please help us by contributing one!
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) 🔗
There is currently no description for this method. Please help us by contributing one!
Creates a new voxel-based global illumination object and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all voxel_gi_* RenderingServer functions.
Once finished with your RID, you will want to free the RID using the RenderingServer's free_rid() method.
Note: The equivalent node is VoxelGI.
PackedByteArray voxel_gi_get_data_cells(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedByteArray voxel_gi_get_distance_field(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedInt32Array voxel_gi_get_level_counts(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
PackedByteArray voxel_gi_get_octree_cells(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
Vector3i voxel_gi_get_octree_size(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
Transform3D voxel_gi_get_to_cell_xform(voxel_gi: RID) const 🔗
There is currently no description for this method. Please help us by contributing one!
void voxel_gi_set_baked_exposure_normalization(voxel_gi: RID, baked_exposure: float) 🔗
Used to inform the renderer what exposure normalization value was used while baking the voxel gi. This value will be used and modulated at run time to ensure that the voxel gi maintains a consistent level of exposure even if the scene-wide exposure normalization is changed at run time. For more information see camera_attributes_set_exposure().
void voxel_gi_set_bias(voxel_gi: RID, bias: float) 🔗
Establece el valor de VoxelGIData.bias a usar en el RID del voxel_gi especificado.
void voxel_gi_set_dynamic_range(voxel_gi: RID, range: float) 🔗
Establece el valor de VoxelGIData.dynamic_range a usar en el RID del voxel_gi especificado.
void voxel_gi_set_energy(voxel_gi: RID, energy: float) 🔗
Establece el valor de VoxelGIData.energy a usar en el RID del voxel_gi especificado.
void voxel_gi_set_interior(voxel_gi: RID, enable: bool) 🔗
Establece el valor de VoxelGIData.interior a usar en el RID del voxel_gi especificado.
void voxel_gi_set_normal_bias(voxel_gi: RID, bias: float) 🔗
Establece el valor de VoxelGIData.normal_bias a usar en el RID del voxel_gi especificado.
void voxel_gi_set_propagation(voxel_gi: RID, amount: float) 🔗
Establece el valor de VoxelGIData.propagation a usar en el RID del voxel_gi especificado.
void voxel_gi_set_quality(quality: VoxelGIQuality) 🔗
Establece el valor de ProjectSettings.rendering/global_illumination/voxel_gi/quality a usar al renderizar. Este parámetro es global y no puede establecerse para cada VoxelGI.
void voxel_gi_set_use_two_bounces(voxel_gi: RID, enable: bool) 🔗
Establece el valor de VoxelGIData.use_two_bounces a usar en el RID del voxel_gi especificado.