ComfyUI Trellis2 | Workflow de Génération de Maillage Image-3D

ComfyUI Trellis2 : Image vers 3D, raffinement, multi-vues, low-poly, et texturation PBR en un seul workflow

Note : Ce workflow a été mis à jour le 28 février 2026.

ComfyUI Trellis2 intègre le modèle image-3D TRELLIS.2 de Microsoft dans un pipeline ComfyUI pratique et adapté aux créateurs. À partir d'une ou plusieurs images de référence, il peut générer des maillages, affiner des actifs existants, déplier des UV, cuire des textures PBR, produire des variantes low-poly, et exporter des fichiers prêts à l'emploi pour les outils DCC et les moteurs de jeux. En plus des chemins originaux de texturation d'image unique et de maillage, ce workflow mis à jour inclut maintenant des pipelines dédiés de haute qualité et qualité maximale, des branches de génération multi-vues et de texturation multi-vues, une branche low-poly, et un pipeline de maillage par lots assisté par Qwen + RMBG.

Le graphique est organisé en groupes clairs pour des sorties rapides en un clic, un contrôle avancé, un raffinement, une génération uniquement de maillage, une génération uniquement de texture, une génération plus orientée texture, une génération par étapes de haute qualité, une génération multi-vues, une conversion de maillage uniquement multi-vues, une texturation multi-vues, et un workflow d'assistance Qwen/RMBG. Comparé aux versions précédentes, plusieurs branches utilisent maintenant Trellis2ReconstructMeshWithQuad, Trellis2FillHolesWithMeshlib, et Trellis2SmoothNormals, et les itinéraires multi-vues utilisent maintenant des nœuds multi-vues TRELLIS.2 dédiés au lieu de regrouper les images dans un générateur de vue unique régulier.

Les nœuds source sont principalement fournis par l'extension ComfyUI visualbruno/ComfyUI-Trellis2.

Note : Ce workflow ne peut fonctionner que sur des machines de taille Medium, Large, X Large. Les machines 2X Large ou plus grandes afficheront une erreur.

Note : Dans la section Using_Qwen_Rembg, un contour de nœud rouge peut apparaître dans le frontend. Il s'agit d'un avertissement de frontend erroné et n'empêche pas l'exécution. Si le workflow s'exécute avec succès, vous pouvez l'ignorer.

Modèles clés et systèmes d'assistance utilisés dans ce workflow

• Microsoft TRELLIS.2-4B Le modèle image-3D central utilisé tout au long du workflow. Il génère une structure 3D consciente des voxels, prend en charge le raffinement du maillage, et alimente la génération de textures. Voir microsoft/TRELLIS.2-4B et microsoft/TRELLIS.2.
• BRIA RMBG-2.0 Utilisé dans le pipeline d'assistance Using_Qwen_Rembg pour supprimer les arrière-plans avant la génération de maillage et encore après l'image guide de style normal-map générée. Cela aide à isoler le sujet et à réduire la contamination de l'arrière-plan.
• Pile d'édition d'image Qwen Utilisée dans le workflow d'assistance Using_Qwen_Rembg pour générer une image guide de style normal-map avant la génération de maillage. La pile configurée inclut un GGUF Qwen Image Edit UNet, des actifs Qwen image VAE/CLIP, et un Qwen Image Edit Lightning LoRA.

Aperçu du workflow

À un niveau élevé, le workflow prend désormais en charge les catégories de tâches suivantes :

• Génération texturée d'image unique : Simple, Advanced
• Raffinement de maillage existant : MeshRefiner
• Génération uniquement de maillage : Only_Mesh_Simple, Only_Mesh_Advanced
• Génération uniquement de texture : TextureMesh
• Géométrie + texturation plus forte d'image unique : Better_Texture
• Pipelines de qualité par étapes : High_Quality, Max_Quality
• Génération et texturation low-poly : Lowpoly
• Génération et texturation dédiées multi-vues : MultViews, MultViews_MeshOnly, MultViews_TextureMesh
• Workflow par lots assisté par Qwen + RMBG : Using_Qwen_Rembg

Chaque groupe est autonome et produit son propre export et aperçu.

Comment utiliser chaque groupe

