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...
LightmapGI
Hérite de : VisualInstance3D < Node3D < Node < Object
Calcule et stocke les lightmaps pré-calculées pour une illumination globale rapide.
Description
Le nœud LightmapGI est utilisé pour calculer et stocker des lightmaps pré-calculées. Les lightmaps sont utilisées pour fournir un éclairage indirect de haute qualité avec très peu de fuites de lumière. LightmapGI peut également fournir des reflets rugueux en utilisant des harmoniques sphériques si directional est activé. Les objets dynamiques peuvent recevoir un éclairage indirect grâce à des sondes de lumière, qui peuvent être automatiquement placées en définissant generate_probes_subdiv à une valeur autre que GENERATE_PROBES_DISABLED. Des sondes de lightmap supplémentaires peuvent également être ajoutées en créant des nœuds LightmapProbe. Le désavantage est que les lightmaps sont entièrement statiques et ne peuvent pas être pré-calculées dans un projet exporté. Pré-calculer un nœud LightmapGI est également plus lent que VoxelGI.
Génération procédurale : La fonctionnalité de pré-calcul des lightmaps est uniquement disponible dans l'éditeur. Cela signifie que LightmapGI n'est pas adapté aux niveaux générés procéduralement ou construits par l'utilisateur. Pour les niveaux générés procéduralement ou construits par l'utilisateur, utilisez VoxelGI ou SDFGI (voir Environment.sdfgi_enabled).
Performance : LightmapGI fournit la meilleure performance d'exécution possible pour l'éclairage global. Il convient pour du matériel bas de gamme, y compris les graphismes intégrés et les appareils mobiles.
Note : En raison de la façon dont fonctionnent les lightmaps, la plupart des propriétés n'ont qu'un effet visible qu'une fois que les lightmaps sont de nouveau pré-calculées.
Note : Le pré-calcul des lightmaps sur des CSGShape3Ds et PrimitiveMeshes n'est pas supporté, car ils ne peuvent pas stocker les données UV2 requises pour le pré-calcul.
Note : Si aucun lightmapper personnalisé n'est installé, LightmapGI ne peut être pré-calculée qu'à partir d'appareils qui supportent les moteurs de rendus Forward+ ou Mobile.
Note : Le nœud LightmapGI ne fait que pré-calculer des données de lumière pour les nœuds enfants de son parent. Les nœuds plus haut la hiérarchie de la scène ne seront pas pré-calculés.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Énumérations
enum BakeQuality: 🔗
BakeQuality BAKE_QUALITY_LOW = 0
Qualité de calcul faible (temps de calcul les plus rapides). La qualité de ce préréglage peut être ajustée en changeant ProjectSettings.rendering/lightmapping/bake_quality/low_quality_ray_count et ProjectSettings.rendering/lightmapping/bake_quality/low_quality_probe_ray_count.
BakeQuality BAKE_QUALITY_MEDIUM = 1
Qualité de calcul moyenne (temps de calcul rapides). La qualité de ce préréglage peut être ajustée en changeant ProjectSettings.rendering/lightmapping/bake_quality/medium_quality_ray_count et ProjectSettings.rendering/lightmapping/bake_quality/medium_quality_probe_ray_count.
BakeQuality BAKE_QUALITY_HIGH = 2
Qualité de calcul élevée (temps de calcul lents). La qualité de ce préréglage peut être ajustée en changeant ProjectSettings.rendering/lightmapping/bake_quality/high_quality_ray_count et ProjectSettings.rendering/lightmapping/bake_quality/high_quality_probe_ray_count.
BakeQuality BAKE_QUALITY_ULTRA = 3
Qualité de calcul la plus élevée (temps de calcul les plus lents). La qualité de ce préréglage peut être ajustée en changeant ProjectSettings.rendering/lightmapping/bake_quality/ultra_quality_ray_count et ProjectSettings.rendering/lightmapping/bake_quality/ultra_quality_probe_ray_count.
enum GenerateProbes: 🔗
GenerateProbes GENERATE_PROBES_DISABLED = 0
Ne pas générer de sondes de lightmap pour éclairer les objets dynamiques.
GenerateProbes GENERATE_PROBES_SUBDIV_4 = 1
Niveau le plus bas de sous-division (temps de calcul les plus rapides, tailles de fichiers les plus petites).
GenerateProbes GENERATE_PROBES_SUBDIV_8 = 2
Faible niveau de sous-division (temps de calcul rapide, petites tailles de fichiers).
GenerateProbes GENERATE_PROBES_SUBDIV_16 = 3
Niveau élevé de sous-division (temps de calcul lent, tailles de fichiers importantes).
GenerateProbes GENERATE_PROBES_SUBDIV_32 = 4
Niveau le plus élevé de sous-division (temps de calcul les plus lents, tailles de fichiers les plus grandes).
enum BakeError: 🔗
BakeError BAKE_ERROR_OK = 0
Le pré-calcul de la lightmap a réussi.
BakeError BAKE_ERROR_NO_SCENE_ROOT = 1
Le pré-calcul des lightmaps a échoué car il était impossible d'accéder au nœud racine de la scène éditée.
BakeError BAKE_ERROR_FOREIGN_DATA = 2
Le pré-calcul des lightmaps a échoué car la ressource des données de lightmap est intégrée dans une ressource étrangère.
BakeError BAKE_ERROR_NO_LIGHTMAPPER = 3
Le pré-calcul des lightmaps a échoué car il n'y a pas de lightmapper disponible dans cette compilation de Godot.
BakeError BAKE_ERROR_NO_SAVE_PATH = 4
Le pré-calcul des lightmaps a échoué car le chemin de sauvegarde des LightmapGIData n'est pas configuré dans la ressource.
BakeError BAKE_ERROR_NO_MESHES = 5
Le pré-calcul des lightmaps a échoué car il n'y a pas de maillage dont le GeometryInstance3D.gi_mode vaut GeometryInstance3D.GI_MODE_STATIC et avec un mapping UV2 valide dans la scène actuelle. Vous pourriez avoir besoin de sélectionner des scène 3D dans le dock Import et changer leur mode d'illumination globale de manière appropriée.
BakeError BAKE_ERROR_MESHES_INVALID = 6
Le pré-calcul des lightmaps a échoué car le lightmapper a échoué à analyser certains des maillages marqués comme statique pour le pré-calcul.
BakeError BAKE_ERROR_CANT_CREATE_IMAGE = 7
Le pré-calcul des lightmaps a échoué car l'image résultante n'a pas pu être sauvegardée ou importée par Godot après sa sauvegarde.
BakeError BAKE_ERROR_USER_ABORTED = 8
L'utilisateur a avorté l'opération de pré-calcul des lightmaps (généralement en cliquant sur le bouton Annuler dans le fenêtre de progression).
BakeError BAKE_ERROR_TEXTURE_SIZE_TOO_SMALL = 9
Le pré-calcul des lightmaps a échoué car la taille de texture maximale est trop petite pour faire rentrer certains des maillages marqués pour le pré-calcul.
BakeError BAKE_ERROR_LIGHTMAP_TOO_SMALL = 10
Le pré-calcul de la lightmap a échoué car la lightmap est trop petite.
BakeError BAKE_ERROR_ATLAS_TOO_SMALL = 11
Le pré-calcul de la lightmap a échoué car la lightmap ne rentrait pas dans un atlas (atlas trop petit).
enum EnvironmentMode: 🔗
EnvironmentMode ENVIRONMENT_MODE_DISABLED = 0
Ignorer l'éclairage de l'environnement lors du pré-calcul des lightmaps.
EnvironmentMode ENVIRONMENT_MODE_SCENE = 1
Utiliser l'éclairage de l'environnement de la scène lors du pré-calcul des lightmaps.
Note : Si vous calculez des lightmaps dans une scène sans nœud WorldEnvironment, cela se comportera comme ENVIRONMENT_MODE_DISABLED. Le ciel de prévisualisation de l'éditeur et le soleil ne sont pas pris en compte par LightmapGI lors du pré-calcul des lightmaps.
EnvironmentMode ENVIRONMENT_MODE_CUSTOM_SKY = 2
Utiliser environment_custom_sky comme source de l'éclairage de l'environnement lors du pré-calcul des lightmaps.
EnvironmentMode ENVIRONMENT_MODE_CUSTOM_COLOR = 3
Utiliser environment_custom_color multiplié par environment_custom_energy comme source constante d'éclairage de l'environnement lors du pré-calcul des lightmaps.
Descriptions des propriétés
Le biais à utiliser lors du calcul des ombres. Augmenter bias peut corriger le "shadow acne" (litt. "acné des ombres", des pointillés apparaissant sur les ombres) sur les lightmap résultantes, mais peut introduire du peter-panning (des ombres ne se connectant pas à leur projeteur). Les ombres de Light3D en temps réel ne sont pas affectées par cette propriété bias.
float bounce_indirect_energy = 1.0 🔗
Le multiplicateur d'énergie pour chaque rebond. Des valeurs plus élevées rendront l'éclairage indirect plus lumineux. Une valeur de 1.0 représente un comportement physiquement correct, mais des valeurs plus élevées peuvent être utilisées pour que l'éclairage indirect se propage de manière plus visible lors de l'utilisation d'un faible nombre de rebonds. Cela peut être utilisé pour accélérer les temps de calcul en baissant le nombre de rebonds bounces puis en augmentant bounce_indirect_energy.
Note : bounce_indirect_energy a seulement un effet si bounces est défini à une valeur supérieure ou égale à 1.
Nombre de rebonds de la lumière qui sont pris en compte lors du pré-calcul. Des valeurs plus élevées résultent en un éclairage plus lumineux et plus réaliste, à un coût de temps de calcul plus long. S'il est défini à 0, seuls l'éclairage de l'environnement, la lumière directe et l'éclairage d'émission sont pré-calculés.
CameraAttributes camera_attributes 🔗
void set_camera_attributes(value: CameraAttributes)
CameraAttributes get_camera_attributes()
La ressource CameraAttributes qui précise les niveaux d'exposition auxquels pré-calculer. Les propriétés d'auto-exposition et de non-exposition seront ignorées. Les paramètres d'exposition devraient être utilisés pour réduire la plage dynamique présente lors du pré-calcul. Si l'exposition est trop élevée, le LightmapGI aura des artéfacts de bande ou peut avoir des artéfacts de sur-exposition.
La distance en pixels sur laquelle le dé-bruiteur échantillonne. Les valeurs inférieures conservent plus de détails, mais peuvent donner des résultats en tâches si la qualité de la lightmap n'est pas assez élevée. Seulement effectif si use_denoiser vaut true et ProjectSettings.rendering/lightmapping/denoising/denoiser est défini à JNLM.
float denoiser_strength = 0.1 🔗
La force de l'étape de suppression du bruit appliquée aux lightmaps générées. Seulement effective si use_denoiser vaut true et ProjectSettings.rendering/lightmapping/denoising/denoiser est défini à JNLM.
Si true, pré-calcule les lightmaps pour qu'elles contiennent des informations directionnelles en tant qu'harmoniques sphériques. Cela résulte en une apparence plus réaliste de l'éclairage, en particulier avec des matériaux avec des normal maps et pour les lumières qui ont leur lumière directe pré-calculée (Light3D.light_bake_mode défini à Light3D.BAKE_STATIC et avec Light3D.editor_only défini à false). L'information directionnelle est également utilisée pour fournir des reflets rugueux pour les objets statiques et dynamiques. Ceci a un petit coût de performance lors de l'exécution puisque le shader doit effectuer plus de travail pour interpréter les informations de direction de la lightmap. Les lightmaps directionnelles prennent également plus de temps pour pré-calculer et résultent en des tailles de fichiers plus grandes.
Note : Le nom de la propriété n'est pas lié à DirectionalLight3D. directional fonctionne avec tous les types de lumière.
Color environment_custom_color = Color(1, 1, 1, 1) 🔗
La couleur à utiliser pour l'éclairage de l'environnement. Seulement effective lorsque environment_mode vaut ENVIRONMENT_MODE_CUSTOM_COLOR.
float environment_custom_energy = 1.0 🔗
Le multiplicateur de couleur à utiliser pour l'éclairage de l'environnement. Seulement effectif si environment_mode est ENVIRONMENT_MODE_CUSTOM_COLOR.
Le ciel à utiliser comme source d'éclairage de l'environnement. Seulement effectif si environment_mode vaut ENVIRONMENT_MODE_CUSTOM_SKY.
EnvironmentMode environment_mode = 1 🔗
void set_environment_mode(value: EnvironmentMode)
EnvironmentMode get_environment_mode()
Le mode d'environnement à utiliser lors du pré-calcul des lightmaps.
GenerateProbes generate_probes_subdiv = 2 🔗
void set_generate_probes(value: GenerateProbes)
GenerateProbes get_generate_probes()
Le niveau de sous-division à utiliser lors de la génération automatique de LightmapProbes pour l'éclairage dynamique des objets. Des valeurs plus élevées résultent en un éclairage indirect plus précis sur les objets dynamiques, avec un coût de temps de calcul plus long et des tailles de fichiers plus grandes.
Note : Les LightmapProbes générées automatiquement ne sont pas visibles comme des nœuds dans le dock Scène, et ne peuvent pas être modifiés de cette façon après leur génération.
Note : Indépendamment de generate_probes_subdiv, l'éclairage direct sur les objets dynamiques est toujours appliqué en utilisant des nœuds Light3D en temps réel.
Si true, ignore la contribution de l'environnement lors du pré-calcul des lightmaps.
LightmapGIData light_data 🔗
void set_light_data(value: LightmapGIData)
LightmapGIData get_light_data()
La LightmapGIData associé à ce nœud LightmapGI. Cette ressource est créée automatiquement après le pré-calcul, et n'est pas destinée à être créée manuellement.
int max_texture_size = 16384 🔗
La taille de texture maximale pour l'atlas de texture généré. Des valeurs plus élevées résulteront en moins de tranches générées, mais ne fonctionneront pas sur tout les matériels en raison des limitations matérielles sur les tailles de texture. Laissez max_texture_size à sa valeur par défaut de 16384 si vous n'êtes pas sur.
BakeQuality quality = 1 🔗
void set_bake_quality(value: BakeQuality)
BakeQuality get_bake_quality()
Le pré-réglage de qualité à utiliser lors du pré-calcul des lightmaps. Cela affecte les temps de calcul, mais les tailles des fichiers de sortie restent généralement identiques à tous les niveaux de qualité.
Pour accélérer davantage les temps de calcul, diminuez bounces, désactivez use_denoiser et/ou diminuez texel_scale.
Pour augmenter encore la qualité, activez supersampling et/ou augmentez texel_scale.
ShadowmaskMode shadowmask_mode = 0 🔗
void set_shadowmask_mode(value: ShadowmaskMode)
ShadowmaskMode get_shadowmask_mode()
Expérimental : Cette propriété peut être changée ou retirée dans de futures versions.
La politique de shadowmasking à utiliser pour les ombres directionnelles sur des objets statiques qui sont pré-calculés avec cette instance LightmapGI.
Le shadowmasking permet aux nœuds DirectionalLight3D de projeter des ombres même en dehors de la plage définie par leur propriété DirectionalLight3D.directional_shadow_max_distance. Ceci est fait en pré-calculant une texture qui contient une shadowmap pour la lumière directionnelle, puis en utilisant cette texture selon le mode de shadowmask actuel.
Note : La texture Shadowmask n'est créée que si shadowmask_mode ne vaut pas LightmapGIData.SHADOWMASK_MODE_NONE. Pour voir une différence, vous devez de nouveau pré-calculer les lightmaps après avoir changé de LightmapGIData.SHADOWMASK_MODE_NONE vers tout autre mode.
Si true, les lightmaps sont pré-calculées avec l'échelle de texel multipliée par supersampling_factor et sous-échantilionnées avant d'enregistrer la lightmap (ainsi, la densité de texel effective est identique à celle avec le Suréchantillonnage désactivé).
Le suréchantillonnage offre une qualité de lightmap accrue avec moins de bruit, des ombres plus lisses et un meilleur ombrage de petites caractéristiques d'objets. Cependant, il peut entraîner une augmentation significative des temps de calcul et d'utilisation de la mémoire pendant le pré-calcul des lightmaps. Le rembourrage est automatiquement ajusté pour éviter d'augmenter les fuites de lumière.
float supersampling_factor = 2.0 🔗
Le facteur par lequel la densité de texel est multipliée pour le suréchantillionnage. Pour les meilleurs résultats, utilisez une valeur entière. Bien que les valeurs fractionnelles soient autorisées, elles peuvent entraîner une fuite des lumières accrue et une lightmap floue.
Des valeurs plus élevées peuvent résulter en une meilleure qualité, mais également augmenter les temps de calcul et l'utilisation de la mémoire pendant le calcul.
Voir supersampling pour plus d'informations.
Redimensionne la densité de texel de lightmap de tous les maillages pour le pré-calcul actuel. Il s'agit d'un multiplicateur qui s'appuie sur la taille de texel de lightmap existante définie dans chaque scène 3D importée, ainsi que sur le multiplicateur de densité par maillage (qui est conçu pour être utilisé lorsque le même maillage est utilisé à différentes échelles). les valeurs inférieures résulteront en des temps de calcul plus rapides.
Par exemple, doubler texel_scale double la résolution de texture de la lightmap pour tous les objets sur chaque axe, de sorte qu'il quadruple le compte de texels.
Si true, utilise un algorithme de dé-bruitage basé sur le GPU sur la lightmap générée. Cela élimine la plupart du bruit dans la lightmap générée au coût d'un temps de calcul plus long. Les tailles de fichiers ne sont généralement pas impactées significativement par l'utilisation d'un dé-bruiteur, bien que la compression sans perte peut faire un meilleur travail pour compresser une image dé-bruitée.
bool use_texture_for_bounces = true 🔗
Si true, une texture avec les informations d'éclairage sera générée pour accélérer la génération de l'éclairage indirect avec un coût sur la précision. La géométrie peut présenter des artéfacts de fuite de lumière supplémentaires lors de l'utilisation de lightmaps basse résolution ou d'UVs qui étirent significativement la lightmap sur les surfaces. Laissez use_texture_for_bounces à sa valeur par défaut de true si vous n'êtes pas sûr.
Note : use_texture_for_bounces a seulement un effet si bounces est défini à une valeur supérieure ou égale à 1.