# Pixal3D (modelo 3D)

> Generación 3D local desde imagen: Pixal3D de Tencent ARC, un fine-tune de TRELLIS.2, convierte una foto en un modelo 3D con textura (GLB con materiales PBR) cuya geometría sigue de cerca los píxeles de la foto. Se ejecuta con trellis.cpp en una GPU NVIDIA o Vulkan con 16 GB de memoria de vídeo. MIT, con la licencia DINOv3 de Meta para el codificador de imagen.

- Id: `aigd.model3d-pixal3d`
- Origen: Oficial (propio `aigd.*`)
- Categoría: 3D
- Editor: AI Game Dev (`aigd`), verificado
- Última versión: 1.0.5 (publicado el 2026-11-22)
- Licencia: SEE LICENSE IN README.md
- Requiere la app AI Game Dev: `>=0.32.0-beta.6`
- Código nativo: no
- Valoración: aún sin valoraciones
- Página HTML: https://ai-game.dev/es/packages/aigd.model3d-pixal3d

## Instalar

Con la CLI gamedev, en la carpeta del proyecto:

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

En la app de escritorio: abre la ventana Packages (el icono de paquete en la barra de estado), selecciona **Browse**, busca `aigd.model3d-pixal3d` y haz clic en **Add to Project**. Más: https://ai-game.dev/docs/wiki/app/packages

## Versiones

| Versión | Publicado | Requiere app | Notas |
|---|---|---|---|
| 1.0.5 | 2026-11-22 | `>=0.32.0-beta.6` | la más reciente |
| 1.0.4 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descripción

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

