ComfyUI Trellis2 | Workflow di generazione mesh 3D da immagine

ComfyUI Trellis2: da immagine a 3D, perfezionamento, multi-vista, low-poly e texturing PBR in un unico workflow

Nota: Questo workflow è stato aggiornato il 28 febbraio 2026.

ComfyUI Trellis2 porta il modello TRELLIS.2 da immagine a 3D di Microsoft in una pipeline ComfyUI pratica e user-friendly. Partendo da una o più immagini di riferimento, può generare mesh, perfezionare asset esistenti, eseguire UV unwrap, bakeare texture PBR, produrre varianti low-poly ed esportare file pronti all'uso per strumenti DCC e motori di gioco. Oltre ai percorsi originali singola immagine e mesh-texturing, questo workflow aggiornato include ora pipeline dedicate di alta qualità e massima qualità, rami dedicati di generazione e texturing multi-vista, un ramo low-poly e una pipeline batch mesh assistita da Qwen + RMBG.

Il grafo è organizzato in gruppi chiari per output veloci con un clic, controllo avanzato, perfezionamento, generazione solo mesh, generazione solo texture, generazione texture-first più forte, generazione staged di alto livello, generazione multi-vista, conversione multi-vista solo mesh, texturing multi-vista e un workflow helper assistito da Qwen/RMBG. Rispetto alle versioni precedenti, diversi rami ora usano Trellis2ReconstructMeshWithQuad, Trellis2FillHolesWithMeshlib e Trellis2SmoothNormals, e i percorsi multi-vista ora usano nodi TRELLIS.2 multi-vista dedicati invece di raggruppare immagini in un generatore regolare a vista singola.

I nodi sorgente sono forniti principalmente dall'estensione ComfyUI visualbruno/ComfyUI-Trellis2.

Nota: Questo workflow può essere eseguito solo su macchine Medium, Large, X Large. Le macchine 2X Large o più grandi genereranno un errore.

Nota: Nella sezione Using_Qwen_Rembg, potrebbe apparire un contorno rosso del nodo nel frontend. Questo è un falso avviso del frontend e non blocca l'esecuzione. Se il workflow viene eseguito con successo, puoi ignorarlo.

Modelli chiave e sistemi helper usati in questo workflow

• Microsoft TRELLIS.2-4B Il modello core da immagine a 3D usato in tutto il workflow. Genera struttura 3D consapevole dei voxel, supporta il perfezionamento della mesh e guida la generazione delle texture. Vedi microsoft/TRELLIS.2-4B e microsoft/TRELLIS.2.
• BRIA RMBG-2.0 Usato nella pipeline helper Using_Qwen_Rembg per rimuovere gli sfondi prima della generazione mesh e di nuovo dopo l'immagine guida stile normal-map generata. Questo aiuta a isolare il soggetto e ridurre la contaminazione dello sfondo.
• Stack Qwen Image Edit Usato nel workflow helper Using_Qwen_Rembg per generare un'immagine guida stile normal-map prima della generazione mesh. Lo stack configurato include una UNet Qwen Image Edit GGUF, asset Qwen image VAE/CLIP e un LoRA Qwen Image Edit Lightning.

Panoramica del workflow

A un livello alto, il workflow ora supporta le seguenti categorie di compiti:

• Generazione con texture da singola immagine: Simple, Advanced
• Perfezionamento mesh esistente: MeshRefiner
• Generazione solo mesh: Only_Mesh_Simple, Only_Mesh_Advanced
• Generazione solo texture: TextureMesh
• Geometria + texturing più forte da singola immagine: Better_Texture
• Pipeline di qualità staged: High_Quality, Max_Quality
• Generazione e texturing low-poly: Lowpoly
• Generazione e texturing multi-vista dedicati: MultViews, MultViews_MeshOnly, MultViews_TextureMesh
• Workflow batch assistito da Qwen + RMBG: Using_Qwen_Rembg

Ogni gruppo è autonomo e produce la propria esportazione e anteprima.