1) Simple

C'est l'itinéraire d'image unique le plus rapide vers un GLB texturé. Chargez le pipeline TRELLIS.2 avec Trellis2LoadModel (#139), chargez votre image de sujet avec transparence via Trellis2LoadImageWithTransparency (#279), et nettoyez-la avec Trellis2PreProcessImage (#142). Trellis2MeshWithVoxelGenerator (#278) produit l'actif voxelisé, et Trellis2PostProcessAndUnWrapAndRasterizer (#141) gère le nettoyage, le dépliage UV, et la cuisson de texture PBR en une étape. Exportez avec Trellis2ExportMesh (#140) et inspectez le résultat dans Preview3D (#149).

Cette branche est maintenant plus simple qu'avant : elle n'utilise plus de nœud Trellis2SimplifyMesh séparé avant le dépliage. Le nettoyage, la rasterisation, et la cuisson sont gérés à l'intérieur de l'étape de post-traitement/dépliage/rasteriseur.

2) Advanced

Utilisez cette branche lorsque vous souhaitez plus de contrôle sur l'inférence de la structure et de l'apparence à partir d'une seule image. Chargez le modèle avec Trellis2LoadModel (#144), l'image source avec Trellis2LoadImageWithTransparency (#299), et prétraitez-la avec Trellis2PreProcessImage (#148). Trellis2MeshWithVoxelAdvancedGenerator (#146) expose plus de contrôles de génération détaillés que le chemin Simple, et Trellis2PostProcessAndUnWrapAndRasterizer (#147) effectue le nettoyage, la génération UV, et la cuisson de texture. Exportez avec Trellis2ExportMesh (#145) et examinez dans Preview3D (#314).

Cette branche n'utilise plus non plus une étape Trellis2PostProcessMesh séparée. L'étape de dépliage et de cuisson est maintenant le bloc de traitement principal en aval.

3) MeshRefiner

