ComfyUI Trellis2 | Fluxo de Trabalho de Geração de Malha 3D

ComfyUI Trellis2: Imagem para 3D, refinamento, multi-vista, low-poly e texturização PBR em um fluxo de trabalho

Nota: Este fluxo de trabalho foi atualizado em 28 de fevereiro de 2026.

ComfyUI Trellis2 traz o modelo de imagem para 3D TRELLIS.2 da Microsoft para um pipeline ComfyUI prático e amigável para criadores. Começando com uma ou mais imagens de referência, pode gerar malhas, refinar ativos existentes, desenrolar UVs, fazer baking de texturas PBR, produzir variantes low-poly e exportar arquivos prontos para uso em ferramentas DCC e motores de jogo. Além dos caminhos originais de imagem única e texturização de malha, este fluxo de trabalho atualizado agora inclui pipelines dedicados de alta qualidade e qualidade máxima, geração dedicada de múltiplas vistas e ramificações de texturização de múltiplas vistas, uma ramificação low-poly e um pipeline de malha em lote assistido por Qwen + RMBG.

O gráfico é organizado em grupos claros para saídas rápidas com um clique, controle avançado, refinamento, geração apenas de malha, geração apenas de textura, geração mais forte primeiro de textura, geração escalonada de alta qualidade, geração multi-vista, conversão apenas de malha multi-vista, texturização multi-vista e um fluxo de trabalho auxiliar assistido por Qwen/RMBG. Comparado com versões anteriores, várias ramificações agora usam Trellis2ReconstructMeshWithQuad, Trellis2FillHolesWithMeshlib e Trellis2SmoothNormals, e as rotas multi-vista agora usam nós dedicados TRELLIS.2 multi-vista em vez de agrupar imagens em um gerador de vista única regular.

Os nós de origem são fornecidos principalmente pela extensão ComfyUI visualbruno/ComfyUI-Trellis2.

Nota: Este fluxo de trabalho só pode ser executado em Máquinas Médias, Grandes, X Grandes. Máquinas 2X Grandes ou maiores gerarão um erro.

Nota: Na seção Using_Qwen_Rembg, um contorno de nó vermelho pode aparecer na interface. Este é um aviso falso da interface e não bloqueia a execução. Se o fluxo de trabalho for executado com sucesso, você pode ignorá-lo.

Modelos chave e sistemas auxiliares usados neste fluxo de trabalho

• Microsoft TRELLIS.2-4B O modelo central de imagem para 3D usado em todo o fluxo de trabalho. Gera estrutura 3D consciente de voxel, suporta refinamento de malha e impulsiona a geração de textura. Veja microsoft/TRELLIS.2-4B e microsoft/TRELLIS.2.
• BRIA RMBG-2.0 Usado no pipeline auxiliar Using_Qwen_Rembg para remover fundos antes da geração de malha e novamente após a imagem guia de estilo normal-map gerada. Isso ajuda a isolar o sujeito e reduzir a contaminação do fundo.
• Qwen Image Edit stack Usado no fluxo de trabalho auxiliar Using_Qwen_Rembg para gerar uma imagem de guia de estilo normal-map antes da geração de malha. A pilha configurada inclui um GGUF Qwen Image Edit UNet, ativos Qwen image VAE/CLIP e um Qwen Image Edit Lightning LoRA.

Visão geral do fluxo de trabalho

Em um nível alto, o fluxo de trabalho agora suporta as seguintes categorias de tarefas:

• Geração texturizada de imagem única: Simple, Advanced
• Refinamento de malha existente: MeshRefiner
• Geração apenas de malha: Only_Mesh_Simple, Only_Mesh_Advanced
• Geração apenas de textura: TextureMesh
• Geometria e texturização mais fortes de imagem única: Better_Texture
• Pipelines de qualidade escalonada: High_Quality, Max_Quality
• Geração e texturização low-poly: Lowpoly
• Geração e texturização multi-vista dedicadas: MultViews, MultViews_MeshOnly, MultViews_TextureMesh
• Fluxo de trabalho assistido por Qwen + RMBG: Using_Qwen_Rembg

