# Pixal3D (modelo 3D)

> Imagem para 3D local: o Pixal3D, do Tencent ARC, um fine-tune do TRELLIS.2, transforma uma foto em um modelo 3D texturizado (GLB com materiais PBR) cuja geometria acompanha de perto os pixels da foto. Roda com trellis.cpp em uma GPU NVIDIA ou Vulkan com 16 GB de memória de vídeo. MIT, com a licença DINOv3 da Meta para o codificador de imagem.

- Id: `aigd.model3d-pixal3d`
- Origem: Oficial (de primeira parte `aigd.*`)
- Categoria: 3D
- Publicador: AI Game Dev (`aigd`), verificado
- Versão mais recente: 1.0.5 (publicado em 2026-11-22)
- Licença: SEE LICENSE IN README.md
- Requer o app AI Game Dev: `>=0.32.0-beta.6`
- Código nativo: não
- Avaliação: ainda sem avaliações
- Página HTML: https://ai-game.dev/pt-br/packages/aigd.model3d-pixal3d

## Instalar

Com o CLI gamedev, na pasta do projeto:

```bash
gamedev pkg add aigd.model3d-pixal3d
```

No app desktop: abra a janela Packages (o ícone de pacote na barra de status), selecione **Browse**, busque `aigd.model3d-pixal3d` e clique em **Add to Project**. Mais: https://ai-game.dev/docs/wiki/app/packages

## Versões

| Versão | Publicado | Requer o app | Observações |
|---|---|---|---|
| 1.0.5 | 2026-11-22 | `>=0.32.0-beta.6` | mais recente |
| 1.0.4 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descrição

````markdown
# Pixal3D (`aigd.model3d-pixal3d`)

