Meilleurs générateurs d'arbres 3D pour les jeux en 2026 : FoliMesh vs SpeedTree, The Grove, Blender et l'IA

Tout jeu en extérieur vit ou meurt par sa végétation. Un château peut être parfait, mais si chaque arbre autour a le même tronc, les mêmes angles de branches et la même couronne, le monde paraît faux en quelques secondes. Modéliser les arbres à la main donne le contrôle, mais une forêt demande des centaines de variantes — et chacune doit rester légère à cent mètres de la caméra.

C'est le rôle des générateurs d'arbres. Dans ce guide, nous comparons les principales options de 2026 — FoliMesh, SpeedTree, The Grove, Blender Sapling, Geometry Nodes, les bibliothèques d'assets et les outils d'IA texte/image vers 3D comme Tripo — sur ce qui compte vraiment dans un jeu : niveaux de détail, budgets de triangles, feuillage, vent, collision, pivot, export vers le moteur et modèle de prix.

En toute transparence : FoliMesh est notre outil. Nous l'avons créé pour notre propre jeu, nous savons donc exactement où il excelle — et nous vous dirons aussi quand un autre outil est le meilleur choix.

En bref

• FoliMesh — un générateur procédural dans le navigateur, conçu pour les jeux : vous fixez un budget de triangles pour chaque LOD et vous obtenez un modèle prêt pour le jeu avec LOD0–LOD3, un imposteur, une collision, des données de vent et un pivot à la base, exporté en GLB, FBX, OBJ ou en paquet prêt pour Unity, Unreal Engine ou Godot. 10 styles visuels, saisons et états (souche, rondin, chicot…) depuis un seul générateur. Rien à installer, aucun abonnement obligatoire.
• SpeedTree — le standard de l'industrie pour les grands studios : profond, puissant, avec son propre runtime et la courbe d'apprentissage la plus raide.
• The Grove — simulation de croissance pour Blender et Houdini : de beaux arbres botaniquement crédibles pour l'archviz et le cinéma ; l'optimisation pour le jeu est à votre charge.
• Blender Sapling et Geometry Nodes — gratuits et flexibles, mais LOD, cartes de feuilles, collision et vent sont à faire à la main.
• IA texte/image vers 3D (Tripo, Meshy et autres) — idéal pour un arbre « héros » inhabituel ou un concept. Selon les éditeurs eux-mêmes, le résultat a encore besoin de LOD, de cartes de feuilles, d'une collision, d'un pivot et du vent avant d'être prêt pour le jeu.

L'éditeur FoliMesh dans le navigateur : une bibliothèque de presets à gauche, le modèle 3D en direct à droite, le nombre de triangles et la hauteur en bas.

Ce qu'un générateur d'arbres doit vraiment faire pour un jeu

Un arbre qui rend bien en image n'est pas automatiquement un asset de jeu. Avant de le mettre dans Unity, Unreal ou Godot, il lui faut :

1. Une chaîne de LOD avec un nombre de triangles prévisible à chaque distance — et la même silhouette, pour que la transition soit invisible.
2. Un feuillage efficace. Des feuilles modélisées une à une font exploser le nombre de triangles ; d'immenses cartes transparentes font exploser l'overdraw. Il faut des grappes qui remplissent bien leurs cartes.
3. Des données de vent — tronc immobile, grosses branches lentes, extrémités des feuilles rapides — stockées là où votre shader peut les lire.
4. Une collision — une forme simple pour le tronc, pas toute la couronne.
5. Un pivot à la base du tronc, une échelle réelle et des normales propres.
6. De la variété — de nouveaux arbres de la même essence qui ne sont pas des copies.
7. Un export que votre moteur comprend, idéalement sans une heure de réglages d'import.

Gardez cette liste en tête : c'est le test honnête pour chacun des outils ci-dessous.

Comment fonctionnent les générateurs d'arbres procéduraux

Sous le capot, presque tous les générateurs d'arbres répondent à la même question : où pousse la branche suivante ? Il existe trois réponses classiques.

Les L-systèmes. Un système de Lindenmayer part d'un seul symbole — le tronc — et le réécrit encore et encore selon des règles de grammaire : « pousse en avant, tourne, divise-toi en deux ». Quelques règles suffisent à obtenir une ramification étonnamment naturelle, et changer les règles donne une autre essence. La plupart des outils destinés aux artistes cachent la grammaire derrière des curseurs.

