# Giro assado — mesa giratória em quadros, do Blender, do ComfyUI, de um vídeo ou de código

## Fonte

Aprendido em 2026-10-01, montando a Fita NASH
(`~/Documents/Profissional/replicas/nash-fita/`) com o N da casa, depois de
medir a mecânica da fita no estudo do pear.no
([fita-de-rolagem.md](fita-de-rolagem.md)). Escopo medido: quadros de
1600×1000, tela de 1512×900, Mac com Apple Silicon e o ComfyUI do servidor
da casa.

O giro de um site em fita parece 3D ao vivo e é um flipbook: uma sequência
numerada de imagens, e a rolagem escolhe qual mostrar. Todo o trabalho caro
acontece antes, num render. Esta técnica é a fábrica desses quadros; a
página que os toca está em [fita-de-rolagem.md](fita-de-rolagem.md),
[rolagem-amaciada-por-captura-da-roda.md](rolagem-amaciada-por-captura-da-roda.md)
e no `fita.js` da Fita NASH.

## Receita

O contrato de saída é o mesmo para qualquer rota:

```text
pasta      frames/<nome>/f_001.<ext> … f_<N>.<ext>, três casas
quadros    121 é o padrão (89 a 362 medidos em produção)
tamanho    1600×1000 (16:10); a página cobre a tela com um corte no shader
formato    WebP para imagem tonal, PNG de paleta para imagem de poucos
           tons, JPG quando o ffmpeg não grava WebP
tempo      linear de ponta a ponta — a aceleração é da rolagem
```

E o giro em si tem uma regra que vale para as quatro rotas: **quem anda é a
câmera, nunca a peça**. Um eixo vazio no centro gira, a câmera vai presa
nele. A luz, o chão e o fundo ficam no mundo, e a peça para à direita do
quadro deslocando o sensor (`shift_x` no Blender, `camera.position.x` com o
mesmo `lookAt` no three.js), sem mover o objeto.

Arco ou laço muda a conta do quadro:

```text
arco (−60° a +60°)   t = i / (N − 1)    primeiro e último são as pontas
laço (360°)          t = i / N          o quadro N+1 seria igual ao 1
```

### Rota 1 — Blender, para objeto com corpo

`scripts/giro-blender.py` monta a cena inteira sem abrir a interface e grava
a sequência:

```bash
/Applications/Blender.app/Contents/MacOS/Blender -b \
  -P ~/.claude/skills/nxx-sharingan/scripts/giro-blender.py -- \
  --saida frames/meu-giro --quadros 121 --de -70 --ate 70 --entra 11
```

Sem `--modelo`, o objeto é o N da casa, montado das quatro lajes do
`#marca-n` com a profundidade de cada uma. `--modelo` aceita
`.glb`/`.gltf`/`.obj`/`.fbx`/`.stl`, centraliza e escala para 5 de altura.

```text
câmera     lente 50, raio 14, altura 0,6; --entra faz a câmera chegar
           perto enquanto gira (14 → 11)
luz        chave branca 1800 W, contra vermelho imperial 1600 W,
           preenchimento quente 120 W, três luzes de área
reflexo    duas placas emissivas fora do quadro — janela branca (14) e
           faixa vermelha (8) — invisíveis para a câmera
material   vidro fumê: base 0,012, rugosidade 0,08, verniz 1,
           transmissão 0,35, IOR 1,5 (--material fosco | branco)
motor      EEVEE, 64 amostras; --motor cycles usa a GPU por Metal
medido     121 quadros em 2 min 58 s a 64 amostras (~1,47 s por quadro),
           2,2 MB; diferença média entre quadros vizinhos 0,55 de 255,
           máxima 1,11 — o giro não salta
```

### Rota 2 — código (three.js no navegador), para peça que já existe em WebGL

Quando a cena já é código — as três dobras do N, o orbe — o forno roda a
mesma cena num Chrome headless trocando o relógio por `t`:

```text
forno      nash-fita/bake/bake.html — window.quadro(dobra, i, N) devolve
           o quadro i em dataURL
driver     nash-fita/bake/bake.py, por CDP, grava a pasta
superamostra  renderiza em 2× e reduz num canvas 2D
medido     121 quadros em 12–26 s por dobra
```

### Rota 3 — qualquer vídeo de giro

Render de outro programa, geração de IA, celular filmando um objeto num prato
giratório:

```bash
sh ~/.claude/skills/nxx-sharingan/scripts/giro-de-video.sh ~/Desktop/giro.mp4 frames/meu-giro
```

Amostra 121 quadros por igual ao longo do vídeo inteiro, escala para
preencher 1600×1000 e corta o excesso. Argumentos opcionais: quadros,
largura, altura.

### Rota 4 — ComfyUI, para movimento orgânico

Medida em 2026-10-01 no servidor da casa, com o quadro 31 do Monólito como
imagem de partida. A rota funciona de ponta a ponta — gera, arquiva o grafo,
traz o vídeo, vira quadros —, e **o giro saiu reprovado nas duas receitas**.
Para peça rígida com geometria conhecida, a rota é o Blender ou o código: a
rotação sai exata por construção. O ComfyUI fica para movimento que não tem
geometria — tecido, fumaça, gente — ou como passada de acabamento quadro a
quadro sobre um render.