Cada grupo é autônomo e produz sua própria exportação e visualização.

Como usar cada grupo

1) Simple

Esta é a rota de imagem única mais rápida para um GLB texturizado. Carregue o pipeline TRELLIS.2 com Trellis2LoadModel (#139), carregue sua imagem de sujeito com transparência via Trellis2LoadImageWithTransparency (#279) e limpe-a com Trellis2PreProcessImage (#142). Trellis2MeshWithVoxelGenerator (#278) produz o ativo voxelizado, e Trellis2PostProcessAndUnWrapAndRasterizer (#141) lida com limpeza, desenrolamento UV e baking de textura PBR em um passo. Exporte com Trellis2ExportMesh (#140) e inspecione o resultado em Preview3D (#149).

Esta ramificação agora é mais simples do que antes: não usa mais um nó separado Trellis2SimplifyMesh antes do desenrolamento. Limpeza, rasterização e baking são tratados dentro do estágio de pós-processo/desenrolamento/rasterizador.

2) Advanced

Use esta ramificação quando quiser mais controle sobre a inferência de estrutura e aparência a partir de uma imagem única. Carregue o modelo com Trellis2LoadModel (#144), a imagem fonte com Trellis2LoadImageWithTransparency (#299) e pré-processá-la com Trellis2PreProcessImage (#148). Trellis2MeshWithVoxelAdvancedGenerator (#146) expõe controles de geração mais detalhados do que o caminho Simple, e Trellis2PostProcessAndUnWrapAndRasterizer (#147) executa limpeza, geração UV e baking de textura. Exporte com Trellis2ExportMesh (#145) e revise em Preview3D (#314).

Esta ramificação também não usa mais um passo separado Trellis2PostProcessMesh. O estágio de desenrolamento e baking agora é o principal bloco de processamento subsequente.

3) MeshRefiner