Pixal3D es [Pixal3D](https://huggingface.co/TencentARC/Pixal3D) de Tencent ARC (SIGGRAPH 2026), un fine-tune de TRELLIS.2 que condiciona cada vóxel según el píxel de la imagen al que se proyecta, de modo que la geometría sigue más de cerca la silueta de la foto. Convierte una imagen en un GLB con textura y materiales PBR. En AI Game Dev se ejecuta en tu GPU a través de **[Generación 3D local](https://ai-game.dev/packages/aigd.trellis)** (`aigd.trellis`, trellis.cpp v0.8+), en GPU NVIDIA (CUDA) o Vulkan con 16 GB de memoria de vídeo. Resulta adecuado para assets cuya forma deba coincidir de cerca con una foto o un concepto de referencia.

## Qué puedes crear

- Props y objetos con textura y listos para PBR que conservan el contorno de la foto de origen.
- Versiones 3D de objetos reales que hayas fotografiado, encuadrados con algo de espacio alrededor.
- Modelos detallados con resolución 1024 o 1536.

## Ejemplos de peticiones

- "Convierte mi foto `Photos/teapot.jpg` en un modelo 3D con textura usando Pixal3D."
- "Crea un modelo 3D de este concepto de escudo a 1536."
- "El modelo Pixal3D se desvía del contorno; vuelve a intentarlo con un campo de visión distinto."

## Aspectos destacados

|  |  |
|---|---|
| ID del modelo | `aigd.model3d-pixal3d.bf16` |
| Operación | imagen a 3D (una foto PNG o JPEG de un solo objeto) |
| Salida | GLB con textura y materiales PBR (texturas PNG) |
| Resoluciones | 1024 (predeterminada), 1536 |
| Pasos | 12 de forma predeterminada |
| Campo de visión | opcional `fov`, 49.13 grados por defecto |
| Se ejecuta en | GPU NVIDIA (CUDA) o Vulkan con 16 GB de memoria de vídeo (el proyecto original advierte de que una tarjeta de 16 GB puede quedarse sin memoria en la fase de texturizado) |
| Descarga | 14.5 GB, 10 archivos (3.5 GB compartidos con TRELLIS.2) |
| Licencia | MIT; el codificador DINOv3 está bajo la DINOv3 License de Meta |

## Pixal3D o TRELLIS.2

- **Pixal3D** (este paquete): la geometría sigue más de cerca los píxeles de la foto; solo 1024 y 1536.
- **[TRELLIS.2 4B](https://ai-game.dev/packages/aigd.model3d-trellis2-4b)**: el modelo base, con una resolución 512 más ligera también.

Ambos juntos ocupan unos 27 GB, porque comparten 3.5 GB de archivos.

## Límites y mediciones

- **Entrada:** una foto PNG o JPEG de un solo objeto, encuadrada con algo de espacio alrededor.
- **Salida:** un único GLB autocontenido (texturas PNG).
- **Resoluciones:** 1024 (predeterminada) y 1536. Pixal3D no publica ningún modelo de textura de 512, por lo que no se ofrece 512.
- **Siempre con textura:** no se ofrece una ejecución solo de geometría. trellis.cpp v0.8.1 simplifica la malla solo durante el texturizado, así que sin texturas escribe la malla decodificada en bruto, que supera los límites de GLB de la app.
- **Campo de visión:** `fov` opcional (grados, 49.13 por defecto). trellis.cpp no lo estima como lo hace la referencia (MoGe-2), así que si la geometría se desvía de la silueta significa que el FOV es incorrecto.
- **No disponible: varias vistas.** Tencent publica `_mv` checkpoints multi-vista y, desde septiembre de 2026, inferencia multi-vista (`pipeline_mv.json`), pero trellis.cpp v0.8.1 es de una sola vista. La conversión de multivista a 3D espera soporte en el runtime.
- **Hardware:** una GPU NVIDIA (CUDA) o Vulkan con **16 GB** de memoria de vídeo. La fase de texturizado es el pico de memoria de Pixal3D, y el proyecto original advierte de que una tarjeta de 16 GB puede quedarse sin memoria ahí.
- **Descarga:** 14.5 GB, 10 archivos. 3.5 GB de ellos (decodificadores, DINOv3, BiRefNet) son idénticos byte a byte a los de TRELLIS.2 y se comparten con `aigd.model3d-trellis2-4b`.

En Windows con una RTX 4090, una imagen a resolución 1024 con semilla 42 y 12 pasos tardó 197.96 s en CUDA y 442.57 s en Vulkan. La VRAM de todo el dispositivo alcanzó un pico de 12,460 MiB en CUDA y 15,933 MiB en Vulkan. El uso inicial era de 4,622 y 4,690 MiB, respectivamente. En CUDA, una entrada JPEG distinta a resolución 1536 produjo un GLB PBR válido en 558.58 s. La VRAM de todo el dispositivo pasó de 3,924 MiB al inicio a un pico de 11,756 MiB.

## Qué se descarga

| Archivo | Qué es | Descargado de (revisión fijada) | Licencia |
|---|---|---|---|
| `pixal3d_ss_flow`, `pixal3d_shape_flow_512`, `pixal3d_shape_flow_1024`, `pixal3d_tex_flow_1024` | Transformers de flujo de Pixal3D (BF16) | [`vegax87/Pixal3D`](https://huggingface.co/vegax87/Pixal3D) `51de7d1764f4b735c4e3aaea40e5ba60c18ca707`, convertido desde [TencentARC/Pixal3D](https://huggingface.co/TencentARC/Pixal3D) | [MIT](https://huggingface.co/TencentARC/Pixal3D/blob/b0cb2e1b794cab9aa0ac38a95d794a4d9337437f/LICENSE) |
| `pixal3d_naf` | Upsampler de características NAF | `vegax87/Pixal3D`, convertido desde [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 a los de TRELLIS.2 | [`ilintar/trellis2-gguf`](https://huggingface.co/ilintar/trellis2-gguf) `a57397bd3d351599d9729fc144b3f87c3f87d65b` | [MIT](https://huggingface.co/microsoft/TRELLIS.2-4B) |
| `dinov3` | Codificador de imagen DINOv3 ViT-L/16 | `ilintar/trellis2-gguf` (del DINOv3 de Meta) | [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) |
| `birefnet` | eliminación de fondo | `ilintar/trellis2-gguf` (de [ZhengPeng7/BiRefNet](https://huggingface.co/ZhengPeng7/BiRefNet)) | MIT |

`vegax87/Pixal3D` (MIT) es la conversión que indica la documentación de Pixal3D de trellis.cpp; su autor contribuyó el backend de Pixal3D a trellis.cpp.

## Licencia

Pixal3D es **MIT** (© 2026 Tencent): se permite el uso comercial y tú eres el propietario de lo que generas. Como la licencia del codificador DINOv3 prohíbe algunos usos (más abajo), la app te pide que aceptes la licencia antes de la descarga. El NOTICE de Tencent enumera TRELLIS.2, Direct3D-S2 y MoGe (MIT) y dinov2 (Apache-2.0) como componentes de terceros y no añade restricciones propias.

- **Codificador de imagen DINOv3** — la [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) de Meta, no MIT. Se permite el uso comercial, pero: cuando distribuyas el codificador o un derivado, incluye la licencia y **muestra de forma destacada "Built with DINOv3"**; no se permite ningún uso militar o bélico, nuclear, de espionaje o de armas, ni nada prohibido por controles comerciales (ITAR, sanciones); no se permite la ingeniería inversa.
- **NAF** — Apache-2.0 (conserva su licencia y sus avisos si lo redistribuyes).
- **Bandera de la UE.** La tarjeta de Tencent en Hugging Face establece `extra_gated_eu_disallowed: true`. Hugging Face usa esa bandera para rechazar a usuarios de la UE en el formulario de acceso de un repositorio **con acceso restringido**. El repositorio de Pixal3D **no está restringido** (cualquiera lo descarga sin cuenta) y la licencia MIT no nombra ningún territorio, así que hoy la bandera no restringe nada. Puede sugerir que Tencent no tiene intención de ofrecer Pixal3D en la UE. Esto se declara como una restricción "otra" sin más, no como una prohibición territorial; compruébalo tú mismo antes de usar Pixal3D en la UE.

Texto de atribución obligatorio:

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

Las restricciones, en claro: la atribución de DINOv3 y la prohibición de usos militares, de armas y sujetos a controles comerciales; la bandera de la UE mencionada arriba. Sin límite de ingresos ni marca de agua.

Todos los archivos se descargan de Hugging Face. AI Game Dev no los aloja. Aceptas estas licencias al descargar el modelo.
````
