Baked lightmaps

Introduction

Les Baked lightmaps sont un flux de travail alternatif pour ajouter un éclairage indirect (ou préparé) à une scène. Contrairement à l’approche GI Probes, les Baked lightmaps fonctionnent très bien sur les PC et les appareils mobiles bas de gamme, car elles ne consomment pratiquement pas de ressources en temps réel.

Contrairement aux « GIProbe », les Baked lightmaps sont complètement statiques. Une fois préparées, elles ne peuvent pas être modifiées du tout. Elles ne fournissent pas non plus de reflets à la scène, donc l’utilisation de Reflection probes avec elle à l’intérieur (ou l’utilisation d’un Sky à l’extérieur) est une condition pour obtenir une bonne qualité.

Comme elles sont préparées, elles ont moins de problèmes que GIProbe en ce qui concerne le saignement de la lumière, et la lumière indirecte peut sembler meilleure si on utilise le mode Raytrace sur un réglage de haute qualité (mais la préparation peut prendre un certain temps).

En fin de compte, le choix de l’approche d’éclairage indirect qui convient le mieux dépend de votre cas d’utilisation. En général, GIProbe est plus esthétique et beaucoup plus facile à mettre ne place. Pour une compatibilité mobile ou bas de gamme, cependant, les cartes de lumières préparées sont votre seul choix.

Comparaison visuelle

Voici quelques comparaisons entre Baked Lightmaps et GIProbe. Notez que les lightmaps sont plus précises, mais souffrent aussi du fait que l’éclairage est sur une texture non enveloppée, donc les transitions et la résolution peuvent ne pas être aussi bonnes. GIProbe semble moins précis (car c’est une approximation), mais globalement plus lisse.

../../_images/baked_light_comparison.png

Mise en place

Tout d’abord, pour que le Lightmapper puisse faire quoi que ce soit, les objets à préparer ont besoin d’un calque UV2 et d’une taille de texture. Une couche UV2 est un ensemble de coordonnées de texture secondaires garantissant que chaque face de l’objet a sa propre place dans la carte UV. Les faces ne doivent pas partager de pixels dans la texture.

Il y a plusieurs façons de s’assurer qu’un objet dispose d’un calque UV2 et une taille de texture unique :

Déplier depuis votre logiciel 3D

Une option est de le faire depuis votre logiciel de modélisation 3D. Bien que peu recommandée, cette approche est listée ici pour que vous sachiez qu’elle existe. L’avantage principal de cette méthode est de contourner le processus de génération de texture natif de Godot, celui-ci utilisant d’importantes ressources sur des objets complexes. Déplier depuis votre logiciel 3D permet d’accélérer l’importation.

Il suffit simplement de dérouler la deuxième couche d’UV2.

../../_images/baked_light_blender.png

Et importe normalement. N’oubliez pas que vous devrez définir la taille de la texture sur le maillage après l’importation.

../../_images/baked_light_lmsize.png

Si vous utilisez des maillages (meshes) externes lors de l’importation, la taille sera conservée. Attention car la plupart des décompresseurs des logiciels 3D ne sont pas réglés pour la qualité mais pour la rapidité de traitement. Vous devrez surtout utiliser les coutures (seams) ou d’autres techniques pour créer un meilleur dépliage.

Dépliage depuis Godot

Godot a une option pour déplier les maillages (meshes) et visualiser les chaîne UV. On peut la trouver dans le menu Mesh :

../../_images/baked_light_mesh_menu.png

Cela va générer un second ensemble de coordonné UV2 qui peut être utilisé pour un baking, et cela va aussi configurer automatiquement la taille de la texture.

Dépliage d’une scène importée

Ceci est probablement la meilleur approche globale. Le seul inconvénient est que, sur les grands modèles, le dépliage peut prendre un certain temps à l’importation. Sélectionnez simplement la scène importée dans le système de fichiers, puis allez à l’onglet Importer. Là, l’option suivante peut être modifiée :

../../_images/baked_light_import.png

Le mode ** Light Baking ** doit être réglé sur ** « Gen Lightmaps » **. Une taille de texel en unités mondiales doit également être fournie, car cela déterminera la taille finale de la texture lightmap (et, par conséquent, le remplissage UV de la carte).

L’effet du réglage de cette option est que toutes les mailles (meshes) au sein de la scène auront leurs cartes UV2 correctement générés.

Avertissement : lorsque de la réutilisation d’un maillage (meshe) dans une scène, gardez à l’esprit que les UVs sont générés pour la première instance trouvée. Si la maille est réutilisée à différentes échelles (et que les échelles sont très différentes, plus de la moitié ou deux fois), cela se traduira par un lightmaps inefficace. Juste, ne réutilisez pas les maillages sources à différentes échelles si vous envisagez d’utiliser lightmapping.

Vérification UV2

Dans le menu de maillage mentionné précédemment, les coordonnées de texture UV2 peuvent être visualisées. S’assurer, si quelque chose ne fonctionne pas, que les mailles ont ces coordonnées UV2 :

../../_images/baked_light_uvchannel.png

Mise en place de la scène

Avant de faire quoi que ce soit, un nœud ** BakedLightmap ** doit être ajouté à une scène. Cela permettra le light baking sur tous les nœuds (et sous-nœuds) de cette scène, même sur les scènes instanciées.

../../_images/baked_light_scene.png

Une sous-scène peut être instanciée plusieurs fois, car cela est supporté par le baker, et chacune se verra attribuer une lightmap (assurez-vous juste de respecter la règle de mise à l’échelle mentionnée précédemment) :

Configurer les limites

