Light3D

Hereda: VisualInstance3D < Node3D < Node < Object

Heredado por: DirectionalLight3D, OmniLight3D, SpotLight3D

Proporciona una clase base para diferentes tipos de nodos de luz.

Descripción

Light3D es la clase base abstracta para los nodos de luz. Dado que no se puede instanciar, no debe usarse directamente. Otros tipos de nodos de luz heredan de ella. Light3D contiene las variables y parámetros comunes utilizados para la iluminación.

Tutoriales

Propiedades

float

distance_fade_begin

40.0

bool

distance_fade_enabled

false

float

distance_fade_length

10.0

float

distance_fade_shadow

50.0

bool

editor_only

false

float

light_angular_distance

0.0

BakeMode

light_bake_mode

2

Color

light_color

Color(1, 1, 1, 1)

int

light_cull_mask

4294967295

float

light_energy

1.0

float

light_indirect_energy

1.0

float

light_intensity_lumens

float

light_intensity_lux

bool

light_negative

false

Texture2D

light_projector

float

light_size

0.0

float

light_specular

1.0

float

light_temperature

float

light_volumetric_fog_energy

1.0

float

shadow_bias

0.1

float

shadow_blur

1.0

int

shadow_caster_mask

4294967295

bool

shadow_enabled

false

float

shadow_normal_bias

2.0

float

shadow_opacity

1.0

bool

shadow_reverse_cull_face

false

float

shadow_transmittance_bias

0.05

Métodos

Color

get_correlated_color() const

float

get_param(param: Param) const

void

set_param(param: Param, value: float)

Enumeraciones

enum Param: 🔗

Param PARAM_ENERGY = 0

Constante para acceder a light_energy.

Param PARAM_INDIRECT_ENERGY = 1

Constante para acceder a light_indirect_energy.

Param PARAM_VOLUMETRIC_FOG_ENERGY = 2

Constante para acceder a light_volumetric_fog_energy.

Param PARAM_SPECULAR = 3

Constante para acceder a light_specular.

Param PARAM_RANGE = 4

Constante para acceder a OmniLight3D.omni_range o SpotLight3D.spot_range.

Param PARAM_SIZE = 5

Constante para acceder a light_size.

Param PARAM_ATTENUATION = 6

Constante para acceder a OmniLight3D.omni_attenuation o SpotLight3D.spot_attenuation.

Param PARAM_SPOT_ANGLE = 7

Constante para acceder a SpotLight3D.spot_angle.

Param PARAM_SPOT_ATTENUATION = 8

Constante para acceder a SpotLight3D.spot_angle_attenuation.

Param PARAM_SHADOW_MAX_DISTANCE = 9

Constante para acceder a DirectionalLight3D.directional_shadow_max_distance.

Param PARAM_SHADOW_SPLIT_1_OFFSET = 10

Constante para acceder a DirectionalLight3D.directional_shadow_split_1.

Param PARAM_SHADOW_SPLIT_2_OFFSET = 11

Constante para acceder a DirectionalLight3D.directional_shadow_split_2.

Param PARAM_SHADOW_SPLIT_3_OFFSET = 12

Constante para acceder a DirectionalLight3D.directional_shadow_split_3.

Param PARAM_SHADOW_FADE_START = 13

Constante para acceder a DirectionalLight3D.directional_shadow_fade_start.

Param PARAM_SHADOW_NORMAL_BIAS = 14

Constante para acceder a shadow_normal_bias.

Param PARAM_SHADOW_BIAS = 15

Constante para acceder a shadow_bias.

Param PARAM_SHADOW_PANCAKE_SIZE = 16

Constante para acceder a DirectionalLight3D.directional_shadow_pancake_size.

Param PARAM_SHADOW_OPACITY = 17

Constante para acceder a shadow_opacity.

Param PARAM_SHADOW_BLUR = 18

Constante para acceder a shadow_blur.

Param PARAM_TRANSMITTANCE_BIAS = 19

Constante para acceder a shadow_transmittance_bias.

Param PARAM_INTENSITY = 20

Constante para acceder a light_intensity_lumens y light_intensity_lux. Solo se usa cuando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units es true.

Param PARAM_MAX = 21

Representa el tamaño del enum Param.

enum BakeMode: 🔗