La colonisation de l'espace. La couronne est d'abord remplie de points d'attraction ; les branches poussent vers les points libres les plus proches jusqu'à ce que l'espace soit « colonisé ». On obtient des couronnes qui remplissent naturellement un volume donné — pratique quand un arbre doit épouser une silhouette.

Les modèles paramétriques et de croissance. Chaque niveau de branches a ses paramètres — longueur, angle, courbure, nombre d'enfants et leur position. Les simulateurs de croissance comme The Grove ajoutent la lumière, l'ombre et la gravité sur plusieurs saisons simulées : les arbres se penchent vers la lumière et perdent leurs branches ombragées.

Une fois le squelette obtenu, le générateur doit encore faire le travail qui compte pour un jeu : transformer les branches en maillage avec le bon nombre d'anneaux et de segments, placer les feuilles, cuire les textures, construire les LOD et exporter. C'est dans cette seconde moitié que les outils diffèrent le plus — et c'est là que part l'essentiel du temps en production.

Comment fait FoliMesh. Chaque essence est un ensemble de règles de croissance pour le tronc, les niveaux de branches et les feuilles, avec son écorce et son feuillage propres. Le squelette pousse avec son propre pas fixe, indépendant du niveau de détail des polygones. Ce n'est qu'ensuite que le mailleur décide combien d'anneaux et de segments reçoit chaque branche et combien de grappes de feuilles la couronne conserve — et il choisit ces valeurs par recherche dichotomique sur un compteur analytique de triangles, jusqu'à ce que le résultat tienne dans votre budget. C'est pourquoi changer un budget ne change jamais la forme de l'arbre, seulement son poids.

Comparatif en un coup d'œil

	FoliMesh	SpeedTree	The Grove	Sapling / Geometry Nodes	IA texte/image vers 3D
Où il tourne	Navigateur, rien à installer	Application de bureau	Add-on Blender, Houdini	Blender	Web / API
Comment on le pilote	Presets, curseurs, budgets de triangles, texte	Générateurs procéduraux + retouche manuelle	Simulation de croissance	Paramètres / graphes de nœuds	Prompt texte ou image de référence
Chaîne de LOD	LOD0–LOD3 automatiques + imposteur, budget par LOD	Oui, contrôle poussé	Manuelle / étapes en plus	Manuelle	Non incluse — à faire à la main
Budget de triangles par LOD	Oui, séparément pour l'écorce et les feuilles	Via les réglages de LOD	Non	Non	Outils de retopologie, pas de chaîne de LOD
Feuillage	Cartes en grappes avec contrôle du remplissage et de l'overdraw	Maillages de feuilles, atlas, découpes	Assets de rameaux	Manuel	Souvent une masse pleine — à reconstruire
Données de vent	Intégrées (données de sommets + shaders moteur)	Oui, son propre système de vent	Oui	Manuelles	Non incluses
Collision et pivot	Intégrés	Oui	Manuels	Manuels	Non inclus
Paquets moteur	Unity, Unreal, Godot ; GLB pour three.js, Babylon.js, PlayCanvas, Bevy	Unity, Unreal, format propre	Via FBX/GLB depuis Blender	Via FBX/GLB depuis Blender	GLB / FBX / OBJ
Styles	10 (réaliste, low-poly, voxel, pixel, anime, peint à la main, toon, PS1, palette, mobile/VR)	Surtout réaliste	Réaliste	Tous — si vous les construisez	Dépend du modèle
Saisons et états	Printemps–hiver ; souche, arbre tombé, rondin, chicot, motte racinaire, broussailles	Saisons via le réglage des essences	Par la croissance	Manuels	Régénérer
Forêts entières	Dispersion par biome, GLB avec instanciation GPU + points	Via les outils du moteur	Via Blender	Via Geometry Nodes	Non
Même entrée = même arbre	Oui (seed)	Oui	Oui	Oui	Non
Modèle de prix	Téléchargements gratuits pour démarrer, packs, abonnement optionnel	Abonnement	Licence unique	Gratuit	Crédits / abonnement

Les prix changent souvent : vérifiez la page actuelle de chaque éditeur avant d'acheter.

FoliMesh — un générateur pensé autour des budgets du jeu

FoliMesh est né comme outil interne pour Alardon Online, notre jeu en ligne médiéval avec des batailles allant jusqu'à 5 000 guerriers par camp. Un tel jeu doit afficher des milliers de soldats et la forêt qui les entoure à chaque image ; nous avons donc écrit un générateur avec une seule règle : chaque arbre est construit pour un budget. (L'histoire de la naissance de FoliMesh.)

