# Pixal3D (3D-Modell)

> Lokales Image-to-3D: Pixal3D von Tencent ARC, ein TRELLIS.2-Fine-Tune, macht aus einem Foto ein texturiertes 3D-Modell (GLB mit PBR-Materialien), dessen Geometrie den Pixeln des Fotos eng folgt. Läuft mit trellis.cpp auf einer NVIDIA- oder Vulkan-GPU mit 16 GB Videospeicher. MIT, mit Metas DINOv3-Lizenz für den Bild-Encoder.

- Id: `aigd.model3d-pixal3d`
- Quelle: Offiziell (First-Party `aigd.*`)
- Kategorie: 3D
- Herausgeber: AI Game Dev (`aigd`), verifiziert
- Neueste Version: 1.0.5 (veröffentlicht am 2026-11-22)
- Lizenz: SEE LICENSE IN README.md
- Erfordert die AI Game Dev App: `>=0.32.0-beta.6`
- Nativer Code: nein
- Bewertung: noch nicht bewertet
- HTML-Seite: https://ai-game.dev/de/packages/aigd.model3d-pixal3d

## Installieren

Mit der gamedev CLI im Projektordner:

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

In der Desktop-App: Öffne das Fenster Packages (das Paket-Symbol in der Statusleiste), wähle **Browse**, suche nach `aigd.model3d-pixal3d` und klicke auf **Add to Project**. Mehr: https://ai-game.dev/docs/wiki/app/packages

## Versionen

| Version | Veröffentlicht | Erfordert App | Hinweise |
|---|---|---|---|
| 1.0.5 | 2026-11-22 | `>=0.32.0-beta.6` | neueste |
| 1.0.4 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Beschreibung

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

