Génération de plantes, matériaux et animation

D'un asset rapide à un arbre héros animé par le vent

Construire une végétation crédible

Créer une végétation convaincante est l'un des défis les plus difficiles en production 3D. Une plante réaliste n'est pas juste un joli modèle - elle a besoin d'une géométrie cohérente avec une croissance biologique, de matériaux simulant précisément les propriétés optiques d'une plante (translucidité, subsurface scattering, reflet cireux), et éventuellement d'une animation capturant le mouvement léger et organique du vent.

Houdini offre plusieurs approches complémentaires pour y arriver, de la plus rapide à la plus contrôlée : les outils Labs pour des assets rapides, des nœuds de génération avancés pour un contrôle total, l'import d'assets Quixel ou polygonaux pour s'appuyer sur des bibliothèques existantes, et KineFX pour l'animation procédurale. Cet article couvre tout ce pipeline de bout en bout.

Un rappel : les L-Systems, le fondement

Avant d'aborder les outils dédiés aux plantes de Houdini, il est utile de rappeler le concept qui sous-tend presque tous les systèmes de génération de végétation : les L-Systems (systèmes de Lindenmayer), développés en 1968 par le biologiste Aristid Lindenmayer - couverts en détail dans L-Systems et génération procédurale. Houdini inclut nativement un SOP L-System, et chaque outil spécialisé (SpeedTree, PlantFactory) exécute une variante du même principe en coulisses.

  • SpeedTree - le standard de l'industrie pour la végétation professionnelle dans les jeux et le cinéma, exécutant un moteur L-System sophistiqué derrière une interface intuitive, avec des LODs automatiques, une simulation de vent intégrée, et un export vers Houdini, Unity et Unreal. Utilisé dans presque toutes les productions AAA.
  • PlantFactory (e-on Software) - une alternative très capable spécialisée dans les écosystèmes complets et les plantes ultra-réalistes pour le cinéma et le matte painting, gérant des niveaux de complexité très élevés (brins d'herbe individuels, racines aériennes, plantes tropicales), avec de vastes bibliothèques botaniques et un export vers les formats standards (FBX, Alembic, OBJ).

SideFX Labs : Quick Tree Generator

Le package gratuit SideFX Labs (téléchargeable via le Houdini Launcher) inclut le Labs Quick Tree Generator, conçu pour générer rapidement un arbre complet de qualité production sans configuration complexe - idéal pour peupler une scène rapidement ou prototyper une forêt avant de passer à des assets plus soignés.

Paramètres principaux

  • Seed - la seed aléatoire contrôlant la forme générale de l'arbre. La changer produit un arbre complètement différent avec les mêmes paramètres - la première chose à explorer pour obtenir une bonne silhouette.
  • Trunk Height / Trunk Radius - la hauteur et le rayon de base du tronc, définissant les proportions générales de l'arbre.
  • Branch Levels - le nombre de niveaux de ramification (1 = tronc + grosses branches, 2 = + branches secondaires, 3 = + petites branches). Chaque niveau multiplie la complexité géométrique.
  • Branch Angle - l'angle moyen auquel les branches émergent par rapport à leur parent. Un petit angle donne des arbres élancés (peuplier) ; un grand angle donne des arbres étalés (chêne).
  • Branch Spread - dispersion aléatoire autour de l'angle de base. Des valeurs plus élevées rendent l'arbre plus irrégulier et naturel.
  • Leaf Density - densité du feuillage sur les branches terminales, contrôlant directement la masse visuelle de la couronne.
  • Leaf Size - la taille des cartes de feuilles, à ajuster à l'échelle de la scène.
  • Leaf Shape - le profil géométrique de la carte de feuille (rectangulaire, losange, goutte d'eau), influençant la silhouette du feuillage.

Sortie

Le nœud produit directement deux groupes de géométrie distincts : trunk_branches (la structure de bois) et leaves (les cartes de feuilles). Ces groupes peuvent être ciblés séparément pour différents matériaux - essentiel pour le workflow de matériaux décrit plus loin dans cet article.

Limites et quand l'utiliser

Quick Tree Generator est excellent pour le prototypage, les arrière-plans, et les scènes de forêt dense où les arbres individuels ne sont pas au premier plan. Pour des arbres héros (visibles au premier plan, animés, ou nécessitant un détail botanique précis), il vaut mieux utiliser les nœuds avancés ci-dessous ou importer des assets SpeedTree/PlantFactory.

Nœuds avancés de construction d'arbres

Pour un contrôle total sur la géométrie d'un arbre, Houdini offre plusieurs nœuds SOP spécialisés qui permettent de construire un arbre pièce par pièce avec une précision chirurgicale.

Le SOP L-System

Le nœud L-System est la base purement procédurale, où axiome, règles de remplacement, angle et nombre d'itérations sont définis manuellement. C'est l'outil le plus flexible mais aussi le plus exigeant - il nécessite une bonne compréhension du langage Turtle et de l'expérience avec les L-Systems pour produire des formes convaincantes. Son principal avantage est d'être entièrement contrôlable via des expressions et des paramètres, ce qui le rend parfait pour une intégration dans des réseaux TOPs/PDG pour générer en lot des variations d'arbres.

Labs Tree Trunk Generator

Ce nœud Labs génère le tronc et les branches principales d'un arbre avec un haut niveau de détail géométrique - un maillage organique avec une section irrégulière, des racines contreforts à la base, et des cicatrices de branches. Contrairement à Quick Tree, il se concentre purement sur la structure de bois et est destiné à être combiné avec d'autres nœuds pour le feuillage.

Labs Branch Generator

En complément du Tree Trunk Generator, ce nœud génère les branches secondaires et tertiaires selon une logique de distribution paramétrique, en utilisant les points et normales de la géométrie entrante pour positionner les branches de façon cohérente avec la direction de croissance du tronc parent.

Copy to Points pour le feuillage

Le feuillage d'un arbre est presque toujours construit en instanciant des cartes de feuilles sur les extrémités des branches. Le workflow standard :

  1. Construire une carte de feuille : un simple plan polygonal (2 triangles) avec une texture de feuille transparente.
  2. Disperser des points sur les branches terminales avec un nœud Scatter ou Heightfield Scatter.
  3. Orienter les points avec un Point Wrangle pour qu'ils suivent la direction de la branche et fassent face à la lumière.
  4. Instancier la carte de feuille sur ces points avec Copy to Points.
  5. Varier la taille, la rotation et l'inclinaison de chaque feuille pour éviter la répétition visuelle.
// Point Wrangle pour orienter les feuilles
vector up = {0, 1, 0};
vector branch_dir = normalize(v@N);
vector right = normalize(cross(up, branch_dir));
matrix3 rot = maketransform(right, up, branch_dir);
p@orient = quaternion(rot);
f@scale = fit01(rand(@ptnum), 0.8, 1.2); // variation de taille

Importer des assets : Quixel et bibliothèques polygonales

En production, il n'est pas toujours nécessaire - ni souhaitable - de générer chaque plante à partir de zéro dans Houdini. Des bibliothèques d'assets comme Quixel Megascans offrent des plantes scannées par photogrammétrie d'une qualité exceptionnelle, bien plus efficaces à importer et intégrer dans un pipeline Houdini.

Importer des assets Quixel Megascans

Quixel Megascans offre une vaste bibliothèque de plantes scannées par photogrammétrie : herbes, fougères, arbustes, fleurs, mousse, algues. Ces assets sont livrés avec un ensemble complet de cartes de texture (Albedo, Normal, Roughness, Translucency, Opacity). Le workflow d'import dans Houdini :

  1. Télécharger l'asset depuis Quixel Bridge (FBX ou OBJ de préférence).
  2. Dans Houdini, utiliser un File SOP pour importer le FBX, ou Alembic si l'asset est disponible en .abc.
  3. Vérifier l'échelle : les assets Quixel sont calibrés en centimètres, donc un Transform SOP avec une échelle de 0.01 est souvent nécessaire pour convertir en mètres.
  4. Identifier les groupes de géométrie (branches, feuilles, sol) pour appliquer les matériaux séparément.
  5. Connecter les textures Megascans aux paramètres du shader Houdini (voir la section Matériaux ci-dessous).

Importer des assets polygonaux standards

Pour des assets provenant d'autres logiciels (SpeedTree, PlantFactory, Blender, 3ds Max), le workflow est similaire avec quelques points à surveiller :

  • FBX avec matériaux intégrés - le nœud FBX Character Import ou un File SOP avec l'import de matériaux activé ; Houdini crée automatiquement des Principled Shaders correspondants.
  • OBJ + MTL - l'import OBJ ramène la géométrie et tente de lire le fichier MTL pour les matériaux de base ; les textures doivent être dans le même répertoire ou référencées avec des chemins absolus.
  • Alembic (.abc) - le format recommandé pour les assets animés (arbres avec simulation de vent pré-bakée depuis SpeedTree), préservant animation, géométrie et groupes.
  • USD - le format de référence pour les pipelines complexes, supportant les instances légères, les matériaux, et la hiérarchie de scène complète.

Le nœud Pack : pourquoi il est essentiel

C'est l'un des concepts les plus importants pour travailler efficacement avec la végétation dans Houdini : le nœud Pack (Packed Primitives). Quand on place des centaines ou des milliers d'arbres dans une scène, stocker la géométrie complète de chaque instance en mémoire est désastreux pour la performance. Pack résout ce problème en stockant la géométrie une seule fois et en ne gardant qu'une référence légère (un point avec des attributs de transformation) pour chaque instance.

  • Pack SOP - encapsule la géométrie d'un asset dans une Packed Primitive. La géométrie est stockée une seule fois en mémoire quel que soit le nombre d'instances - 1000 arbres instanciés via des Packed Primitives utilisent à peu près la même mémoire qu'un seul arbre.
  • Unpack SOP - l'opération inverse, décompressant les Packed Primitives en géométrie polygonale complète. À utiliser uniquement en cas de nécessité (édition de géométrie, baking), car cela détruit l'avantage de performance.
  • Instance SOP vs. Copy to Points - Instance utilise nativement les Packed Primitives et est encore plus léger que Copy to Points pour de grandes quantités - le choix recommandé pour les scènes de forêt avec des milliers d'arbres.

Le workflow recommandé pour placer de la végétation à grande échelle : importer l'asset → Pack SOP → disperser les points de placement → Copy to Points ou Instance. Chaque moteur de rendu moderne (Karma, Mantra, Arnold, Redshift) gère nativement les Packed Primitives et les instancie efficacement au moment du rendu, sans les décompresser en mémoire.

// Pipeline Pack recommandé
asset_geo [File SOP]
    ↓
pack [Pack SOP]        ← géométrie stockée une seule fois
    ↓
copy_to_points [Copy to Points SOP avec points scatter]
    ↓
OUT_vegetation         ← milliers d'instances, mémoire minimale

Matériaux et textures

La qualité visuelle finale d'une plante dépend autant de ses matériaux que de sa géométrie - une géométrie parfaite avec des matériaux médiocres décevra toujours, tandis que des matériaux soignés peuvent transformer un arbre géométriquement simple en un asset convaincant. Voici les composants de texture essentiels pour chaque type d'élément végétal.

Le Principled Shader de Houdini (Karma/Mantra)

Le Principled Shader est le matériau de base universel de Houdini, implémentant le modèle PBR (Physically Based Rendering) complet et acceptant toutes les textures décrites ci-dessous. Pour la végétation, c'est le point de départ systématique, avec des ajustements spécifiques par type d'élément (écorce, feuille, mousse).

1. Écorce : tronc et branches

  • Albedo (Base Color) - la couleur diffuse de l'écorce. La vraie écorce présente une variation subtile : crevasses plus sombres, arêtes plus claires. Une écorce trop uniforme se lit immédiatement comme artificielle.
  • Normal Map - la carte la plus importante pour l'écorce, simulant sillons, fissures et nœuds sans ajouter de polygones. Une bonne normal map change radicalement la lecture de la surface.
  • Roughness - l'écorce est généralement très rugueuse (0.8-1.0), sauf pour des espèces comme le bouleau (écorce lisse, 0.3-0.5). Les zones humides ou moussues sont plus rugueuses que les zones sèches.
  • Displacement / Height Map - pour les plans rapprochés (arbres héros), un vrai displacement géométrique de l'écorce donne un réalisme inégalé, mais coûte cher en polygones - à réserver aux plans rapprochés.
  • AO (Ambient Occlusion) - à multiplier sur l'Albedo pour accentuer les ombres dans les crevasses et ajouter de la profondeur. Peut être baké depuis la géométrie ou fourni directement par des bibliothèques comme Quixel.

2. Feuilles : la translucidité, le paramètre clé

Les feuilles sont l'élément le plus difficile à rendre de façon convaincante. Leur propriété optique principale, la translucidité, est souvent négligée par les débutants, produisant des feuilles qui paraissent opaques et plastiques. En réalité, la lumière traverse partiellement une feuille verte - c'est ce qui lui donne cet aspect lumineux, presque éclairé de l'intérieur, que l'on observe en regardant un arbre à contre-jour.

  • Albedo (Base Color) - la couleur de la face avant de la feuille. Éviter les verts trop saturés et uniformes - une vraie feuille montre de la variation : nervures plus claires, zones de chlorophylle plus denses, bords légèrement plus translucides.
  • Opacity / Alpha Mask - une carte en niveaux de gris définissant la forme exacte de la feuille sur la carte polygonale. Blanc est opaque (la feuille), noir est transparent (l'espace vide autour) - essentiel pour les cartes de feuilles.
  • Translucency / Subsurface Scattering (SSS) - le paramètre le plus important pour des feuilles réalistes. Il définit la quantité de lumière traversant la feuille. Dans le Principled Shader de Houdini, le paramètre Thin Walled SSS est spécifiquement conçu pour les surfaces fines comme les feuilles - une valeur entre 0.3 et 0.7 selon l'épaisseur et la densité de la feuille donne des résultats très convaincants. Sans lui, les feuilles paraissent opaques et lourdes.
  • Normal Map - simule le relief des nervures et la courbure naturelle du limbe, ajoutant une tridimensionnalité perçue même sur une géométrie plate.
  • Roughness - les feuilles vertes fraîches ont une surface légèrement cireuse (0.4-0.6) ; les feuilles sèches ou mortes sont mates (0.7-0.9) ; les feuilles tropicales sont souvent brillantes (0.2-0.4).

Variation des feuilles : la diversité naturelle

Un arbre en bonne santé n'a pas un feuillage uniforme. Pour le réalisme, préparez plusieurs variantes de texture de feuille et distribuez-les aléatoirement sur l'arbre :

  • Feuilles vertes saines - vert moyen à intense, translucidité élevée, léger éclat cireux. La majorité du feuillage (70-80%).
  • Feuilles légèrement sèches ou stressées - vert plus terne, bords brunâtres, translucidité réduite. Ajoute de la crédibilité écologique (10-15%).
  • Feuilles jaunissantes - pour les arbres d'automne ou en stress hydrique, virant vers le jaune-orange avec une translucidité très élevée à mesure que la chlorophylle décline (5-10%).
  • Feuilles mortes encore attachées - brunes, mates, sans translucidité - caractéristique de certaines espèces hivernales comme les chênes marcescents (0-5%).

3. Mousse et lichen

La mousse sur les troncs et les branches basses est un élément de détail qui transforme radicalement l'âge et l'authenticité perçus d'un arbre. Elle se concentre généralement sur les surfaces orientées nord et dans les zones humides (base du tronc, fourches de branches, zones rugueuses).

  • Albedo de mousse - vert franc à vert-gris selon l'espèce et l'hydratation ; la mousse sèche vire vers le beige-gris, la mousse humide est d'un vert saturé et vif.
  • Roughness de mousse - très élevée (0.9-1.0) ; la mousse est l'une des surfaces les plus mates qui soit, sans reflet directionnel.
  • Normal map de mousse - simule sa texture touffue et granuleuse avec un micro-relief significatif.
  • Masque de placement - utiliser un Layer Blend ou un masque d'occlusion calculé sur la géométrie pour concentrer la mousse dans les zones basses, les creux et les faces exposées à l'humidité. Dans Houdini, ce masque peut être baké via le nœud Labs Bake Texture.

Récupérer et organiser les matériaux

L'import d'un asset FBX ou Alembic fait créer automatiquement des matériaux par Houdini dans le contexte /mat. Ces matériaux auto-générés sont souvent basiques et nécessitent un ajustement :

  1. Identifier les groupes de géométrie - vérifier les groupes du File SOP ou les attributs shop_materialpath pour voir quels matériaux s'appliquent à quelles parties.
  2. Ouvrir le Material Network (/mat) où apparaissent les matériaux importés ; les nommer clairement (tree_bark, tree_leaves, tree_moss).
  3. Convertir en Principled Shader si les matériaux importés sont dans un format incompatible, en transférant les textures manuellement vers un nouveau matériau.
  4. Connecter les textures manquantes - les assets Quixel livrent chaque carte nécessaire ; câbler Translucency vers Thin Walled SSS, et Normal Map vers le bon emplacement en tenant compte du format (DirectX vs. OpenGL).
  5. Assigner les matériaux via un Material SOP en aval plutôt que directement dans le File SOP - cela permet de changer le matériau sans toucher à l'asset source, une approche plus propre et non destructive.

Pour un pipeline propre, organisez les matériaux en sous-réseaux dans /mat, un par asset ou biome, en utilisant des nœuds Null comme points d'entrée pour les paramètres partagés (intensité de translucidité, teinte générale) qui peuvent être ajustés globalement sans ouvrir chaque matériau individuel.

Animer avec KineFX : le vent dans les arbres

KineFX est le système d'animation par rig procédural introduit dans Houdini 18.5. Bien que principalement associé à l'animation de personnages, il convient parfaitement à l'animation procédurale de végétation, en particulier la simulation de vent - offrant un contrôle artistique que les simulations physiques pures (Vellum, FEM) ne permettent pas toujours.

Le principe derrière l'animation de vent KineFX

L'idée centrale est de traiter la structure d'un arbre comme un rig hiérarchique : le tronc est la racine, les branches principales sont des os de premier niveau, les branches secondaires de deuxième niveau, et ainsi de suite. Appliquer des rotations procédurales à chaque niveau de cette hiérarchie - avec une amplitude décroissante et une fréquence croissante à mesure que l'on descend - produit un mouvement de vent très naturel.

Étape 1 : construire le squelette de l'arbre

  1. À partir de la géométrie des branches de l'arbre, extraire un squelette à l'aide du nœud Labs Tree Skeleton ou d'un Ends SOP pour trouver les extrémités des branches.
  2. Utiliser un Find Shortest Path ou un Connectivity SOP pour établir la hiérarchie parent/enfant entre les segments de branches.
  3. Convertir la structure en rig KineFX via le Skeleton SOP, en définissant les joints à partir des points de ramification.

Étape 2 : appliquer la déformation de vent

Dans un nœud Pose-O-Matic ou directement via un Rig Pose SOP, appliquer des rotations procédurales à chaque joint :

// Animation de vent dans un Rig Wrangle
// Amplitude décroissante selon le niveau hiérarchique
float level = f@bone_level;          // niveau dans l'arbre
float amp   = 0.3 / (level + 1.0);  // amplitude décroissante
float freq  = 0.5 + level * 0.3;    // fréquence croissante
float phase = @ptnum * 0.7;          // décalage de phase par branche

float wind_x = sin(@Time * freq + phase) * amp;
float wind_z = cos(@Time * freq * 0.7 + phase) * amp * 0.5;

// Appliquer la rotation au joint
vector rot = set(wind_x, 0, wind_z);
p@local_transform = qrotate(quaternion(rot), {0,1,0});

Étape 3 : transférer la déformation vers la géométrie

Une fois le rig animé, le Bone Deform SOP transfère les transformations du squelette vers la géométrie polygonale de l'arbre (skin weighting). Les poids de skin peuvent être calculés automatiquement via Capture Geometry ou peints manuellement pour un contrôle fin.

Alternative : Vellum pour le mouvement secondaire de végétation

Pour le mouvement secondaire fin (feuilles, herbe, petites tiges), Vellum (le solveur de corps mous de Houdini) est souvent plus approprié que KineFX. Vellum Hair fonctionne particulièrement bien pour l'herbe, et Vellum Cloth pour les grandes feuilles larges (bananiers, hostas). Les deux approches peuvent se combiner : KineFX pour le mouvement primaire de l'arbre, Vellum pour la dynamique secondaire des feuilles.

Animation de bruit procédural sans KineFX

Pour les scènes où une animation de vent simplifiée suffit (végétation d'arrière-plan, assets packés), une approche plus légère utilise directement un Point Deform SOP avec un champ de bruit animé :

// Point Wrangle simple pour simuler le vent
// À appliquer sur une géométrie déjà placée
float height_factor = fit(v@P.y, 0, chf('tree_height'), 0, 1);
float wind_amp = chf('wind_amplitude') * height_factor;
float wind_freq = chf('wind_frequency');

float nx = snoise(set(v@P.x*0.1, @Time*wind_freq, v@P.z*0.1));
float nz = snoise(set(v@P.z*0.1, @Time*wind_freq*0.8, v@P.x*0.1));

v@P.x += nx * wind_amp;
v@P.z += nz * wind_amp * 0.6;

Cette approche est plus rapide à mettre en place et fonctionne bien pour les plans larges. L'attribut height_factor est crucial - il garantit un mouvement nul à la base (les racines ne bougent pas) et un mouvement maximal en haut des branches, conformément au comportement physique réel.

Le workflow complet

Le pipeline recommandé pour intégrer de la végétation dans une scène de production, combinant tout ce qui précède :

  1. Définir les besoins - identifier quels arbres/plantes sont des héros au premier plan, en plan moyen, ou en arrière-plan. Les héros nécessitent des assets de haute qualité et une animation soignée ; les arrière-plans peuvent utiliser des assets Quick Tree ou des instances pré-bakées.
  2. Générer ou importer les assets - pour les héros : import Quixel ou SpeedTree. Pour le plan moyen : Labs Quick Tree Generator avec personnalisation. Pour les arrière-plans : SOP L-System en lot via TOPs/PDG en suivant la règle des 3×3.
  3. Packer et préparer les instances - packer systématiquement chaque asset avant le placement ; construire une bibliothèque d'assets packés (Small, Medium, Large par espèce, selon la règle des 3×3).
  4. Créer les matériaux - un Principled Shader par composant (écorce, feuilles, mousse) ; toujours configurer la translucidité pour les feuilles ; tester les matériaux sur les assets héros avant de les appliquer à grande échelle.
  5. Placer sur le terrain - utiliser Heightfield Scatter avec des masques de biomes pour distribuer la végétation écologiquement (voir Terrains heightfield et biomes) ; Copy to Points ou Instance selon la quantité.
  6. Animer - pour les héros : KineFX avec un rig de vent. Pour le plan moyen : Point Deform avec bruit animé. Pour l'arrière-plan : animation bakée ou assets statiques.
  7. Rendre - vérifier les réglages de translucidité dans Karma/Mantra ; activer le ray tracing pour que la lumière traverse correctement les couches de feuilles ; tester avec un contre-jour pour valider la translucidité.

Ressources

← Précédent : L-Systems et génération procédurale Suivant : Terrains heightfield et biomes →