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...

Shader di cielo

Gli shader di cielo sono un tipo speciale di shader utilizzato per disegnare sfondi cielo e per aggiornare le cubemap di radianza, le quali sono utilizzate per l'illuminazione basata su immagini (IBL). Gli shader di cielo hanno una sola funzione di elaborazione, la funzione sky().

Lo shader di cielo è utilizzato in tre situazioni.

Primo, lo shader di cielo è utilizzato per disegnare il cielo quando è stato scelto di utilizzare una risorsa Sky come sfondo nella scena.
Secondo, lo shader di cielo è utilizzato per aggiornare la cubemap di radianza quando si utilizza il cielo per il colore ambientale o per i riflessi.
Terzo, lo shader di cielo è utilizzato per disegnare i sotto-passaggi a bassa risoluzione che si possono utilizzare nello sfondo ad alta risoluzione o nel passaggio di cubemap.

In totale, ciò significa che lo shader di cielo può essere eseguito fino a sei volte per frame, tuttavia, in pratica, il numero di ripetizioni sarà molto inferiore, perché la cubemap di radianza non deve essere aggiornata a ogni frame e non saranno utilizzati tutti i sotto-passaggi. È possibile modificare il comportamento dello shader in base a dove è richiamato, verificando i valori booleani AT_*_PASS. Per esempio:

shader_type sky;

void sky() {
    if (AT_CUBEMAP_PASS) {
        // Sets the radiance cubemap to a nice shade of blue instead of doing
        // expensive sky calculations
        COLOR = vec3(0.2, 0.6, 1.0);
    } else {
        // Do expensive sky calculations for background sky only
        COLOR = get_sky_color(EYEDIR);
    }
}

Quando si utilizza lo shader di cielo per disegnare uno sfondo, lo shader sarà richiamato per tutti i frammenti non occlusi sullo schermo. Tuttavia, per i sotto-passaggi dello sfondo, lo shader sarà richiamato per ogni pixel del sotto-passaggio.

Quando si utilizza lo shader di cielo per aggiornare la cubemap di radianza, lo shader di cielo sarà chiamato per ogni pixel nella cubemap. D'altra parte, lo shader sarà richiamato solo quando la cubemap di radianza si deve aggiornare. La cubemap di radianza si deve aggiornare quando uno qualsiasi dei parametri dello shader viene aggiornato. Ad esempio, se si utilizza TIME nello shader, la cubemap di radianza verrà aggiornata a ogni frane. Il seguente elenco di modifiche forza un aggiornamento della cubemap di radianza:

TIME è utilizzato.
POSITION è utilizzato e la posizione della telecamera cambia.
Se una qualunque proprietà LIGHTX_* viene utilizzata e un qualunque DirectionalLight3D viene modificato.
Se un'uniforme viene modificata nello shader.
Se lo schermo viene ridimensionato e uno dei sotto-passaggi viene utilizzato.

Cercare di evitare di aggiornare inutilmente la cubemap di radianza. Se è necessario aggiornare la cubemap di radianza a ogni frame, assicurarsi che Sky process mode sia impostato su PROCESS_MODE_REALTIME.

Note that the process mode only affects the rendering of the radiance cubemap. The visible sky is always rendered by calling the fragment shader for every pixel. With complex fragment shaders, this can result in a high rendering overhead. If the sky is static (the conditions listed above are met) or changes slowly, running the full fragment shader every frame is not needed. This can be avoided by rendering the full sky into the radiance cubemap, and reading from this cubemap when rendering the visible sky. With a completely static sky, this means that it needs to be rendered only once.

Il codice seguente renderizza il cielo completo nella cubemap di radianza e legge da tale cubemap per visualizzare il cielo visibile:

shader_type sky;

void sky() {
    if (AT_CUBEMAP_PASS) {
        vec3 dir = EYEDIR;

        vec4 col = vec4(0.0);

        // Complex color calculation

        COLOR = col.xyz;
        ALPHA = 1.0;
    } else {
        COLOR = texture(RADIANCE, EYEDIR).rgb;
    }
}

In questo modo, i calcoli complessi avvengono solo nel passaggio della cubemap, che può essere ottimizzato impostando la modalità di elaborazione del cielo e la dimensione di radianza per ottenere l'equilibrio desiderato tra prestazioni e fedeltà visiva.

Modalità di rendering