Des budgets plutôt que des approximations

La plupart des outils vous font construire un arbre puis le réduire. FoliMesh fait l'inverse : vous fixez combien de triangles l'écorce et les feuilles peuvent utiliser à chaque niveau de détail, et le générateur trouve seul le bon niveau de détail. Voici un vrai chêne tiré de l'éditeur :

Niveau	Triangles	Écorce : utilisé / budget	Feuilles : utilisé / budget
Gros plan	44 294	20 000 / 20 000	24 294 / 27 000
LOD0	14 490	990 / 1 000	13 500 / 13 500
LOD1	3 984	288 / 300	3 696 / 3 700
LOD2	1 154	56 / 60	1 098 / 1 100
Imposteur	2	—	—

L'arbre complet, avec tous ses niveaux, a été généré en 532 ms dans le navigateur (WebGPU). Les presets de plateforme — Mobile, PC et consoles, Gros plan — fixent des budgets raisonnables en un clic.

Le panneau « triangles par LOD » : nombre réel face au budget pour l'écorce et les feuilles, grappes de feuilles, overdraw et couches.

Le même arbre à chaque niveau

La forme et les polygones sont séparés : le squelette pousse une seule fois, et les anneaux et segments sont simplement tendus sur la courbe finale. C'est pourquoi le LOD2 a la même silhouette que le LOD0 — il est simplement plus léger. Les niveaux lointains retirent d'abord les grappes de feuilles intérieures et agrandissent les autres en conservant leur surface : le ton et la densité de la couronne ne « sautent » pas quand le moteur change de niveau.

Un chêne, quatre niveaux de détail : la silhouette et la densité de la couronne restent identiques.

La vue « Tous côte à côte » : chaque niveau dans une même scène, sous la même lumière.

Les données de jeu font partie du modèle

• Le vent est cuit dans les données de sommets (tronc 0, grosses branches environ 0,3, extrémités des feuilles 1,0), et les paquets moteur incluent des shaders de vent qui les lisent.
• La collision est générée comme une forme simple autour du tronc.
• Le pivot se trouve au centre de la base du tronc, à l'échelle réelle.
• La variété : chaque seed donne un nouvel arbre de la même essence ; la même seed donne toujours le même arbre.

Un export qui fonctionne tout simplement

• Unity — FBX avec des nœuds _LOD0…_LOD3, pour que Unity crée le LOD Group à l'import, plus un importeur et des shaders de vent pour le pipeline Built-in et l'URP.
• Unreal Engine — FBX avec un groupe de LOD et une collision UCX_, plus un script d'import.
• Godot 4 — GLB plus une scène .tscn prête : LOD via les plages de visibilité, vent et collision StaticBody3D inclus.
• Le web et Rust — GLB pour three.js, Babylon.js, PlayCanvas et Bevy.
• Et aussi : OBJ, MagicaVoxel .vox pour le style voxel, sprite sheets pour les jeux 2D, et images d'imposteur pour le lointain.

Un générateur, dix styles, toutes les saisons

Le même chêne — et chaque autre essence — peut être construit dans dix styles visuels : réaliste, low-poly, palette (façon Synty), pixel, voxels, rétro PS1, mobile/VR, anime (façon Ghibli), peint à la main et toon avec contour.

Un chêne, dix styles : réaliste, low-poly, palette, pixel, voxels, PS1, mobile/VR, anime, peint à la main et toon.

Saisons et états font partie du même générateur, si bien qu'un biome entier reste cohérent :

Saisons : floraison au printemps, couronne pleine en été, couleurs d'automne, branches nues sous la neige en hiver.

États : vivant, souche, tombé, abattu, rondin, chicot, motte racinaire et broussailles — tout ce qu'il faut pour un sol forestier et une mécanique de bûcheronnage.

Pas seulement des chênes

Le générateur couvre des dizaines d'essences d'arbres — du pin, du bouleau et du saule au baobab, au sakura, au séquoia, au ginkgo et au dragonnier — ainsi que palmiers, cactus et plantes grasses, arbustes et bambous, herbes et fougères, lianes, cultures et fleurs, champignons et bois mort, rochers et falaises, grottes et cristaux, et plantes sous-marines.

Quelques essences d'arbres : chacune a ses propres règles de ramification, son écorce et ses feuilles.

Des forêts entières en un seul export