Come usare ogni gruppo

1) Simple

Questo è il percorso più veloce da singola immagine a un GLB con texture. Carica la pipeline TRELLIS.2 con Trellis2LoadModel (#139), carica la tua immagine soggetto con trasparenza tramite Trellis2LoadImageWithTransparency (#279) e puliscila con Trellis2PreProcessImage (#142). Trellis2MeshWithVoxelGenerator (#278) produce l'asset voxelizzato, e Trellis2PostProcessAndUnWrapAndRasterizer (#141) gestisce pulizia, UV unwrap e baking delle texture PBR in un solo passaggio. Esporta con Trellis2ExportMesh (#140) e ispeziona il risultato in Preview3D (#149).

Questo ramo è ora più semplice rispetto a prima: non usa più un nodo Trellis2SimplifyMesh separato prima dell'unwrap. Pulizia, rasterizzazione e baking sono gestiti all'interno dello stadio di post-processo/unwrap/rasterizzatore.

2) Advanced

Usa questo ramo quando vuoi più controllo sull'inferenza di struttura e aspetto da una singola immagine. Carica il modello con Trellis2LoadModel (#144), l'immagine sorgente con Trellis2LoadImageWithTransparency (#299) e preprocessala con Trellis2PreProcessImage (#148). Trellis2MeshWithVoxelAdvancedGenerator (#146) espone controlli di generazione più dettagliati rispetto al percorso Simple, e Trellis2PostProcessAndUnWrapAndRasterizer (#147) esegue pulizia, generazione UV e baking delle texture. Esporta con Trellis2ExportMesh (#145) e rivedi in Preview3D (#314).

Anche questo ramo non usa più un passaggio Trellis2PostProcessMesh separato. Lo stadio di unwrap e baking è ora il principale blocco di elaborazione a valle.

3) MeshRefiner