BakeMode BAKE_DISABLED = 0

La luz se ignora al procesar. Este es el modo más rápido, pero la luz no se tendrá en cuenta al procesar la iluminación global. Este modo generalmente debería usarse para luces dinámicas que cambian rápidamente, ya que el efecto de la iluminación global es menos notable en esas luces.

Nota: Ocultar una luz no afecta el procesado de LightmapGI. Ocultar una luz seguirá afectando el procesado de VoxelGI y SDFGI (ver Environment.sdfgi_enabled).

BakeMode 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 grandes cambios, como encender y apagar una luz.

Nota: La luz no se procesa en LightmapGI si editor_only es true.

BakeMode 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 y la iluminación global se actualiza en tiempo real. La apariencia de iluminación global de la luz será ligeramente diferente en comparación con BAKE_STATIC. Esto tiene un mayor costo de rendimiento en comparación con BAKE_STATIC. Cuando se usa SDFGI, la velocidad de actualización de las luces dinámicas se ve afectada por ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.

Descripciones de Propiedades

float distance_fade_begin = 40.0 🔗

  • void set_distance_fade_begin(value: float)

  • float get_distance_fade_begin()

La distancia desde la cámara a la que la luz comienza a desvanecerse (en unidades 3D).

Nota: Solo es efectivo para OmniLight3D y SpotLight3D.

bool distance_fade_enabled = false 🔗

  • void set_enable_distance_fade(value: bool)

  • bool is_distance_fade_enabled()

Si es true, la luz se desvanecerá suavemente cuando esté lejos de la Camera3D activa, comenzando en distance_fade_begin. Esto actúa como una forma de nivel de detalle (LOD). La luz se desvanecerá sobre distance_fade_begin + distance_fade_length, después de lo cual se eliminará y no se enviará al shader en absoluto. Utiliza esto para reducir el número de luces activas en una escena y, por lo tanto, mejorar el rendimiento.

Nota: Solo es efectivo para OmniLight3D y SpotLight3D.

float distance_fade_length = 10.0 🔗

  • void set_distance_fade_length(value: float)

  • float get_distance_fade_length()

Distancia sobre la cual la luz y su sombra se desvanecen. La energía de la luz y la opacidad de la sombra se reducen progresivamente a lo largo de esta distancia y es completamente invisible al final.

Nota: Solo es efectivo para OmniLight3D y SpotLight3D.

float distance_fade_shadow = 50.0 🔗

  • void set_distance_fade_shadow(value: float)

  • float get_distance_fade_shadow()

La distancia desde la cámara a la que se corta la sombra de la luz (en unidades 3D). Establece esto a un valor inferior a distance_fade_begin + distance_fade_length para mejorar aún más el rendimiento, ya que el renderizado de sombras suele ser más caro que el renderizado de la propia luz.

Nota: Solo es efectivo para OmniLight3D y SpotLight3D, y solo cuando shadow_enabled es true.

bool editor_only = false 🔗

  • void set_editor_only(value: bool)

  • bool is_editor_only()

Si es true, la luz solo aparece en el editor y no será visible en tiempo de ejecución. Si es true, la luz nunca se procesará en LightmapGI independientemente de su light_bake_mode.

float light_angular_distance = 0.0 🔗

El tamaño angular de la luz en grados. Aumentar esto hará que las sombras sean más suaves a mayores distancias (también llamadas sombras suaves de porcentaje más cercano, o PCSS). Solo disponible para DirectionalLight3Ds. Como referencia, el Sol desde la Tierra es aproximadamente 0.5. Aumentar este valor por encima de 0.0 para las luces con sombras habilitadas tendrá un costo de rendimiento notable debido a PCSS.

Nota: light_angular_distance no se ve afectado por Node3D.scale (la escala de la luz o la escala de su padre).

Nota: PCSS para luces direccionales solo se admite en el método de renderizado Forward+, no en Mobile o Compatibility.

BakeMode light_bake_mode = 2 🔗

El modo de procesado de la luz. Esto afectará a las técnicas de iluminación global que tienen un efecto en el renderizado de la luz.

Nota: El modo de iluminación global de las mallas también afectará al renderizado de la iluminación global. Véase GeometryInstance3D.gi_mode.

Color light_color = Color(1, 1, 1, 1) 🔗

