mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
225 lines
10 KiB
ReStructuredText
225 lines
10 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Sky:
|
||
|
||
Sky
|
||
===
|
||
|
||
**Hérite de :** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
||
|
||
Définit l'arrière-plan d'un environnement 3D en utilisant un :ref:`Material<class_Material>`.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Description
|
||
-----------
|
||
|
||
La classe **Sky** utilise un :ref:`Material<class_Material>` pour rendre le fond d'un environnement 3D (son ciel) et la lumière qu'il émet en mettant à jour les cubemaps de réflexion/radiance.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Propriétés
|
||
--------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+--------------------------------------------+--------------------------------------------------------+-------+
|
||
| :ref:`ProcessMode<enum_Sky_ProcessMode>` | :ref:`process_mode<class_Sky_property_process_mode>` | ``0`` |
|
||
+--------------------------------------------+--------------------------------------------------------+-------+
|
||
| :ref:`RadianceSize<enum_Sky_RadianceSize>` | :ref:`radiance_size<class_Sky_property_radiance_size>` | ``3`` |
|
||
+--------------------------------------------+--------------------------------------------------------+-------+
|
||
| :ref:`Material<class_Material>` | :ref:`sky_material<class_Sky_property_sky_material>` | |
|
||
+--------------------------------------------+--------------------------------------------------------+-------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Énumérations
|
||
------------------------
|
||
|
||
.. _enum_Sky_RadianceSize:
|
||
|
||
.. rst-class:: classref-enumeration
|
||
|
||
enum **RadianceSize**: :ref:`🔗<enum_Sky_RadianceSize>`
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_32:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_32** = ``0``
|
||
|
||
La texture de rayonnement fait 32x32 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_64:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_64** = ``1``
|
||
|
||
La texture de rayonnement fait 64x64 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_128:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_128** = ``2``
|
||
|
||
La texture de rayonnement fait 128x128 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_256:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_256** = ``3``
|
||
|
||
La texture de rayonnement fait 256x256 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_512:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_512** = ``4``
|
||
|
||
La texture de rayonnement fait 512x512 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_1024:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_1024** = ``5``
|
||
|
||
La texture de rayonnement fait 1024×1024 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_2048:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_2048** = ``6``
|
||
|
||
La texture de rayonnement fait 2048×2048 pixels.
|
||
|
||
.. _class_Sky_constant_RADIANCE_SIZE_MAX:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **RADIANCE_SIZE_MAX** = ``7``
|
||
|
||
Représente la taille de l'énumération :ref:`RadianceSize<enum_Sky_RadianceSize>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _enum_Sky_ProcessMode:
|
||
|
||
.. rst-class:: classref-enumeration
|
||
|
||
enum **ProcessMode**: :ref:`🔗<enum_Sky_ProcessMode>`
|
||
|
||
.. _class_Sky_constant_PROCESS_MODE_AUTOMATIC:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`ProcessMode<enum_Sky_ProcessMode>` **PROCESS_MODE_AUTOMATIC** = ``0``
|
||
|
||
Sélectionner automatiquement le mode de traitement approprié basé sur votre shader de ciel. Si votre shader utilise ``TIME`` ou ``POSITION``, cela utilisera :ref:`PROCESS_MODE_REALTIME<class_Sky_constant_PROCESS_MODE_REALTIME>`. Si votre shader utilise l'une des variables ``LIGHT_*`` ou tout uniform personnalisé, cela utilise :ref:`PROCESS_MODE_INCREMENTAL<class_Sky_constant_PROCESS_MODE_INCREMENTAL>`. Sinon, cela utilisera par défaut :ref:`PROCESS_MODE_QUALITY<class_Sky_constant_PROCESS_MODE_QUALITY>`.
|
||
|
||
.. _class_Sky_constant_PROCESS_MODE_QUALITY:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`ProcessMode<enum_Sky_ProcessMode>` **PROCESS_MODE_QUALITY** = ``1``
|
||
|
||
Utiliser un échantillonnage d'importance de haute qualité pour traiter la radiance map. En général, cela résulte en une qualité beaucoup plus élevée que :ref:`PROCESS_MODE_REALTIME<class_Sky_constant_PROCESS_MODE_REALTIME>` mais prend beaucoup plus de temps à générer. Cela ne devrait pas être utilisé si vous prévoyez de changer le ciel durant l'exécution. Si vous constatez que la réflexion n'est pas assez floue et affiche des étincelles ou des lucioles, essayez d'augmenter :ref:`ProjectSettings.rendering/reflections/sky_reflections/ggx_samples<class_ProjectSettings_property_rendering/reflections/sky_reflections/ggx_samples>`.
|
||
|
||
.. _class_Sky_constant_PROCESS_MODE_INCREMENTAL:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`ProcessMode<enum_Sky_ProcessMode>` **PROCESS_MODE_INCREMENTAL** = ``2``
|
||
|
||
Utiliser le même échantillonnage d'importance de haute qualité pour traiter la radiance map que :ref:`PROCESS_MODE_QUALITY<class_Sky_constant_PROCESS_MODE_QUALITY>`, mais se met à jour sur plusieurs trames. Le nombre de trames est déterminé par :ref:`ProjectSettings.rendering/reflections/sky_reflections/roughness_layers<class_ProjectSettings_property_rendering/reflections/sky_reflections/roughness_layers>`. Utilisez ceci lorsque vous avez besoin de radiance map de la plus haute qualité, mais que vous avez un ciel qui se met à jour lentement.
|
||
|
||
.. _class_Sky_constant_PROCESS_MODE_REALTIME:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`ProcessMode<enum_Sky_ProcessMode>` **PROCESS_MODE_REALTIME** = ``3``
|
||
|
||
Utiliser l'algorithme de filtrage rapide pour traiter la radiance map. En général, cela résulte en une qualité inférieure, mais en des temps d'exécution nettement plus rapides. Si vous avez besoin d'une meilleure qualité, mais avez toujours besoin de mettre à jour le ciel à chaque trame, envisagez d'activer :ref:`ProjectSettings.rendering/reflections/sky_reflections/fast_filter_high_quality<class_ProjectSettings_property_rendering/reflections/sky_reflections/fast_filter_high_quality>`.
|
||
|
||
\ **Note :** L'algorithme de filtrage rapide est limité à des cubemaps 256×256, donc :ref:`radiance_size<class_Sky_property_radiance_size>` doit être défini à :ref:`RADIANCE_SIZE_256<class_Sky_constant_RADIANCE_SIZE_256>`. Sinon, un avertissement est affiché et la taille du rayonnement redéfinie est ignorée.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Descriptions des propriétés
|
||
------------------------------------------------------
|
||
|
||
.. _class_Sky_property_process_mode:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`ProcessMode<enum_Sky_ProcessMode>` **process_mode** = ``0`` :ref:`🔗<class_Sky_property_process_mode>`
|
||
|
||
.. rst-class:: classref-property-setget
|
||
|
||
- |void| **set_process_mode**\ (\ value\: :ref:`ProcessMode<enum_Sky_ProcessMode>`\ )
|
||
- :ref:`ProcessMode<enum_Sky_ProcessMode>` **get_process_mode**\ (\ )
|
||
|
||
La méthode pour générer la radiance map du ciel. La radiance map est une cubemap avec des versions de plus en plus floues du ciel correspondant à différents niveaux de rugosité. Les radiance maps peuvent être chères à calculer.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Sky_property_radiance_size:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`RadianceSize<enum_Sky_RadianceSize>` **radiance_size** = ``3`` :ref:`🔗<class_Sky_property_radiance_size>`
|
||
|
||
.. rst-class:: classref-property-setget
|
||
|
||
- |void| **set_radiance_size**\ (\ value\: :ref:`RadianceSize<enum_Sky_RadianceSize>`\ )
|
||
- :ref:`RadianceSize<enum_Sky_RadianceSize>` **get_radiance_size**\ (\ )
|
||
|
||
La taille de la radiance map du **Sky**. Plus la taille de la radiance map sera élevée, plus l'éclairage du ciel **Sky** sera détaillé.
|
||
|
||
\ **Note :** Certains matériels auront des problèmes avec des tailles de radiance plus élevées, en particulier pour :ref:`RADIANCE_SIZE_512<class_Sky_constant_RADIANCE_SIZE_512>` et plus. Utilisez ces valeurs élevées seulement sur du matériel haut de gamme.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Sky_property_sky_material:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`Material<class_Material>` **sky_material** :ref:`🔗<class_Sky_property_sky_material>`
|
||
|
||
.. rst-class:: classref-property-setget
|
||
|
||
- |void| **set_material**\ (\ value\: :ref:`Material<class_Material>`\ )
|
||
- :ref:`Material<class_Material>` **get_material**\ (\ )
|
||
|
||
:ref:`Material<class_Material>` utilisé pour dessiner l'arrière-plan. Peut être un :ref:`PanoramaSkyMaterial<class_PanoramaSkyMaterial>`, :ref:`ProceduralSkyMaterial<class_ProceduralSkyMaterial>`, :ref:`PhysicalSkyMaterial<class_PhysicalSkyMaterial>`, ou même un :ref:`ShaderMaterial<class_ShaderMaterial>` si vous voulez utiliser votre propre shader personnalisé.
|
||
|
||
.. |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.)`
|