```text
Wan 2.2 TI2V 5B     768×480 (16:10), 49 quadros, 20 passos, uni_pc, cfg 5,
                    shift 8, VAE wan2.2, só cuda:0 — 204 s
                    REPROVADO: o objeto apaga do quadro 3 ao 37, sem órbita
Wan 2.2 A14B i2v    768×480, 49 quadros, 8 passos (4 + 4), euler, cfg 3,5,
                    shift 5, VAE wan 2.1, split cuda:0 2 GB + cuda:1 2 GB +
                    cpu — 831 s
                    REPROVADO: gira 15–20° no primeiro quarto e funde as
                    quatro lajes numa letra N maciça que some na sombra
```

Os grafos exatos estão arquivados no servidor, em
`nash used workflows/`, com o veredito no nome.

O que tentar na próxima rodada — hipóteses, nenhuma isolada ainda:

- descrever a geometria em vez do significado ("quatro placas finas de vidro
  fumê em cata-vento girando juntas num prato giratório"), sem "letter N";
- 81 quadros no A14B, para ter quadros únicos perto dos 121;
- FLF2V — vídeo definido pelo primeiro e pelo último quadro — usando dois
  ângulos reais do giro do Blender para forçar a rotação;
- imagem de partida mais iluminada: o quadro 31 tem luma média 22 de 255, e
  os dois modelos perderam o objeto quando ele saiu da luz.

### Ligar na fita

Uma linha na lista de dobras do `fita.js` — `{ nome, n, de, ate, ext }`,
com `de` e `ate` em fração da rolagem — e o texto do capítulo no
`index.html`. A Fita NASH reserva 28% da rolagem por dobra e 7% para cada
passagem.

## Aprendizados

- **2026-10-01 — raio 9 cortava a peça.** Com lente de 50 e a peça
  normalizada para 5 de altura, a câmera a 9 cortou a laje de cima e a de
  baixo. Raio 14 enquadra com folga; `--entra 11` aproxima sem cortar.
- **2026-10-01 — vidro escuro some no preto.** Sem nada para refletir, o
  verniz não acende e a peça vira silhueta. O que dá a borda são as placas
  emissivas fora do quadro (Blender) ou o ambiente pintado num canvas
  (three.js) — a luz direta sozinha não basta.
- **2026-10-01 — ASCII em WebP com perda pesa 25×.** 121 quadros de ASCII
  saíram com 32 MB em WebP e 1,3 MB em PNG de paleta de três tons, sem o
  borrão da compressão. Imagem de poucos tons vai em PNG de paleta.
- **2026-10-01 — o ponto do fundo do ASCII engole o texto.** A grade de `·`
  a 100% cobre a tela toda e o corpo de texto por cima deixa de ler. O ponto
  do fundo a 35% mantém a grade e devolve a leitura.
- **2026-10-01 — a dispersão inicial da Constelação era invisível.** Pontos
  de 1–2 px a alfa 0,25 somem depois da redução de 2×; o quadro 1 media 0,13
  de luminância. Pontos maiores e mais opacos no estado disperso
  (`mix(1.7, 1.15, k)` no tamanho) fizeram a poeira ler.
- **2026-10-01 — o ffmpeg do Homebrew não grava WebP.** `libwebp` não vem no
  build; a rota de vídeo sai em JPG, que a fita lê pela extensão. O Blender
  grava WebP sozinho, e `cwebp` existe para converter.
- **2026-10-01 — Blender 5.** `Material.use_nodes` só avisa que vai sair no
  6.0; as ações viraram camadas (`layers` › `strips` › `channelbags` ›
  `fcurves`). Com uma chave por quadro, a interpolação entre chaves não
  muda nada do que se vê.
- **2026-10-01 — IA de vídeo não gira peça rígida.** Pedir órbita a um
  modelo de vídeo a partir de uma imagem trocou a escultura por uma letra
  maciça (A14B) ou apagou o objeto (5B). O modelo preenche o lado escondido
  com o que o prompt sugere — "letter N" virou uma letra N.
- **2026-10-01 — 49 quadros esticados para 121 andam em degraus.** Cada
  quadro se repete umas 2,5 vezes e a rolagem sente o salto. Quadros únicos
  têm de chegar perto do total; não há modelo de interpolação (RIFE, FILM)
  instalado no servidor.
- **2026-10-01 — `VAEDecodeTiled` com `temporal_size` 16 salta de cor a cada
  12 quadros.** Com `temporal_size` maior ou igual ao comprimento do vídeo o
  decode sai num bloco só, em 12 s, sem estourar memória.
- **2026-10-01 — a porta 8188 do servidor não é o ComfyUI.** Responde
  `/system_stats` igual, mas é o serviço sob demanda da casa; o container
  direto está em `127.0.0.1:8189`.
- **2026-10-01 — nome de arquivo de grafo arquivado passou de 255 bytes.**
  `OSError: [Errno 36]`; mantenha abaixo de ~230.
- **2026-10-01 — o shift do 5B é 8.** O 5 do manual do ComfyUI vale para os
  experts de 14B; o template oficial do 5B usa 8, uni_pc e cfg 5.
- **2026-10-01 — `sh` do macOS come byte de UTF-8 colado em variável.**
  `"$W×$H"` saiu como `(�1000)`; `${W}×${H}` resolve.

## Conota

O giro diz que a peça é um objeto e não uma imagem: tem lado de trás,
espessura, peso. E como quem gira é quem rola, o leitor sente que está
andando em volta dela, e não vendo um vídeo passar.
