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...
Screen-reading shaders
Introduzione
Spesso si desidera creare uno shader che legga dallo stesso schermo su cui scrive. Le API 3D, come OpenGL o DirectX, lo rendono molto difficile a causa delle limitazioni hardware interne. Le GPU sono estremamente parallele, quindi le operazioni di lettura e scrittura causano ogni sorta di problema di cache e coerenza. Di conseguenza, nemmeno l'hardware più moderno supporta correttamente questa funzionalità.
La soluzione alternativa consiste nel creare una copia dello schermo, o di una parte di esso, in un back buffer e poi leggere da esso durante il disegno. Godot offre alcuni mezzi che facilitano questo processo.
Texture di schermo
l Linguaggio di shading di Godot ha una texture speciale per accedere al contenuto già renderizzato dello schermo. Si utilizza specificando un suggerimento nella dichiarazione di un'uniforme sampler2D : hint_screen_texture. È possibile usare un varying integrato speciale, SCREEN_UV, per ottenere le coordinate UV relative allo schermo per il frammento attuale. Di conseguenza, questo shader di frammento canvas_item produce un oggetto invisibile, perché mostra solo ciò che si trova dietro:
shader_type canvas_item;
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
void fragment() {
COLOR = textureLod(screen_texture, SCREEN_UV, 0.0);
}
Qui si usa textureLod perché vogliamo leggere solo dalla mipmap più bassa. Se invece vuoi leggere da una versione sfocata della texture, è possibile aumentare il terzo argomento a textureLod e cambiare il suggerimento filter_nearest in filter_nearest_mipmap (o qualsiasi altro filtro con mipmap abilitate). Se si usa un filtro con le mipmap, Godot calcolerà automaticamente la texture sfocata.
Avvertimento
Se la modalità di filtro non viene cambiata in una modalità che contiene mipmap nel suo nome, textureLod con un parametro LOD maggiore di 0.0 avrà lo stesso aspetto di quello con un parametro LOD pari a 0.0.
Screen texture example
La texture dello schermo può servire per molte cose. È disponibile una demo speciale per gli Screen Space Shaders, da scaricare come punto di riferimento. Un esempio è un semplice shader per regolare luminosità, contrasto e saturazione:
shader_type canvas_item;
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
uniform float brightness = 1.0;
uniform float contrast = 1.0;
uniform float saturation = 1.0;
void fragment() {
vec3 c = textureLod(screen_texture, SCREEN_UV, 0.0).rgb;
c.rgb = mix(vec3(0.0), c.rgb, brightness);
c.rgb = mix(vec3(0.5), c.rgb, contrast);
c.rgb = mix(vec3(dot(vec3(1.0), c.rgb) * 0.33333), c.rgb, saturation);
COLOR.rgb = c;
}
Dietro le quinte
Sebbene potrebbe sembrare magico, non lo è. In 2D, quando hint_screen_texture viene trovato per la prima volta in un nodo che sta per essere disegnato, Godot effettua una copia a schermo intero in un back buffer. I nodi successivi che lo utilizzano negli shader non avranno lo schermo copiato per loro, perché questo risulterebbe inefficiente. In 3D, lo schermo viene copiato dopo il passaggio della geometria opaca, ma prima del passaggio della geometria trasparente, quindi gli oggetti trasparenti non verranno catturati nella texture dello schermo.
Di conseguenza, in 2D, se gli shader che usano hint_screen_texture si sovrappongono, il secondo non utilizzerà il risultato del primo, producendo effetti visivi inaspettati:
In the above image, the second sphere (top right) is using the same source for the screen texture as the first one below, so the first one "disappears", or is not visible.
In 2D, si può correggere tramite il nodo BackBufferCopy, che si può istanziare tra le due sfere. BackBufferCopy può funzionare specificando una regione dello schermo oppure l'intero schermo:
With correct back-buffer copying, the two spheres blend correctly:
Avvertimento
In 3D, materials that use hint_screen_texture are considered transparent themselves and
will not appear in the resulting screen texture of other materials.
If you plan to instantiate a scene that uses a material with hint_screen_texture,
you will need to use a BackBufferCopy node.
In 3D, c'è meno flessibilità per risolvere questo problema specifico, perché la texture dello schermo viene catturata una sola volta. Bisogna fare attenzione durante l'uso della texture dello schermo in 3D, poiché non catturerà oggetti trasparenti e potrebbe catturare alcuni oggetti opachi che si trovano davanti all'oggetto che sta usando la texture dello schermo.
È possibile riprodurre la logica del back buffer in 3D creando una Viewport con una telecamera nella stessa posizione dell'oggetto, e poi utilizzando la texture della Viewport invece della texture dello schermo.
Logica del back buffer
Quindi, per chiarire meglio, ecco come funziona la logica di copia del backbuffer in 2D in Godot:
Se un nodo usa
hint_screen_texture, l'interno schermo viene copiato nel back buffer prima di disegnare quel nodo. Questo avviene solo la prima volta; i nodi successivi non eseguono questa operazione.Se un nodo BackBufferCopy è stato elaborato prima della situazione descritta nel punto precedente (anche se
hint_screen_texturenon è stato usato), il comportamento descritto nel punto precedente non avviene. In altre parole, la copia automatica dell'intero schermo avviene solo sehint_screen_textureè usato in un nodo per la prima volta e nessun nodo BackBufferCopy (non disabilitato) è stato trovato in precedenza in order ad albero.BackBufferCopy può copiare l'intero schermo o una regione. Se impostato su una sola regione (e non sull'intero schermo) e lo shader utilizza pixel non presenti nella regione copiata, il risultato di tale lettura non è definito (molto probabilmente sono dati a caso provenienti dai frame precedenti). In altre parole, è possibile utilizzare BackBufferCopy per copiare una regione dello schermo e poi leggere la texture dello schermo da una regione diversa. Evita questo comportamento!
Texture di profondità
Per gli shader 3D, è anche possibile accedere al buffer di profondità dello schermo. Per farlo, si usa il suggerimento hint_depth_texture. Questa texture non è lineare; deve essere convertita tramite la matrice di proiezione inversa.
Il seguente codice recupera la posizione 3D sotto al pixel che si sta disegnando:
uniform sampler2D depth_texture : hint_depth_texture, repeat_disable, filter_nearest;
void fragment() {
float depth = textureLod(depth_texture, SCREEN_UV, 0.0).r;
vec4 upos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 - 1.0, depth, 1.0);
vec3 pixel_position = upos.xyz / upos.w;
}
Texture normale-rugosità
Nota
La texture normale-rugosità è supportata solo nel metodo di rendering Forward+, non in Mobile o Compatibilità.
Similmente, la texture normale-rugosità serve per leggere le normali e la rugosità degli oggetti renderizzati nel pre-passaggio di profondità. La normale è memorizzata nei canali .xyz (mappati nell'intervallo 0-1) mentre la rugosità è memorizzata nel canale .w.
uniform sampler2D normal_roughness_texture : hint_normal_roughness_texture, repeat_disable, filter_nearest;
void fragment() {
float screen_roughness = texture(normal_roughness_texture, SCREEN_UV).w;
vec3 screen_normal = texture(normal_roughness_texture, SCREEN_UV).xyz;
screen_normal = screen_normal * 2.0 - 1.0;
Ridefinire le texture dello schermo
I suggerimenti per la texture dello schermo (hint_screen_texture, hint_depth_texture e hint_normal_roughness_texture) si possono usare con più uniformi. Ad esempio, potresti voler leggere dalla texture più volte con un diverso flag di ripetizione o flag di filtro.
L'esempio seguente mostra uno shader che legge la normale nello spazio dello schermo con un filtro lineare, ma legge la rugosità nello spazio dello schermo con un filtro vicino più ravvicinato.
uniform sampler2D normal_roughness_texture : hint_normal_roughness_texture, repeat_disable, filter_nearest;
uniform sampler2D normal_roughness_texture2 : hint_normal_roughness_texture, repeat_enable, filter_linear;
void fragment() {
float screen_roughness = texture(normal_roughness_texture, SCREEN_UV).w;
vec3 screen_normal = texture(normal_roughness_texture2, SCREEN_UV).xyz;
screen_normal = screen_normal * 2.0 - 1.0;