CompositorEffect

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

Hereda: Resource < RefCounted < Object

Este recurso permite crear un efecto de renderizado personalizado.

Descripción

Este recurso define un efecto de renderizado personalizado que se puede aplicar a los Viewports a través del Environment de los viewports. Puedes implementar una retrollamada que se llama durante el renderizado en una etapa dada de la pipeline de renderizado y te permite insertar pases adicionales. Ten en cuenta que esta retrollamada se produce en el hilo de renderizado. CompositorEffect es una clase base abstracta y debe ser extendida para implementar una lógica de renderizado específica.

Tutoriales

El Compositor

Propiedades

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

Métodos

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

Enumeraciones

enum EffectCallbackType: 🔗

EffectCallbackType EFFECT_CALLBACK_TYPE_PRE_OPAQUE = 0

La retrollamada se llama antes de nuestro pase de renderizado opaco, pero después del pre-pase de profundidad (si corresponde).

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_OPAQUE = 1

La retrollamada se llama después de nuestro pase de renderizado opaco, pero antes de que se renderice nuestro cielo.

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_SKY = 2

La retrollamada se llama después de que se renderice nuestro cielo, pero antes de que se creen nuestros búferes de fondo (y, si está habilitado, antes de la dispersión subsuperficial y/o los reflejos del espacio de pantalla).

EffectCallbackType EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT = 3

La retrollamada se llama antes de nuestro pase de renderizado transparente, pero después de que se renderice nuestro cielo y hayamos creado nuestros búferes de fondo.

EffectCallbackType EFFECT_CALLBACK_TYPE_POST_TRANSPARENT = 4

La retrollamada se llama después de nuestro pase de renderizado transparente, pero antes de cualquier efecto de post-procesamiento incorporado y de la salida a nuestro objetivo de renderizado.

EffectCallbackType EFFECT_CALLBACK_TYPE_MAX = 5

Representa el tamaño del enum EffectCallbackType.

Descripciones de Propiedades

bool access_resolved_color 🔗

void set_access_resolved_color(value: bool)
bool get_access_resolved_color()

Si es true y MSAA está habilitado, esto activará una resolución del búfer de color antes de que se ejecute el efecto.

Nota: En _render_callback(), para acceder al búfer resuelto, 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()

Si es true y MSAA está habilitado, esto activará una resolución del búfer de profundidad antes de que se ejecute el efecto.

Nota: En _render_callback(), para acceder al búfer resuelto, 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()

El tipo de efecto que se implementa determina en qué etapa del renderizado se llama al callback.

bool enabled 🔗

void set_enabled(value: bool)
bool get_enabled()

Si es true, este efecto de renderizado se aplica a cualquier viewport al que se añada.

bool needs_motion_vectors 🔗

void set_needs_motion_vectors(value: bool)
bool get_needs_motion_vectors()

Si es true, esto activa el cálculo de vectores de movimiento durante el estado de renderizado opaco.

Nota: En _render_callback(), para acceder al búfer de vectores de movimiento, 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()

Si es true, esto activa la salida de los datos normales y de rugosidad durante nuestro pre-pase de profundidad, solo aplicable para el renderizador Forward+.

Nota: En _render_callback(), para acceder al búfer de rugosidad, usa:

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

El búfer bruto normal y de rugosidad se almacena en un formato optimizado, diferente del disponible en los shaders espaciales. Al muestrear el búfer, debe aplicarse una función de conversión. Usa esta función, copiada de aquí:

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()

Si es true, esto activa que los datos especulares se rendericen en un búfer separado y se combinen después de que se hayan aplicado los efectos, solo aplicable para el renderizador Forward+.

Descripciones de Métodos

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

Implementa esta función con tu código de renderizado personalizado. effect_callback_type siempre debe coincidir con el tipo de retrollamada de efecto que has especificado en effect_callback_type. render_data proporciona acceso al estado de renderizado, sólo es válido durante el renderizado y no debe ser almacenado.