# SkinTokens (rig automático local)

> Rig automático local: o SkinTokens da VAST-AI adiciona esqueleto e pesos de skin a uma malha de personagem ou criatura (GLB, OBJ ou FBX) e grava um GLB com rig que mantém os materiais e UVs originais. Roda no Asset Studio na sua GPU NVIDIA com 14 GB de VRAM. MIT, uso comercial permitido.

- Id: `aigd.model3d-skintokens`
- Origem: Oficial (de primeira parte `aigd.*`)
- Categoria: Ferramentas
- Publicador: AI Game Dev (`aigd`), verificado
- Versão mais recente: 1.0.4 (publicado em 2026-11-22)
- Licença: MIT
- 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-skintokens

## Instalar

Com o CLI gamedev, na pasta do projeto:

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

No app desktop: abra a janela Packages (o ícone de pacote na barra de status), selecione **Browse**, busque `aigd.model3d-skintokens` 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.4 | 2026-11-22 | `>=0.32.0-beta.6` | mais recente |
| 1.0.3 | 2026-11-21 | `>=0.32.0-beta.6` | - |

## Descrição

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

O SkinTokens faz o rig de um modelo 3D na sua GPU NVIDIA (14 GB de VRAM ou mais) com [SkinTokens](https://github.com/VAST-AI-Research/SkinTokens) da VAST-AI. Ele prevê um esqueleto e pesos de skin para uma malha de personagem ou criatura e os grava no seu arquivo original, de modo que seus materiais e UVs são mantidos. O resultado é um GLB com rig. No AI Game Dev ele roda localmente pelo **Local Python models runtime** (`aigd.python`). Serve para desenvolvedores que precisam de um primeiro rig para um personagem gerado ou feito à mão antes de animá-lo.

## O que você pode criar

- Personagens e criaturas com rig a partir de uma malha GLB, OBJ ou FBX, prontos para animar na sua engine ou ferramenta DCC.
- Esqueletos e pesos de skin de primeira passada para malhas feitas pelos modelos locais de imagem para 3D.
- Vários candidatos de rig para uma mesma malha: cada execução amostra um novo esqueleto.

## Como usar

O rig roda no **Asset Studio**, e não pelo agente do chat:

1. Abra o Asset Studio e escolha **3D → SkinTokens → Rig**.
2. Adicione a malha a rigar: um arquivo GLB, OBJ ou FBX, como `Assets/Models/goblin.glb`.
3. Confira o GLB com rig. Se o esqueleto não servir para o modelo, rode de novo: cada execução amostra um novo esqueleto.

## Destaques

|  |  |
|---|---|
| Id do modelo | `aigd.model3d-skintokens.v1` |
| Operação | fazer o rig de um modelo 3D (uma malha de entrada: GLB, OBJ ou FBX) |
| Saída | GLB com rig, com esqueleto e pesos de skin; materiais e UVs originais mantidos |
| Roda em | GPU NVIDIA (CUDA) com 14 GB de VRAM ou mais |
| Download | cerca de 1,6 GB, mais o ambiente Python do runtime (com o Blender como módulo Python) no primeiro carregamento |
| Licença | MIT, uso comercial do modelo e dos rigs gerados permitido |

As malhas para rigar podem vir do [TripoSG](https://ai-game.dev/packages/aigd.model3d-triposg), do [Hunyuan3D-2.1 Shape](https://ai-game.dev/packages/aigd.model3d-hunyuan3d-2-1-shape), do [Step1X-3D Geometry](https://ai-game.dev/packages/aigd.model3d-step1x-3d-geometry), do [TRELLIS.2](https://ai-game.dev/packages/aigd.model3d-trellis2-4b) ou das suas próprias ferramentas.

## Como ele roda

Este pacote é apenas dados. Ele precisa do **Local Python models runtime** (`aigd.python`). O primeiro carregamento monta um ambiente Python 3.11 privado com PyTorch e Blender como módulo Python (`bpy` 4.5 LTS, cerca de 330 MB). O Blender lê e grava as malhas. O FlashAttention não é instalado: a atenção roda nos kernels nativos do PyTorch. O Open3D também não é instalado: a grade de voxels para a suavização dos pesos de skin é construída em NumPy com a mesma matemática da do Open3D. Os checkpoints são carregados apenas como tensores, nunca como código. Os modelos rodam offline; seus pesos vêm apenas dos arquivos abaixo, baixados do Hugging Face depois da sua confirmação. O AI Game Dev não os hospeda.

## O que é baixado

Cerca de 1,6 GB, fixados por revisão e sha256 do Hugging Face:

| Arquivo | Tamanho | Licença | Origem |
|---|---|---|---|
| `skin_vae_2_10_32768-last.ckpt` | 0.49 GB | MIT | [arquivo](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 | [arquivo](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 | [arquivo](https://huggingface.co/Qwen/Qwen3-0.6B/resolve/c1899de289a04d12100db370d81485cdf75e47ca/config.json) |

O código Python do modelo (`src/`, `configs/skeleton/`) é baixado do GitHub no commit [`273b691`](https://github.com/VAST-AI-Research/SkinTokens/tree/273b691d35989d71cd17ff2895fdc735097b92d1), com cada arquivo verificado por sha256.

## Licença

- **Pesos e código: MIT**, © 2025 VAST-AI-Research ([licença](https://github.com/VAST-AI-Research/SkinTokens/blob/273b691d35989d71cd17ff2895fdc735097b92d1/LICENSE), [card do modelo](https://huggingface.co/VAST-AI/SkinTokens/tree/79736cad0fd84de384d5eede659b4ebd24effe33)).
- **Arquivo de configuração do Qwen3-0.6B**: Apache-2.0, © Alibaba Cloud ([card do modelo](https://huggingface.co/Qwen/Qwen3-0.6B/tree/c1899de289a04d12100db370d81485cdf75e47ca)). Só o `config.json` dele é baixado; os pesos do modelo de linguagem fazem parte do SkinTokens.
- **Blender como módulo Python** (`bpy` 4.5.16): GPL-3.0-or-later, © Blender Foundation ([PyPI](https://pypi.org/project/bpy/4.5.16/)). O runtime o instala do PyPI no ambiente privado do modelo, onde o handler de rig do app o importa para ler e gravar malhas. O AI Game Dev não distribui o bpy.
- **O handler de rig** (`skintokens/handler.py` no runtime Python do app): **GPL-3.0-or-later**, porque importa o bpy. Ele roda como um programa separado, no processo worker Python do próprio modelo, que o app inicia e com o qual se comunica apenas por mensagens JSON via stdio. Seu código-fonte acompanha o app; veja `THIRD_PARTY_NOTICES.md`.

Atribuição exigida: "SkinTokens © 2025 VAST-AI-Research (MIT)".

**Restrições:** o uso comercial do modelo e dos rigs que ele gera é permitido. Redistribuir os pesos exige o aviso de copyright do MIT.
````
