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

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

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 callback 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 callback 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 callback 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 callback 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 callback 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 🔗

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