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

CompositorEffect

Sperimentale: The implementation may change as more of the rendering internals are exposed over time.

Eredita: Resource < RefCounted < Object

Questa risorsa consente di creare un effetto di rendering personalizzato.

Descrizione

Questa risorsa definisce un effetto di rendering personalizzato che può essere applicato alle Viewport attraverso l'Environment delle viewport. È possibile implementare un callback che è chiamato durante il rendering in una determinata fase della pipeline di rendering e consente di inserire passaggi aggiuntivi. Nota che questo callback avviene sul thread di rendering. CompositorEffect è una classe base astratta e deve essere estesa per implementare una logica di rendering specifica.

Tutorial

Il compositore

Proprietà

bool	access_resolved_color
bool	access_resolved_depth
EffectCallbackType	effect_callback_type
bool	enabled
bool	needs_motion_vectors
bool	needs_normal_roughness
bool	needs_separate_specular

Metodi

void	_render_callback(effect_callback_type: int, render_data: RenderData) virtual

Enumerazioni

enum EffectCallbackType: 🔗

EffectCallbackType EFFECT_CALLBACK_TYPE_PRE_OPAQUE = 0

Il callback viene richiamato prima del nostro passaggio di rendering opaco, ma dopo il pre-passaggio di profondità (se applicabile).

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_OPAQUE = 1

Il callback viene richiamato dopo il nostro passaggio di rendering opaco, ma prima che venga renderizzato il cielo.

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_SKY = 2

Il callback viene chiamato dopo il rendering del cielo, ma prima che vengano creati i back buffer (e, se abilitato, prima del subsurface scattering e/o delle riflessioni nello spazio dello schermo).

EffectCallbackType EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT = 3

Il callback viene chiamato prima del nostro passaggio di rendering trasparente, ma dopo che il cielo è stato renderizzato e abbiamo creato i nostri back buffer.

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_TRANSPARENT = 4

Il callback viene chiamato dopo il passaggio di rendering trasparente, ma prima di qualsiasi effetto di post-elaborazione e inviato sulla destinazione di rendering.

EffectCallbackType EFFECT_CALLBACK_TYPE_MAX = 5

Rappresenta la dimensione dell'enumerazione EffectCallbackType.

Descrizioni delle proprietà

bool access_resolved_color 🔗

void set_access_resolved_color(value: bool)
bool get_access_resolved_color()

Se true e MSAA è abilitato, sarà attivata la risoluzione del buffer di colore prima che l'effetto sia eseguito.

Nota: In _render_callback(), per accedere al buffer risolto usa:

var render_scene_buffers = render_data.get_render_scene_buffers()
var color_buffer = render_scene_buffers.get_texture("render_buffers", "color")

bool access_resolved_depth 🔗

void set_access_resolved_depth(value: bool)
bool get_access_resolved_depth()

Se true e MSAA è abilitato, sarà attivata la risoluzione del buffer di profondità prima che l'effetto sia eseguito.

Nota: In _render_callback(), per accedere al buffer risolto usa:

var render_scene_buffers = render_data.get_render_scene_buffers()
var depth_buffer = render_scene_buffers.get_texture("render_buffers", "depth")

EffectCallbackType effect_callback_type 🔗

void set_effect_callback_type(value: EffectCallbackType)
EffectCallbackType get_effect_callback_type()

Il tipo di effetto che è implementato. Determina in quale fase del rendering viene chiamato il callback.

bool enabled 🔗

void set_enabled(value: bool)
bool get_enabled()

Se true questo effetto di rendering è applicato a qualsiasi viewport a cui viene aggiunto.

bool needs_motion_vectors 🔗

void set_needs_motion_vectors(value: bool)
bool get_needs_motion_vectors()

Se true questo attiva i vettori di movimento calcolati durante lo stato del rendering opaco.

Nota: In _render_callback(), per accedere al buffer dei vettori di movimento usa:

var render_scene_buffers = render_data.get_render_scene_buffers()
var motion_buffer = render_scene_buffers.get_velocity_texture()

bool needs_normal_roughness 🔗

void set_needs_normal_roughness(value: bool)
bool get_needs_normal_roughness()

Se true questo assicura che i dati di normale e di rugosità siano prodotti durante il nostro pre-passaggio di profondità, applicabile solo per il renderer Forward+.

Nota: In _render_callback(), per accedere al buffer di rugosità usa:

var render_scene_buffers = render_data.get_render_scene_buffers()
var roughness_buffer = render_scene_buffers.get_texture("forward_clustered", "normal_roughness")

Il buffer grezzo di rugosità e di normale è memorizzato in un formato ottimizzato, diverso da quello disponibile negli shader Spatial. Quando viene campionato il buffer, è necessario applicare una funzione di conversione. Usa questa funzione, copiata da qui:

vec4 normal_roughness_compatibility(vec4 p_normal_roughness) {
    float roughness = p_normal_roughness.w;
    if (roughness > 0.5) {
        roughness = 1.0 - roughness;
    }
    roughness /= (127.0 / 255.0);
    return vec4(normalize(p_normal_roughness.xyz * 2.0 - 1.0) * 0.5 + 0.5, roughness);
}

bool needs_separate_specular 🔗

void set_needs_separate_specular(value: bool)
bool get_needs_separate_specular()

Se true questo attiva il rendering dei dati speculari in un buffer separato e li combina dopo che gli effetti siano applicati, applicabile solo per il renderer Forward+.

Descrizioni dei metodi

void _render_callback(effect_callback_type: int, render_data: RenderData) virtual 🔗

Implementa questa funzione con il tuo codice di rendering personalizzato. effect_callback_type dovrebbe sempre corrispondere al tipo di callback dell'effetto specificato in effect_callback_type. render_data fornisce l'accesso allo stato di rendering, è valido solo durante il rendering e non dovrebbe essere memorizzato.