Scegli questo ramo quando hai già una mesh e vuoi migliorarla con guida da immagine. Carica il modello con Trellis2LoadModel (#157), una mesh esistente con Trellis2LoadMesh (#293) e un'immagine di riferimento guida con Trellis2LoadImageWithTransparency (#280) seguita da Trellis2PreProcessImage (#156). Trellis2MeshRefiner (#153) aggiorna la geometria mantenendo il legame con la mesh di input e l'immagine guida.

Dopo il perfezionamento, il ramo ora esegue una sequenza di pulizia più forte rispetto alla versione precedente: Trellis2Remesh (#281), Trellis2SimplifyMesh (#150), Trellis2FillHolesWithMeshlib (#155), e Trellis2MeshWithVoxelToTrimesh (#151). Esporta con Trellis2ExportMesh (#154) e ispeziona in Preview3D (#315).

4) Only_Mesh_Simple

Questo è il percorso rapido solo mesh per la generazione da singola immagine. Carica il modello con Trellis2LoadModel (#165), carica l'immagine con Trellis2LoadImageWithTransparency (#282) e preprocessala con Trellis2PreProcessImage (#164). Trellis2MeshWithVoxelGenerator (#162) genera la mesh iniziale. Il ramo poi esegue Trellis2Remesh (#291), Trellis2SimplifyMesh (#161), Trellis2FillHolesWithMeshlib (#163), e Trellis2MeshWithVoxelToTrimesh (#159). Esporta con Trellis2ExportMesh (#160) e ispeziona in Preview3D (#316).

Questo percorso è ora più robusto della versione precedente perché riempie i buchi prima della conversione a trimesh.

5) Only_Mesh_Advanced

Usa questo percorso quando vuoi solo geometria, ma con più controllo rispetto al percorso solo mesh semplice. Carica il modello con Trellis2LoadModel (#166), la tua immagine sorgente con Trellis2LoadImageWithTransparency (#283) e preprocessala con Trellis2PreProcessImage (#173). Trellis2MeshWithVoxelAdvancedGenerator (#169) produce la struttura iniziale, poi Trellis2Remesh (#292), Trellis2SimplifyMesh (#171), Trellis2FillHolesWithMeshlib (#172), e Trellis2MeshWithVoxelToTrimesh (#168) puliscono e convertono per l'esportazione. Esporta con Trellis2ExportMesh (#170) e ispeziona in Preview3D (#317).

Questo ramo è adatto a soggetti dove la topologia conta più dell'output texture immediato.

6) TextureMesh

Se hai già una mesh pulita e hai bisogno solo delle texture, usa questo percorso. Carica la pipeline TRELLIS.2 con Trellis2LoadModel (#177), carica la tua immagine di riferimento con Trellis2LoadImageWithTransparency (#297), preprocessala con Trellis2PreProcessImage (#180) e carica la tua mesh usando Trellis2LoadMesh (#294). Trellis2MeshTexturing (#174) bakea le texture sulla mesh e produce la trimesh aggiornata più le immagini texture. PreviewImage (#175, #178) ti permette di ispezionare le mappe texture bakate, e Preview3D (#318) mostra il risultato finale ombreggiato. Esporta con Trellis2ExportMesh (#179).

7) Better_Texture

Questo ramo è un workflow di generazione e texturing da singola immagine più forte rispetto ai percorsi Simple/Advanced. Inizia con Trellis2LoadModel (#189), Trellis2LoadImageWithTransparency (#285) e Trellis2PreProcessImage (#181), poi genera la geometria con Trellis2MeshWithVoxelAdvancedGenerator (#184). La mesh viene pulita usando Trellis2Remesh (#295), Trellis2SimplifyMesh (#182), Trellis2FillHolesWithMeshlib (#186), e Trellis2MeshWithVoxelToTrimesh (#187) prima di essere texturata da Trellis2MeshTexturing (#188). Esporta con Trellis2ExportMesh (#185) e ispeziona in Preview3D (#320).

Questo ramo è utile quando vuoi una base geometrica migliore prima del texturing, ma non hai bisogno del flusso completo di perfezionamento staged delle preimpostazioni di alta qualità.

8) High_Quality

Questa è una pipeline di qualità staged che esporta mesh intermedie e un asset con texture finale. Inizia con un nome in PrimitiveString (#203), un'immagine sorgente in Trellis2LoadImageWithTransparency (#284), e Trellis2PreProcessImage (#191). Il primo stadio usa Trellis2LoadModel (#192), Trellis2MeshWithVoxelAdvancedGenerator (#207), Trellis2ReconstructMeshWithQuad (#206), Trellis2SimplifyMesh (#190), Trellis2FillHolesWithMeshlib (#204), e Trellis2MeshWithVoxelToTrimesh (#197) per costruire una mesh bianca pulita, che viene esportata con Trellis2ExportMesh (#196).

Il secondo stadio continua da quel risultato usando Trellis2Continue (#198), poi lo perfeziona con Trellis2MeshRefiner (#208), Trellis2ReconstructMeshWithQuad (#209), Trellis2SimplifyMesh (#193), Trellis2FillHolesWithMeshlib (#205), e Trellis2MeshWithVoxelToTrimesh (#200). La mesh perfezionata viene esportata con Trellis2ExportMesh (#201).

Lo stadio finale usa Trellis2Continue (#202), Trellis2MeshTexturing (#213), e Trellis2SmoothNormals (#211) prima dell'esportazione finale attraverso Trellis2ExportMesh (#212). Rivedi il risultato con texture in Preview3D (#319).

Questo ramo è ideale quando vuoi un workflow staged più pulito con checkpoint intermedi: mesh bianca, mesh perfezionata e mesh con texture finale.

9) Lowpoly

Usa questo percorso quando hai bisogno di un asset low-poly controllato fin dall'inizio. Il ramo inizia con un nome in PrimitiveString (#224), un budget target di triangoli/facce in PrimitiveInt (#228), e un'immagine di riferimento tramite Trellis2LoadImageWithTransparency (#298) e Trellis2PreProcessImage (#214). Trellis2LoadModel (#227) e Trellis2MeshWithVoxelAdvancedGenerator (#216) creano la mesh base. Il percorso di pulizia poi esegue Trellis2Remesh (#296), Trellis2SimplifyMesh (#218) usando il numero target di facce, Trellis2FillHolesWithMeshlib (#219), e Trellis2MeshWithVoxelToTrimesh (#220).

Una differenza chiave in questo ramo è che l'esportazione della mesh bianca usa Trellis2ExportMesh (#217) con output OBJ, non GLB. Dopo, Trellis2Continue (#222) passa la mesh a Trellis2MeshTexturing (#221), Trellis2SmoothNormals (#229), e un'esportazione GLB con texture finale attraverso Trellis2ExportMesh (#223). Ispeziona l'output finale in Preview3D (#322).

10) Max_Quality

Questo ramo è la pipeline staged più pesante nel workflow ed è destinata alla massima qualità. Segue la stessa struttura a tre stadi di High_Quality, ma con impostazioni di generazione e texturing più aggressive. Inizia con PrimitiveString (#243), Trellis2LoadImageWithTransparency (#286), e Trellis2PreProcessImage (#231). Lo stadio mesh iniziale usa Trellis2LoadModel (#232), Trellis2MeshWithVoxelAdvancedGenerator (#251), Trellis2ReconstructMeshWithQuad (#246), Trellis2SimplifyMesh (#230), Trellis2FillHolesWithMeshlib (#244), e Trellis2MeshWithVoxelToTrimesh (#237), poi esporta la mesh bianca con Trellis2ExportMesh (#236).

Lo stadio di perfezionamento continua con Trellis2Continue (#238), Trellis2MeshRefiner (#252), Trellis2ReconstructMeshWithQuad (#247), Trellis2SimplifyMesh (#233), Trellis2FillHolesWithMeshlib (#245), e Trellis2MeshWithVoxelToTrimesh (#240), poi esporta la mesh perfezionata con Trellis2ExportMesh (#241).

Lo stadio finale continua con Trellis2Continue (#242), poi textura attraverso Trellis2MeshTexturing (#253), uniforma l'ombreggiatura con Trellis2SmoothNormals (#249), ed esporta la mesh con texture finale con Trellis2ExportMesh (#250). Rivedi in Preview3D (#321).

Usa questo percorso quando il soggetto ha dettagli fini e sei disposto a spendere più tempo e memoria per una migliore fedeltà dell'output.

11) MultViews

Questo è il percorso principale dedicato alla generazione multi-vista. A differenza del workflow precedente, ora usa il nodo dedicato Trellis2MeshWithVoxelMultiViewGenerator invece di raggruppare più immagini in un generatore avanzato regolare. Carica il modello con Trellis2LoadModel (#256), poi carica le tue viste con Trellis2LoadImageWithTransparency (#287, #288) e preprocessale attraverso Trellis2PreProcessImage (#255, #257). Il cablaggio di esempio attualmente usa input front e back, mentre il nodo supporta anche left e right se vuoi collegarli.

Trellis2MeshWithVoxelMultiViewGenerator (#254) genera l'asset, Trellis2PostProcessAndUnWrapAndRasterizer (#258) esegue unwrap e bake delle texture, e Trellis2ExportMesh (#259) scrive il risultato. Ispezionalo in Preview3D (#324).

12) MultViews_MeshOnly

Usa questo ramo quando vuoi solo geometria multi-vista. Carica il modello con Trellis2LoadModel (#262), due o più viste di riferimento con Trellis2LoadImageWithTransparency (#300, #301), e preprocessale attraverso Trellis2PreProcessImage (#261, #263). Trellis2MeshWithVoxelMultiViewGenerator (#264) gestisce la fusione delle viste, poi Trellis2RemeshWithQuad (#302), Trellis2SimplifyMesh (#265), Trellis2FillHolesWithMeshlib (#266), e Trellis2MeshWithVoxelToTrimesh (#268) lo convertono in un output solo mesh pulito. Esporta con Trellis2ExportMesh (#267) e ispeziona in Preview3D (#325).

Come nel ramo multi-vista con texture, il cablaggio di esempio usa immagini front e back, mentre left/right rimangono opzionali.

13) MultViews_TextureMesh

Se hai già una mesh e vuoi texturarla da più viste, usa questo percorso. Carica il modello con Trellis2LoadModel (#271), carica la mesh con Trellis2LoadMesh (#275), e carica le viste di riferimento attraverso Trellis2LoadImageWithTransparency (#289, #290) più Trellis2PreProcessImage (#272, #274). Il nodo dedicato Trellis2MeshTexturingMultiView (#276) proietta e bakea le texture usando più viste. Esporta il risultato con Trellis2ExportMesh (#273) e ispezionalo in Preview3D (#326).

Di nuovo, l'esempio attualmente usa le viste front e back, ma il nodo supporta anche input left e right.

14) Using_Qwen_Rembg

Questo è il workflow helper più specializzato nel grafo. Combina rimozione automatica dello sfondo, generazione di normal map basata su Qwen, generazione batch di mesh a più budget di facce, selezione mesh e texturing finale.

Inizia nella sezione Name - Nb Faces - Image con nodi StringConstant per il nome dell'asset (#91) e i conteggi target delle facce (#113), più la tua immagine sorgente in Trellis2LoadImageWithTransparency (#127). Il primo sottografo Remove Background (#133) isola il soggetto. Generate Normal Map (#116) poi crea un'immagine stile normal-map usando lo stack Qwen Image Edit. Il secondo sottografo Remove Background (#115) pulisce nuovamente quella normal map generata prima di passarla a Generate Meshes (#114).

All'interno di Generate Meshes, il workflow preprocessa l'immagine guida, genera una mesh di alta qualità, esegue post-elaborazione aggiuntiva e ricostruzione quad, e poi usa semplificazione/esportazione batch per produrre più varianti mesh dalla lista di conteggi facce. Trellis2StringSelector (#132) ti permette di scegliere uno di quei percorsi mesh esportati. Infine, il sottografo Texture Mesh (#131) carica la mesh selezionata, la textura usando l'immagine di riferimento originale pulita, ed esporta il GLB finale, che puoi ispezionare in Preview3D (#323).

Questo ramo è particolarmente utile quando vuoi:

• isolare il soggetto automaticamente,
• generare più varianti geometriche in un solo passaggio,
• scegliere una versione con il conteggio facce preferito,
• e solo allora eseguire il texturing finale.

Nodi chiave in questo workflow aggiornato

• Trellis2PreProcessImage Usato in tutto il grafo prima della maggior parte dei nodi di generazione o texturing. Standardizza l'immagine di input ed è ora presente in quasi ogni ramo principale.
• Trellis2MeshWithVoxelGenerator Il generatore veloce da singola immagine usato nei rami Simple e Only_Mesh_Simple.
• Trellis2MeshWithVoxelAdvancedGenerator Il generatore controllato principale da singola immagine usato in Advanced, Better_Texture, High_Quality, Max_Quality, Lowpoly e nella pipeline batch mesh assistita da Qwen/RMBG.
• Trellis2MeshRefiner Perfeziona una mesh esistente con guida da immagine. Usato in MeshRefiner, High_Quality e Max_Quality.
• Trellis2PostProcessAndUnWrapAndRasterizer Gestisce pulizia, generazione UV e baking. Nel workflow attuale, è il nodo principale di finitura con texture in Simple, Advanced e MultViews.
• Trellis2ReconstructMeshWithQuad Ricostruisce la struttura della mesh con un passaggio di ricostruzione orientato ai quad. Ora è una parte importante delle pipeline High_Quality, Max_Quality e batch mesh assistita da Qwen.
• Trellis2Remesh e Trellis2RemeshWithQuad Usati per regolarizzare la topologia prima della semplificazione, conversione o ulteriore elaborazione. Trellis2RemeshWithQuad appare nel ramo solo mesh multi-vista.
• Trellis2SimplifyMesh Riduce i conteggi dei triangoli ed è ora usato in molti rami insieme al riempimento buchi.
• Trellis2FillHolesWithMeshlib Un nuovo importante passaggio di pulizia in più rami. Aiuta a chiudere piccoli buchi prima della conversione a trimesh o ulteriore elaborazione.
• Trellis2MeshWithVoxelToTrimesh Converte l'output voxel-mesh di TRELLIS in una mesh triangolare regolare per l'esportazione o il texturing.
• Trellis2MeshTexturing Il nodo principale di baking delle texture per la proiezione texture da singola immagine. Usato in TextureMesh, Better_Texture, High_Quality, Max_Quality, Lowpoly e nel percorso assistito da Qwen.
• Trellis2MeshWithVoxelMultiViewGenerator Il nodo dedicato alla generazione mesh multi-vista. Sostituisce il vecchio approccio "raggruppa più immagini in un generatore normale".
• Trellis2MeshTexturingMultiView Il nodo dedicato al texturing multi-vista per proiettare texture da diverse viste su una mesh esistente.
• Trellis2SmoothNormals Usato in diversi rami di texturing avanzato per migliorare l'aspetto ombreggiato finale prima dell'esportazione.
• Trellis2BatchSimplifyMeshAndExport Usato all'interno del sottografo di generazione batch assistita da Qwen/RMBG per esportare più varianti mesh a diversi conteggi di facce.
• Trellis2StringSelector Ti permette di scegliere un percorso mesh da una lista di esportazione batch prima di eseguire il texturing finale.

Consigli pratici

• Usa immagini centrate sul soggetto con sfondo trasparente o già isolato quando possibile.
• I rami multi-vista supportano input front/back/left/right, ma il workflow di esempio attualmente collega solo front e back. Aggiungi left/right se li hai.
• Usa Simple o Advanced per iterazione veloce, poi passa a Better_Texture, High_Quality o Max_Quality quando hai bisogno di struttura più pulita o materiali migliori.
• Usa Only_Mesh_* quando prevedi di eseguire unwrap, retopo o texturing esternamente.
• Usa Lowpoly quando hai bisogno di conteggi facce controllati e un asset più leggero per uso in giochi o tempo reale.
• Nei rami staged come High_Quality e Max_Quality, conserva le esportazioni intermedie bianche e perfezionate. Sono checkpoint utili se il risultato con texture finale deve essere rifatto.
• Per la generazione multi-vista, mantieni scala, inquadratura e illuminazione consistenti tra le viste.
• Per il texturing guidato da immagine, mantieni l'illuminazione neutra per evitare di bakeare highlights o ombre forti nell'albedo.
• Se vedi un falso contorno rosso del nodo nella sezione Using_Qwen_Rembg, prova a eseguire il workflow comunque prima di assumere che il ramo sia rotto.

Risorse

• Scheda modello TRELLIS.2: microsoft/TRELLIS.2-4B
• Repository TRELLIS.2: microsoft/TRELLIS.2
• Repository TRELLIS originale: microsoft/TRELLIS
• Estensione ComfyUI usata: visualbruno/ComfyUI-Trellis2
• Modello di rimozione sfondo usato nel flusso helper: briaai/RMBG-2.0

Ringraziamenti

Questo workflow implementa e si basa sui seguenti lavori e risorse. Ringraziamo con gratitudine visualbruno per ComfyUI-Trellis2 e i manutentori dei nodi di supporto e dei modelli helper usati in questo grafo, inclusi TRELLIS.2, RMBG e gli asset di image-edit basati su Qwen configurati nel workflow.

Nota: L'uso dei modelli, dei dataset e del codice referenziati è soggetto alle rispettive licenze e termini forniti dai loro autori e manutentori.