Choisissez cette branche lorsque vous avez déjà un maillage et que vous souhaitez l'améliorer avec une guidance d'image. Chargez votre modèle avec Trellis2LoadModel (#157), un maillage existant avec Trellis2LoadMesh (#293), et une image de référence guide avec Trellis2LoadImageWithTransparency (#280) suivie de Trellis2PreProcessImage (#156). Trellis2MeshRefiner (#153) met à jour la géométrie tout en restant lié au maillage d'entrée et à l'image guide.

Après le raffinement, la branche effectue maintenant une séquence de nettoyage plus forte que la version antérieure : Trellis2Remesh (#281), Trellis2SimplifyMesh (#150), Trellis2FillHolesWithMeshlib (#155), et Trellis2MeshWithVoxelToTrimesh (#151). Exportez avec Trellis2ExportMesh (#154) et inspectez dans Preview3D (#315).

4) Only_Mesh_Simple

C'est l'itinéraire rapide uniquement maillage pour la génération d'image unique. Chargez le modèle avec Trellis2LoadModel (#165), chargez l'image avec Trellis2LoadImageWithTransparency (#282), et prétraitez-la avec Trellis2PreProcessImage (#164). Trellis2MeshWithVoxelGenerator (#162) génère le maillage initial. La branche exécute ensuite Trellis2Remesh (#291), Trellis2SimplifyMesh (#161), Trellis2FillHolesWithMeshlib (#163), et Trellis2MeshWithVoxelToTrimesh (#159). Exportez avec Trellis2ExportMesh (#160) et inspectez dans Preview3D (#316).

Ce chemin est maintenant plus robuste que la version plus ancienne car il comble les trous avant la conversion en trimesh.

5) Only_Mesh_Advanced

Utilisez ce chemin lorsque vous souhaitez uniquement la géométrie, mais avec plus de contrôle que l'itinéraire uniquement maillage simple. Chargez le modèle avec Trellis2LoadModel (#166), votre image source avec Trellis2LoadImageWithTransparency (#283), et prétraitez-la avec Trellis2PreProcessImage (#173). Trellis2MeshWithVoxelAdvancedGenerator (#169) produit la structure initiale, puis Trellis2Remesh (#292), Trellis2SimplifyMesh (#171), Trellis2FillHolesWithMeshlib (#172), et Trellis2MeshWithVoxelToTrimesh (#168) nettoient et convertissent pour l'exportation. Exportez avec Trellis2ExportMesh (#170) et inspectez dans Preview3D (#317).

Cette branche convient bien aux sujets où la topologie est plus importante que la sortie de texture immédiate.

6) TextureMesh

Si vous avez déjà un maillage propre et que vous avez seulement besoin de textures, utilisez cet itinéraire. Chargez le pipeline TRELLIS.2 avec Trellis2LoadModel (#177), chargez votre image de référence avec Trellis2LoadImageWithTransparency (#297), prétraitez-la avec Trellis2PreProcessImage (#180), et chargez votre maillage en utilisant Trellis2LoadMesh (#294). Trellis2MeshTexturing (#174) cuit les textures sur le maillage et produit le trimesh mis à jour plus les images de texture. PreviewImage (#175, #178) vous permet d'inspecter les cartes de texture cuites, et Preview3D (#318) montre le résultat ombré final. Exportez avec Trellis2ExportMesh (#179).

7) Better_Texture

Cette branche est un workflow de génération-et-texture plus fort d'image unique que les itinéraires Simple/Advanced. Elle commence avec Trellis2LoadModel (#189), Trellis2LoadImageWithTransparency (#285), et Trellis2PreProcessImage (#181), puis génère la géométrie avec Trellis2MeshWithVoxelAdvancedGenerator (#184). Le maillage est nettoyé en utilisant Trellis2Remesh (#295), Trellis2SimplifyMesh (#182), Trellis2FillHolesWithMeshlib (#186), et Trellis2MeshWithVoxelToTrimesh (#187) avant d'être texturé par Trellis2MeshTexturing (#188). Exportez avec Trellis2ExportMesh (#185) et inspectez dans Preview3D (#320).

Cette branche est utile lorsque vous voulez une meilleure fondation géométrique avant le texturage, mais n'avez pas besoin du flux de raffinement par étapes complet des presets de haute qualité.

8) High_Quality

C'est un pipeline de qualité par étapes qui exporte des maillages intermédiaires et un actif texturé final. Commencez avec un nom dans PrimitiveString (#203), une image source dans Trellis2LoadImageWithTransparency (#284), et Trellis2PreProcessImage (#191). La première étape utilise Trellis2LoadModel (#192), Trellis2MeshWithVoxelAdvancedGenerator (#207), Trellis2ReconstructMeshWithQuad (#206), Trellis2SimplifyMesh (#190), Trellis2FillHolesWithMeshlib (#204), et Trellis2MeshWithVoxelToTrimesh (#197) pour construire un maillage blanc propre, qui est exporté avec Trellis2ExportMesh (#196).

La deuxième étape continue à partir de ce résultat en utilisant Trellis2Continue (#198), puis le raffine avec Trellis2MeshRefiner (#208), Trellis2ReconstructMeshWithQuad (#209), Trellis2SimplifyMesh (#193), Trellis2FillHolesWithMeshlib (#205), et Trellis2MeshWithVoxelToTrimesh (#200). Le maillage raffiné est exporté avec Trellis2ExportMesh (#201).

L'étape finale utilise Trellis2Continue (#202), Trellis2MeshTexturing (#213), et Trellis2SmoothNormals (#211) avant l'exportation finale à travers Trellis2ExportMesh (#212). Examinez le résultat texturé dans Preview3D (#319).

Cette branche est idéale lorsque vous souhaitez un workflow par étapes plus propre avec des points de contrôle intermédiaires : maillage blanc, maillage raffiné, et maillage texturé final.

9) Lowpoly

Utilisez cet itinéraire lorsque vous avez besoin d'un actif low-poly contrôlé dès le départ. La branche commence avec un nom dans PrimitiveString (#224), un budget cible de triangles/faces dans PrimitiveInt (#228), et une image de référence via Trellis2LoadImageWithTransparency (#298) et Trellis2PreProcessImage (#214). Trellis2LoadModel (#227) et Trellis2MeshWithVoxelAdvancedGenerator (#216) créent le maillage de base. Le chemin de nettoyage exécute ensuite Trellis2Remesh (#296), Trellis2SimplifyMesh (#218) en utilisant le nombre de faces cible, Trellis2FillHolesWithMeshlib (#219), et Trellis2MeshWithVoxelToTrimesh (#220).

Une différence clé dans cette branche est que l'exportation de maillage blanc utilise Trellis2ExportMesh (#217) avec une sortie OBJ, pas GLB. Après cela, Trellis2Continue (#222) passe le maillage à Trellis2MeshTexturing (#221), Trellis2SmoothNormals (#229), et une exportation finale GLB texturée à travers Trellis2ExportMesh (#223). Inspectez la sortie finale dans Preview3D (#322).

10) Max_Quality

Cette branche est le pipeline par étapes le plus lourd du workflow et est destinée à une qualité maximale. Elle suit la même structure en trois étapes que High_Quality, mais avec des paramètres de génération et de texturation plus agressifs. Commencez par PrimitiveString (#243), Trellis2LoadImageWithTransparency (#286), et Trellis2PreProcessImage (#231). L'étape initiale de maillage utilise Trellis2LoadModel (#232), Trellis2MeshWithVoxelAdvancedGenerator (#251), Trellis2ReconstructMeshWithQuad (#json 246), Trellis2SimplifyMesh (#230), Trellis2FillHolesWithMeshlib (#244), et Trellis2MeshWithVoxelToTrimesh (#237), puis exporte le maillage blanc avec Trellis2ExportMesh (#236).

L'étape de raffinement continue avec Trellis2Continue (#238), Trellis2MeshRefiner (#252), Trellis2ReconstructMeshWithQuad (#247), Trellis2SimplifyMesh (#233), Trellis2FillHolesWithMeshlib (#245), et Trellis2MeshWithVoxelToTrimesh (#240), puis exporte le maillage raffiné avec Trellis2ExportMesh (#241).

L'étape finale continue avec Trellis2Continue (#242), puis texture à travers Trellis2MeshTexturing (#253), adoucit l'ombrage avec Trellis2SmoothNormals (#249), et exporte le maillage texturé final avec Trellis2ExportMesh (#250). Examinez dans Preview3D (#321).

Utilisez cet itinéraire lorsque le sujet présente des caractéristiques fines et que vous êtes prêt à consacrer plus de temps et de mémoire pour une meilleure fidélité de sortie.

11) MultViews

C'est le principal chemin de génération multi-vues dédié. Contrairement au workflow précédent, il utilise maintenant le nœud dédié Trellis2MeshWithVoxelMultiViewGenerator au lieu de regrouper plusieurs images dans un générateur avancé régulier. Chargez le modèle avec Trellis2LoadModel (#256), puis chargez vos vues avec Trellis2LoadImageWithTransparency (#287, #288) et prétraitez-les à travers Trellis2PreProcessImage (#255, #257). Le câblage d'exemple utilise actuellement les entrées avant et arrière, tandis que le nœud prend également en charge gauche et droite si vous souhaitez les connecter.

Trellis2MeshWithVoxelMultiViewGenerator (#254) génère l'actif, Trellis2PostProcessAndUnWrapAndRasterizer (#258) déplie et cuit les textures, et Trellis2ExportMesh (#259) écrit le résultat. Inspectez-le dans Preview3D (#324).

12) MultViews_MeshOnly

Utilisez cette branche lorsque vous souhaitez uniquement la géométrie multi-vues. Chargez le modèle avec Trellis2LoadModel (#262), deux ou plusieurs vues de référence avec Trellis2LoadImageWithTransparency (#300, #301), et prétraitez-les à travers Trellis2PreProcessImage (#261, #263). Trellis2MeshWithVoxelMultiViewGenerator (#264) gère la fusion des vues, puis Trellis2RemeshWithQuad (#302), Trellis2SimplifyMesh (#265), Trellis2FillHolesWithMeshlib (#266), et Trellis2MeshWithVoxelToTrimesh (#268) le convertissent en une sortie propre uniquement maillage. Exportez avec Trellis2ExportMesh (#267) et inspectez dans Preview3D (#325).

Comme dans la branche multi-vues texturée, le câblage d'exemple utilise des images avant et arrière, tandis que les images gauche/droite restent facultatives.

13) MultViews_TextureMesh

Si vous avez déjà un maillage et que vous souhaitez le texturer à partir de plusieurs vues, utilisez cet itinéraire. Chargez le modèle avec Trellis2LoadModel (#271), chargez le maillage avec Trellis2LoadMesh (#275), et chargez les vues de référence à travers Trellis2LoadImageWithTransparency (#289, #290) plus Trellis2PreProcessImage (#272, #274). Le nœud dédié Trellis2MeshTexturingMultiView (#276) projette et cuit les textures en utilisant plusieurs vues. Exportez le résultat avec Trellis2ExportMesh (#273) et inspectez-le dans Preview3D (#326).

Encore une fois, l'exemple utilise actuellement les vues avant et arrière, mais le nœud prend également en charge les entrées gauche et droite.

14) Using_Qwen_Rembg

C'est le workflow d'assistance le plus spécialisé dans le graphique. Il combine la suppression automatique de l'arrière-plan, la génération de carte normale basée sur Qwen, la génération de maillage par lots à plusieurs budgets de faces, la sélection de maillage, et le texturage final.

Commencez dans la section Name - Nb Faces - Image avec les nœuds StringConstant pour le nom de l'actif (#91) et les comptes de faces cibles (#113), plus votre image source dans Trellis2LoadImageWithTransparency (#127). Le premier sous-graphe Remove Background (#133) isole le sujet. Generate Normal Map (#116) crée ensuite une image de style carte normale en utilisant la pile d'édition d'image Qwen. Le deuxième sous-graphe Remove Background (#115) nettoie à nouveau cette carte normale générée avant qu'elle ne soit passée dans Generate Meshes (#114).

À l'intérieur de Generate Meshes, le workflow prétraite l'image guide, génère un maillage de haute qualité, exécute un post-traitement supplémentaire et une reconstruction de quad, puis utilise la simplification/exportation par lots pour produire plusieurs variantes de maillage à partir de la liste de comptage de faces. Trellis2StringSelector (#132) vous permet de choisir l'un de ces chemins de maillage exportés. Enfin, le sous-graphe Texture Mesh (#131) charge le maillage sélectionné, le texture en utilisant l'image de référence nettoyée originale, et exporte le GLB final, que vous pouvez inspecter dans Preview3D (#323).

Cette branche est particulièrement utile lorsque vous souhaitez :

• isoler automatiquement le sujet,
• générer plusieurs variantes de géométrie en un seul passage,
• choisir une version de nombre de faces préférée,
• et seulement ensuite exécuter le texturage final.

Nœuds clés dans ce workflow mis à jour

• Trellis2PreProcessImage Utilisé dans tout le graphique avant la plupart des nœuds de génération ou de texturage. Il standardise l'image d'entrée et est maintenant présent dans presque toutes les grandes branches.
• Trellis2MeshWithVoxelGenerator Le générateur d'image unique rapide utilisé dans les branches Simple et Only_Mesh_Simple.
• Trellis2MeshWithVoxelAdvancedGenerator Le générateur principal contrôlé d'image unique utilisé dans Advanced, Better_Texture, High_Quality, Max_Quality, Lowpoly, et le pipeline par lots assisté par Qwen/RMBG.
• Trellis2MeshRefiner Raffine un maillage existant avec une guidance d'image. Il est utilisé dans MeshRefiner, High_Quality, et Max_Quality.
• Trellis2PostProcessAndUnWrapAndRasterizer Gère le nettoyage, la génération UV, et la cuisson. Dans le workflow actuel, il est le nœud de finition texturé principal dans Simple, Advanced, et MultViews.
• Trellis2ReconstructMeshWithQuad Reconstruit la structure du maillage avec une étape de reconstruction orientée quad. C'est maintenant une partie majeure du pipeline High_Quality, Max_Quality, et de la génération par lots assistée par Qwen.
• Trellis2Remesh et Trellis2RemeshWithQuad Utilisés pour régulariser la topologie avant simplification, conversion, ou traitement ultérieur. Trellis2RemeshWithQuad apparaît dans la branche de maillage uniquement multi-vues.
• Trellis2SimplifyMesh Réduit le nombre de triangles et est maintenant utilisé dans de nombreuses branches avec le remplissage de trous.
• Trellis2FillHolesWithMeshlib Une nouvelle étape de nettoyage importante dans plusieurs branches. Elle aide à fermer les petits trous avant la conversion en trimesh ou le traitement ultérieur.
• Trellis2MeshWithVoxelToTrimesh Convertit la sortie de maillage voxel de TRELLIS en un maillage triangulaire régulier pour l'exportation ou le texturage.
• Trellis2MeshTexturing Le nœud principal de cuisson de texture pour la projection de texture d'image unique. Il est utilisé dans TextureMesh, Better_Texture, High_Quality, Max_Quality, Lowpoly, et le chemin assisté par Qwen.
• Trellis2MeshWithVoxelMultiViewGenerator Le nœud de génération de maillage multi-vues dédié. Cela remplace l'ancienne approche "regrouper plusieurs images dans un générateur normal".
• Trellis2MeshTexturingMultiView Le nœud de texturation multi-vues dédié pour projeter les textures de plusieurs vues sur un maillage existant.
• Trellis2SmoothNormals Utilisé dans plusieurs branches de texturage avancé pour améliorer l'aspect ombré final avant l'exportation.
• Trellis2BatchSimplifyMeshAndExport Utilisé à l'intérieur du sous-graphe de génération par lots assistée par Qwen/RMBG pour exporter plusieurs variantes de maillage à différents comptes de faces.
• Trellis2StringSelector Vous permet de choisir un chemin de maillage dans une liste d'exportation par lots avant d'exécuter le texturage final.

Conseils pratiques

• Utilisez des images centrées sur le sujet avec un arrière-plan transparent ou déjà isolé dans la mesure du possible.
• Les branches multi-vues prennent en charge les entrées avant/arrière/gauche/droite, mais le workflow d'exemple câble actuellement uniquement avant et arrière. Ajoutez gauche/droite si vous les avez.
• Utilisez Simple ou Advanced pour une itération rapide, puis passez à Better_Texture, High_Quality, ou Max_Quality lorsque vous avez besoin d'une structure plus propre ou de meilleurs matériaux.
• Utilisez Only_Mesh_* lorsque vous prévoyez de déplier, retopo, ou texturer à l'extérieur.
• Utilisez Lowpoly lorsque vous avez besoin de comptes de faces contrôlés et d'un actif plus léger pour le jeu ou l'utilisation en temps réel.
• Dans les branches par étapes telles que High_Quality et Max_Quality, conservez les exports blancs et raffinés intermédiaires. Ce sont des points de contrôle utiles si le résultat texturé final doit être refait.
• Pour la génération multi-vues, gardez l'échelle, le cadrage, et l'éclairage cohérents à travers les vues.
• Pour le texturage guidé par image, gardez l'éclairage neutre pour éviter de cuire des reflets ou des ombres sévères dans l'albédo.
• Si vous voyez un faux contour de nœud rouge dans la section Using_Qwen_Rembg, essayez d'exécuter le workflow de toute façon avant de supposer que la branche est cassée.

Ressources

• Carte modèle TRELLIS.2 : microsoft/TRELLIS.2-4B
• Référentiel TRELLIS.2 : microsoft/TRELLIS.2
• Référentiel TRELLIS original : microsoft/TRELLIS
• Extension ComfyUI utilisée : visualbruno/ComfyUI-Trellis2
• Modèle de suppression d'arrière-plan utilisé dans le flux d'assistance : briaai/RMBG-2.0

Remerciements

Ce workflow implémente et s'appuie sur les travaux et ressources suivants. Nous remercions chaleureusement visualbruno pour ComfyUI-Trellis2 et les mainteneurs des nœuds de support et des modèles d'assistance utilisés dans ce graphique, y compris TRELLIS.2, RMBG, et les actifs d'édition d'image basés sur Qwen configurés dans le workflow.

Note : L'utilisation des modèles, ensembles de données et code référencés est soumise aux licences et conditions respectives fournies par leurs auteurs et mainteneurs.