Le Lightmap a besoin d’un volume approximatif de la zone affectée, car elle l’utilise pour transférer la lumière aux objets dynamiques se trouvant à l’intérieur (plus de détails plus tard). Recouvrez simplement la scène avec le volume de la même manière que vous le faites avec `` GIProbe`` :

../../_images/baked_light_bounds.png

Mise en place des maillages

Pour qu’un nœud ** MeshInstance ** prenne part au processus de baking, la propriété « Utiliser dans Baked Light » doit être activée.

../../_images/baked_light_use.png

Lors de la génération automatique du lightmaps d’une scène importé, celle-ci est activé automatiquement.

Mise en place des lumières

Les lumières sont « baker » par défaut avec une lumière indirecte. Cela signifie que la shadowmapping (cartographie des ombres) et l’éclairage sont toujours dynamiques et affectent les objets en mouvement, mais la lumière rebondit à partir de cette lumière sera « baké ».

Les lumières peuvent être désactivées (pas de baking) ou entièrement « baked » (directes et indirectes). Ceci peut être contrôlé à partir du menu Bake Mode dans les éclairages :

../../_images/baked_light_bake_mode.png

Les modes sont :

  • ** Désactivé: ** La lumière est ignorée lors du « baking ». Gardez à l’esprit que cacher une lumière n’aura aucun effet sur le « baking », cela doit être utilisé à la place.
  • ** Indirect: ** Ceci est le mode par défaut. Seul l’éclairage indirect sera « baked ».
  • All: Les éclairages directs et indirects seront « baked ». Si vous ne voulez pas que la lumière apparaisse deux fois (dynamiquement et statiquement), masquez-la simplement.

Qualité de « Baking »

BakedLightmap utilise par simplicité une version voxelisée de la scène afin de calculer l’éclairage. La taille de Voxel peut-être ajustée via le paramètre Bake Subdiv. Un plus grand nombre de sous-divisions apportera plus de détail, mais augmentera également le temps requis du « baking ».

En général, les paramètres par défaut suffisent. Si vous souhaitez capturer la lumière d’objets dynamiques (plus d’infos là dessus plus tard), vous pouvez également utiliser Capture Subdivision (doit toujours être inférieur ou égal au nombre de sous-divisions principal). La valeur par défaut pour ce paramètre est également suffisante dans la plupart des cas.

../../_images/baked_light_capture.png

Outre la taille de la capture, la qualité peut être modifiée en réglant le Bake Mode. Deux modes de capture indirecte sont proposés :

../../_images/baked_light_mode.png
  • Voxel Cone: Trace: est la valeur par défaut; C’est moins précis, mais plus rapide. Similaire à (mais un peu mieux que) “” GIProbe”“.
  • Ray Tracing : Cette méthode est plus précise, mais peut avoir un temps de rendu considérable. Si la qualité basse ou médium est utilisé, certaine scènes peuvent produire du grain.

Pré-calcul

Pour pré-calculer les lumières, appuyer sur le bouton Bake Lightmaps (en haut quand vous sélectionnez le noeud BakeLightmap) :

../../_images/baked_light_bake.png

Cela peut prendre quelques secondes, voir des heures. La taille de la scène, la méthode de pré-calcul et sa qualité impacte le temps de calcul.

Configurer les pré-calculs

Différentes options sont disponibles pour le pré-calcul :

  • Sous-division des pré-calculs : Dans le système de cartographie de lumière utilisée par Godot, une grille est utilisée pour le transfert de l’information lumineuse. Augmenter la densité de la grille pour améliorer les détails lumineux.
  • Sous-division de capture : il s’agit d’une grille utilisée pour la capture temps-réel d’information lumineuse (produit par des objets dynamiques). La valeur par défaut est généralement correcte. Elle doit être plus petite que la grille de sous-division utilisée pour les pré-calculs.
  • Qualité des pré-calculs : Trois sont disponibles. Basse, Moyenne et Haute. Impact la durée des pré-calculs.
  • Mode de pré-calcul : Deux techniques sont proposées : Voxel Cone Tracing (rapide, mais approximatif), et Lancé de rayons (lent, mais précis).
  • Propagation : Utilisé par le mode Voxel Cone Trace. Fonctionne comme le GIProbe.
  • HDR : Si désactivée, les « lightmaps » seront plus petites, mais ne pourront pas capturer toutes les lumières au-dessus du blanc (1.0).
  • Chemin de l’image : Où les lightmaps seront sauvegardées. Par défaut, sur le même répertoire que la scène (« . »), mais il peut être modifié.
  • Extensions : Taille de la zone affectée (peut être modifiée visuellement)
  • Données lumière : Contient les données de pré-calcul de lumière après le pré-calcul. Les textures sont sauvegardées sur le disque, mais il contient aussi les données de capture pour les objets dynamiques, qui peuvent être un peu lourds. Si vous utilisez des formats.tscn (au lieu de.scn), vous pouvez les enregistrer sur le disque.

Objets dynamiques

Dans d’autres moteurs ou implémentateur de lightmapper, vous devez placer manuellement de petits objets appelés «  »lightprobes » tout autour du niveau pour générer des données * capture *. Ceci est utilisé pour, ensuite, transférer la lumière sur des objets dynamiques qui se déplacent dans la scène.

Cependant, cette implementation de la cartographie de la lumière utilise une méthode différente. Le processus est automatique, vous n’avez donc rien à faire. Il suffit de déplacer vos objets, et ils seront éclairés en conséquence. Bien sûr, vous devez vous assurer que vous configurez vos limites de scène en conséquence ou cela ne fonctionnera pas.

../../_images/baked_light_indirect.gif