mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
318 lines
15 KiB
ReStructuredText
318 lines
15 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_CompositorEffect:
|
|
|
|
CompositorEffect
|
|
================
|
|
|
|
**Experimental:** The implementation may change as more of the rendering internals are exposed over time.
|
|
|
|
**Hereda:** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
|
|
|
Este recurso permite crear un efecto de renderizado personalizado.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Este recurso define un efecto de renderizado personalizado que se puede aplicar a los :ref:`Viewport<class_Viewport>`\ s a través del :ref:`Environment<class_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.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutoriales
|
|
--------------------
|
|
|
|
- :doc:`El Compositor <../tutorials/rendering/compositor>`
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`access_resolved_color<class_CompositorEffect_property_access_resolved_color>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`access_resolved_depth<class_CompositorEffect_property_access_resolved_depth>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` | :ref:`effect_callback_type<class_CompositorEffect_property_effect_callback_type>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`enabled<class_CompositorEffect_property_enabled>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`needs_motion_vectors<class_CompositorEffect_property_needs_motion_vectors>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`needs_normal_roughness<class_CompositorEffect_property_needs_normal_roughness>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`needs_separate_specular<class_CompositorEffect_property_needs_separate_specular>` |
|
|
+---------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`_render_callback<class_CompositorEffect_private_method__render_callback>`\ (\ effect_callback_type\: :ref:`int<class_int>`, render_data\: :ref:`RenderData<class_RenderData>`\ ) |virtual| |
|
|
+--------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _enum_CompositorEffect_EffectCallbackType:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **EffectCallbackType**: :ref:`🔗<enum_CompositorEffect_EffectCallbackType>`
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_PRE_OPAQUE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_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).
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_OPAQUE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_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.
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_SKY:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_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).
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_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.
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_TRANSPARENT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_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.
|
|
|
|
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_MAX:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_MAX** = ``5``
|
|
|
|
Representa el tamaño del enum :ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>`.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_CompositorEffect_property_access_resolved_color:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **access_resolved_color** :ref:`🔗<class_CompositorEffect_property_access_resolved_color>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_access_resolved_color**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_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 :ref:`_render_callback()<class_CompositorEffect_private_method__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")
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_access_resolved_depth:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **access_resolved_depth** :ref:`🔗<class_CompositorEffect_property_access_resolved_depth>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_access_resolved_depth**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_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 :ref:`_render_callback()<class_CompositorEffect_private_method__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")
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_effect_callback_type:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **effect_callback_type** :ref:`🔗<class_CompositorEffect_property_effect_callback_type>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_effect_callback_type**\ (\ value\: :ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>`\ )
|
|
- :ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **get_effect_callback_type**\ (\ )
|
|
|
|
El tipo de efecto que se implementa determina en qué etapa del renderizado se llama al callback.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_enabled:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **enabled** :ref:`🔗<class_CompositorEffect_property_enabled>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **get_enabled**\ (\ )
|
|
|
|
Si es ``true``, este efecto de renderizado se aplica a cualquier viewport al que se añada.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_needs_motion_vectors:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **needs_motion_vectors** :ref:`🔗<class_CompositorEffect_property_needs_motion_vectors>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_needs_motion_vectors**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_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 :ref:`_render_callback()<class_CompositorEffect_private_method__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()
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_needs_normal_roughness:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **needs_normal_roughness** :ref:`🔗<class_CompositorEffect_property_needs_normal_roughness>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_needs_normal_roughness**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_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 :ref:`_render_callback()<class_CompositorEffect_private_method__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í <https://github.com/godotengine/godot/blob/da5f39889f155658cef7f7ec3cc1abb94e17d815/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered_inc.glsl#L334-L341>`__:
|
|
|
|
::
|
|
|
|
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);
|
|
}
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_CompositorEffect_property_needs_separate_specular:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **needs_separate_specular** :ref:`🔗<class_CompositorEffect_property_needs_separate_specular>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_needs_separate_specular**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_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+.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_CompositorEffect_private_method__render_callback:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **_render_callback**\ (\ effect_callback_type\: :ref:`int<class_int>`, render_data\: :ref:`RenderData<class_RenderData>`\ ) |virtual| :ref:`🔗<class_CompositorEffect_private_method__render_callback>`
|
|
|
|
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 :ref:`effect_callback_type<class_CompositorEffect_property_effect_callback_type>`. ``render_data`` proporciona acceso al estado de renderizado, sólo es válido durante el renderizado y no debe ser almacenado.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
|
|
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
|
|
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
|