Le mode forêt remplit une parcelle selon les règles d'un biome — taïga, forêt de feuillus, tropiques, désert, marais, savane — avec arbres, sous-bois, herbe et rochers dans le style et la saison en cours. Une parcelle de feuillus de 60 × 60 m a donné 824 plantes et environ 574 000 triangles en seulement 46 maillages, car les modèles identiques sont exportés une seule fois et placés comme instances GPU (EXT_mesh_gpu_instancing), avec une liste de points en JSON pour votre propre système de dispersion.

Une parcelle de feuillus de 60 m : 824 plantes, 46 maillages grâce à l'instanciation GPU.

L'IA là où elle aide

Dans FoliMesh, l'IA n'invente pas la géométrie. Elle transforme vos mots en réglages du générateur, et le maillage est toujours construit par le cœur procédural — il reste donc prévisible, reproductible et dans votre budget. Les mêmes outils sont accessibles aux assistants IA via MCP. (Pourquoi ce choix : nous générons les arbres avec des maths, pas avec des maillages neuronaux.)

Quand FoliMesh n'est pas le meilleur choix

• Vous avez besoin d'un arbre « héros » unique, sculpté à la main et fidèle au concept art branche par branche — un workflow manuel ou les outils de retouche de SpeedTree donnent un contrôle plus direct.
• Votre studio a déjà un pipeline SpeedTree avec des centaines d'essences réglées — changer est rarement rentable.
• Vous faites du rendu de croissance botanique de qualité cinéma pour l'archviz — la simulation de croissance de The Grove est faite pour ça.

Statut

L'éditeur dans le navigateur visible sur les captures est en cours de migration vers folimesh.com. Des modèles prêts sont déjà disponibles dans le catalogue — chacun avec LOD0–LOD3, collision et pivot — avec des téléchargements gratuits pour les nouveaux comptes et des tarifs simples.

Pas à pas : un arbre prêt pour le jeu dans FoliMesh

1. Choisissez quoi créer. Prenez une essence dans la bibliothèque — ou cherchez « chêne », « champignon », « rocher ».
2. Choisissez un style. Réaliste pour les jeux PBR, low-poly pour le mobile et les jeux stylisés, voxels ou pixel art pour un look rétro, anime ou peint à la main pour les mondes stylisés.
3. Choisissez une saison et un état. L'été par défaut ; floraison printanière, couleurs d'automne ou branches d'hiver. Pour un sol forestier ou une mécanique de bûcheronnage, passez en souche, arbre tombé, rondin, chicot, motte racinaire ou broussailles.
4. Réglez la plateforme. Mobile, PC et consoles, ou gros plan. Le preset remplit des budgets de triangles raisonnables pour chaque LOD ; vous pouvez affiner l'écorce et les feuilles séparément.
5. Générez des variantes. Chaque nouvelle seed donne un nouvel arbre de la même essence. Gardez trois ou quatre seeds par essence et votre forêt n'aura jamais l'air d'un copier-coller.
6. Vérifiez chaque niveau. Passez à « Tous côte à côte » et au panneau des triangles par LOD. Assurez-vous que le LOD2 se lit toujours comme le même arbre à la distance où il sera utilisé.
7. Téléchargez. Un seul GLB/FBX/OBJ, ou un paquet pour Unity, Unreal Engine ou Godot avec LOD, collision et vent déjà branchés.
8. Déposez-le dans le moteur et testez-le avec le nombre réel d'instances, pas un seul arbre sur une carte vide.

Toute la boucle prend des minutes, pas des jours — et si la direction artistique change, vous modifiez un paramètre et réexportez au lieu de tout remodéliser.

SpeedTree — le standard de l'industrie

SpeedTree est l'outil de végétation le plus établi de l'industrie et a été utilisé dans une longue liste de jeux AAA. Son Modeler combine générateurs procéduraux et retouche manuelle : vous pouvez faire pousser un tronc et des branches de façon procédurale, puis les élaguer et les remodeler à la main, créer plusieurs variantes apparentées, le vent, les LOD, des atlas de feuilles et des billboards, et exporter vers les outils DCC et les moteurs de jeu. Unity et Unreal prennent tous deux SpeedTree en charge de manière dédiée.

Choisissez SpeedTree si vous êtes un studio avec un gros pipeline de végétation, des technical artists prêts à maîtriser son graphe de générateurs et un budget pour un abonnement. Réfléchissez-y à deux fois si vous avez besoin de quelques dizaines d'arbres pour un petit jeu : la courbe d'apprentissage et le coût peuvent dépasser les besoins.

The Grove — la simulation de croissance pour Blender et Houdini