El color de la luz en el espacio de color sRGB no lineal. Se puede usar un color sobrebrillante para lograr un resultado equivalente a aumentar la light_energy de la luz.

int light_cull_mask = 4294967295 🔗

  • void set_cull_mask(value: int)

  • int get_cull_mask()

The light will affect objects in the selected layers.

Note: The light cull mask is ignored by VoxelGI, SDFGI, LightmapGI, and volumetric fog. These will always render lights in a way that ignores the cull mask. See also VisualInstance3D.layers.

float light_energy = 1.0 🔗

El multiplicador de fuerza de la luz (esta no es una unidad física). Para OmniLight3D y SpotLight3D, cambiar este valor solo cambiará la intensidad del color de la luz, no el radio de la luz.

float light_indirect_energy = 1.0 🔗

Multiplicador secundario utilizado con luz indirecta (rebotes de luz). Se utiliza con VoxelGI y SDFGI (véase Environment.sdfgi_enabled).

Nota: Esta propiedad se ignora si light_energy es igual a 0.0, ya que la luz no estará presente en absoluto en el shader de GI.

float light_intensity_lumens 🔗

Utilizado por las luces posicionales (OmniLight3D y SpotLight3D) cuando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units es true. Establece la intensidad de la fuente de luz medida en lúmenes. Los lúmenes son una medida del flujo luminoso, que es la cantidad total de luz visible emitida por una fuente de luz por unidad de tiempo.

Para SpotLight3Ds, asumimos que el área fuera del cono visible está rodeada por un material perfecto que absorbe la luz. En consecuencia, el brillo aparente del área del cono no cambia a medida que el cono aumenta y disminuye de tamaño.

Una bombilla doméstica típica puede oscilar entre 600 y 1200 lúmenes, una vela tiene unos 13 lúmenes, mientras que una farola puede tener aproximadamente 60.000 lúmenes.

float light_intensity_lux 🔗

Utilizado por DirectionalLight3Ds cuando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units es true. Establece la intensidad de la fuente de luz medida en Lux. Lux es una medida del flujo luminoso por unidad de área, es igual a un lumen por metro cuadrado. Lux es la medida de cuánta luz golpea una superficie en un momento dado.

En un día claro y soleado, una superficie a la luz directa del sol puede tener aproximadamente 100,000 lux, una habitación típica en una casa puede tener aproximadamente 50 lux, mientras que el suelo iluminado por la luna puede tener aproximadamente 0.1 lux.

bool light_negative = false 🔗

  • void set_negative(value: bool)

  • bool is_negative()

Si es true, el efecto de la luz se invierte, oscureciendo áreas y proyectando sombras brillantes.

Texture2D light_projector 🔗

Texture2D proyectada por la luz. shadow_enabled debe estar activado para que el proyector funcione. Los proyectores de luz hacen que la luz aparezca como si brillara a través de un objeto coloreado pero transparente, casi como la luz que brilla a través de vidrieras.

Nota: A diferencia de BaseMaterial3D, cuyo modo de filtro se puede ajustar por material, el modo de filtro para las texturas del proyector de luz se establece globalmente con ProjectSettings.rendering/textures/light_projectors/filter.

Nota: Las texturas del proyector de luz solo se admiten en los métodos de renderizado Forward+ y Mobile, no en Compatibility.

float light_size = 0.0 🔗

El tamaño de la luz en unidades de Godot. Solo disponible para OmniLight3Ds y SpotLight3Ds. Aumentar este valor hará que la luz se desvanezca más lentamente y que las sombras aparezcan más borrosas (también llamadas sombras suaves de porcentaje más cercano, o PCSS). Esto se puede usar para simular luces de área hasta cierto punto. Aumentar este valor por encima de 0.0 para las luces con sombras habilitadas tendrá un costo de rendimiento notable debido a PCSS.

Nota: light_size no se ve afectado por Node3D.scale (la escala de la luz o la escala de su padre).

Nota: PCSS para luces posicionales solo se admite en los métodos de renderizado Forward+ y Mobile, no en Compatibility.

float light_specular = 1.0 🔗

La intensidad de la mancha especular en los objetos afectados por la luz. En 0, la luz se convierte en una luz difusa pura. Cuando no se emite, puede utilizarse para evitar reflejos poco realistas al colocar las luces sobre una superficie emisora.

