# SkinTokens (rigging automático local)

> Rigging automático local: SkinTokens, de VAST-AI, añade un esqueleto y pesos de skin a una malla de personaje o criatura (GLB, OBJ o FBX) y escribe un GLB con rig que conserva los materiales y las UV originales. Se ejecuta desde Asset Studio en tu GPU NVIDIA con 14 GB de VRAM. MIT, se permite el uso comercial.

- Id: `aigd.model3d-skintokens`
- Origen: Oficial (propio `aigd.*`)
- Categoría: Herramientas
- Editor: AI Game Dev (`aigd`), verificado
- Última versión: 1.0.4 (publicado el 2026-11-22)
- Licencia: MIT
- 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-skintokens

## Instalar

Con la CLI gamedev, en la carpeta del proyecto:

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

En la app de escritorio: abre la ventana Packages (el icono de paquete en la barra de estado), selecciona **Browse**, busca `aigd.model3d-skintokens` 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.4 | 2026-11-22 | `>=0.32.0-beta.6` | la más reciente |
| 1.0.3 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descripción

````markdown
# SkinTokens (`aigd.model3d-skintokens`)

SkinTokens crea el rig de un modelo 3D en tu GPU NVIDIA (14 GB de VRAM o más) con [SkinTokens](https://github.com/VAST-AI-Research/SkinTokens) de VAST-AI. Predice un esqueleto y pesos de skin para una malla de personaje o criatura y los escribe en tu archivo original, de modo que se conservan sus materiales y sus UV. El resultado es un GLB con rig. En AI Game Dev se ejecuta localmente mediante el **runtime de modelos Python locales** (`aigd.python`). Resulta útil para desarrolladores que necesitan un primer rig para un personaje generado o hecho a mano antes de animarlo.

## Qué puedes crear

- Personajes y criaturas con rig a partir de una malla GLB, OBJ o FBX, listos para animar en tu motor o en tu herramienta DCC.
- Esqueletos y pesos de skin de primera pasada para mallas creadas por los modelos locales de imagen a 3D.
- Varios candidatos de rig para una misma malla: cada ejecución muestrea un esqueleto nuevo.

## Cómo se usa

El rigging se ejecuta desde **Asset Studio**, no desde el agente del chat:

1. Abre Asset Studio y elige **3D → SkinTokens → Rig**.
2. Añade la malla a la que quieres crear el rig: un archivo GLB, OBJ o FBX, como `Assets/Models/goblin.glb`.
3. Revisa el GLB con rig. Si el esqueleto no encaja con el modelo, vuelve a ejecutarlo: cada ejecución muestrea un esqueleto nuevo.

## Aspectos destacados

|  |  |
|---|---|
| ID del modelo | `aigd.model3d-skintokens.v1` |
| Operación | crear el rig de un modelo 3D (una malla de entrada: GLB, OBJ o FBX) |
| Salida | GLB con rig, con esqueleto y pesos de skin; se conservan los materiales y las UV originales |
| Se ejecuta en | GPU NVIDIA (CUDA) con 14 GB de VRAM o más |
| Descarga | unos 1.6 GB, más el entorno Python del runtime (con Blender como módulo de Python) en la primera carga |
| Licencia | MIT, se permite el uso comercial del modelo y de sus rigs |

Las mallas para crear el rig pueden venir de [TripoSG](https://ai-game.dev/packages/aigd.model3d-triposg), [Hunyuan3D-2.1 Shape](https://ai-game.dev/packages/aigd.model3d-hunyuan3d-2-1-shape), [Step1X-3D Geometry](https://ai-game.dev/packages/aigd.model3d-step1x-3d-geometry), [TRELLIS.2](https://ai-game.dev/packages/aigd.model3d-trellis2-4b) o de tus propias herramientas.

## Cómo funciona

Este paquete solo contiene datos. Necesita el **runtime de modelos Python locales** (`aigd.python`). La primera carga crea un entorno privado de Python 3.11 con PyTorch y Blender como módulo de Python (`bpy` 4.5 LTS, unos 330 MB). Blender lee y escribe las mallas. FlashAttention no está instalado: la atención se ejecuta con los kernels integrados de PyTorch. Open3D tampoco está instalado: la rejilla de vóxeles para el suavizado de los pesos de skin se construye en NumPy con las mismas matemáticas que las de Open3D. Los checkpoints se cargan solo como tensores, nunca como código. Los modelos se ejecutan sin conexión; sus pesos provienen únicamente de los archivos que se indican abajo, descargados de Hugging Face después de que lo confirmes. AI Game Dev no los aloja.

## Qué se descarga

Unos 1.6 GB, fijados por revisión y sha256 de Hugging Face:

| Archivo | Tamaño | Licencia | Origen |
|---|---|---|---|
| `skin_vae_2_10_32768-last.ckpt` | 0.49 GB | MIT | [archivo](https://huggingface.co/VAST-AI/SkinTokens/resolve/79736cad0fd84de384d5eede659b4ebd24effe33/experiments/skin_vae_2_10_32768/last.ckpt) |
| `articulation_xl_quantization_256_token_4-grpo_1400.ckpt` | 1.13 GB | MIT | [archivo](https://huggingface.co/VAST-AI/SkinTokens/resolve/79736cad0fd84de384d5eede659b4ebd24effe33/experiments/articulation_xl_quantization_256_token_4/grpo_1400.ckpt) |
| `Qwen3-0.6B-config.json` | 0.00 GB | Apache-2.0 | [archivo](https://huggingface.co/Qwen/Qwen3-0.6B/resolve/c1899de289a04d12100db370d81485cdf75e47ca/config.json) |

El código Python del modelo (`src/`, `configs/skeleton/`) se descarga de GitHub en el commit [`273b691`](https://github.com/VAST-AI-Research/SkinTokens/tree/273b691d35989d71cd17ff2895fdc735097b92d1), con cada archivo verificado por sha256.

## Licencia

- **Pesos y código: MIT**, © 2025 VAST-AI-Research ([licencia](https://github.com/VAST-AI-Research/SkinTokens/blob/273b691d35989d71cd17ff2895fdc735097b92d1/LICENSE), [ficha del modelo](https://huggingface.co/VAST-AI/SkinTokens/tree/79736cad0fd84de384d5eede659b4ebd24effe33)).
- **Archivo de configuración de Qwen3-0.6B**: Apache-2.0, © Alibaba Cloud ([ficha del modelo](https://huggingface.co/Qwen/Qwen3-0.6B/tree/c1899de289a04d12100db370d81485cdf75e47ca)). Solo se descarga su `config.json`; los pesos del modelo de lenguaje forman parte de SkinTokens.
- **Blender como módulo de Python** (`bpy` 4.5.16): GPL-3.0-or-later, © Blender Foundation ([PyPI](https://pypi.org/project/bpy/4.5.16/)). El runtime lo instala desde PyPI en el entorno privado del modelo, donde el gestor de rigging de la app lo importa para leer y escribir mallas. AI Game Dev no distribuye bpy.
- **El gestor de rigging** (`skintokens/handler.py` en el runtime de Python de la app): **GPL-3.0-or-later**, porque importa bpy. Se ejecuta como un programa aparte, en el proceso worker de Python del propio modelo, que la app inicia y con el que solo se comunica mediante mensajes JSON por stdio. Su código fuente se distribuye con la app; consulta `THIRD_PARTY_NOTICES.md`.

Atribución obligatoria: "SkinTokens © 2025 VAST-AI-Research (MIT)".

**Restricciones:** se permite el uso comercial del modelo y de los rigs que genera. La redistribución de los pesos exige incluir el aviso de copyright de MIT.
````