O Pixal3D é o [Pixal3D](https://huggingface.co/TencentARC/Pixal3D) do Tencent ARC (SIGGRAPH 2026), um fine-tune do TRELLIS.2 que condiciona cada voxel ao pixel da imagem em que ele é projetado, de modo que a geometria acompanhe a silhueta da foto mais de perto. Ele transforma uma imagem em um GLB texturizado com materiais PBR. No AI Game Dev ele roda na sua GPU por meio de **[Geração 3D local](https://ai-game.dev/packages/aigd.trellis)** (`aigd.trellis`, trellis.cpp v0.8+), em GPUs NVIDIA (CUDA) ou Vulkan com 16 GB de memória de vídeo. Ele serve para assets cuja forma precisa corresponder de perto a uma foto ou concept de referência.

## O que você pode criar

- Props e objetos texturizados e prontos para PBR que mantêm o contorno da foto de origem.
- Versões 3D de objetos reais que você fotografou, enquadrados com um pouco de espaço ao redor.
- Modelos detalhados na resolução 1024 ou 1536.

## Exemplos de solicitações

- "Transforme minha foto `Photos/teapot.jpg` em um modelo 3D texturizado com o Pixal3D."
- "Faça um modelo 3D deste concept de escudo em 1536."
- "O modelo Pixal3D está se desviando do contorno; tente de novo com um campo de visão diferente."

## Destaques

|  |  |
|---|---|
| ID do modelo | `aigd.model3d-pixal3d.bf16` |
| Operação | imagem para 3D (uma foto PNG ou JPEG de um objeto) |
| Saída | GLB texturizado com materiais PBR (texturas PNG) |
| Resoluções | 1024 (padrão), 1536 |
| Passos | 12 por padrão |
| Campo de visão | opcional `fov`, padrão 49.13 graus |
| Roda em | GPU NVIDIA (CUDA) ou Vulkan com 16 GB de memória de vídeo (o upstream avisa que uma placa de 16 GB pode ficar sem memória na etapa de textura) |
| Download | 14.5 GB, 10 arquivos (3.5 GB compartilhados com o TRELLIS.2) |
| Licença | MIT; o codificador DINOv3 está sob a DINOv3 License da Meta |

## Pixal3D ou TRELLIS.2

- **Pixal3D** (este pacote): a geometria acompanha os pixels da foto mais de perto; somente 1024 e 1536.
- **[TRELLIS.2 4B](https://ai-game.dev/packages/aigd.model3d-trellis2-4b)**: o modelo base, com uma resolução 512 mais leve também.

Os dois juntos somam cerca de 27 GB, porque 3.5 GB de arquivos são compartilhados.

## Limites e medições

- **Entrada:** uma foto PNG ou JPEG de um objeto, enquadrada com um pouco de espaço ao redor.
- **Saída:** um GLB autocontido (texturas PNG).
- **Resoluções:** 1024 (padrão) e 1536. O Pixal3D não publica modelo de textura 512, então 512 não é oferecido.
- **Sempre texturizado:** uma execução só de geometria não é oferecida. O trellis.cpp v0.8.1 simplifica a malha apenas durante a texturização, então sem texturas ele grava a malha decodificada bruta, que ultrapassa os limites de GLB do app.
- **Campo de visão:** opcional `fov` (graus, padrão 49.13). O trellis.cpp não o estima como a referência faz (MoGe-2), então uma geometria que se desvia da silhueta significa que o FOV está errado.
- **Não oferecido: várias vistas.** A Tencent publica checkpoints multi-view `_mv` e, desde setembro de 2026, inferência multi-view (`pipeline_mv.json`), mas o trellis.cpp v0.8.1 é single-view. O multiview-to-3D aguarda suporte no runtime.
- **Hardware:** uma GPU NVIDIA (CUDA) ou Vulkan com **16 GB** de memória de vídeo. A etapa de textura é o pico de memória do Pixal3D, e o upstream avisa que uma placa de 16 GB pode ficar sem memória nessa etapa.
- **Download:** 14.5 GB, 10 arquivos. 3.5 GB deles (decodificadores, DINOv3, BiRefNet) são idênticos byte a byte aos do TRELLIS.2 e são compartilhados com `aigd.model3d-trellis2-4b`.

No Windows com uma RTX 4090, uma imagem na resolução 1024 com seed 42 e 12 passos levou 197.96 s em CUDA e 442.57 s em Vulkan. A VRAM do dispositivo inteiro atingiu o pico de 12,460 MiB em CUDA e 15,933 MiB em Vulkan. O uso inicial era de 4,622 e 4,690 MiB, respectivamente. Em CUDA, uma entrada JPEG separada na resolução 1536 gerou um GLB PBR válido em 558.58 s. A VRAM do dispositivo inteiro foi de 3,924 MiB no início até um pico de 11,756 MiB.

## O que é baixado

| Arquivo | O que é | Baixado de (revisão fixada) | Licença |
|---|---|---|---|
| `pixal3d_ss_flow`, `pixal3d_shape_flow_512`, `pixal3d_shape_flow_1024`, `pixal3d_tex_flow_1024` | flow transformers do Pixal3D (BF16) | [`vegax87/Pixal3D`](https://huggingface.co/vegax87/Pixal3D) `51de7d1764f4b735c4e3aaea40e5ba60c18ca707`, convertido de [TencentARC/Pixal3D](https://huggingface.co/TencentARC/Pixal3D) | [MIT](https://huggingface.co/TencentARC/Pixal3D/blob/b0cb2e1b794cab9aa0ac38a95d794a4d9337437f/LICENSE) |
| `pixal3d_naf` | upsampler de features NAF | `vegax87/Pixal3D`, convertido de [valeoai/NAF](https://github.com/valeoai/NAF) | [Apache-2.0](https://github.com/valeoai/NAF/blob/main/LICENSE) |
| `ss_dec`, `shape_dec`, `tex_dec` | decodificadores, idênticos aos do TRELLIS.2 | [`ilintar/trellis2-gguf`](https://huggingface.co/ilintar/trellis2-gguf) `a57397bd3d351599d9729fc144b3f87c3f87d65b` | [MIT](https://huggingface.co/microsoft/TRELLIS.2-4B) |
| `dinov3` | codificador de imagem DINOv3 ViT-L/16 | `ilintar/trellis2-gguf` (do DINOv3 da Meta) | [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) |
| `birefnet` | remoção de fundo | `ilintar/trellis2-gguf` (do [ZhengPeng7/BiRefNet](https://huggingface.co/ZhengPeng7/BiRefNet)) | MIT |

`vegax87/Pixal3D` (MIT) é a conversão que a documentação do Pixal3D no trellis.cpp indica; seu autor contribuiu com o backend Pixal3D para o trellis.cpp.

## Licença

O Pixal3D é **MIT** (© 2026 Tencent): o uso comercial é permitido, e você é dono do que gerar. Como a licença do codificador DINOv3 barra alguns usos (abaixo), o app pede que você aceite a licença antes do download. O NOTICE da Tencent lista TRELLIS.2, Direct3D-S2 e MoGe (MIT) e dinov2 (Apache-2.0) como componentes de terceiros e não acrescenta restrições próprias.

- **Codificador de imagem DINOv3** — a [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) da Meta, não MIT. O uso comercial é permitido, mas: ao distribuir o codificador ou um derivado, inclua a licença e **exiba com destaque "Built with DINOv3"**; nada de usos militares ou de guerra, nucleares, de espionagem ou de armamentos, nada barrado por controles comerciais (ITAR, sanções); nada de engenharia reversa.
- **NAF** — Apache-2.0 (mantenha a licença e os avisos se você redistribuí-lo).
- **Bandeira da UE.** O card do Hugging Face da Tencent define `extra_gated_eu_disallowed: true`. O Hugging Face usa essa bandeira para recusar usuários da UE no formulário de acesso de um repositório **com acesso restrito**. O repositório do Pixal3D **não tem acesso restrito** (qualquer pessoa baixa sem conta), e a licença MIT não nomeia território algum, então a bandeira não restringe nada hoje. Ela pode sugerir que a Tencent não pretende oferecer o Pixal3D na UE. Isso é divulgado como uma restrição "outra" simples, não como um bloqueio territorial; verifique você mesmo antes de usar o Pixal3D na UE.

Texto de atribuição exigido:

> Pixal3D © Tencent (MIT). TRELLIS.2 © Microsoft Corporation (MIT). NAF © valeo.ai (Apache-2.0).
> Built with DINOv3 (DINOv3 License, © Meta Platforms). BiRefNet © ZhengPeng7 (MIT).

Restrições, sem rodeios: a atribuição do DINOv3 e a proibição de uso militar/armamentos/controles comerciais; a bandeira da UE acima. Sem limite de receita, sem marca d'água.

Todos os arquivos são baixados do Hugging Face. O AI Game Dev não os hospeda. Você aceita essas licenças ao baixar o modelo.
````
