Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Light3D
Eredita: VisualInstance3D < Node3D < Node < Object
Ereditato da: AreaLight3D, DirectionalLight3D, OmniLight3D, SpotLight3D
Fornisce una classe di base per diversi tipi di nodi luce.
Descrizione
Light3D è la classe di base astratta per i nodi di luce. Poiché non può essere istanziata, non dovrebbe essere utilizzata direttamente. Altri tipi di nodi di luce ereditano da essa. Light3D contiene le variabili e i parametri comuni utilizzati per l'illuminazione.
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Metodi
get_correlated_color() const |
|
void |
Enumerazioni
enum Param: 🔗
Param PARAM_ENERGY = 0
Costante per accedere a light_energy.
Param PARAM_INDIRECT_ENERGY = 1
Costante per accedere a light_indirect_energy.
Param PARAM_VOLUMETRIC_FOG_ENERGY = 2
Costante per accedere a light_volumetric_fog_energy.
Param PARAM_SPECULAR = 3
Costante per accedere a light_specular.
Param PARAM_RANGE = 4
Costante per accedere a OmniLight3D.omni_range o SpotLight3D.spot_range.
Param PARAM_SIZE = 5
Costante per accedere a light_size.
Param PARAM_ATTENUATION = 6
Costante per accedere a OmniLight3D.omni_attenuation o SpotLight3D.spot_attenuation.
Param PARAM_SPOT_ANGLE = 7
Costante per accedere a SpotLight3D.spot_angle.
Param PARAM_SPOT_ATTENUATION = 8
Costante per accedere a SpotLight3D.spot_angle_attenuation.
Param PARAM_SHADOW_MAX_DISTANCE = 9
Costante per accedere a DirectionalLight3D.directional_shadow_max_distance.
Param PARAM_SHADOW_SPLIT_1_OFFSET = 10
Costante per accedere a DirectionalLight3D.directional_shadow_split_1.
Param PARAM_SHADOW_SPLIT_2_OFFSET = 11
Costante per accedere a DirectionalLight3D.directional_shadow_split_2.
Param PARAM_SHADOW_SPLIT_3_OFFSET = 12
Costante per accedere a DirectionalLight3D.directional_shadow_split_3.
Param PARAM_SHADOW_FADE_START = 13
Costante per accedere a DirectionalLight3D.directional_shadow_fade_start.
Param PARAM_SHADOW_NORMAL_BIAS = 14
Costante per accedere a shadow_normal_bias.
Param PARAM_SHADOW_BIAS = 15
Costante per accedere a shadow_bias.
Param PARAM_SHADOW_PANCAKE_SIZE = 16
Costante per accedere a DirectionalLight3D.directional_shadow_pancake_size.
Param PARAM_SHADOW_OPACITY = 17
Costante per accedere a shadow_opacity.
Param PARAM_SHADOW_BLUR = 18
Costante per accedere a shadow_blur.
Param PARAM_TRANSMITTANCE_BIAS = 19
Costante per accedere a shadow_transmittance_bias.
Param PARAM_INTENSITY = 20
Costante per accedere a light_intensity_lumens e light_intensity_lux. Usato solo quando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units è true.
Param PARAM_MAX = 21
Rappresenta la dimensione dell'enumerazione Param.
enum BakeMode: 🔗
BakeMode BAKE_DISABLED = 0
La luce è ignorata durante il precalcolo. Questa è la modalità più veloce, ma la luce sarà presa in considerazione durante il precalcolo dell'illuminazione globale. Questa modalità si dovrebbe generalmente utilizzare per luci dinamiche che cambiano rapidamente, poiché l'effetto dell'illuminazione globale è meno evidente su tali luci.
Nota: Nascondere una luce non influisce sul precalcolo di LightmapGI. Nascondere una luce influenzerà comunque il precalcolo di VoxelGI e di SDFGI (vedi Environment.sdfgi_enabled).
BakeMode BAKE_STATIC = 1
La luce è presa in considerazione nel precalcolo statico (VoxelGI, LightmapGI, SDFGI (Environment.sdfgi_enabled)). La luce può essere spostata o modificata, ma la sua illuminazione globale non sarà aggiornata in tempo reale. Questo è adatto per lievi cambiamenti (come lo sfarfallio di una torcia), ma non solitamente per grandi cambiamenti come l'accensione e lo spegnimento di una luce.
Nota: La luce non è precalcolata in LightmapGI se editor_only è true.
BakeMode BAKE_DYNAMIC = 2
La luce è presa in considerazione nel precalcolo dinamico (solo VoxelGI e SDFGI (Environment.sdfgi_enabled)). La luce può essere spostata o modificata e l'illuminazione globale sarà aggiornata in tempo reale. L'aspetto dell'illuminazione globale della luce sarà leggermente diverso rispetto a BAKE_STATIC. Ciò ha un costo in termini di prestazioni maggiore rispetto a BAKE_STATIC. Quando si utilizza SDFGI, la frequenza di aggiornamento delle luci dinamiche è influenzata da ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.
Descrizioni delle proprietà
float distance_fade_begin = 40.0 🔗
Distanza dalla telecamera alla quale la luce inizia a svanire (in unità 3D).
Nota: Efficace solo per OmniLight3D e SpotLight3D.
bool distance_fade_enabled = false 🔗
Se true, la luce svanirà gradualmente quando è lontana dalla Camera3D attiva a partire da distance_fade_begin. Questo agisce come una forma di livello di dettaglio (LOD). La luce svanirà su distance_fade_begin + distance_fade_length, dopodiché sarà scartata e non sarà inviata allo shader. Usalo per ridurre il numero di luci attive in una scena e quindi migliorare le prestazioni.
Nota: Efficace solo per OmniLight3D e SpotLight3D.
float distance_fade_length = 10.0 🔗
Distanza su cui la luce e la sua ombra svaniscono. L'energia della luce e l'opacità dell'ombra sono ridotti progressivamente su questa distanza, fino a diventare completamente invisibili.
Nota: Efficace solo per OmniLight3D e SpotLight3D.
float distance_fade_shadow = 50.0 🔗
La distanza dalla telecamera a cui l'ombra della luce è interrotta (in unità 3D). Imposta questo valore su un valore inferiore a distance_fade_begin + distance_fade_length per migliorare ulteriormente le prestazioni, poiché il rendering delle ombre è spesso più costoso del rendering della luce stessa.
Nota: Efficace solo per OmniLight3D e SpotLight3D e solo quando shadow_enabled è true.
Se true, la luce appare solo nell'editor e non sarà visibile in fase di esecuzione. Se true, la luce non sarà mai precalcolata nei LightmapGI, a prescindere dalla sua light_bake_mode.
float light_angular_distance = 0.0 🔗
La dimensione angolare della luce in gradi. Aumentando questo valore, le ombre saranno più morbide a distanze maggiori (chiamate anche ombre morbide percentuali più vicine, o PCSS). Disponibile solo per DirectionalLight3D. Per riferimento, il Sole dalla Terra è approssimativamente 0.5. Aumentare questo valore oltre 0.0 per luci con ombre abilitate avrà un costo di prestazioni notevole a causa di PCSS.
Nota: light_angular_distance non è influenzato da Node3D.scale (la scala della luce o la scala del suo genitore).
Nota: PCSS per luci direzionali è supportato solo nel metodo di rendering Forward+, non Mobile o Compatibilità.
BakeMode light_bake_mode = 2 🔗
La modalità di precalcolo della luce. Ciò influirà sulle tecniche di illuminazione globale che influenzano il rendering della luce.
Nota: La modalità di illuminazione globale delle mesh influirà anche sul rendering dell'illuminazione globale. Vedi GeometryInstance3D.gi_mode.
Color light_color = Color(1, 1, 1, 1) 🔗
The light's color in nonlinear sRGB encoding. An overbright color can be used to achieve a result equivalent to increasing the light's light_energy.
int light_cull_mask = 4294967295 🔗
La luce influenzerà gli oggetti negli strati selezionati.
Nota: La maschera di culling della luce è ignorata da VoxelGI, SDFGI, LightmapGI e la nebbia volumetrica. Questi renderizzeranno sempre le luci in modo da ignorare la maschera di culling. Vedi anche VisualInstance3D.layers.
Il moltiplicatore di intensità della luce (non è un'unità fisica). Per OmniLight3D e SpotLight3D, la modifica di questo valore cambierà solo l'intensità del colore della luce, non il raggio della luce.
float light_indirect_energy = 1.0 🔗
Moltiplicatore secondario utilizzato con la luce indiretta (rimbalzi di luce). Utilizzato con VoxelGI e SDFGI (vedi Environment.sdfgi_enabled).
Nota: Questa proprietà è ignorata se light_energy è uguale a 0.0, poiché la luce non sarà affatto presente nello shader GI.
float light_intensity_lumens 🔗
Utilizzato dalle luci posizionali (OmniLight3D e SpotLight3D) quando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units è true. Imposta l'intensità della sorgente luminosa misurata in lumen. I lumen sono una misura del flusso luminoso, ovvero la quantità totale di luce visibile emessa da una sorgente luminosa per unità di tempo.
Per SpotLight3D, assumiamo che l'area esterna al cono visibile sia circondata da un materiale che assorbe perfettamente la luce. Di conseguenza, la luminosità apparente dell'area del cono non cambia quando il cono aumenta e diminuisce di dimensioni.
Una tipica lampadina domestica può variare da circa 600 lumen a 1.200 lumen, una candela è di circa 13 lumen, mentre un lampione può essere di circa 60.000 lumen.
Utilizzato da DirectionalLight3Ds quando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units è true. Imposta l'intensità della sorgente luminosa misurata in Lux. Lux è una misura del flusso luminoso per unità di area, è uguale a un lumen per metro quadrato. Lux è la misura di quanta luce colpisce una superficie in un determinato momento.
In una giornata limpida e soleggiata una superficie esposta alla luce solare diretta può essere di circa 100.000 lux, una stanza tipica di una casa può essere di circa 50 lux, mentre il terreno illuminato dalla luna può essere di circa 0,1 lux.
Se true, l'effetto della luce è invertito, scurendo aree e proiettando ombre luminose.
La Texture2D proiettata dalla luce. shadow_enabled deve essere attivo affinché il proiettore funzioni. I proiettori di luce fanno apparire la luce come se splendesse attraverso un oggetto colorato ma trasparente, quasi come la luce che splende attraverso una vetrata.
Nota: A differenza di BaseMaterial3D la cui modalità filtro può essere regolata in base al materiale, la modalità filtro per le texture del proiettore di luce è impostata globalmente con ProjectSettings.rendering/textures/light_projectors/filter.
Nota: Le texture del proiettore di luce sono supportate solo nei metodi di rendering Forward+ e Mobile, non Compatibilità.
The simulated size of the light in Godot units, affecting shading and shadows. For OmniLight3Ds and SpotLight3Ds, increasing this value simulates a spherical area light, expanding the size of specular highlights. If shadows are enabled, a penumbra is rendered, making shadows appear blurrier. For AreaLight3Ds, only the shadows are affected. Penumbras are simulated with percentage-closer soft shadows, or PCSS, which has a noticeable performance cost for values above 0.0.
Note: light_size is not affected by Node3D.scale (the light's scale or its parent's scale).
Note: PCSS for positional lights is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
L'intensità della macchia speculare negli oggetti influenzati dalla luce. A 0, la luce diventa una luce puramente diffusa. Se l'emissione non è precalcolata, questa può essere utilizzata per evitare riflessi poco realistici quando si posizionano le luci sopra una superficie emissiva.
Imposta la temperatura di colore della sorgente luminosa, misurata in Kelvin. Serve per calcolare una temperatura di colore correlata che tinge il light_color.
Il sole in una giornata nuvolosa è di circa 6500 Kelvin, in una giornata limpida è tra 5500 e 6000 Kelvin e in una giornata limpida all'alba o al tramonto varia fino a circa 1850 Kelvin.
float light_volumetric_fog_energy = 1.0 🔗
Moltiplicatore secondario moltiplicato con light_energy, quindi utilizzato con la nebbia volumetrica di Environment (se abilitata). Se impostato su 0.0, il calcolo della nebbia volumetrica sarà saltato per questa luce, il che può migliorare le prestazioni per grandi quantità di luci quando la nebbia volumetrica è abilitata.
Nota: Per evitare che gli effetti di luce dinamici di breve durata interagiscano male con la nebbia volumetrica, le luci usate in tali effetti dovrebbero avere light_volumetric_fog_energy impostato su 0.0 a meno che Environment.volumetric_fog_temporal_reprojection_enabled non sia disabilitato (o a meno che la quantità di riproiezione non sia notevolmente ridotta).
Utilizzato per regolare l'aspetto delle ombre. Un valore troppo piccolo provoca l'auto-ombreggiatura ("shadow acne"), mentre un valore troppo grande produce ombre separate dall'oggetto che le crea ("peter-panning"). Regola come necessario.
Sfoca i bordi dell'ombra. Può essere utilizzato per nascondere gli artefatti di pixel nelle mappe ombra a bassa risoluzione. Un valore elevato può influire sulle prestazioni, rende le ombre granulose e provocare altri artefatti indesiderati. Cerca di mantenere il valore il più vicino possibile a quello predefinito.
int shadow_caster_mask = 4294967295 🔗
La luce proietterà ombre solo sugli oggetti presenti negli strati selezionati.
Se true, la luce proietterà ombre in tempo reale. Ciò ha un costo significativo in termini di prestazioni. Abilita il rendering delle ombre solo quando fa una differenza evidente nell'aspetto della scena e considera di usare distance_fade_enabled per nascondere la luce quando è lontana dal Camera3D.
float shadow_normal_bias = 2.0 🔗
Compensa la ricerca nella mappa delle ombre in base alla normale dell'oggetto. Può essere utilizzato per ridurre gli artefatti di auto-ombreggiatura senza utilizzare shadow_bias. In pratica, questo valore dovrebbe essere modificato insieme a shadow_bias per ridurre il più possibile gli artefatti.
L'opacità da usare quando si renderizza la mappa di ombre della luce. Valori inferiori a 1.0 fanno apparire la luce attraverso le ombre. Questo può essere usato per fingere un illuminazione globale a basso costo in termini di prestazioni.
bool shadow_reverse_cull_face = false 🔗
Se true, inverte il backface culling della mesh. Questo può essere utile quando hai una mesh piatta che ha una luce dietro di essa. Se hai bisogno di proiettare un'ombra su entrambi i lati della mesh, imposta la mesh in modo che utilizzi ombre bifacciali 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!
Descrizioni dei metodi
Restituisce il Color di un corpo nero idealizzato alla temperatura della luce (light_temperature). Questo valore è calcolato internamente in base a light_temperature. Questo Color è moltiplicato per light_color prima di essere inviato al RenderingServer.
float get_param(param: Param) const 🔗
Restituisce il valore del parametro Param specificato.
void set_param(param: Param, value: float) 🔗
Imposta il valore del parametro Param specificato.