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...
Environment
Eredita: Resource < RefCounted < Object
Risorsa per i nodi di ambiente (come WorldEnvironment) che definiscono molteplici opzioni di rendering.
Descrizione
Risorsa per nodi di ambiente (come WorldEnvironment) che definiscono molteplici operazioni d'ambiente (come lo sfondo di Sky o Color, luce ambientale, nebbia, profondità di campo...). Questi parametri influenzano il rendering finale della scena. L'ordine di queste operazioni è:
Sfocatura della profondità di campo
Esposizione automatica
Bagliore
Mappa dei toni (Esposizione automatica)
Aggiustamenti
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Metodi
get_glow_level(idx: int) const |
|
void |
set_glow_level(idx: int, intensity: float) |
Enumerazioni
enum BGMode: 🔗
BGMode BG_CLEAR_COLOR = 0
Pulisce lo sfondo usando il colore di cancellazione definito in ProjectSettings.rendering/environment/defaults/default_clear_color.
BGMode BG_COLOR = 1
Pulisce lo sfondo utilizzando un colore di cancellazione personalizzato.
BGMode BG_SKY = 2
Visualizza un cielo definito dall'utente nello sfondo .
BGMode BG_CANVAS = 3
Visualizza un CanvasLayer nello sfondo .
BGMode BG_KEEP = 4
Mantiene sullo schermo ogni pixel disegnato sullo sfondo. Questa è la modalità di sfondo più veloce, ma può essere utilizzata in modo sicuro solo in scene completamente interne (senza cielo visibile o riflessi del cielo). Se abilitata in una scena in cui lo sfondo è visibile, gli artefatti "ghost trail" saranno visibili quando si sposta la telecamera.
BGMode BG_CAMERA_FEED = 5
Visualizza un feed di una telecamera nello sfondo.
BGMode BG_MAX = 6
Rappresenta la dimensione dell'enumerazione BGMode.
enum AmbientSource: 🔗
AmbientSource AMBIENT_SOURCE_BG = 0
Raccoglie la luce ambientale da qualsiasi fonte specificata come sfondo.
AmbientSource AMBIENT_SOURCE_DISABLED = 1
Disattiva la luce ambientale. Ciò fornisce un leggero aumento delle prestazioni rispetto a AMBIENT_SOURCE_SKY.
AmbientSource AMBIENT_SOURCE_COLOR = 2
Specifica un Color specifico per la luce ambientale. Ciò fornisce un leggero aumento delle prestazioni rispetto a AMBIENT_SOURCE_SKY.
AmbientSource AMBIENT_SOURCE_SKY = 3
Raccoglie la luce ambientale dal cielo (Sky), a prescindere da quale sia lo sfondo.
enum ReflectionSource: 🔗
ReflectionSource REFLECTION_SOURCE_BG = 0
Utilizza lo sfondo per i riflessi.
ReflectionSource REFLECTION_SOURCE_DISABLED = 1
Disattiva i riflessi. Ciò fornisce un leggero aumento delle prestazioni rispetto ad altre opzioni.
ReflectionSource REFLECTION_SOURCE_SKY = 2
Utilizza il cielo (Sky) per i riflessi, a prescindere da quale sia lo sfondo.
enum ToneMapper: 🔗
ToneMapper TONE_MAPPER_LINEAR = 0
Non modifica i dati di colore, risultando in una curva di mappatura dei toni lineare che taglia in modo innaturale i valori luminosi, facendo apparire spente le luci brillanti. Il mappatore dei toni più semplice e veloce.
ToneMapper TONE_MAPPER_REINHARDT = 1
Una semplice curva di mappatura dei toni che scarta i valori luminosi per evitare il clipping. Ciò risulta in un'immagine che può apparire opaca e con basso contrasto. Più lenta di TONE_MAPPER_LINEAR.
Nota: Quando tonemap_white viene lasciato al valore predefinito di 1.0, TONE_MAPPER_REINHARDT produce un'immagine identica a TONE_MAPPER_LINEAR.
ToneMapper TONE_MAPPER_FILMIC = 2
Utilizza una curva di mappatura dei toni simile a quella di una pellicola per impedire il clipping dei valori luminosi e fornire un contrasto migliore rispetto a TONE_MAPPER_REINHARDT. Leggermente più lento di TONE_MAPPER_REINHARDT.
Nota: Questa mappatura non supporta l'output HDR perché produce un output nella gamma SDR. Si consiglia di utilizzare una mappatura diversa quando si renderizza su uno schermo HDR.
ToneMapper TONE_MAPPER_ACES = 3
Utilizza una curva di mappatura dei toni ad alto contrasto simile a quella di un film e desatura i valori luminosi per un aspetto più realistico. Leggermente più lento di TONE_MAPPER_FILMIC.
Nota: Questo operatore di mappatura dei toni è chiamato "ACES Fitted" in Godot 3.x.
Nota: Questa mappatura non supporta l'output HDR perché produce un output nella gamma SDR. Si consiglia di utilizzare una mappatura diversa quando si renderizza su uno schermo HDR.
ToneMapper TONE_MAPPER_AGX = 4
Utilizza una curva di mappatura dei toni simile a quella di una pellicola e desatura i valori brillanti per un aspetto più realistico. Meglio di altri mappatori dei toni nel mantenere la tonalità dei colori mentre diventano più brillanti. L'opzione di mappatura dei toni più lenta.
enum GlowBlendMode: 🔗
GlowBlendMode GLOW_BLEND_MODE_ADDITIVE = 0
Adds the glow effect to the scene.
GlowBlendMode GLOW_BLEND_MODE_SCREEN = 1
Adds the glow effect to the scene after modifying the glow influence based on the scene value; dark values will be highly influenced by glow and bright values will not be influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. tonemap_white is used to determine the maximum scene value where the glow should have no influence. When tonemap_mode is set to TONE_MAPPER_LINEAR and Viewport.use_hdr_2d is true, the parent window's Window.get_output_max_linear_value() will be used as the maximum scene value.
GlowBlendMode GLOW_BLEND_MODE_SOFTLIGHT = 2
Adds the glow effect to the tonemapped image after modifying the glow influence based on the image value; dark values and bright values will not be influenced by glow and mid-range values will be highly influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. The glow will have the largest influence on image values of 0.25 and will have no influence when applied to image values greater than 1.0.
Note: This blend mode does not support HDR output because expects a maximum output value of 1.0. It is recommended to use a different blend mode when rendering to an HDR screen.
GlowBlendMode GLOW_BLEND_MODE_REPLACE = 3
Replaces all pixels' color by the glow effect. This can be used to simulate a full-screen blur effect by tweaking the glow parameters to match the original image's brightness or to preview glow configuration in the editor.
GlowBlendMode GLOW_BLEND_MODE_MIX = 4
Mixes the glow image with the scene image. Best used with glow_bloom to avoid darkening the scene.
enum FogMode: 🔗
FogMode FOG_MODE_EXPONENTIAL = 0
Utilizza un modello di nebbia basato sulla fisica, definito principalmente dalla densità della nebbia.
FogMode FOG_MODE_DEPTH = 1
Utilizza un semplice modello di nebbia definito da posizioni di inizio e fine e una curva personalizzata. Sebbene non sia fisicamente accurato, questo modello può essere utile quando hai bisogno di un maggiore controllo artistico.
enum SDFGIYScale: 🔗
SDFGIYScale SDFGI_Y_SCALE_50_PERCENT = 0
Usa una scala del 50% per SDFGI sull'asse Y (verticale). Le celle SDFGI saranno corte il doppio della loro larghezza. Ciò consente di fornire maggiori dettagli di GI e perdite di luce ridotte tra pavimenti e soffitti sottili. Questa è solitamente la scelta migliore per scene che non presentano molta verticalità.
SDFGIYScale SDFGI_Y_SCALE_75_PERCENT = 1
Usa una scala del 75% per SDFGI sull'asse Y (verticale). Questo è una via di mezzo tra le scale Y SDFGI del 50% e del 100%.
SDFGIYScale SDFGI_Y_SCALE_100_PERCENT = 2
Usa una scala del 100% per SDFGI sull'asse Y (verticale). Le celle SDFGI saranno alte quanto larghe. Questa è solitamente la scelta migliore per scene molto verticali. Lo svantaggio è che la perdita di luce potrebbe diventare più evidenti con pavimenti e soffitti sottili.
Descrizioni delle proprietà
float adjustment_brightness = 1.0 🔗
Applies a simple brightness adjustment to the rendered image after tonemaping. To adjust scene brightness use tonemap_exposure instead, which is applied before tonemapping and thus less prone to issues with bright colors. Effective only if adjustment_enabled is true.
Texture adjustment_color_correction 🔗
La tabella di ricerca (LUT) Texture2D o Texture3D da utilizzare per la correzione integrata del colore in post-elaborazione. È possibile utilizzare una GradientTexture1D per una LUT monodimensionale o una Texture3D per una LUT più complessa. Efficace solo se adjustment_enabled è true.
Nota: La correzione del colore attualmente non supporta l'output HDR poiché supporta solo valori nella gamma SDR (da 0.0 a 1.0).
float adjustment_contrast = 1.0 🔗
Increasing adjustment_contrast will make dark values darker and bright values brighter. This simple adjustment is applied to the rendered image after tonemaping. When set to a value greater than 1.0, adjustment_contrast is prone to clipping colors that become too bright or too dark. Effective only if adjustment_enabled is true.
bool adjustment_enabled = false 🔗
Se true, abilita le proprietà adjustment_* fornite da questa risorsa. Se false, le modifiche alle proprietà adjustment_* non avranno alcun effetto sulla scena renderizzata.
float adjustment_saturation = 1.0 🔗
Applies a simple saturation adjustment to the rendered image after tonemaping. When adjustment_saturation is set to 0.0, the rendered image will be fully converted to a grayscale image. Effective only if adjustment_enabled is true.
Color ambient_light_color = Color(0, 0, 0, 1) 🔗
Il Color della luce ambientale. Efficace solo se ambient_light_sky_contribution è inferiore a 1.0 (esclusivo).
float ambient_light_energy = 1.0 🔗
L'energia della luce ambientale. Più alto è il valore, più intensa è la luce. Efficace solo se ambient_light_sky_contribution è inferiore a 1.0 (esclusivo).
float ambient_light_sky_contribution = 1.0 🔗
Definisce la quantità di luce che il cielo trasmette sulla scena. Un valore di 0.0 significa che l'emissione di luce del cielo non ha alcun effetto sull'illuminazione della scena, quindi tutta l'illuminazione ambientale è fornita dalla luce ambientale. Al contrario, un valore di 1.0 significa che tutta la luce che influenza la scena è fornita dal cielo, quindi il parametro luce ambientale non ha alcun effetto sulla scena.
Nota: ambient_light_sky_contribution è limitato internamente tra 0.0 e 1.0 (inclusi).
AmbientSource ambient_light_source = 0 🔗
void set_ambient_source(value: AmbientSource)
AmbientSource get_ambient_source()
La sorgente di luce ambientale da utilizzare per il rendering dei materiali e l'illuminazione globale.
int background_camera_feed_id = 1 🔗
L'ID del feed della telecamera da mostrare nello sfondo.
int background_canvas_max_layer = 0 🔗
L'ID dello strato massimo da visualizzare. Efficace solo quando si utilizza la modalità di sfondo BG_CANVAS.
Color background_color = Color(0, 0, 0, 1) 🔗
Il Color visualizzato per le aree libere della scena. Efficace solo quando si utilizza la modalità di sfondo BG_COLOR.
float background_energy_multiplier = 1.0 🔗
Moltiplicatore per l'energia dello sfondo. Aumentalo per rendere più luminoso lo sfondo, diminuiscilo per rendere lo sfondo più scuro.
float background_intensity = 30000.0 🔗
Luminanza dello sfondo misurata in nit (candela per metro quadrato). Utilizzata solo quando ProjectSettings.rendering/lights_and_shadows/use_physical_light_units è abilitata. Il valore predefinito è più o meno equivalente al cielo a mezzogiorno.
La modalità dello sfondo.
float fog_aerial_perspective = 0.0 🔗
Se impostato maggiore di 0.0 (esclusivo), fonde tra il colore della nebbia e il colore del cielo (Sky) di sfondo. Questo ha un piccolo costo in termini di prestazioni se impostato sopra 0.0. Deve avere background_mode impostato su BG_SKY.
Questo è utile per simulare la prospettiva aerea in grandi scene con nebbia a bassa densità. Tuttavia, non è molto utile per la nebbia ad alta densità, poiché il cielo risplenderebbe attraverso di essa. Se impostato su 1.0, il colore della nebbia proviene completamente dal cielo (Sky). Se impostato su 0.0, la prospettiva aerea è disabilitata.
Si noti che questo non campiona direttamente il cielo (Sky), bensì la cubemap di radianza. La cubemap è campionata a un livello di mipmap a seconda della profondità del pixel renderizzato; più è lontano, più alta è la risoluzione della mipmap campionata. Ciò risulta nel colore effettivo a essere una versione sfocata del cielo, con una sfocatura maggiore più vicino alla telecamera. La risoluzione della mipmap più alta è utilizzata a una profondità di Camera3D.far.
La densità della nebbia da utilizzare. Questa è dimostrata in modi diversi a seconda della modalità fog_mode scelta:
Exponential Fog Mode: Valori più alti risultano in una nebbia più densa. Il rendering della nebbia è esponenziale come nella vita reale.
Depth Fog mode: L'intensità massima della nebbia profonda, l'effetto apparirà in lontananza (relativo alla telecamera). A 1.0 la nebbia oscurerà completamente la scena, a 0.0 la nebbia non sarà visibile.
float fog_depth_begin = 10.0 🔗
La profondità iniziale della nebbia dalla telecamera. Disponibile solo quando fog_mode è impostato su FOG_MODE_DEPTH.
La curva di intensità della profondità della nebbia. Sono disponibili diversi preset nell'Inspector facendo clic con il pulsante destro del mouse sulla curva. Disponibile solo quando fog_mode è impostato su FOG_MODE_DEPTH.
La distanza finale della profondità della nebbia dalla telecamera. Se questo valore è impostato su 0, sarà uguale al valore Camera3D.far della telecamera attuale. Disponibile solo quando fog_mode è impostato su FOG_MODE_DEPTH.
Se true, gli effetti della nebbia sono abilitati.
L'altezza alla quale inizia l'effetto nebbia.
float fog_height_density = 0.0 🔗
La densità utilizzata per aumentare la nebbia man mano che l'altezza diminuisce. Per aumentare la nebbia man mano che l'altezza aumenta, imposta un valore negativo.
Color fog_light_color = Color(0.518, 0.553, 0.608, 1) 🔗
Il colore della nebbia.
float fog_light_energy = 1.0 🔗
La luminosità della nebbia. Valori più alti risultano in una nebbia più luminosa.
La modalità della nebbia.
Il fattore da usare quando si influenza il cielo con nebbia non volumetrica. 1.0 significa che la nebbia può oscurare completamente il cielo. Valori più bassi riducono l'impatto della nebbia sul rendering del cielo, con 0.0 che non influenza affatto il rendering del cielo.
Nota: fog_sky_affect non ha alcun effetto visivo se fog_aerial_perspective è 1.0.
Se impostato maggiore di 0.0, colora le luci direzionali nella scena con il colore della nebbia a seconda dell'angolo di visione. Questo può essere usato per dare l'impressione che il sole stia "perforando" la nebbia.
GlowBlendMode glow_blend_mode = 1 🔗
void set_glow_blend_mode(value: GlowBlendMode)
GlowBlendMode get_glow_blend_mode()
The glow blending mode.
Note: The Compatibility renderer always uses GLOW_BLEND_MODE_SCREEN and glow_blend_mode will have no effect.
L'intensità dell'effetto bloom. Se impostato su un valore superiore a 0, questo renderà visibile il bloom nelle aree più scure di a glow_hdr_threshold.
If true, the glow effect is enabled. This simulates real world atmosphere and eye/camera behavior by causing bright pixels to bleed onto surrounding pixels.
Note: When using the Mobile rendering method, glow looks different due to the lower dynamic range available in the Mobile rendering method.
Note: When using the Compatibility rendering method, glow uses a different implementation with some properties being unavailable and hidden from the inspector: glow_levels/*, glow_normalized, glow_strength, glow_blend_mode, glow_mix, glow_map, and glow_map_strength. This implementation is optimized to run on low-end devices and is less flexible as a result.
float glow_hdr_luminance_cap = 12.0 🔗
La soglia più alta del bagliore del HDR. Le aree più luminose di questa soglia saranno limitate ai fini dell'effetto bagliore.
Smooths the transition between values that are below and above glow_hdr_threshold by reducing the amount of glow generated by values that are close to glow_hdr_threshold. Values above glow_hdr_threshold + glow_hdr_scale will not have glow reduced in this way.
float glow_hdr_threshold = 1.0 🔗
La soglia inferiore del bagliore del HDR. Quando si utilizza il metodo di rendering Mobile (che supporta solo una gamma dinamica inferiore fino a 2.0), potrebbe essere necessario che questa soglia sia inferiore a 1.0 affinché il bagliore sia visibile. Un valore di 0.9 funziona bene in questo caso. Questo valore deve anche essere ridotto al di sotto di 1.0 quando si utilizza il bagliore in 2D, poiché il rendering 2D è eseguito in SDR.
The overall brightness multiplier that is applied to the glow effect just before it is blended with the scene. When using the Mobile rendering method (which only supports a lower dynamic range up to 2.0), this should be increased to 1.5 to compensate.
L'intensità del 1° livello di bagliore. Questo è il livello più "locale" (meno sfocato).
Nota: glow_levels/1 non ha effetto quando si usa il metodo di rendering Compatibilità, perché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 2° livello di luminosità.
Nota: glow_levels/2 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 3° livello di luminosità.
Nota: glow_levels/3 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 4° livello di luminosità.
Nota: glow_levels/4 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 5° livello di luminosità.
Nota: glow_levels/5 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 6° livello di luminosità.
Nota: glow_levels/6 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
L'Intensità del 7° livello di luminosità. Questo è il livello più "globale" (il più sfocato).
Nota: glow_levels/7 non ha effetto quando si usa il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
La texture che dovrebbe essere usata come mappa del bagliore per moltiplicare il colore del bagliore risultante in base a glow_map_strength. Questo può essere usato per creare un effetto "lenti sporche". I canali colore RGB della texture sono usati per la modulazione, ma il canale alfa è ignorato.
Nota: La texture sarà allungata per adattarsi allo schermo. Pertanto, si consiglia di usare una texture con un rapporto di aspetto che corrisponda al rapporto di aspetto di base del progetto (in genere 16:9).
Nota: glow_map non ha effetto quando si usa il metodo di rendering Compatibilità, perché questo metodo di rendering usa un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
float glow_map_strength = 0.8 🔗
Quanto forte dovrebbe essere l'impatto della glow_map sull'effetto bagliore complessivo. Una forza di 0.0 significa che la mappa del bagliore non ha alcun effetto. Una forza di 1.0 significa che la mappa del bagliore ha un effetto completo.
Nota: Se la mappa del bagliore contiene aree nere, un valore di 1.0 può disattivare completamente il bagliore in aree specifiche dello schermo.
Nota: glow_map_strength non ha effetto quando si utilizza il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
Quando si usa GLOW_BLEND_MODE_MIX per glow_blend_mode, questo controlla quanto l'immagine sorgente è fusa con lo strato del bagliore. Un valore di 0.0 rende il rendering del bagliore invisibile , mentre un valore di 1.0 equivale a GLOW_BLEND_MODE_REPLACE.
Nota: glow_mix non ha effetto quando si utilizza il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
bool glow_normalized = false 🔗
Se true, i livelli di bagliore saranno normalizzati in modo che se sommati insieme le loro intensità siano uguali a 1.0.
Nota: glow_normalized non ha effetto quando si utilizza il metodo di rendering Compatibilità, poiché questo metodo di rendering utilizza un'implementazione del bagliore più semplice, ottimizzata per dispositivi di fascia bassa.
The strength that is used when blurring across the screen to generate the glow effect. This affects the distance and intensity of the blur. When using the Mobile rendering method, this should be increased to compensate for the lower dynamic range.
Note: glow_strength has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.
ReflectionSource reflected_light_source = 0 🔗
void set_reflection_source(value: ReflectionSource)
ReflectionSource get_reflection_source()
La sorgente di luce riflessa (speculare).
float sdfgi_bounce_feedback = 0.5 🔗
Il moltiplicatore di energia applicato alla luce ogni volta che rimbalza da una superficie quando si usa SDFGI. Valori maggiori di 0.0 simuleranno più rimbalzi, con un aspetto più realistico. Aumentare sdfgi_bounce_feedback in genere non ha alcun impatto sulle prestazioni. Vedi anche sdfgi_energy.
Nota: Valori maggiori di 0.5 possono causare cicli di feedback infiniti e dovrebbero essere evitati in scene con materiali luminosi.
Nota: Se sdfgi_bounce_feedback è 0.0, l'illuminazione indiretta non sarà rappresentata nei riflessi poiché la luce rimbalzerà solo una volta.
float sdfgi_cascade0_distance = 12.8 🔗
Nota: Questa proprietà è collegata a sdfgi_min_cell_size e sdfgi_max_distance. Modificandone il valore saranno modificate automaticamente anche queste proprietà.
Numero di cascate da utilizzare per SDFGI (tra 1 e 8). Un numero maggiore di cascate consente di visualizzare SDFGI più lontano, preservando i dettagli da vicino, a scapito delle prestazioni. Quando si utilizza SDFGI su livelli di piccola scala, sdfgi_cascades può spesso essere ridotto tra 1 e 4 per migliorare le prestazioni.
Se true, abilita l'illuminazione globale del campo di distanza con segno per le mesh che hanno il loro GeometryInstance3D.gi_mode impostato su GeometryInstance3D.GI_MODE_STATIC. SDFGI è una tecnica di illuminazione globale in tempo reale che funziona bene con livelli generati proceduralmente e creati dall'utente, anche in situazioni in cui la geometria viene creata durante il gioco. Il campo di distanza con segno è generato automaticamente attorno alla telecamera mentre si muove. Sono supportate luci dinamiche, ma non occlusori dinamici e superfici emissive.
Nota: SDFGI è supportato solo nel metodo di rendering Forward+, non Mobile o Compatibilità.
Prestazioni: SDFGI è relativamente esigente sulla GPU e non è adatto ad hardware di fascia bassa come la grafica integrata (considera invece LightmapGI). Per migliorare le prestazioni di SDFGI, abilita ProjectSettings.rendering/global_illumination/gi/use_half_resolution nelle Impostazioni del progetto.
Nota: Le mesh dovrebbero avere pareti abbastanza spesse per evitare perdite di luce (evita pareti unilaterali). Per i livelli interni, racchiudi la geometria del tuo livello in una scatola abbastanza grande e collega le estremità per chiudere la mesh.
Il moltiplicatore di energia da usare per SDFGI. Valori più alti risulteranno in un'illuminazione indiretta e in riflessi più luminosi. Vedi anche sdfgi_bounce_feedback.
float sdfgi_max_distance = 204.8 🔗
La distanza massima a cui il SDFGI è visibile. Oltre questa distanza, l'illuminazione ambientale o altre fonti di GI come ReflectionProbe saranno utilizzate come fallback.
Nota: Questa proprietà è collegata a sdfgi_min_cell_size e sdfgi_cascade0_distance. Modificandone il valore saranno modificate automaticamente anche queste proprietà.
float sdfgi_min_cell_size = 0.2 🔗
La dimensione della cella da usare per la cascata SDFGI più vicina (in unità 3D). Valori più bassi consentono a SDFGI di essere più preciso da vicino, a costo di rendere gli aggiornamenti SDFGI più esigenti. Ciò può causare scatti quando la telecamera si muove velocemente. Valori più alti consentono a SDFGI di coprire più terreno, riducendo anche l'impatto sulle prestazioni degli aggiornamenti SDFGI.
Nota: Questa proprietà è collegata a sdfgi_max_distance e sdfgi_cascade0_distance. Modificandone il valore saranno modificate automaticamente anche queste proprietà.
float sdfgi_normal_bias = 1.1 🔗
Il bias normale da usare per le sonde SDFGI. Aumentare questo valore può ridurre gli artefatti di striature visibili sulle superfici inclinate, a costo di una maggiore perdita di luce.
float sdfgi_probe_bias = 1.1 🔗
Il bias costante da usare per le sonde SDFGI. Aumentare questo valore può ridurre gli artefatti di striature visibili sulle superfici inclinate, a costo di una maggiore perdita di luce.
bool sdfgi_read_sky_light = true 🔗
Se true, SDFGI tiene conto dell'illuminazione ambientale. Questo dovrebbe essere impostato su false per scene di interiori.
bool sdfgi_use_occlusion = false 🔗
Se true, SDFGI utilizza un approccio di rilevamento dell'occlusione per ridurre la perdita di luce. L'occlusione può tuttavia introdurre macchie scure in determinati punti, il che potrebbe essere indesiderato in scene per lo più all'aperto. sdfgi_use_occlusion ha un impatto sulle prestazioni e dovrebbe essere abilitato solo quando necessario.
SDFGIYScale sdfgi_y_scale = 1 🔗
void set_sdfgi_y_scale(value: SDFGIYScale)
SDFGIYScale get_sdfgi_y_scale()
La scala Y da usare per le celle SDFGI. Valori più bassi comprimeranno le celle SDFGI più vicine all'asse Y. Questo è usato per bilanciare la qualità e coprire molto terreno verticale. sdfgi_y_scale dovrebbe essere impostato a seconda di quanto è verticale la scena (e di quanto velocemente la telecamera può muoversi sull'asse Y).
La risorsa Sky utilizzata per questo Environment.
Se impostato su un valore maggiore di 0.0, sostituisce il campo visivo da utilizzare per il rendering del cielo. Se impostato su 0.0, lo stesso FOV del Camera3D attuale è utilizzato per il rendering del cielo.
Vector3 sky_rotation = Vector3(0, 0, 0) 🔗
La rotazione da utilizzare per il rendering del cielo.
float ssao_ao_channel_affect = 0.0 🔗
Intensità di occlusione ambientale dello spazio dello schermo (SSAO) su materiali che hanno una texture di AO definita. Valori superiori a 0 renderanno visibile l'effetto SSAO nelle aree oscurate dalle texture di AO.
Imposta l'intensità del livello del dettaglio aggiuntivo per l'effetto di occlusione ambientale dello spazio dello schermo. Un valore elevato rende il passaggio del dettaglio più evidente, ma potrebbe contribuire all'aliasing nell'immagine finale.
If true, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. Godot uses a form of SSAO called Adaptive Screen Space Ambient Occlusion which is itself a form of Horizon Based Ambient Occlusion.
Note: SSAO is only supported in the Forward+ and Compatibility rendering methods, not Mobile.
La soglia per considerare se un dato punto su una superficie è occluso o meno rappresentato come un angolo dall'orizzonte mappato nell'intervallo 0.0-1.0. Un valore di 1.0 non risulta in alcuna occlusione.
Intensità primaria di occlusione ambientale dello spazio dello schermo. Agisce come moltiplicatore per l'effetto di occlusione ambientale dello spazio dello schermo. Un valore più alto risulta in un'occlusione più scura.
float ssao_light_affect = 0.0 🔗
L'intensità dell'occlusione ambientale dello spazio dello schermo in luce diretta. Nella vita reale, l'occlusione ambientale si applica solo alla luce indiretta, il che significa che i suoi effetti non possono essere visti in luce diretta. Valori superiori a 0 renderanno l'effetto SSAO visibile in luce diretta.
La distribuzione dell'occlusione. Un valore più alto risulta in un'occlusione più scura, simile a ssao_intensity, ma con un calo più netto.
La distanza alla quale gli oggetti possono occludersi a vicenda quando si calcola l'occlusione ambientale dello spazio dello schermo. Valori più alti risultano nell'occlusione su una distanza maggiore a scapito di prestazioni e qualità.
La quantità di sfocatura sui bordi degli oggetti consentita all'effetto di occlusione ambientale dello spazio sullo schermo. Un'impostazione troppo alta causerà l'aliasing sui bordi degli oggetti. Un'impostazione troppo bassa renderà i bordi degli oggetti sfocati.
Se true, l'effetto di illuminazione indiretta nello spazio dello schermo è abilitato. L'illuminazione indiretta nello spazio dello schermo è una forma di illuminazione indiretta che consente alla luce diffusa di rimbalzare tra gli oggetti vicini. L'illuminazione indiretta nello spazio dello schermo funziona in modo molto simile all'occlusione ambientale nello spazio dello schermo, in quanto influisce solo su un intervallo limitato. È progettata per essere utilizzata insieme a una forma di illuminazione globale appropriata come SDFGI o VoxelGI. L'illuminazione indiretta nello spazio dello schermo non è influenzata dal valore Light3D.light_indirect_energy di una luce individuale.
Nota: SSIL è supportato solo nel metodo di rendering Forward+, non Mobile o Compatibilità.
Il moltiplicatore di luminosità per l'effetto di illuminazione indiretta dello spazio dello schermo. Un valore più alto produrrà una luce più brillante.
float ssil_normal_rejection = 1.0 🔗
Quantità di rigetto normale utilizzata nel calcolo dell'illuminazione indiretta dello spazio sullo schermo. La rigetto normale utilizza la normale di un dato punto campione per rigettare i campioni che sono rivolti lontano dal pixel attuale. Il rigetto normale è necessario per evitare perdite di luce quando è illuminato solo un lato di un oggetto. Tuttavia, il rigetto normale può essere disabilitato se si desidera la perdita di luce, ad esempio quando la scena contiene in gran parte oggetti emissivi che emettono luce da facce che non si possono vedere dalla telecamera.
La distanza che la luce rimbalzata può percorrere quando si usa l'effetto di illuminazione indiretta dello spazio dello schermo. Un valore più alto rimbalzerà la luce più lontano in una scena, ma potrebbe causare artefatti di sottocampionamento, che assomigliano a lunghe punte che circondano le sorgenti luminose.
La quantità di sfocatura sui bordi degli oggetti per l'effetto di illuminazione indiretta dello spazio dello schermo. Un'impostazione troppo alta causerà l'aliasing sui bordi degli oggetti. Un'impostazione troppo bassa renderà i bordi degli oggetti sfocati.
float ssr_depth_tolerance = 0.5 🔗
La tolleranza di profondità per i riflessi sullo spazio dello schermo.
Se true, i riflessi sullo spazio dello schermo sono abilitati. I riflessi sullo spazio dello schermo sono più precisi dei riflessi di VoxelGI o ReflectionProbe, ma sono più lenti e non possono riflettere le superfici occluse da altre.
Nota: SSR è supportato solo nel metodo di rendering Forward+, non Mobile o Compatibilità.
Nota: SSR non è supportato nelle viewport che hanno uno sfondo trasparente (dove Viewport.transparent_bg è true).
La distanza di dissolvenza in entrata per i riflessi sullo spazio dello schermo. Influisce sull'area dal materiale riflesso al riflesso sullo spazio dello schermo. Sono validi solo i valori positivi (i valori negativi saranno limitati a 0.0).
La distanza di dissolvenza in uscita per i riflessi dello spazio dello schermo. Influisce sull'area dal riflesso sullo spazio dello schermo al riflesso "globale". Sono validi solo i valori positivi (i valori negativi saranno limitati a 0.0).
Il numero massimo di passaggi per i riflessi sullo spazio dello schermo. I valori più alti sono più lenti.
float tonemap_agx_contrast = 1.25 🔗
Increasing tonemap_agx_contrast will make dark values darker and bright values brighter. Produces a higher quality result than adjustment_contrast without any additional performance cost, but is only available when using the TONE_MAPPER_AGX tonemapper.
float tonemap_agx_white = 16.29 🔗
The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set tonemap_agx_white to at least 6.0. Higher values result in less blown out highlights, but may make the scene appear lower contrast. tonemap_agx_white is the same as tonemap_white, but is only effective with the TONE_MAPPER_AGX tonemapper. See also tonemap_exposure.
Note: When using the Mobile renderer with Viewport.use_hdr_2d disabled, tonemap_agx_white is ignored and a white value of 2.0 will always be used instead. Otherwise, tonemap_agx_white will be dynamically adjusted at runtime by multiplying it by the parent window's Window.get_output_max_linear_value() when using Viewport.use_hdr_2d to ensure good behavior with both SDR and HDR output.
float tonemap_exposure = 1.0 🔗
Regola la luminosità dei valori prima che vengano forniti al mappatore dei toni. Valori di tonemap_exposure più alti producono un'immagine più luminosa. Vedi anche tonemap_white.
Nota: I valori forniti al mappatore dei toni saranno anche moltiplicati per 2.0 e 1.8 rispettivamente per TONE_MAPPER_FILMIC e TONE_MAPPER_ACES per produrre una luminosità simile in apparenza a TONE_MAPPER_LINEAR.
ToneMapper tonemap_mode = 0 🔗
void set_tonemapper(value: ToneMapper)
ToneMapper get_tonemapper()
La modalità di mappatura dei toni da usare. La mappatura dei toni è il processo che "converte" i valori in HDR per renderli adatti al rendering su un display in LDR. (Godot non supporta ancora il rendering su display HDR.)
Il valore di riferimento bianco per la mappatura dei toni (detto anche "punto di bianco"), che indica dove si trova il bianco brillante nella scala di valori forniti al mappatore dei toni. Per un'illuminazione fotorealistica, si consiglia di impostare tonemap_white ad almeno 6.0. Valori più alti rendono i chiari più spenti, ma potrebbero far apparire la scena meno contrastata. Sarà utilizzato tonemap_agx_white in alternativa quando si usa la mappatura TONE_MAPPER_AGX. Vedi anche tonemap_exposure.
Nota: tonemap_white deve essere impostato a 2.0 o inferiore sul renderer Mobile per produrre immagini luminose.
Nota: tonemap_white è ignorato quando si usa TONE_MAPPER_LINEAR e sarà regolato dinamicamente in fase di esecuzione in modo che non sia mai inferiore a Window.get_output_max_linear_value() della finestra padre quando si utilizza TONE_MAPPER_REINHARDT con Viewport.use_hdr_2d.
Color volumetric_fog_albedo = Color(1, 1, 1, 1) 🔗
Il Color della nebbia volumetrica quando interagisce con le luci. La foschia e la nebbia hanno un albedo vicino a Color(1, 1, 1, 1) mentre il fumo ha un albedo più scuro.
float volumetric_fog_ambient_inject = 0.0 🔗
Scala l'intensità della luce ambientale usata nella nebbia volumetrica. Un valore di 0.0 significa che la luce ambientale non avrà alcun impatto sulla nebbia volumetrica. volumetric_fog_ambient_inject ha un piccolo costo in termini di prestazioni se impostato sopra 0.0.
Nota: Questo non ha alcun effetto visibile se volumetric_fog_density è 0.0 o se volumetric_fog_albedo è un colore completamente nero.
float volumetric_fog_anisotropy = 0.2 🔗
La direzione della luce diffusa mentre attraversa la nebbia volumetrica. Un valore vicino a 1.0 significa che quasi tutta la luce è diffusa in avanti. Un valore vicino a 0.0 significa che la luce è diffusa equamente in tutte le direzioni. Un valore vicino a -1.0 significa che la luce è diffusa principalmente all'indietro. La nebbia e la foschia diffondono la luce leggermente in avanti, mentre il fumo diffonde la luce equamente in tutte le direzioni.
float volumetric_fog_density = 0.05 🔗
Densità di base esponenziale della nebbia volumetrica. Impostala sulla densità più bassa che desideri avere globalmente. I FogVolume possono essere usati per aggiungere o sottrarre da questa densità in aree specifiche. Il rendering della nebbia è esponenziale come nella vita reale.
Un valore di 0.0 disabilita la nebbia volumetrica globale mentre consente ai FogVolume di visualizzare la nebbia volumetrica in aree specifiche.
Per far funzionare la nebbia volumetrica come una soluzione di illuminazione volumetrica, imposta volumetric_fog_density sul valore più basso diverso da zero (0.0001), quindi aumenta la proprietà Light3D.light_volumetric_fog_energy delle luci a valori compresi tra 10000 e 100000 per compensare la densità molto bassa.
float volumetric_fog_detail_spread = 2.0 🔗
La distribuzione delle dimensioni lungo la lunghezza del buffer dei froxel. Un valore più alto comprime i froxel più vicino alla telecamera e colloca più dettagli più vicino alla telecamera.
Color volumetric_fog_emission = Color(0, 0, 0, 1) 🔗
La luce emessa dalla nebbia volumetrica. Anche con l'emissione, la nebbia volumetrica non proietterà luce su altre superfici. L'emissione è utile per stabilire un colore ambientale. Poiché l'effetto nebbia volumetrica utilizza solo la dispersione singola, la nebbia tende ad aver bisogno di un po' di emissione per ammorbidire le ombre brusche.
float volumetric_fog_emission_energy = 1.0 🔗
La luminosità della luce emessa dalla nebbia volumetrica.
bool volumetric_fog_enabled = false 🔗
Abilita l'effetto nebbia volumetrica. La nebbia volumetrica utilizza un buffer dei froxel allineato allo schermo per calcolare la dispersione volumetrica accurata a distanze brevi e medie. La nebbia volumetrica interagisce con i FogVolume e le luci per calcolare la nebbia sia localizzata sia globale. La nebbia volumetrica utilizza un modello di dispersione singola PBR basato su estinzione, dispersione, ed emissione che espone agli utenti come proprietà di densità, albedo, ed emissione.
Nota: La nebbia volumetrica è supportata solo nel metodo di rendering Forward+, non Mobile o Compatibilità.
float volumetric_fog_gi_inject = 1.0 🔗
Scala l'intensità dell'illuminazione globale utilizzata nel colore albedo della nebbia volumetrica. Un valore di 0.0 significa che l'illuminazione globale non avrà alcun impatto sulla nebbia volumetrica. volumetric_fog_gi_inject ha un piccolo costo in termini di prestazioni se impostato sopra 0.0.
Nota: Questo non ha alcun effetto visibile se volumetric_fog_density è 0.0 o se volumetric_fog_albedo è un colore completamente nero.
Nota: Solo VoxelGI e SDFGI (sdfgi_enabled) sono presi in considerazione quando si utilizza volumetric_fog_gi_inject. L'illuminazione globale da LightmapGI, ReflectionProbe, e SSIL (vedere ssil_enabled) sarà ignorata dalla nebbia volumetrica.
float volumetric_fog_length = 64.0 🔗
La distanza su cui viene calcolata la nebbia volumetrica. Aumentala per calcolare la nebbia su una portata più ampia, diminuiscila per aggiungere più dettagli quando non è necessario una portata lunga. Per una nebbia di qualità migliore, mantieni questo valore il più basso possibile. Vedi anche ProjectSettings.rendering/environment/volumetric_fog/volume_depth.
float volumetric_fog_sky_affect = 1.0 🔗
Il fattore da usare quando si influenza il cielo con la nebbia volumetrica. 1.0 significa che la nebbia volumetrica può oscurare totalmente il cielo. Valori più bassi riducono l'impatto della nebbia volumetrica sul rendering del cielo, con 0.0 che non influenza affatto il rendering del cielo.
Nota: volumetric_fog_sky_affect influenza anche i FogVolume, anche se volumetric_fog_density è 0.0. Se noti che i FogVolume scompaiono quando guardi verso il cielo, imposta volumetric_fog_sky_affect su 1.0.
float volumetric_fog_temporal_reprojection_amount = 0.9 🔗
void set_volumetric_fog_temporal_reprojection_amount(value: float)
float get_volumetric_fog_temporal_reprojection_amount()
La quantità con cui fondere l'ultimo fotogramma con il fotogramma attuale. Un numero più alto produce una nebbia volumetrica più uniforme, ma peggiora notevolmente l'effetto "ghosting". Un valore più basso riduce l'effetto ghosting ma potrebbe rendere visibile il tremolio temporale per fotogramma.
bool volumetric_fog_temporal_reprojection_enabled = true 🔗
void set_volumetric_fog_temporal_reprojection_enabled(value: bool)
bool is_volumetric_fog_temporal_reprojection_enabled()
Abilita la riproiezione temporale nella nebbia volumetrica. La riproiezione temporale fonde la nebbia volumetrica del fotogramma attuale con la nebbia volumetrica dell'ultimo fotogramma per smussare i bordi frastagliati. Il costo in termini di prestazioni è minimo; tuttavia, provoca un effetto "ghosting" per i FogVolume e i Light3D in movimento, lasciando una scia dietro di loro. Quando la riproiezione temporale è abilitata, cerca di evitare di muovere i FogVolume o i Light3D troppo velocemente. Gli effetti di illuminazione dinamica di breve durata dovrebbero avere Light3D.light_volumetric_fog_energy impostato su 0.0 per evitare l'effetto ghosting.
Descrizioni dei metodi
float get_glow_level(idx: int) const 🔗
Restituisce l'intensità del livello di bagliore all'indice idx.
void set_glow_level(idx: int, intensity: float) 🔗
Imposta l'intensità del livello di bagliore all'indice idx. Un valore superiore a 0.0 abilita il livello. Ogni livello si basa sul livello precedente. Ciò significa che abilitare livelli di bagliore più alti rallenterà il rendering dell'effetto bagliore, anche se i livelli precedenti non sono abilitati.