Escolha esta ramificação quando você já tiver uma malha e quiser melhorá-la com orientação de imagem. Carregue seu modelo com Trellis2LoadModel (#157), uma malha existente com Trellis2LoadMesh (#293) e uma imagem de referência guia com Trellis2LoadImageWithTransparency (#280) seguido por Trellis2PreProcessImage (#156). Trellis2MeshRefiner (#153) atualiza a geometria enquanto permanece ligada à malha de entrada e à imagem guia.

Após o refinamento, a ramificação agora executa uma sequência de limpeza mais forte do que a versão anterior: Trellis2Remesh (#281), Trellis2SimplifyMesh (#150), Trellis2FillHolesWithMeshlib (#155) e Trellis2MeshWithVoxelToTrimesh (#151). Exporte com Trellis2ExportMesh (#154) e inspecione em Preview3D (#315).

4) Only_Mesh_Simple

Esta é a rota rápida apenas de malha para geração de imagem única. Carregue o modelo com Trellis2LoadModel (#165), carregue a imagem com Trellis2LoadImageWithTransparency (#282) e pré-processá-la com Trellis2PreProcessImage (#164). Trellis2MeshWithVoxelGenerator (#162) gera a malha inicial. A ramificação então executa Trellis2Remesh (#291), Trellis2SimplifyMesh (#161), Trellis2FillHolesWithMeshlib (#163) e Trellis2MeshWithVoxelToTrimesh (#159). Exporte com Trellis2ExportMesh (#160) e inspecione em Preview3D (#316).

Este caminho agora é mais robusto do que a versão anterior porque preenche buracos antes da conversão para trimesh.

5) Only_Mesh_Advanced

Use este caminho quando você quiser apenas geometria, mas com mais controle do que a rota simples apenas de malha. Carregue o modelo com Trellis2LoadModel (#166), sua imagem fonte com Trellis2LoadImageWithTransparency (#283) e pré-processá-la com Trellis2PreProcessImage (#173). Trellis2MeshWithVoxelAdvancedGenerator (#169) produz a estrutura inicial, depois Trellis2Remesh (#292), Trellis2SimplifyMesh (#171), Trellis2FillHolesWithMeshlib (#172) e Trellis2MeshWithVoxelToTrimesh (#168) limpam e convertem para exportação. Exporte com Trellis2ExportMesh (#170) e inspecione em Preview3D (#317).

Esta ramificação é bem adequada para assuntos onde a topologia importa mais do que a saída de textura imediata.

6) TextureMesh

Se você já tem uma malha limpa e precisa apenas de texturas, use esta rota. Carregue o pipeline TRELLIS.2 com Trellis2LoadModel (#177), carregue sua imagem de referência com Trellis2LoadImageWithTransparency (#297), pré-processá-la com Trellis2PreProcessImage (#180) e carregue sua malha usando Trellis2LoadMesh (#294). Trellis2MeshTexturing (#174) faz baking de texturas na malha e produz a trimesh atualizada mais imagens de textura. PreviewImage (#175, #178) permite inspecionar os mapas de textura baked, e Preview3D (#318) mostra o resultado sombreado final. Exporte com Trellis2ExportMesh (#179).

7) Better_Texture

Esta ramificação é um fluxo de trabalho mais forte de geração e texturização de imagem única do que as rotas Simple/Advanced. Começa com Trellis2LoadModel (#189), Trellis2LoadImageWithTransparency (#285) e Trellis2PreProcessImage (#181), depois gera geometria com Trellis2MeshWithVoxelAdvancedGenerator (#184). A malha é limpa usando Trellis2Remesh (#295), Trellis2SimplifyMesh (#182), Trellis2FillHolesWithMeshlib (#186) e Trellis2MeshWithVoxelToTrimesh (#187) antes de ser texturizada por Trellis2MeshTexturing (#188). Exporte com Trellis2ExportMesh (#185) e inspecione em Preview3D (#320).

Esta ramificação é útil quando você quer uma melhor base geométrica antes da texturização, mas não precisa do fluxo completo de refinamento escalonado dos presets de alta qualidade.

8) High_Quality

Este é um pipeline de qualidade escalonada que exporta malhas intermediárias e um ativo texturizado final. Comece com um nome em PrimitiveString (#203), uma imagem fonte em Trellis2LoadImageWithTransparency (#284) e Trellis2PreProcessImage (#191). O primeiro estágio usa Trellis2LoadModel (#192), Trellis2MeshWithVoxelAdvancedGenerator (#207), Trellis2ReconstructMeshWithQuad (#206), Trellis2SimplifyMesh (#190), Trellis2FillHolesWithMeshlib (#204) e Trellis2MeshWithVoxelToTrimesh (#197) para construir uma malha branca limpa, que é exportada com Trellis2ExportMesh (#196).

O segundo estágio continua a partir desse resultado usando Trellis2Continue (#198), depois refina com Trellis2MeshRefiner (#208), Trellis2ReconstructMeshWithQuad (#209), Trellis2SimplifyMesh (#193), Trellis2FillHolesWithMeshlib (#205) e Trellis2MeshWithVoxelToTrimesh (#200). A malha refinada é exportada com Trellis2ExportMesh (#201).

O estágio final usa Trellis2Continue (#202), Trellis2MeshTexturing (#213) e Trellis2SmoothNormals (#211) antes da exportação final através de Trellis2ExportMesh (#212). Revise o resultado texturizado em Preview3D (#319).

Esta ramificação é ideal quando você deseja um fluxo de trabalho escalonado mais limpo com pontos de verificação intermediários: malha branca, malha refinada e malha texturizada final.

9) Lowpoly

Use esta rota quando precisar de um ativo low-poly controlado desde o início. A ramificação começa com um nome em PrimitiveString (#224), um orçamento alvo de triângulos/faces em PrimitiveInt (#228) e uma imagem de referência via Trellis2LoadImageWithTransparency (#298) e Trellis2PreProcessImage (#214). Trellis2LoadModel (#227) e Trellis2MeshWithVoxelAdvancedGenerator (#216) criam a malha base. O caminho de limpeza então executa Trellis2Remesh (#296), Trellis2SimplifyMesh (#218) usando o número de faces alvo, Trellis2FillHolesWithMeshlib (#219) e Trellis2MeshWithVoxelToTrimesh (#220).

Uma diferença chave nesta ramificação é que a exportação de malha branca usa Trellis2ExportMesh (#217) com saída OBJ, não GLB. Após isso, Trellis2Continue (#222) passa a malha adiante para Trellis2MeshTexturing (#221), Trellis2SmoothNormals (#229) e uma exportação final GLB texturizada através de Trellis2ExportMesh (#223). Inspecione a saída final em Preview3D (#322).

10) Max_Quality

Esta ramificação é o pipeline escalonado mais pesado no fluxo de trabalho e é destinado à máxima qualidade. Segue a mesma estrutura de três estágios do High_Quality, mas com configurações de geração e texturização mais agressivas. Comece com PrimitiveString (#243), Trellis2LoadImageWithTransparency (#286) e Trellis2PreProcessImage (#231). O estágio inicial de malha usa Trellis2LoadModel (#232), Trellis2MeshWithVoxelAdvancedGenerator (#251), Trellis2ReconstructMeshWithQuad (#246), Trellis2SimplifyMesh (#230), Trellis2FillHolesWithMeshlib (#244) e Trellis2MeshWithVoxelToTrimesh (#237), depois exporta a malha branca com Trellis2ExportMesh (#236).

O estágio de refinamento continua com Trellis2Continue (#238), Trellis2MeshRefiner (#252), Trellis2ReconstructMeshWithQuad (#247), Trellis2SimplifyMesh (#233), Trellis2FillHolesWithMeshlib (#245) e Trellis2MeshWithVoxelToTrimesh (#240json ), depois exporta a malha refinada com Trellis2ExportMesh (#241).

O estágio final continua com Trellis2Continue (#242), depois texturiza através de Trellis2MeshTexturing (#253), suaviza o sombreamento com Trellis2SmoothNormals (#249) e exporta a malha texturizada final com Trellis2ExportMesh (#250). Revise em Preview3D (#321).

Use esta rota quando o assunto tiver características finas e você estiver disposto a gastar mais tempo e memória para obter melhor fidelidade de saída.

11) MultViews

Esta é a principal rota de geração dedicada de múltiplas vistas. Ao contrário do fluxo de trabalho anterior, agora usa o nó dedicado Trellis2MeshWithVoxelMultiViewGenerator em vez de agrupar várias imagens em um gerador avançado regular. Carregue o modelo com Trellis2LoadModel (#256), depois carregue suas vistas com Trellis2LoadImageWithTransparency (#287, #288) e pré-processá-las através de Trellis2PreProcessImage (#255, #257). A fiação de exemplo atualmente usa entradas front e back, enquanto o nó também suporta left e right se você quiser conectá-las.

Trellis2MeshWithVoxelMultiViewGenerator (#254) gera o ativo, Trellis2PostProcessAndUnWrapAndRasterizer (#258) desenrola e faz baking das texturas, e Trellis2ExportMesh (#259) grava o resultado. Inspecione em Preview3D (#324).

12) MultViews_MeshOnly

Use esta ramificação quando você quiser apenas geometria de múltiplas vistas. Carregue o modelo com Trellis2LoadModel (#262), duas ou mais vistas de referência com Trellis2LoadImageWithTransparency (#300, #301) e pré-processá-las através de Trellis2PreProcessImage (#261, #263). Trellis2MeshWithVoxelMultiViewGenerator (#264) lida com a fusão de vistas, depois Trellis2RemeshWithQuad (#302), Trellis2SimplifyMesh (#265), Trellis2FillHolesWithMeshlib (#266) e Trellis2MeshWithVoxelToTrimesh (#268) convertem em uma saída limpa apenas de malha. Exporte com Trellis2ExportMesh (#267) e inspecione em Preview3D (#325).

Como na ramificação texturizada de múltiplas vistas, a fiação de exemplo usa imagens front e back, enquanto left/right permanecem opcionais.

13) MultViews_TextureMesh

Se você já tem uma malha e quer texturizá-la a partir de múltiplas vistas, use esta rota. Carregue o modelo com Trellis2LoadModel (#271), carregue a malha com Trellis2LoadMesh (#275) e carregue as vistas de referência através de Trellis2LoadImageWithTransparency (#289, #290) mais Trellis2PreProcessImage (#272, #274). O nó dedicado Trellis2MeshTexturingMultiView (#276) projeta e faz baking de texturas usando múltiplas vistas. Exporte o resultado com Trellis2ExportMesh (#273) e inspecione em Preview3D (#326).

Novamente, o exemplo atualmente usa vistas front e back, mas o nó também suporta entradas left e right.

14) Using_Qwen_Rembg

Este é o fluxo de trabalho auxiliar mais especializado no gráfico. Combina remoção automática de fundo, geração de mapa normal baseada em Qwen, geração de malha em lote em múltiplos orçamentos de faces, seleção de malha e texturização final.

Comece na seção Name - Nb Faces - Image com nós StringConstant para o nome do ativo (#91) e contagens alvo de faces (#113), além de sua imagem fonte em Trellis2LoadImageWithTransparency (#127). O primeiro subgrafo Remove Background (#133) isola o sujeito. Generate Normal Map (#116) então cria uma imagem de estilo normal-map usando a pilha Qwen Image Edit. O segundo subgrafo Remove Background (#115) limpa novamente aquele mapa normal gerado antes de ser passado para Generate Meshes (#114).

Dentro de Generate Meshes, o fluxo de trabalho pré-processa a imagem guia, gera uma malha de alta qualidade, executa pós-processamento adicional e reconstrução de quad, e então usa simplificação/exportação em lote para produzir múltiplas variantes de malha da lista de contagem de faces. Trellis2StringSelector (#132) permite escolher um desses caminhos de malha exportados. Finalmente, o subgrafo Texture Mesh (#131) carrega a malha selecionada, texturiza-a usando a imagem de referência original limpa e exporta o GLB final, que você pode inspecionar em Preview3D (#323).

Esta ramificação é especialmente útil quando você quer:

• isolar o sujeito automaticamente,
• gerar múltiplas variantes de geometria em uma única passagem,
• escolher uma versão de contagem de faces preferida,
• e só então executar a texturização final.

Nós chave neste fluxo de trabalho atualizado

• Trellis2PreProcessImage Usado em todo o gráfico antes da maioria dos nós de geração ou texturização. Padroniza a imagem de entrada e agora está presente em quase todos os principais ramos.
• Trellis2MeshWithVoxelGenerator O gerador rápido de imagem única usado nos ramos Simple e Only_Mesh_Simple.
• Trellis2MeshWithVoxelAdvancedGenerator O principal gerador controlado de imagem única usado em Advanced, Better_Texture, High_Quality, Max_Quality, Lowpoly e o pipeline de malha em lote assistido por Qwen/RMBG.
• Trellis2MeshRefiner Refina uma malha existente com orientação de imagem. É usado em MeshRefiner, High_Quality, e Max_Quality.
• Trellis2PostProcessAndUnWrapAndRasterizer Lida com limpeza, geração UV e baking. No fluxo de trabalho atual, é o principal nó de acabamento texturizado em Simple, Advanced e MultViews.
• Trellis2ReconstructMeshWithQuad Reconstrói a estrutura da malha com um passo de reconstrução orientado por quad. Isto agora é uma parte importante do High_Quality, Max_Quality e do pipeline de malha em lote assistido por Qwen.
• Trellis2Remesh e Trellis2RemeshWithQuad Usado para regularizar a topologia antes da simplificação, conversão ou processamento posterior. Trellis2RemeshWithQuad aparece na ramificação apenas de malha de múltiplas vistas.
• Trellis2SimplifyMesh Reduz contagens de triângulos e agora é usado em muitos ramos junto com o preenchimento de buracos.
• Trellis2FillHolesWithMeshlib Um novo passo importante de limpeza em múltiplos ramos. Ajuda a fechar pequenos buracos antes da conversão para trimesh ou processamento posterior.
• Trellis2MeshWithVoxelToTrimesh Converte a saída de malha voxel do TRELLIS em uma malha de triângulo regular para exportação ou texturização.
• Trellis2MeshTexturing O principal nó de baking de textura para projeção de textura de imagem única. É usado em TextureMesh, Better_Texture, High_Quality, Max_Quality, Lowpoly e o caminho assistido por Qwen.
• Trellis2MeshWithVoxelMultiViewGenerator O nó dedicado de geração de malha multi-vista. Isso substitui a abordagem antiga de "agrupar várias imagens em um gerador normal".
• Trellis2MeshTexturingMultiView O nó dedicado de texturização multi-vista para projetar texturas de várias vistas em uma malha existente.
• Trellis2SmoothNormals Usado em vários ramos de texturização avançada para melhorar o visual sombreado final antes da exportação.
• Trellis2BatchSimplifyMeshAndExport Usado dentro do subgrafo de geração em lote assistido por Qwen/RMBG para exportar múltiplas variantes de malha em diferentes contagens de faces.
• Trellis2StringSelector Permite escolher um caminho de malha de uma lista de exportação em lote antes de executar a texturização final.

Dicas práticas

• Use imagens centradas no sujeito com fundo transparente ou já isolado sempre que possível.
• As ramificações multi-vista suportam entradas front/back/left/right, mas o fluxo de trabalho de exemplo atualmente conecta apenas front e back. Adicione left/right se você as tiver.
• Use Simple ou Advanced para iteração rápida, depois passe para Better_Texture, High_Quality ou Max_Quality quando precisar de estrutura mais limpa ou melhores materiais.
• Use Only_Mesh_* quando planejar desenrolar, retopologia ou texturizar externamente.
• Use Lowpoly quando precisar de contagens de faces controladas e um ativo mais leve para uso em jogos ou em tempo real.
• Em ramificações escalonadas como High_Quality e Max_Quality, mantenha as exportações intermediárias de malha branca e refinada. Elas são pontos de verificação úteis se o resultado texturizado final precisar ser refeito.
• Para geração multi-vista, mantenha escala, enquadramento e iluminação consistentes entre as vistas.
• Para texturização guiada por imagem, mantenha a iluminação neutra para evitar baking de destaques ou sombras fortes no albedo.
• Se você vir um contorno de nó vermelho falso na seção Using_Qwen_Rembg, tente executar o fluxo de trabalho de qualquer maneira antes de assumir que a ramificação está quebrada.

Recursos

• Cartão do modelo TRELLIS.2: microsoft/TRELLIS.2-4B
• Repositório TRELLIS.2: microsoft/TRELLIS.2
• Repositório TRELLIS original: microsoft/TRELLIS
• Extensão ComfyUI usada: visualbruno/ComfyUI-Trellis2
• Modelo de remoção de fundo usado no fluxo auxiliar: briaai/RMBG-2.0

Agradecimentos

Este fluxo de trabalho implementa e constrói sobre os seguintes trabalhos e recursos. Agradecemos visualbruno pelo ComfyUI-Trellis2 e os mantenedores dos nós de suporte e modelos auxiliares usados neste gráfico, incluindo TRELLIS.2, RMBG e os ativos de edição de imagem baseados em Qwen configurados no fluxo de trabalho.

Nota: O uso dos modelos, conjuntos de dados e código referenciados está sujeito às respectivas licenças e termos fornecidos por seus autores e mantenedores.