The Grove fait pousser les arbres au lieu de les assembler : des cycles de croissance successifs réagissent à la lumière, à l'ombre, à la gravité, à l'élagage et au poids des branches. Le résultat a l'asymétrie naturelle d'un vrai arbre — il se penche vers la lumière, perd ses branches ombragées, développe un côté plus lourd.

Choisissez The Grove si vous travaillez dans Blender ou Houdini et que la crédibilité botanique compte plus que la vitesse — archviz, animation, cinéma. Pour les jeux, prévoyez des étapes en plus : réduction de la géométrie, cartes de feuilles, atlas, LOD, collision, pivots et vent sont en grande partie à votre charge.

Blender Sapling et Geometry Nodes — gratuits et flexibles

Sapling Tree Gen est un add-on gratuit de Blender (Add → Curve) qui construit des arbres à partir de paramètres de ramification et de presets. C'est un moyen rapide d'obtenir un premier arbre procédural, un accessoire stylisé ou un arbre d'arrière-plan. Le revers, c'est le nettoyage : les courbes de branches denses et la géométrie séparée des feuilles demandent généralement conversion, décimation, cartes de feuilles, UV et LOD faits main avant l'export.

Geometry Nodes permet de construire votre propre système d'arbres à partir de courbes, d'instances et d'attributs — branches d'épaisseur variable, instanciation de rameaux, feuilles par niveau de branche, dégâts, bascules de LOD. C'est infiniment flexible, mais le générateur lui-même devient un projet qu'il faut concevoir, déboguer et maintenir.

Choisissez-les si vous avez du temps, des compétences Blender et un budget nul. Attendez-vous à faire vous-même les LOD, les feuilles, le vent et la collision.

Bibliothèques d'assets (Botaniq et autres)

Des bibliothèques comme Botaniq fournissent une végétation prête à placer dans Blender. Elles sont rapides quand l'essence dont vous avez besoin existe déjà. Ce ne sont pas des générateurs : vous êtes limité à ce que contient la bibliothèque, et des assets faits pour le rendu peuvent encore nécessiter une optimisation pour le jeu.

IA texte/image vers 3D — Tripo, Meshy et autres

Les générateurs IA transforment un prompt texte ou une image de référence en modèle 3D texturé en quelques secondes ou minutes. C'est vraiment utile pour un arbre « héros » inhabituel, une essence fantastique ou un concept rapide.

Pour une forêt, les limites sont importantes — et les éditeurs les reconnaissent ouvertement. Le propre guide de Tripo sur les générateurs d'arbres indique que son optimisation de maillage ne fournit pas automatiquement la chaîne de LOD, les cartes de feuilles, la collision, le pivot ni les données de vent dont un jeu a besoin, que les feuilles générées par IA peuvent sortir sous forme de masses pleines plutôt que de cartes de feuillage efficaces, et qu'une seule image ne peut pas définir entièrement l'arrière caché d'un arbre. Les maillages neuronaux diffèrent aussi à chaque génération : obtenir une famille de variantes cohérentes est difficile.

Choisissez l'IA si vous avez besoin d'un maillage de départ pour un asset « héros » unique et que vous êtes prêt à retopologiser, reconstruire le feuillage et régler les LOD à la main. Pour des forêts de production, un générateur procédural reste la voie la plus rapide.

Procédural, fait main ou IA : quelle approche pour votre projet ?

Critère	Générateur procédural	Modélisation manuelle	Génération par IA
Temps jusqu'au premier arbre	De quelques secondes (FoliMesh) à des heures	Des heures à des jours	De quelques secondes à quelques minutes
Variété	Illimitée, par seed	Manuelle	Différente à chaque fois
Cohérence sur toute une forêt	Élevée	Dépend de l'artiste	Faible
Contrôle	Règles, budgets, presets	Total	Prompt / référence
Résultat prêt pour le jeu	Dépend de l'outil — intégré dans FoliMesh	Dépend de l'artiste	Nécessite LOD, feuilles, vent, collision
Idéal pour	Forêts, biomes, nombreuses essences	Arbres « héros » uniques	Concepts et pièces uniques fantastiques

Beaucoup de projets combinent les approches : un générateur procédural pour la forêt, du travail manuel pour les deux ou trois arbres que le joueur regarde de près, et l'IA pour explorer une silhouette inhabituelle.

Budgets de triangles : des chiffres concrets

Il n'existe pas de chiffre unique — votre plateforme, la distance de caméra, le nombre d'instances, les ombres et le coût des matériaux comptent plus que n'importe quelle règle. Comme point de départ :