Pixal3D ist Tencent ARCs [Pixal3D](https://huggingface.co/TencentARC/Pixal3D) (SIGGRAPH 2026), ein TRELLIS.2-Fine-Tune, das jedes Voxel auf das Bildpixel konditioniert, auf das es projiziert, sodass die Geometrie der Silhouette des Fotos genauer folgt. Es macht aus einem Bild ein texturiertes GLB mit PBR-Materialien. In AI Game Dev läuft es über **[Lokale 3D-Generierung](https://ai-game.dev/packages/aigd.trellis)** (`aigd.trellis`, trellis.cpp v0.8+) auf deiner GPU, auf NVIDIA- (CUDA) oder Vulkan-GPUs mit 16 GB Videospeicher. Es eignet sich für Assets, deren Form eng zu einem Referenzfoto oder Konzept passen muss.

## Was du erstellen kannst

- Texturierte, PBR-fertige Props und Objekte, die die Kontur des Ausgangsfotos beibehalten.
- 3D-Versionen echter Objekte, die du fotografiert hast, mit etwas Platz ringsherum im Bild.
- Detaillierte Modelle mit Auflösung 1024 oder 1536.

## Beispielanfragen

- "Mach aus meinem Foto `Photos/teapot.jpg` mit Pixal3D ein texturiertes 3D-Modell."
- "Erstelle ein 3D-Modell von diesem Schild-Konzept mit 1536."
- "Das Pixal3D-Modell weicht von der Kontur ab; versuch es mit einem anderen Sichtfeld erneut."

## Highlights

|  |  |
|---|---|
| Modell-ID | `aigd.model3d-pixal3d.bf16` |
| Vorgang | Bild zu 3D (ein PNG- oder JPEG-Foto eines einzelnen Objekts) |
| Ausgabe | texturiertes GLB mit PBR-Materialien (PNG-Texturen) |
| Auflösungen | 1024 (Standard), 1536 |
| Schritte | standardmäßig 12 |
| Sichtfeld | optional `fov`, Standard 49.13 Grad |
| Läuft auf | NVIDIA- (CUDA) oder Vulkan-GPU mit 16 GB Videospeicher (upstream wird gewarnt, dass einer 16-GB-Karte in der Texturphase der Speicher ausgehen kann) |
| Download | 14.5 GB, 10 Dateien (3.5 GB gemeinsam mit TRELLIS.2) |
| Lizenz | MIT; der DINOv3-Encoder steht unter Metas DINOv3 License |

## Pixal3D oder TRELLIS.2

- **Pixal3D** (dieses Paket): Die Geometrie folgt den Pixeln des Fotos genauer; nur 1024 und 1536.
- **[TRELLIS.2 4B](https://ai-game.dev/packages/aigd.model3d-trellis2-4b)**: das Basismodell, zusätzlich mit einer leichteren 512er-Auflösung.

Beide zusammen sind etwa 27 GB, weil 3.5 GB der Dateien geteilt werden.

## Grenzen und Messwerte

- **Eingabe:** ein PNG- oder JPEG-Foto eines einzelnen Objekts, mit etwas Platz ringsherum aufgenommen.
- **Ausgabe:** ein eigenständiges GLB (PNG-Texturen).
- **Auflösungen:** 1024 (Standard) und 1536. Pixal3D veröffentlicht kein 512er-Texturmodell, daher wird 512 nicht angeboten.
- **Immer texturiert:** Ein reiner Geometrie-Durchlauf wird nicht angeboten. trellis.cpp v0.8.1 vereinfacht das Mesh nur während der Texturierung; ohne Texturen schreibt es das roh dekodierte Mesh, das über den GLB-Grenzen der App liegt.
- **Sichtfeld:** optional `fov` (Grad, Standard 49.13). trellis.cpp schätzt es nicht so wie die Referenz (MoGe-2), daher bedeutet eine Geometrie, die von der Silhouette abweicht, dass der FOV falsch ist.
- **Nicht angeboten: mehrere Ansichten.** Tencent veröffentlicht `_mv` Multi-View-Checkpoints und seit September 2026 auch Multi-View-Inferenz (`pipeline_mv.json`), aber trellis.cpp v0.8.1 ist Single-View. Multiview-zu-3D wartet auf Runtime-Unterstützung.
- **Hardware:** eine NVIDIA- (CUDA) oder Vulkan-GPU mit **16 GB** Videospeicher. Die Texturphase ist der Speicherhöhepunkt von Pixal3D, und upstream warnt, dass einer 16-GB-Karte dort der Speicher ausgehen kann.
- **Download:** 14.5 GB, 10 Dateien. Davon sind 3.5 GB (Decoder, DINOv3, BiRefNet) byte-identisch mit denen von TRELLIS.2 und werden mit `aigd.model3d-trellis2-4b` geteilt.

Unter Windows mit einer RTX 4090 dauerte ein Bild mit Auflösung 1024, Seed 42 und 12 Schritten 197.96 s auf CUDA und 442.57 s auf Vulkan. Der geräteweite VRAM erreichte Spitzenwerte von 12,460 MiB auf CUDA und 15,933 MiB auf Vulkan. Die Startbelegung lag bei 4,622 bzw. 4,690 MiB. Auf CUDA erzeugte eine separate JPEG-Eingabe mit Auflösung 1536 in 558.58 s ein gültiges PBR-GLB. Der geräteweite VRAM stieg von 3,924 MiB zu Beginn auf einen Spitzenwert von 11,756 MiB.

## Was heruntergeladen wird

| Datei | Was es ist | Heruntergeladen von (fixierte Revision) | Lizenz |
|---|---|---|---|
| `pixal3d_ss_flow`, `pixal3d_shape_flow_512`, `pixal3d_shape_flow_1024`, `pixal3d_tex_flow_1024` | Flow-Transformer von Pixal3D (BF16) | [`vegax87/Pixal3D`](https://huggingface.co/vegax87/Pixal3D) `51de7d1764f4b735c4e3aaea40e5ba60c18ca707`, konvertiert aus [TencentARC/Pixal3D](https://huggingface.co/TencentARC/Pixal3D) | [MIT](https://huggingface.co/TencentARC/Pixal3D/blob/b0cb2e1b794cab9aa0ac38a95d794a4d9337437f/LICENSE) |
| `pixal3d_naf` | NAF-Feature-Upsampler | `vegax87/Pixal3D`, konvertiert aus [valeoai/NAF](https://github.com/valeoai/NAF) | [Apache-2.0](https://github.com/valeoai/NAF/blob/main/LICENSE) |
| `ss_dec`, `shape_dec`, `tex_dec` | Decoder, identisch mit denen von TRELLIS.2 | [`ilintar/trellis2-gguf`](https://huggingface.co/ilintar/trellis2-gguf) `a57397bd3d351599d9729fc144b3f87c3f87d65b` | [MIT](https://huggingface.co/microsoft/TRELLIS.2-4B) |
| `dinov3` | DINOv3 ViT-L/16 Bild-Encoder | `ilintar/trellis2-gguf` (aus Metas DINOv3) | [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/) |
| `birefnet` | Hintergrundentfernung | `ilintar/trellis2-gguf` (aus [ZhengPeng7/BiRefNet](https://huggingface.co/ZhengPeng7/BiRefNet)) | MIT |

`vegax87/Pixal3D` (MIT) ist die Konvertierung, die in der Pixal3D-Dokumentation von trellis.cpp genannt wird; ihr Autor hat das Pixal3D-Backend zu trellis.cpp beigetragen.

## Lizenz

Pixal3D steht unter **MIT** (© 2026 Tencent): Die kommerzielle Nutzung ist erlaubt, und was du erzeugst, gehört dir. Da die Lizenz des DINOv3-Encoders einige Nutzungen untersagt (siehe unten), bittet dich die App, die Lizenz vor dem Download zu akzeptieren. Die NOTICE von Tencent führt TRELLIS.2, Direct3D-S2 und MoGe (MIT) sowie dinov2 (Apache-2.0) als Drittanbieter-Komponenten auf und fügt keine eigenen Einschränkungen hinzu.

- **DINOv3-Bild-Encoder** — Metas [DINOv3 License](https://ai.meta.com/resources/models-and-libraries/dinov3-license/), nicht MIT. Die kommerzielle Nutzung ist erlaubt, aber: Wenn du den Encoder oder ein Derivat verbreitest, füge die Lizenz bei und **weise "Built with DINOv3" deutlich sichtbar aus**; keine militärischen oder kriegerischen, nuklearen, Spionage- oder Waffennutzungen, nichts, was durch Handelskontrollen (ITAR, Sanktionen) untersagt ist; kein Reverse Engineering.
- **NAF** — Apache-2.0 (behalte die Lizenz und die Hinweise bei, wenn du es weiterverbreitest).
- **EU-Flagge.** Die Hugging-Face-Karte von Tencent setzt `extra_gated_eu_disallowed: true`. Hugging Face nutzt diese Flagge, um EU-Nutzer am Zugriffsformular eines **gated** Repos abzuweisen. Das Pixal3D-Repo ist **nicht gated** (jeder lädt es ohne Konto herunter), und die MIT-Lizenz nennt kein Territorium, daher schränkt die Flagge heute nichts ein. Sie könnte andeuten, dass Tencent Pixal3D nicht in der EU anbieten will. Dies wird als schlichte "sonstige" Einschränkung offengelegt, nicht als Gebietssperre; prüfe es selbst, bevor du Pixal3D in der EU verwendest.

Erforderlicher Attributionshinweis:

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

Die Einschränkungen, klar gesagt: die DINOv3-Attribution und das Verbot militärischer, Waffen- und Handelskontroll-Nutzung; die EU-Flagge oben. Keine Umsatzobergrenze, kein Wasserzeichen.

Alle Dateien werden von Hugging Face heruntergeladen. AI Game Dev hostet sie nicht. Mit dem Download des Modells akzeptierst du diese Lizenzen.
````