I sottopassaggi consentono di eseguire calcoli più costosi a una risoluzione inferiore per velocizzare gli shader. Ad esempio, il codice seguente renderizza le nuvole a una risoluzione più bassa rispetto al resto del cielo:

shader_type sky;
render_mode use_half_res_pass;

void sky() {
    if (AT_HALF_RES_PASS) {
        // Run cloud calculation for 1/4 of the pixels
        vec4 color = generate_clouds(EYEDIR);
        COLOR = color.rgb;
        ALPHA = color.a;
    } else {
        // At full resolution pass, blend sky and clouds together
        vec3 color = generate_sky(EYEDIR);
        COLOR = color + HALF_RES_COLOR.rgb * HALF_RES_COLOR.a;
    }
}

Modalità di rendering	Descrizione
use_half_res_pass	Consente allo shader di scrivere e accedere al passaggio a mezza risoluzione.
use_quarter_res_pass	Consente allo shader di scrivere e accedere al passaggio a un quarto della risoluzione.
disable_fog	Se utilizzata, la nebbia non avrà alcun effetto sul cielo.

Variabili integrate

I valori marcati come in sono di sola lettura. I valori marcati come out sono scrivibili facoltativamente e non contengono necessariamente valori sensati. I campionatori non sono scrivibili, quindi non sono marcati.

Variabili integrate globali

Le variabili integrate globali sono disponibili ovunque, comprese le funzioni personalizzate.

Ci sono 4 luci LIGHTX, a cui si accede come LIGHT0, LIGHT1, LIGHT2 e LIGHT3.

Integrato	Descrizione
in float TIME	Global time since the engine has started, in seconds. It repeats after every `3,600` seconds (which can be changed with the rollover setting). It's affected by time_scale but not by pausing. If you need a `TIME` variable that is not affected by time scale, add your own global shader uniform and update it each frame.
in vec3 POSITION	Posizione della telecamera, nello spazio mondiale.
samplerCube RADIANCE	Radiance cubemap. Can only be read from during the background pass. Check `!AT_CUBEMAP_PASS` before using.
in bool AT_HALF_RES_PASS	`true` when rendering to the half resolution pass.
in bool AT_QUARTER_RES_PASS	`true` when rendering to the quarter resolution pass.
in bool AT_CUBEMAP_PASS	`true` when rendering to the radiance cubemap.
in bool LIGHTX_ENABLED	`true` se `LIGHTX` è visibile e presente nella scena. Se `false`, le altre proprietà di luce potrebbero essere incomplete.
in float LIGHTX_ENERGY	Moltiplicatore di energia per `LIGHTX`.
in vec3 LIGHTX_DIRECTION	Direzione verso cui `LIGHTX` è rivolto.
in vec3 LIGHTX_COLOR	Colore di `LIGHTX`.
in float LIGHTX_SIZE	Diametro angolare di `LIGHTX` nel cielo. Espresso in radianti. Per riferimento, il Sole dalla Terra è a circa 0,0087 radianti (0,5 gradi).
in float PI	Una costante `PI` (`3.141592`). Il rapporto tra la circonferenza di un cerchio e il suo diametro, e il numero di radianti in mezzo giro.
in float TAU	Una costante `TAU` (`6.283185`). Equivalente a `PI * 2` e al numero di radianti in un giro completo.
in float E	Una costante `E` (`2.718281`). Numero di Eulero, la base del logaritmo naturale.

Variabili integrate di cielo

Integrato	Descrizione
in vec3 EYEDIR	Direzione normalizzata del pixel attuale. Da utilizzare come direzione di base per gli effetti procedurali.
in vec2 SCREEN_UV	Coordinate UV dello schermo per il pixel attuale. Utilizzata per mappare una texture a tutto lo schermo.
in vec2 SKY_COORDS	UV di sfera . Utilizzata per mappare una texture panoramica sul cielo.
in vec4 HALF_RES_COLOR	Valore di colore del pixel corrispondente da un passaggio a metà risoluzione. Utilizza un filtro lineare.
in vec4 QUARTER_RES_COLOR	Valore di colore del pixel corrispondente da un passaggio a un quarto della risoluzione. Utilizza un filtro lineare.
out vec3 COLOR	Colore in uscita.
out float ALPHA	Valore alfa in output, può essere utilizzato solo nei sotto-passaggi.
out vec4 FOG