Plateforme	Arbre d'arrière-plan (lointain)	Arbre à mi-distance (gameplay)	Arbre « héros » / gros plan
Mobile / VR	100–500	500–2 000	jusqu'à 5 000
Web (WebGL / WebGPU)	200–800	1 000–4 000	jusqu'à 10 000
PC et consoles	500–1 500	3 000–15 000	20 000–50 000

Notre chêne ci-dessus est une bonne référence : environ 14 500 triangles en LOD0, 4 000 en LOD1, 1 150 en LOD2 et un imposteur de deux triangles au loin.

Feuillage : cartes, grappes et overdraw

C'est sur les feuilles que la plupart des budgets d'arbres se gagnent ou se perdent. Il y a trois façons de les faire :

• Des feuilles individuelles en géométrie sont superbes de près, mais un seul arbre réclame vite des centaines de milliers de triangles.
• De grandes cartes alpha (la texture d'une branche entière sur un seul quad) sont peu coûteuses en triangles mais chères pour le GPU : chaque pixel transparent est quand même ombré, et les cartes superposées multiplient ce coût. C'est l'overdraw — et sur mobile, c'est souvent le vrai goulot d'étranglement, pas le nombre de triangles.
• Les grappes — de petits groupes de feuilles sur des cartes serrées — sont entre les deux : peu de triangles, peu d'espace vide.

FoliMesh construit des grappes et les mesure. Le panneau des triangles par LOD affiche le remplissage des cartes (la part de chaque carte réellement occupée par des feuilles — 64 % pour le chêne ci-dessus), l'overdraw (combien de fois en moyenne un pixel de la couronne est dessiné) et les couches (combien de cartes s'empilent le long d'un rayon traversant la couronne). Si l'overdraw est trop élevé pour votre plateforme, baissez le budget des feuilles ou passez à un style plus léger — et regardez les chiffres changer instantanément.

Imposteurs et billboards pour le lointain

Au-delà d'une certaine distance, même 1 000 triangles par arbre, c'est trop pour toute une forêt. La réponse classique est l'imposteur : l'arbre est rendu sous plusieurs angles dans un atlas de textures, et le moteur dessine un seul quad toujours tourné vers la caméra avec la bonne vue. FoliMesh exporte l'imposteur comme un niveau à part — deux triangles — avec un atlas d'albédo et un atlas de normales, si bien que les arbres lointains conservent leur éclairage au lieu de ressembler à des autocollants plats.

Une règle pratique : passez à l'imposteur là où l'arbre ne mesure plus que quelques dizaines de pixels de haut à l'écran. Avant ce point, un vrai LOD2 conserve la parallaxe de la couronne ; après, personne ne voit la différence — mais le GPU, si.

Le vent : comment fonctionnent les données

Dans les jeux, le vent n'est presque jamais une simulation. Ce sont quelques lignes dans un vertex shader, pilotées par des données stockées dans le maillage : un poids indiquant de combien chaque sommet peut bouger. FoliMesh le stocke dans les données de sommets — 0 au tronc, environ 0,3 sur les grosses branches, 1,0 aux extrémités des feuilles — si bien qu'un shader peut se contenter de :

offset = windDirection * sin(time * frequency + phase) * strength * weight

où la phase dépend de la position du sommet, pour que les arbres voisins ne se balancent pas en synchronie. Le paquet Unity inclut des shaders de vent pour le pipeline Built-in et l'URP, et la scène Godot contient son propre script de vent — vous obtenez des arbres qui ondulent sans écrire de shader. Dans Unreal, les mêmes poids peuvent piloter un World Position Offset dans le matériau du feuillage.

Nanite et le feuillage dans Unreal Engine 5

Nanite prend en charge les matériaux masqués depuis UE 5.1, ce qui a rendu le feuillage dense bien plus praticable sur du matériel haut de gamme. Cela ne supprime pas tous les coûts pour autant : l'overdraw, les ombres, la mémoire et l'animation du vent comptent toujours, et Nanite n'est pas disponible sur toutes les plateformes. Si vous visez le mobile, la VR, le web ou du matériel plus ancien, gardez les LOD classiques et les imposteurs — c'est pourquoi FoliMesh les exporte pour chaque arbre.

Checklist « prêt pour le jeu » pour n'importe quel arbre

• Le nombre de triangles tient dans le budget à chaque distance
• Au moins trois LOD plus un imposteur ou un billboard pour le lointain
• Cartes de feuilles bien remplies — peu d'espace transparent, overdraw faible
• Un ou deux matériaux, textures dans un atlas
• Des données de vent lisibles par votre shader
• Une collision simple autour du tronc
• Pivot au centre de la base du tronc, échelle réelle
• Normales et tangentes propres
• Testé avec le nombre réel d'instances, pas un seul arbre sur une carte vide

Erreurs fréquentes avec les arbres de jeu

• Optimiser l'arbre « héros » et oublier la forêt. Un arbre à 30 000 triangles, ça passe ; cinq cents, non. Budgétez pour le nombre d'instances à l'écran.
• Changer la silhouette entre les LOD. Si le LOD1 a une couronne différente, les joueurs voient les arbres « respirer » en marchant. Générez tous les niveaux à partir d'un seul squelette.
• D'immenses cartes de feuilles à moitié vides. Peu de triangles, un overdraw terrible. Mesurez le remplissage, pas seulement les triangles.
• Un pivot au milieu de la couronne. Les outils de dispersion enfoncent alors les arbres dans le sol ou les font flotter en l'air. Le pivot doit être au centre de la base du tronc.
• Un maillage de collision fait de l'arbre entier. Les joueurs doivent buter contre le tronc, pas contre les feuilles. Utilisez une capsule ou une enveloppe simple.
• Une seule seed pour toute la forêt. Même avec rotation et échelle aléatoires, le même arbre répété cent fois se repère facilement. Utilisez trois ou quatre seeds par essence.
• Du vent partout avec la même phase. Une forêt qui se balance en synchronie paraît mécanique. Décalez la phase selon la position.

Licences : ce que vous pouvez faire des arbres générés

Avant de publier, vérifiez la licence de chaque arbre — c'est aussi important que le nombre de polygones.

• FoliMesh : les modèles téléchargés sont libres de redevances pour un usage commercial dans vos jeux et projets. Les détails sont dans la licence.
• Les générateurs IA lient souvent la licence à l'offre. Par exemple, Tripo indique que les modèles créés avec son offre gratuite sont publics, sous CC BY 4.0, l'usage commercial étant réservé aux offres payantes.
• Les bibliothèques d'assets et les packs des stores ont chacun leurs conditions — certains interdisent la redistribution sous forme source, d'autres limitent le nombre de postes.
• Vos propres arbres Blender vous appartiennent, mais vérifiez les textures utilisées pour l'écorce et les feuilles.

Notes par moteur

• Unity : les nœuds FBX nommés _LOD0…_LOD3 deviennent automatiquement un LOD Group ; utilisez l'alpha clipping pour les feuilles et l'instanciation GPU ou le SRP Batcher pour les forêts. Voir arbres 3D pour Unity.
• Unreal Engine : importez les LOD avec le maillage, utilisez des matériaux de feuillage masqués double face, placez avec le Foliage Mode ou le PCG. Voir arbres 3D pour Unreal Engine.
• Godot 4 : le GLB s'importe nativement ; utilisez les plages de visibilité pour les LOD et MultiMesh pour les forêts. Voir arbres 3D pour Godot et notre guide pas à pas d'import dans Godot.
• Le web : chargez le GLB avec GLTFLoader ou le SceneLoader de Babylon, branchez les LOD dans THREE.LOD ou addLODLevel, et instanciez les arbres répétés.

Glossaire

• LOD (niveau de détail) — une version plus légère d'un modèle affichée à distance. Le LOD0 est le niveau le plus détaillé utilisé en jeu ; plus le numéro est élevé, plus le modèle est léger.
• Imposteur — un quad qui affiche une image pré-rendue de l'arbre sous le bon angle ; utilisé pour le lointain.
• Billboard — un imposteur plus simple : une ou quelques images toujours tournées vers la caméra.
• Carte de feuilles — un polygone plat avec une texture de feuilles et de la transparence ; une grappe est un petit groupe de feuilles sur une même carte.
• Alpha clipping (alpha test) — les pixels sous un seuil de transparence sont rejetés, ce qui donne aux feuilles des bords nets sans blending coûteux.
• Overdraw — le même pixel de l'écran ombré plusieurs fois parce que des couches transparentes se superposent ; le principal coût d'un feuillage dense.
• Atlas de textures — plusieurs textures regroupées dans une seule image pour qu'un arbre nécessite moins de matériaux et de draw calls.
• Instanciation — dessiner de nombreuses copies du même maillage en un seul appel ; c'est ainsi que les moteurs affichent les forêts.
• Seed — un nombre qui fixe les choix aléatoires du générateur : la même seed donne toujours le même arbre.
• Pivot — le point d'origine du modèle ; pour un arbre, le centre de la base du tronc.

FAQ

Quel est le meilleur générateur d'arbres pour les jeux ?

Cela dépend de votre équipe. Pour des arbres prêts pour le jeu avec LOD, collision et vent d'emblée — dans le navigateur et sans abonnement — FoliMesh. Pour un grand studio avec un pipeline de végétation — SpeedTree. Pour le réalisme botanique dans Blender — The Grove. Pour démarrer gratuitement — Blender Sapling ou Geometry Nodes.

Existe-t-il un générateur d'arbres gratuit ?

Blender Sapling et Geometry Nodes sont gratuits. FoliMesh offre des téléchargements gratuits aux nouveaux comptes, pour tester de vrais modèles prêts pour le jeu avant de payer quoi que ce soit.

L'IA peut-elle générer des arbres 3D pour les jeux ?

Oui, mais surtout comme point de départ. Les outils texte/image vers 3D sont rapides pour un concept ou un arbre « héros » unique ; pour un jeu, il vous faut encore des LOD, un feuillage efficace, du vent, une collision et un pivot. FoliMesh n'utilise l'IA que pour transformer vos mots en réglages du générateur : le résultat est toujours un maillage procédural propre et dans le budget.

Combien de triangles doit avoir un arbre de jeu ?

Environ 100–1 500 pour les arbres lointains, 500–15 000 à distance de gameplay et jusqu'à 20 000–50 000 pour les gros plans sur PC — toujours avec une chaîne de LOD. Voir le tableau des budgets ci-dessus.

Quels formats fonctionnent avec Unity, Unreal et Godot ?

Le FBX est le choix habituel pour Unity et Unreal, le GLB pour Godot, Blender et les moteurs web. FoliMesh exporte en GLB, FBX et OBJ, ainsi qu'en paquets prêts pour Unity, Unreal Engine et Godot.

Peut-on créer des arbres low-poly ou stylisés avec un générateur ?

Oui. FoliMesh construit la même essence dans dix styles — du réaliste au low-poly, aux voxels, au pixel art, à l'anime et au toon — vous n'avez donc pas besoin d'un outil séparé pour un jeu stylisé. Parcourez les modèles 3D low-poly.

Qu'est-ce qu'un LOD et pourquoi un arbre en a-t-il besoin de plusieurs ?

Un LOD (niveau de détail) est une version plus légère du même modèle que le moteur affiche quand l'objet est plus loin. Les arbres en ont besoin de plusieurs car ils sont à la fois détaillés et nombreux : LOD0 de près, LOD1 et LOD2 aux distances de gameplay et un imposteur pour le lointain gardent une forêt rapide sans sauts visibles.

Comment faire onduler les arbres dans le vent ?

Stockez un poids de vent par sommet (tronc 0, extrémités des feuilles 1) et décalez les sommets dans le shader avec un sinus dépendant du temps, dont la phase dépend de la position. Les arbres FoliMesh contiennent déjà les poids, et les paquets Unity et Godot incluent des shaders et scripts de vent prêts à l'emploi.

Peut-on utiliser des arbres générés dans un jeu commercial ?

Avec FoliMesh — oui, les modèles téléchargés sont libres de redevances pour un usage commercial. Avec d'autres outils, vérifiez la licence de votre offre : certains générateurs IA rendent publics les modèles de l'offre gratuite sous CC BY.

Combien d'essences et de variantes faut-il pour une forêt ?

Pour une forêt tempérée crédible, trois à cinq essences dominantes avec trois ou quatre seeds chacune, plus des arbustes, un couvert au sol, du bois mort et des rochers, ont déjà l'air naturel. Variez un peu l'échelle et la rotation, et ajoutez des arbres tombés, des souches et des chicots.

Conclusion

SpeedTree reste le poids lourd des grands studios, The Grove est un plaisir pour le réalisme botanique dans Blender, et les outils gratuits de Blender sont parfaits si vous avez le temps de construire votre propre pipeline. Les générateurs IA sont un moyen rapide d'explorer un arbre inhabituel.

Si ce qu'il vous faut, c'est une végétation prête pour le jeu — des LOD dans le budget, du vent, une collision, un pivot et un export qui tombe directement dans Unity, Unreal, Godot ou le web, dans le style de votre jeu — c'est exactement ce pour quoi FoliMesh a été conçu. Ouvrez le catalogue et téléchargez vos premiers arbres gratuitement.