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...
Environment
Hérite de : Resource < RefCounted < Object
Ressource pour les nœuds d’environnement (comme WorldEnvironment) qui définissent plusieurs options de rendu.
Description
Resource for environment nodes (like WorldEnvironment) that define multiple environment operations (such as background Sky or Color, ambient light, fog, depth-of-field...). These parameters affect the final render of the scene. The order of these operations is:
Depth of Field Blur
Auto Exposure
Glow
Tonemap
Adjustments
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Méthodes
get_glow_level(idx: int) const |
|
void |
set_glow_level(idx: int, intensity: float) |
Énumérations
enum BGMode: 🔗
BGMode BG_CLEAR_COLOR = 0
Efface l'arrière-plan en utilisant la couleur d'effacement définie dans ProjectSettings.rendering/environment/defaults/default_clear_color.
BGMode BG_COLOR = 1
Efface l'arrière-plan en utilisant la couleur d'effacement personnalisée.
BGMode BG_SKY = 2
Affiche un ciel personnalisé en arrière-plan.
BGMode BG_CANVAS = 3
Affiche un CanvasLayer en arrière-plan.
BGMode BG_KEEP = 4
Garde à l'écran chaque pixel dessiné à l'arrière-plan. Il s'agit du mode d'arrière-plan le plus rapide, mais il ne peut être utilisé en toute sécurité que dans des scènes entièrement intérieures (pas de ciel visible ou de reflets du ciel). S'il est activé dans une scène où l'arrière-plan est visible, des artéfacts de "ghost trail" (traînées fantômes) seront visibles lors du déplacement de la caméra.
BGMode BG_CAMERA_FEED = 5
Afficher le flux de la caméra en arrière-plan.
BGMode BG_MAX = 6
Représente la taille de l'énumération BGMode.
enum AmbientSource: 🔗
AmbientSource AMBIENT_SOURCE_BG = 0
Recueillir la lumière ambiante depuis la source spécifiée comme arrière-plan.
AmbientSource AMBIENT_SOURCE_DISABLED = 1
Désactiver la lumière ambiante. Ceci fournit un léger boost de performance par rapport à AMBIENT_SOURCE_SKY.
AmbientSource AMBIENT_SOURCE_COLOR = 2
Spécifier une Color spécifique pour la lumière ambiante. Ceci fournit un léger boost de performance par rapport à AMBIENT_SOURCE_SKY.
AmbientSource AMBIENT_SOURCE_SKY = 3
Recueillir la lumière ambiante depuis le Sky peu importe de ce qu'est l'arrière-plan.
enum ReflectionSource: 🔗
ReflectionSource REFLECTION_SOURCE_BG = 0
Utiliser l'arrière-plan pour les réflexions.
ReflectionSource REFLECTION_SOURCE_DISABLED = 1
Désactiver les réflexions. Cela donne un léger boost de performance par rapport aux autres options.
ReflectionSource REFLECTION_SOURCE_SKY = 2
Utiliser le Sky pour les réflexions quel que soit l'arrière-plan.
enum ToneMapper: 🔗
ToneMapper TONE_MAPPER_LINEAR = 0
Does not modify color data, resulting in a linear tonemapping curve which unnaturally clips bright values, causing bright lighting to look blown out. The simplest and fastest tonemapper.
ToneMapper TONE_MAPPER_REINHARDT = 1
A simple tonemapping curve that rolls off bright values to prevent clipping. This results in an image that can appear dull and low contrast. Slower than TONE_MAPPER_LINEAR.
Note: When tonemap_white is left at the default value of 1.0, TONE_MAPPER_REINHARDT produces an identical image to TONE_MAPPER_LINEAR.
ToneMapper TONE_MAPPER_FILMIC = 2
Uses a film-like tonemapping curve to prevent clipping of bright values and provide better contrast than TONE_MAPPER_REINHARDT. Slightly slower than TONE_MAPPER_REINHARDT.
Note: This tonemapper does not support HDR output because it produces output in the SDR range. It is recommended to use a different tonemapper when rendering to an HDR screen.
ToneMapper TONE_MAPPER_ACES = 3
Uses a high-contrast film-like tonemapping curve and desaturates bright values for a more realistic appearance. Slightly slower than TONE_MAPPER_FILMIC.
Note: This tonemapping operator is called "ACES Fitted" in Godot 3.x.
Note: This tonemapper does not support HDR output because it produces output in the SDR range. It is recommended to use a different tonemapper when rendering to an HDR screen.
ToneMapper TONE_MAPPER_AGX = 4
Uses an adjustable film-like tonemapping curve and desaturates bright values for a more realistic appearance. Better than other tonemappers at maintaining the hue of colors as they become brighter. The slowest tonemapping option.
enum GlowBlendMode: 🔗
GlowBlendMode GLOW_BLEND_MODE_ADDITIVE = 0
Adds the glow effect to the scene.
GlowBlendMode GLOW_BLEND_MODE_SCREEN = 1
Adds the glow effect to the scene after modifying the glow influence based on the scene value; dark values will be highly influenced by glow and bright values will not be influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. tonemap_white is used to determine the maximum scene value where the glow should have no influence. When tonemap_mode is set to TONE_MAPPER_LINEAR and Viewport.use_hdr_2d is true, the parent window's Window.get_output_max_linear_value() will be used as the maximum scene value.
GlowBlendMode GLOW_BLEND_MODE_SOFTLIGHT = 2
Adds the glow effect to the tonemapped image after modifying the glow influence based on the image value; dark values and bright values will not be influenced by glow and mid-range values will be highly influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. The glow will have the largest influence on image values of 0.25 and will have no influence when applied to image values greater than 1.0.
Note: This blend mode does not support HDR output because expects a maximum output value of 1.0. It is recommended to use a different blend mode when rendering to an HDR screen.
GlowBlendMode GLOW_BLEND_MODE_REPLACE = 3
Replaces all pixels' color by the glow effect. This can be used to simulate a full-screen blur effect by tweaking the glow parameters to match the original image's brightness or to preview glow configuration in the editor.
GlowBlendMode GLOW_BLEND_MODE_MIX = 4
Mixes the glow image with the scene image. Best used with glow_bloom to avoid darkening the scene.
enum FogMode: 🔗
FogMode FOG_MODE_EXPONENTIAL = 0
Utiliser un modèle de brouillard physique défini principalement par la densité du brouillard.
FogMode FOG_MODE_DEPTH = 1
Utiliser un modèle de brouillard simple défini par les positions de démarrage et de fin et une courbe personnalisée. Bien qu'il ne soit pas physiquement exact, ce modèle peut être utile lorsque vous avez besoin d'un contrôle plus artistique.
enum SDFGIYScale: 🔗
SDFGIYScale SDFGI_Y_SCALE_50_PERCENT = 0
Utiliser une échelle de 50% pour la SDFGI sur l'axe Y (vertical). Les cellules de la SDFGI seront deux fois plus courtes que larges. Cela permet d'augmenter les détails de la GI et de réduire les fuites de lumière avec des sols et des plafonds minces. Il s'agit généralement du meilleur choix pour les scènes qui ne présentent pas beaucoup de verticalité.
SDFGIYScale SDFGI_Y_SCALE_75_PERCENT = 1
Utiliser une échelle de 75% pour la SDFGI sur l'axe Y (vertical). Il s'agit d'un équilibre entre les échelles en Y 50% et 100% de la SDFGI.
SDFGIYScale SDFGI_Y_SCALE_100_PERCENT = 2
Utiliser une échelle de 100% pour la SDFGI sur l'axe Y (vertical). Les cellules de la SDFGI seront deux fois plus grandes que larges. Il s'agit généralement du meilleur choix pour les scènes très verticales. Le désavantage est que les fuites de lumières peuvent être plus visibles avec des sols et des plafonds minces.
Descriptions des propriétés
float adjustment_brightness = 1.0 🔗
Applies a simple brightness adjustment to the rendered image after tonemaping. To adjust scene brightness use tonemap_exposure instead, which is applied before tonemapping and thus less prone to issues with bright colors. Effective only if adjustment_enabled is true.
Texture adjustment_color_correction 🔗
The Texture2D or Texture3D lookup table (LUT) to use for the built-in post-process color grading. Can use a GradientTexture1D for a 1-dimensional LUT, or a Texture3D for a more complex LUT. Effective only if adjustment_enabled is true.
Note: Color correction does not currently support HDR output due to only supporting values in the SDR (0.0 to 1.0) range.
float adjustment_contrast = 1.0 🔗
Increasing adjustment_contrast will make dark values darker and bright values brighter. This simple adjustment is applied to the rendered image after tonemaping. When set to a value greater than 1.0, adjustment_contrast is prone to clipping colors that become too bright or too dark. Effective only if adjustment_enabled is true.
bool adjustment_enabled = false 🔗
Si true, active les propriétés adjustment_* fournies par cette ressource. Si false, les modifications aux propriétés adjustment_* n'auront aucun effet sur la scène rendue.
float adjustment_saturation = 1.0 🔗
Applies a simple saturation adjustment to the rendered image after tonemaping. When adjustment_saturation is set to 0.0, the rendered image will be fully converted to a grayscale image. Effective only if adjustment_enabled is true.
Color ambient_light_color = Color(0, 0, 0, 1) 🔗
La Color de la lumière ambiante. Seulement effectif si ambient_light_sky_contribution est inférieur à 1.0 (exclusif).
float ambient_light_energy = 1.0 🔗
L'énergie de la lumière ambiante. Plus la valeur est élevée, plus la lumière est forte. Seulement efficace si ambient_light_sky_contribution est inférieur à 1.0 (exclusif).
float ambient_light_sky_contribution = 1.0 🔗
Définit la quantité de lumière que le ciel apporte à la scène. Une valeur de 0.0 signifie que l'émission de lumière du ciel n'a aucun effet sur l'éclairage de la scène, de sorte que tout l'éclairage ambiant est fourni par la lumière ambiante. Au contraire, une valeur de 1.0 signifie que toute la lumière qui affecte la scène est fournie par le ciel, donc le paramètre de lumière ambiante n'a aucun effet sur la scène.
Note : ambient_light_sky_contribution est borné en interne entre 0.0 et 1.0 (inclusifs).
AmbientSource ambient_light_source = 0 🔗
void set_ambient_source(value: AmbientSource)
AmbientSource get_ambient_source()
La source de lumière ambiante à utiliser pour le rendu des matériaux et l'illumination globale.
int background_camera_feed_id = 1 🔗
L'identifiant du flux de la caméra à afficher en arrière-plan.
int background_canvas_max_layer = 0 🔗
L'ID de couche maximale à afficher. Seulement effectif lors de l'utilisation du mode d'arrière-plan BG_CANVAS.
Color background_color = Color(0, 0, 0, 1) 🔗
La Color affichée pour les zones vides de la scène. Seulement effectif lors de l'utilisation du mode d'arrière-plan BG_COLOR.
float background_energy_multiplier = 1.0 🔗
Multiplicateur pour l'énergie de l'arrière-plan. Augmentez pour rendre le fond plus clair, diminuer pour rendre le fond plus sombre.
float background_intensity = 30000.0 🔗
Luminance de l'arrière-plan mesurée en nits (candela par mètre carré). Seulement utilisé lorsque ProjectSettings.rendering/lights_and_shadows/use_physical_light_units est activé. La valeur par défaut est à peu près équivalente au ciel à midi.
Le mode d'arrière-plan.
float fog_aerial_perspective = 0.0 🔗
Si défini au dessus de 0.0 (exclusif), mélange la couleur du brouillard et la couleur du Sky d'arrière-plan, comme lu de cubemap de radiance. Cela a un petit coût de performance lorsque défini au dessus de 0.0. Doit avoir background_mode défini à BG_SKY.
Ceci est utile pour simuler la perspective aérienne dans de grandes scènes avec un brouillard à faible densité. Cependant, il n'est pas très utile pour le brouillard de haute densité, car le ciel brillera à travers. Lorsque défini à 1.0, la couleur du brouillard provient entièrement du Sky. Si défini à 0.0, la perspective aérienne est désactivée.
Notez que cela n'échantillonne pas le Sky directement, mais plutôt la cubemap de radiance. La cubemap est échantillonnée à un niveau de mipmap dépendant de la profondeur du pixel rendu, plus il est loin, plus la résolution de la mipmap échantillonnée est élevée. Cela résulte en la couleur réelle étant une version floue de celle du ciel, avec plus de flou lorsque plus proche de la caméra. La plus haute résolution de mipmap est utilisée à une profondeur de Camera3D.far.
La densité de brouillard à utiliser. Ceci est démontré de différentes manières selon le mode fog_mode choisi :
Mode de brouillard exponentiel : Des valeurs plus élevées résultent en un brouillard plus dense. Le rendu du brouillard est exponentiel comme dans la vie réelle.
Mode de brouillard de profondeur : L'intensité maximale du brouillard profond, l'effet apparaîtra à une certaine distance (relative à la caméra). À 1.0, le brouillard occultera entièrement la scène, à 0.0, le brouillard ne sera pas visible.
float fog_depth_begin = 10.0 🔗
La distance de départ à partir de la caméra de la profondeur du brouillard. Seulement disponible lorsque fog_mode est défini à FOG_MODE_DEPTH.
La courbe d'intensité de la profondeur brouillard. Un certain nombre de pré-réglages sont disponibles dans l'Inspecteur en faisant un clic droit sur la courbe. Seulement disponible lorsque fog_mode est défini à FOG_MODE_DEPTH.
La distance de fin à partir de la caméra de la profondeur du brouillard. Si cette valeur est défini à 0, elle sera égale à la valeur de Camera3D.far de la caméra actuelle. Seulement disponible lorsque fog_mode est défini à FOG_MODE_DEPTH.
Si true, les effets de brouillard sont activés.
La hauteur à laquelle commence l'effet de brouillard de hauteur.
float fog_height_density = 0.0 🔗
La densité utilisée pour augmenter le brouillard à mesure que la hauteur diminue. Pour augmenter le brouillard à mesure que la hauteur augmente, utilisez une valeur négative.
Color fog_light_color = Color(0.518, 0.553, 0.608, 1) 🔗
La couleur du brouillard.
float fog_light_energy = 1.0 🔗
La luminosité du brouillard. Des valeurs plus élevées entraînent un brouillard plus lumineux.
Le mode du brouillard.
Le facteur à utiliser lorsque le ciel est affecté avec un brouillard non volumétrique. 1.0 signifie que le brouillard peut masquer pleinement le ciel. Les valeurs inférieures réduisent l'impact du brouillard sur le rendu du ciel, avec 0.0 qui n'affecte pas le rendu du ciel.
Note : fog_sky_affect n'a aucun effet visuel si fog_aerial_perspective vaut 1.0.
Si définie au-dessus de 0.0, rend la/les lumière(s) directionnelle(s) de la scène avec la couleur du brouillard selon l'angle de vue. Cela peut être utilisé pour donner l'impression que le soleil est "perce" à travers le brouillard.
GlowBlendMode glow_blend_mode = 1 🔗
void set_glow_blend_mode(value: GlowBlendMode)
GlowBlendMode get_glow_blend_mode()
The glow blending mode.
Note: The Compatibility renderer always uses GLOW_BLEND_MODE_SCREEN and glow_blend_mode will have no effect.
L'intensité du flou lumineux. Si la valeur est supérieure à 0, cela rend le glow visible dans les zones plus foncées que le seuil glow_hdr_threshold.
If true, the glow effect is enabled. This simulates real world atmosphere and eye/camera behavior by causing bright pixels to bleed onto surrounding pixels.
Note: When using the Mobile rendering method, glow looks different due to the lower dynamic range available in the Mobile rendering method.
Note: When using the Compatibility rendering method, glow uses a different implementation with some properties being unavailable and hidden from the inspector: glow_levels/*, glow_normalized, glow_strength, glow_blend_mode, glow_mix, glow_map, and glow_map_strength. This implementation is optimized to run on low-end devices and is less flexible as a result.
float glow_hdr_luminance_cap = 12.0 🔗
Le seuil supérieur du glow HDR. Les zones plus lumineuses que ce seuil seront bornées pour l’effet de glow.
Smooths the transition between values that are below and above glow_hdr_threshold by reducing the amount of glow generated by values that are close to glow_hdr_threshold. Values above glow_hdr_threshold + glow_hdr_scale will not have glow reduced in this way.
float glow_hdr_threshold = 1.0 🔗
Le seuil inférieur du glow HDR. Lors de l'utilisation de la méthode de rendu Mobile (qui ne supporte qu'une plage dynamique inférieure, jusqu'à 2.0), cela peut devoir être inférieur à 1.0 pour que le glow soit visible. Une valeur de 0.9 fonctionne bien dans ce cas. Cette valeur doit également être diminuée en dessous de 1.0 lorsque l'on utilise du glow en 2D, car le rendu 2D est effectué en SDR (plage dynamique standard).
The overall brightness multiplier that is applied to the glow effect just before it is blended with the scene. When using the Mobile rendering method (which only supports a lower dynamic range up to 2.0), this should be increased to 1.5 to compensate.
L'intensité du 1er niveau du glow. C'est le niveau le plus "local" (le moins flou).
Note : glow_levels/1 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 2ème niveau du glow.
Note : glow_levels/2 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 3ème niveau du glow.
Note : glow_levels/3 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 4ème niveau du glow.
Note : glow_levels/4 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 5ème niveau du glow.
Note : glow_levels/5 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 6ème niveau du glow.
Note : glow_levels/6 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
L'intensité du 7ème niveau du glow. Il s'agit du niveau le plus "global" (le plus flou).
Note : glow_levels/7 n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
La texture qui devrait être utilisée comme glow map pour multiplier la couleur de glow résultante selon glow_map_strength. Cela peut être utilisé pour créer un effet de "lentille sale". Les canaux de couleur RGB de la texture sont utilisés pour la modulation, mais le canal alpha est ignoré.
Note : La texture sera étirée pour s'adapter à l'écran. Par conséquent, il est recommandé d'utiliser une texture avec un rapport d'aspect qui correspond au rapport d'aspect de base de votre projet (généralement 16:9).
Note : glow_map n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
float glow_map_strength = 0.8 🔗
La force d'influence que la glow_map devrait avoir sur l'effet de glow global. Une force de 0.0 signifie que la glow map n'a pas d'influence, alors qu'une force de 1.0 signifie que la glow map a une influence complète.
Note : Si la glow map a des zones noires, une valeur de 1.0 peut également éteindre l'effet de glow entièrement dans ces zones spécifiques de l'écran.
Note : glow_map_strength n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
Lors de l'utilisation du mode de mélange glow_blend_mode GLOW_BLEND_MODE_MIX, cela contrôle de combien l'image source est mélangée avec la couche de glow. Une valeur de 0.0 rend le rendu du glow invisible, alors qu'une valeur de 1.0 est équivalente à GLOW_BLEND_MODE_REPLACE.
Note : glow_mix n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
bool glow_normalized = false 🔗
Si true, les niveaux de glow seront normalisés de sorte que la somme de leurs intensités soit égale à 1.0.
Note : glow_normalized n'a aucun effet lors de l'utilisation de la méthode de rendu Compatibilité, en raison de cette méthode de rendu utilisant une simple implémentation du glow optimisée pour les appareils bas de gamme.
The strength that is used when blurring across the screen to generate the glow effect. This affects the distance and intensity of the blur. When using the Mobile rendering method, this should be increased to compensate for the lower dynamic range.
Note: glow_strength has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.
ReflectionSource reflected_light_source = 0 🔗
void set_reflection_source(value: ReflectionSource)
ReflectionSource get_reflection_source()
La source de lumineuse réfléchie (spéculaire).
float sdfgi_bounce_feedback = 0.5 🔗
Le multiplicateur d'énergie appliqué à la lumière chaque fois qu'elle rebondit d'une surface lors de l'utilisation du SDFGI. Les valeurs supérieures à 0.0 simulent plusieurs rebonds, ce qui donne une apparence plus réaliste. Augmenter sdfgi_bounce_feedback n'a généralement pas d'impact sur les performances. Voir aussi sdfgi_energy.
Note : Les valeurs supérieures à 0.5 peuvent provoquer des boucles de rétroaction infinies et devraient être évitées dans des scènes avec des matériaux clairs.
Note : Si sdfgi_bounce_feedback vaut 0.0, l'éclairage indirect ne sera pas représenté dans les réflexions car la lumière ne rebondira qu'une fois.
float sdfgi_cascade0_distance = 12.8 🔗
Note : Cette propriété est liée à sdfgi_min_cell_size et sdfgi_max_distance. Changer sa valeur va automatiquement aussi changer ces propriétés.
Le nombre de cascades à utiliser pour la SDFGI (entre 1 et 8). Un plus grand nombre de cascades permet d'afficher la SDFGI plus loin tout en préservant le détail à proximité, avec un coût sur la performance. Lors de l'utilisation de la SDFGI dans des niveaux à petite échelle, sdfgi_cascades peut souvent être diminué entre 1 et 4 pour améliorer les performances.
Si true, active l'illumination globale par champ de distance signée (SDFGI) pour les maillages ayant leur GeometryInstance3D.gi_mode défini à GeometryInstance3D.GI_MODE_STATIC. La SDFGI est une technique d'illumination globale en temps réel qui fonctionne bien avec les niveaux générés procéduralement ou construits par les utilisateurs, y compris dans les situations où la géométrie est créée durant le gameplay. Le champ de distance signée est généré automatiquement autour de la caméra pendant qu'elle se déplace. Les lumières dynamiques sont supportées, mais les occulteurs dynamiques et les surfaces émissives ne le sont pas.
Note : La SDFGI n'est supportée que dans la méthode de rendu Forward+, pas Mobile ou Compatibilité.
Performance : La SDFGI est relativement exigeante sur le GPU et n'est pas adaptée au matériel de bas de gamme tel que les graphismes intégrés (considérez plutôt LightmapGI). Pour améliorer la performance de la SDFGI, activez ProjectSettings.rendering/global_illumination/gi/use_half_resolution dans les paramètres du projet.
Note : Les maillages doivent avoir des parois suffisamment épaisses pour éviter les fuites de lumière (évitez les murs à un seul côté). Pour les niveaux en intérieur, enfermez votre géométrie du niveau dans une boîte suffisamment grande et collez les extrémités pour fermer le maillage.
Le multiplicateur d'énergie à utiliser pour la SDFGI. Des valeurs plus élevées résulteront un éclairage et des réflexions indirectes plus lumineux. Voir aussi sdfgi_bounce_feedback.
float sdfgi_max_distance = 204.8 🔗
La distance maximale à laquelle la SDFGI est visible. Au-delà de cette distance, l'éclairage de l'environnement ou d'autres sources d'illumination globale telles que les ReflectionProbes seront utilisées en repli.
Note : Cette propriété est liée à sdfgi_min_cell_size et sdfgi_cascade0_distance. Changer sa valeur va automatiquement aussi changer ces propriétés.
float sdfgi_min_cell_size = 0.2 🔗
La taille de cellule à utiliser pour la cascade de SDFGI la plus proche (en unités 3D). Les valeurs inférieures permettent à la SDFGI d'être plus précise, au prix de rendre les mises à jour de la SDFGI plus exigeantes. Cela peut causer du stuttering lorsque la caméra se déplace rapidement. Des valeurs plus élevées permettent à la SDFGI de couvrir plus de terrain, tout en réduisant l'impact sur la performance des mises à jour de la SDFGI.
Note : Cette propriété est liée à sdfgi_max_distance et sdfgi_cascade0_distance. Changer sa valeur va automatiquement aussi changer ces propriétés.
float sdfgi_normal_bias = 1.1 🔗
Le biais des normales à utiliser pour les sondes de la SDFGI. L'augmentation de cette valeur peut réduire les artefacts de traînées visibles sur les surfaces en pente, au coût de fuites de lumière accrues.
float sdfgi_probe_bias = 1.1 🔗
Le biais constant à utiliser pour les sondes de la SDFGI. L'augmentation de cette valeur peut réduire les artefacts de traînées visibles sur les surfaces en pente, au coût de fuites de lumière accrues.
bool sdfgi_read_sky_light = true 🔗
Si true, la SDFGI prend en compte l'éclairage de l'environnement. Cela devrait être défini sur false pour les scènes en intérieur.
bool sdfgi_use_occlusion = false 🔗
Si true, la SDFGI utilise une approche de détection d'occlusion pour réduire les fuites de lumière. L'occlusion peut cependant introduire des taches sombres à certains endroits, qui peuvent être indésirables dans les scènes principalement en extérieur. sdfgi_use_occlusion a un impact sur les performances et ne devrait être activé que lorsque nécessaire.
SDFGIYScale sdfgi_y_scale = 1 🔗
void set_sdfgi_y_scale(value: SDFGIYScale)
SDFGIYScale get_sdfgi_y_scale()
L'échelle Y à utiliser pour les cellules de la SDFGI. Les valeurs inférieures résulteront en des cellules SDFGI regroupées plus étroitement sur l'axe Y. Ceci est utilisé pour équilibrer entre la qualité et couvrir beaucoup de terrain vertical. sdfgi_y_scale doit être défini en fonction de la verticalité de votre scène (et de la vitesse à laquelle votre caméra peut déplacer sur l'axe Y).
La ressource Sky utilisée pour cet Environment.
Si défini à une valeur supérieur à 0.0, redéfinit le champ de vision à utiliser pour le rendu du ciel. Si défini à 0.0, le même FOV que la Camera3D actuelle est utilisé pour le rendu du ciel.
Vector3 sky_rotation = Vector3(0, 0, 0) 🔗
La rotation à utiliser pour le rendu du ciel.
float ssao_ao_channel_affect = 0.0 🔗
L'intensité de l'occlusion ambiante de l'espace-écran sur les matériaux qui ont une texture d'occlusion ambiante définie. Des valeurs supérieures à 0 rendront l'effet SSAO visible dans les zones obscurcies par les textures d'occlusion ambiante.
Définit la force du niveau de détail supplémentaire pour l'effet d'occlusion ambiante de l'espace-écran. Une valeur élevée rend la passe de détails plus importante, mais peut contribuer à du crénelage dans votre image finale.
If true, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. Godot uses a form of SSAO called Adaptive Screen Space Ambient Occlusion which is itself a form of Horizon Based Ambient Occlusion.
Note: SSAO is only supported in the Forward+ and Compatibility rendering methods, not Mobile.
The threshold for considering whether a given point on a surface is occluded or not represented as an angle from the horizon mapped into the 0.0-1.0 range. A value of 1.0 results in no occlusion.
L'intensité de l'occlusion ambiante de l'espace-écran primaire. Agit comme un multiplicateur pour l'effet d'occlusion ambiante de l'espace-écran. Une valeur plus élevée résulte en une occlusion plus sombre.
float ssao_light_affect = 0.0 🔗
L'intensité de l'occlusion ambiante dans l'espace écran sous lumière directe. Dans la vraie vie, l'occlusion ambiante ne s'applique qu'à la lumière indirecte, ce qui signifie que ses effets ne peuvent pas être vus sous lumière directe. Les valeurs supérieures à 0 rendront l'effet SSAO visible sous lumière directe.
La distribution de l'occlusion. Une valeur plus élevée résulte en une occlusion plus sombre, semblable à ssao_intensity, mais avec une décroissance plus nette.
La distance à laquelle des objets peuvent s'obstruer l'un l'autre lors du calcul de l'occlusion ambiante de l'espace-écran. Des valeurs plus élevées résulteront en de l'occlusion sur une plus grande distance au coût de la performance et de la qualité.
La quantité avec laquelle l'effet d'occlusion ambiante de l'espace-écran est autorisé à flouter les bords des objets. Définir ceci trop élevé va résulter en du crénelage autour des bords des objets. Définir ceci trop bas va rendre les bords de l'objet flous.
Si true, l'effet d'éclairage indirect dans l'espace-écran (Screen-Space Indirect Lightning) est activé. L'éclairage indirect dans l'espace-écran est une forme d'éclairage indirect qui permet à la lumière diffuse de rebondir entre des objets voisins. L'éclairage indirect dans l'espace-écran fonctionne de manière très similaire à l'occlusion ambiante dans l'espace-écran, car il affecte seulement une plage limitée. Il est destiné à être utilisé avec une forme d'éclairage global appropriée comme SDFGI ou VoxelGI. L'éclairage indirect dans l'espace-écran n'est pas affecté par les Light3D.light_indirect_energy de lumières individuelles.
Note : Le SSIL n'est supporté que dans la méthode de rendu Forward+, et non Mobile ou Compatibilité.
Le multiplicateur de luminosité pour l'effet d'éclairage indirect dans l'espace-écran. Une valeur plus élevée résultera en une lumière plus brillante.
float ssil_normal_rejection = 1.0 🔗
Amount of normal rejection used when calculating screen-space indirect lighting. Normal rejection uses the normal of a given sample point to reject samples that are facing away from the current pixel. Normal rejection is necessary to avoid light leaking when only one side of an object is illuminated. However, normal rejection can be disabled if light leaking is desirable, such as when the scene mostly contains emissive objects that emit light from faces that cannot be seen from the camera.
The distance that bounced lighting can travel when using the screen space indirect lighting effect. A larger value will result in light bouncing further in a scene, but may result in under-sampling artifacts which look like long spikes surrounding light sources.
The amount that the screen-space indirect lighting effect is allowed to blur over the edges of objects. Setting too high will result in aliasing around the edges of objects. Setting too low will make object edges appear blurry.
float ssr_depth_tolerance = 0.5 🔗
La tolérance de profondeur pour les réflexions sur l'espace de l'écran.
If true, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from VoxelGIs or ReflectionProbes, but are slower and can't reflect surfaces occluded by others.
Note: SSR is only supported in the Forward+ rendering method, not Mobile or Compatibility.
Note: SSR is not supported on viewports that have a transparent background (where Viewport.transparent_bg is true).
The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection. Only positive values are valid (negative values will be clamped to 0.0).
The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. Only positive values are valid (negative values will be clamped to 0.0).
Le nombre maximum d'étapes pour les réflexions de l'espace-écran (SSR). Les valeurs plus élevées sont plus lentes.
float tonemap_agx_contrast = 1.25 🔗
Increasing tonemap_agx_contrast will make dark values darker and bright values brighter. Produces a higher quality result than adjustment_contrast without any additional performance cost, but is only available when using the TONE_MAPPER_AGX tonemapper.
float tonemap_agx_white = 16.29 🔗
The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set tonemap_agx_white to at least 6.0. Higher values result in less blown out highlights, but may make the scene appear lower contrast. tonemap_agx_white is the same as tonemap_white, but is only effective with the TONE_MAPPER_AGX tonemapper. See also tonemap_exposure.
Note: When using the Mobile renderer with Viewport.use_hdr_2d disabled, tonemap_agx_white is ignored and a white value of 2.0 will always be used instead. Otherwise, tonemap_agx_white will be dynamically adjusted at runtime by multiplying it by the parent window's Window.get_output_max_linear_value() when using Viewport.use_hdr_2d to ensure good behavior with both SDR and HDR output.
float tonemap_exposure = 1.0 🔗
Adjusts the brightness of values before they are provided to the tonemapper. Higher tonemap_exposure values result in a brighter image. See also tonemap_white.
Note: Values provided to the tonemapper will also be multiplied by 2.0 and 1.8 for TONE_MAPPER_FILMIC and TONE_MAPPER_ACES respectively to produce a similar apparent brightness as TONE_MAPPER_LINEAR.
ToneMapper tonemap_mode = 0 🔗
void set_tonemapper(value: ToneMapper)
ToneMapper get_tonemapper()
Le mode de tonemapping à utiliser. Le tonemapping est le processus qui "convertit" des valeurs HDR pour être adaptées à du rendu sur un écran LDR. (Godot ne supporte pas encore le rendu sur des écrans HDR.)
The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set tonemap_white to at least 6.0. Higher values result in less blown out highlights, but may make the scene appear lower contrast. tonemap_agx_white will be used instead when using the TONE_MAPPER_AGX tonemapper. See also tonemap_exposure.
Note: tonemap_white must be set to 2.0 or lower on the Mobile renderer to produce bright images.
Note: tonemap_white is ignored when using TONE_MAPPER_LINEAR and will be dynamically adjusted at runtime to never be less than the parent window's Window.get_output_max_linear_value() when using TONE_MAPPER_REINHARDT with Viewport.use_hdr_2d.
Color volumetric_fog_albedo = Color(1, 1, 1, 1) 🔗
La Color du brouillard volumétrique lors de l'interaction avec des lumières. La brume et le brouillard ont un albédo proche de Color(1, 1, 1, 1) tandis que la fumée a un albédo plus foncé.
float volumetric_fog_ambient_inject = 0.0 🔗
Dimensionne la force de la lumière ambiante utilisée dans le brouillard volumétrique. Une valeur de 0.0 signifie que la lumière ambiante n'affectera pas le brouillard volumétrique. volumetric_fog_ambient_inject a un petit coût en performances lorsque défini au-dessus de 0.0.
Note : Cela n'a aucun effet visible si volumetric_fog_density vaut 0.0 ou si volumetric_fog_albedo est une couleur entièrement noire.
float volumetric_fog_anisotropy = 0.2 🔗
The direction of scattered light as it goes through the volumetric fog. A value close to 1.0 means almost all light is scattered forward. A value close to 0.0 means light is scattered equally in all directions. A value close to -1.0 means light is scattered mostly backward. Fog and mist scatter light slightly forward, while smoke scatters light equally in all directions.
float volumetric_fog_density = 0.05 🔗
La densité exponentielle de base du brouillard volumétrique. Définissez ceci à la plus basse densité que vous voulez avoir globalement. Des FogVolumes peuvent être utilisés pour ajouter ou soustraire à cette densité dans des zones spécifiques. Le rendu du brouillard est exponentiel comme dans la vie réelle.
Une valeur de 0.0 désactive le brouillard volumétrique global tout en permettant à des FogVolumes d'afficher du brouillard volumétrique dans des zones spécifiques.
Pour que le brouillard volumétrique fonctionne comme une solution d'éclairage volumique, définissez volumetric_fog_density à la valeur non nulle la plus basse (0.0001) puis augmentez la valeur des Light3D.light_volumetric_fog_energy des lumières à des valeurs entre 10000 et 100000 pour compenser la très faible densité.
float volumetric_fog_detail_spread = 2.0 🔗
The distribution of size down the length of the froxel buffer. A higher value compresses the froxels closer to the camera and places more detail closer to the camera.
Color volumetric_fog_emission = Color(0, 0, 0, 1) 🔗
La lumière émise par le brouillard volumétrique. Même avec l'émission, le brouillard volumétrique ne projettera pas de lumière sur d'autres surfaces. Les émissions sont utiles pour établir une couleur ambiante. Comme l'effet de brouillard volumétrique n'utilise que de la diffusion unique, le brouillard a tendance à avoir besoin d'un peu d'émission pour adoucir les ombres trop nettes.
float volumetric_fog_emission_energy = 1.0 🔗
La luminosité de la lumière émise dans le brouillard volumétrique.
bool volumetric_fog_enabled = false 🔗
Active l'effet de brouillard volumétrique. Le brouillard volumétrique utilise un buffer de froxels alignés sur l'écran pour calculer la diffusion volumétrique exacte à courte et moyenne portée. Le brouillard volumique interagit avec les FogVolumes et les lumières pour calculer le brouillard local et global. Le brouillard volumétrique utilise un modèle PBR à diffusion unique basé sur l'extinction, la diffusion et l'émission qu'il expose aux utilisateurs par la densité, l'albédo et l'émission.
Note : Le brouillard volumétrique n'est supporté que dans la méthode de rendu Forward+, et non Mobile ou Compatibilité.
float volumetric_fog_gi_inject = 1.0 🔗
Redimensionne la force de l'illumination globale utilisée dans la couleur d'albédo du brouillard volumétrique. Une valeur de 0.0 signifie que l'illumination globale n'affectera pas le brouillard volumétrique. volumetric_fog_gi_inject a un petit coût de performance lorsque il est défini au dessus de 0.0.
Note : Cela n'a aucun effet visible si volumetric_fog_density vaut 0.0 ou si volumetric_fog_albedo a une couleur entièrement noire.
Note : Seuls VoxelGI et SDFGI (sdfgi_enabled) sont pris en compte lors de l'utilisation de volumetric_fog_gi_inject. L'illumination globale de LightmapGI, ReflectionProbe et SSIL (voir ssil_enabled) sera ignorée par le brouillard volumétrique.
float volumetric_fog_length = 64.0 🔗
La distance sur laquelle le brouillard volumétrique est calculé. Augmentez la pour calculer le brouillard sur une plus grande portée, diminuez la pour ajouter plus de détails quand une longue portée n'est pas nécessaire. Pour un brouillard de meilleure qualité, gardez ceci aussi bas que possible. Voir aussi ProjectSettings.rendering/environment/volumetric_fog/volume_depth.
float volumetric_fog_sky_affect = 1.0 🔗
Le facteur à utiliser le brouillard volumétrique affecte le ciel. 1.0 signifie que le brouillard volumétrique peut masquer pleinement le ciel. Les valeurs inférieures réduisent l'impact du brouillard volumétrique sur le rendu du ciel, avec 0.0 qui n'affecte pas du tout le rendu du ciel.
Note : volumetric_fog_sky_affect affecte également les FogVolumes, même si volumetric_fog_density vaut 0.0. Si vous remarquez que des FogVolumes disparaissent en regardant vers le ciel, définissez volumetric_fog_sky_affect à 1.0.
float volumetric_fog_temporal_reprojection_amount = 0.9 🔗
void set_volumetric_fog_temporal_reprojection_amount(value: float)
float get_volumetric_fog_temporal_reprojection_amount()
The amount by which to blend the last frame with the current frame. A higher number results in smoother volumetric fog, but makes "ghosting" much worse. A lower value reduces ghosting but can result in the per-frame temporal jitter becoming visible.
bool volumetric_fog_temporal_reprojection_enabled = true 🔗
void set_volumetric_fog_temporal_reprojection_enabled(value: bool)
bool is_volumetric_fog_temporal_reprojection_enabled()
Active la reprojection temporelle dans le brouillard volumétrique. La reprojection temporelle mélange le brouillard volumétrique de la trame actuelle avec le brouillard volumétrique de la dernière trame pour lisser les bords irréguliers. Le coût en performance est minime, cependant, cela conduit à du "ghosting" sur les FogVolumes et Light3Ds mouvants, qui laissant alors une traînée derrière eux. Lorsque la reprojection temporelle est activée, essayez d'éviter de déplacer des FogVolumes ou des Light3Ds trop vite. Les effets d'éclairage dynamique de courte durée devraient avoir Light3D.light_volumetric_fog_energy définis sur 0.0 pour éviter le ghosting.
Descriptions des méthodes
float get_glow_level(idx: int) const 🔗
Renvoie l'intensité du niveau de glow à l'index idx.
void set_glow_level(idx: int, intensity: float) 🔗
Définit l'intensité du niveau de glow à l'index idx. Une valeur supérieure à 0.0 active le niveau. Chaque niveau dépend du niveau précédent. Cela signifie qu'activer des niveaux de glow plus élevés ralentira le rendu de l'effet de glow, même si les niveaux précédents ne sont pas activés.