mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
318 lines
14 KiB
ReStructuredText
318 lines
14 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_CompositorEffect:
|
||
|
||
CompositorEffect
|
||
================
|
||
|
||
**Expérimental :** The implementation may change as more of the rendering internals are exposed over time.
|
||
|
||
**Hérite de :** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
||
|
||
Cette ressource permet de créer un effet de rendu personnalisé.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Description
|
||
-----------
|
||
|
||
Cette ressource définit un effet de rendu personnalisé qui peut être appliqué à des :ref:`Viewport<class_Viewport>`\ s par l'intermédiaire de l'environnement :ref:`Environment<class_Environment>`. Vous pouvez implémenter un callback qui est appelé lors du rendu à une étape donnée de la pipeline de rendu et vous permet d'insérer des passes supplémentaires. Notez que cet appel se produit sur le thread de rendu. CompositorEffect est une classe de base abstraite et doit être étendue pour implémenter une logique de rendu spécifique.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Tutoriels
|
||
------------------
|
||
|
||
- :doc:`Le compositeur <../tutorials/rendering/compositor>`
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Propriétés
|
||
--------------------
|
||
|
||
.. 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éthodes
|
||
----------------
|
||
|
||
.. 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
|
||
|
||
Énumérations
|
||
------------------------
|
||
|
||
.. _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``
|
||
|
||
Le callback est appelé avant notre passe de rendu opaque, mais après la pré-passe de profondeur (le cas échéant).
|
||
|
||
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_OPAQUE:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_POST_OPAQUE** = ``1``
|
||
|
||
Le callback est appelé après notre passe de rendu opaque, mais avant que notre ciel soit rendu.
|
||
|
||
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_SKY:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_POST_SKY** = ``2``
|
||
|
||
Le callback est appelé après que notre ciel soit rendu, mais avant que nos buffers arrières soient créés (et si activés, avant la transluminescence et/ou les réflexions de l'espace-écran).
|
||
|
||
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT** = ``3``
|
||
|
||
The callback is called before our transparent rendering pass, but after our sky is rendered and we've created our back buffers.
|
||
|
||
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_POST_TRANSPARENT:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_POST_TRANSPARENT** = ``4``
|
||
|
||
The callback is called after our transparent rendering pass, but before any built-in post-processing effects and output to our render target.
|
||
|
||
.. _class_CompositorEffect_constant_EFFECT_CALLBACK_TYPE_MAX:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>` **EFFECT_CALLBACK_TYPE_MAX** = ``5``
|
||
|
||
Représente la taille de l'énumération :ref:`EffectCallbackType<enum_CompositorEffect_EffectCallbackType>`.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Descriptions des propriétés
|
||
------------------------------------------------------
|
||
|
||
.. _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**\ (\ )
|
||
|
||
If ``true`` and MSAA is enabled, this will trigger a color buffer resolve before the effect is run.
|
||
|
||
\ **Note:** In :ref:`_render_callback()<class_CompositorEffect_private_method__render_callback>`, to access the resolved buffer use:
|
||
|
||
::
|
||
|
||
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**\ (\ )
|
||
|
||
If ``true`` and MSAA is enabled, this will trigger a depth buffer resolve before the effect is run.
|
||
|
||
\ **Note:** In :ref:`_render_callback()<class_CompositorEffect_private_method__render_callback>`, to access the resolved buffer use:
|
||
|
||
::
|
||
|
||
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**\ (\ )
|
||
|
||
Le type d'effet qui est implémenté, détermine à quel stade du rendu le callback est appelé.
|
||
|
||
.. 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 ``true``, cet effet de rendu est appliqué à tout viewport auquel il est ajouté.
|
||
|
||
.. 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**\ (\ )
|
||
|
||
If ``true`` this triggers motion vectors being calculated during the opaque render state.
|
||
|
||
\ **Note:** In :ref:`_render_callback()<class_CompositorEffect_private_method__render_callback>`, to access the motion vector buffer use:
|
||
|
||
::
|
||
|
||
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**\ (\ )
|
||
|
||
If ``true`` this triggers normal and roughness data to be output during our depth pre-pass, only applicable for the Forward+ renderer.
|
||
|
||
\ **Note:** In :ref:`_render_callback()<class_CompositorEffect_private_method__render_callback>`, to access the roughness buffer use:
|
||
|
||
::
|
||
|
||
var render_scene_buffers = render_data.get_render_scene_buffers()
|
||
var roughness_buffer = render_scene_buffers.get_texture("forward_clustered", "normal_roughness")
|
||
|
||
The raw normal and roughness buffer is stored in an optimized format, different than the one available in Spatial shaders. When sampling the buffer, a conversion function must be applied. Use this function, copied from `here <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**\ (\ )
|
||
|
||
If ``true`` this triggers specular data being rendered to a separate buffer and combined after effects have been applied, only applicable for the Forward+ renderer.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Descriptions des méthodes
|
||
--------------------------------------------------
|
||
|
||
.. _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>`
|
||
|
||
Implémentez cette fonction avec votre code de rendu personnalisé. ``effect_callback_type`` doit toujours correspondre au type du callback d'effet que vous avez spécifié dans :ref:`effect_callback_type<class_CompositorEffect_property_effect_callback_type>`. ``render_data`` donne accès à l'état du rendu, il n'est valable que pendant le rendu et ne doit pas être stocké.
|
||
|
||
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
|
||
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
||
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
|
||
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
|
||
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
|
||
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
|
||
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
|
||
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
|
||
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
|