float light_temperature 🔗

  • void set_temperature(value: float)

  • float get_temperature()

Establece la temperatura de color de la fuente de luz, medida en Kelvin. Esto se utiliza para calcular una temperatura de color correlacionada que tiñe el light_color.

El sol en un día nublado es de aproximadamente 6500 Kelvin, en un día despejado está entre 5500 y 6000 Kelvin, y en un día despejado al amanecer o al atardecer varía alrededor de 1850 Kelvin.

float light_volumetric_fog_energy = 1.0 🔗

Multiplicador secundario multiplicado con light_energy luego usado con la niebla volumétrica del Environment (si está habilitada). Si se establece en 0.0, se omitirá el cálculo de la niebla volumétrica para esta luz, lo que puede mejorar el rendimiento para grandes cantidades de luces cuando la niebla volumétrica está habilitada.

Nota: Para evitar que los efectos de luz dinámicos de corta duración interactúen mal con la niebla volumétrica, las luces utilizadas en esos efectos deben tener light_volumetric_fog_energy establecido en 0.0 a menos que Environment.volumetric_fog_temporal_reprojection_enabled esté deshabilitado (o a menos que la cantidad de reproyección se reduzca significativamente).

float shadow_bias = 0.1 🔗

Se usa para ajustar la apariencia de las sombras. Un valor demasiado pequeño da como resultado una sombra propia ("shadow acne"), mientras que un valor demasiado grande hace que las sombras se separen de las ruedas ("peter-panning"). Ajústalo según sea necesario.

float shadow_blur = 1.0 🔗

Difumina los bordes de la sombra. Se puede usar para ocultar artefactos de píxeles en mapas de sombras de baja resolución. Un valor alto puede afectar el rendimiento, hacer que las sombras parezcan granuladas y puede causar otros artefactos no deseados. Intenta mantenerte lo más cerca posible del valor predeterminado.

int shadow_caster_mask = 4294967295 🔗

  • void set_shadow_caster_mask(value: int)

  • int get_shadow_caster_mask()

La luz solo proyectará sombras utilizando objetos en las capas seleccionadas.

bool shadow_enabled = false 🔗

  • void set_shadow(value: bool)

  • bool has_shadow()

Si es true, la luz proyectará sombras en tiempo real. Esto tiene un costo de rendimiento significativo. Solo habilita el renderizado de sombras cuando haga una diferencia notable en la apariencia de la escena, y considera usar distance_fade_enabled para ocultar la luz cuando esté lejos de la Camera3D.

float shadow_normal_bias = 2.0 🔗

Desplaza la búsqueda en el mapa de sombras por la normal del objeto. Esto se puede usar para reducir los artefactos de auto-sombreado sin usar shadow_bias. En la práctica, este valor debe ajustarse junto con shadow_bias para reducir los artefactos tanto como sea posible.

float shadow_opacity = 1.0 🔗

La opacidad a usar al renderizar el mapa de sombras de la luz. Los valores inferiores a 1.0 hacen que la luz aparezca a través de las sombras. Esto se puede usar para simular la iluminación global a un bajo costo de rendimiento.

bool shadow_reverse_cull_face = false 🔗

  • void set_shadow_reverse_cull_face(value: bool)

  • bool get_shadow_reverse_cull_face()

Si es true, invierte el descarte de caras traseras de la malla. Esto puede ser útil cuando tienes una malla plana que tiene una luz detrás de ella. Si necesitas proyectar una sombra en ambos lados de la malla, establece la malla para usar sombras de doble cara con GeometryInstance3D.SHADOW_CASTING_SETTING_DOUBLE_SIDED.

float shadow_transmittance_bias = 0.05 🔗

There is currently no description for this property. Please help us by contributing one!

Descripciones de Métodos

Color get_correlated_color() const 🔗

Devuelve el Color de un cuerpo negro idealizado a la light_temperature dada. Este valor se calcula internamente basándose en la light_temperature. Este Color se multiplica por light_color antes de enviarse al RenderingServer.

float get_param(param: Param) const 🔗

Devuelve el valor del parámetro Param especificado.

void set_param(param: Param, value: float) 🔗

Establece el valor del parámetro Param especificado.