Rigging de Personagem 3D para Jogos Explicado: Esqueleto, Weight Paint e Exportação

Rigging de personagem para jogo é a etapa que transforma uma estátua em alguém. Você modelou o personagem, ele está lindo parado, e agora precisa andar, pular e segurar uma espada. O rig é o esqueleto digital que permite isso: um conjunto de ossos (bones) ligado à malha, que a animação move e a malha acompanha.

É também a etapa onde a maioria das pessoas trava. Não porque rigging é difícil de entender, mas porque os erros aparecem longe da causa: o cotovelo amassa na animação porque o weight paint estava errado lá atrás, o personagem chega na engine deitado porque a orientação estava errada no export. Esse artigo cobre o fluxo inteiro no Blender, do esqueleto à exportação com animação funcionando na engine, com foco no que dá errado de verdade.

O que é rigging de personagem para jogo (e por que difere de cinema)

Rigging tem três partes que as pessoas costumam misturar:

1. Esqueleto (armature): a hierarquia de bones dentro da malha. Quadril, coluna, braços, pernas, cabeça.
2. Skinning (weight paint): a ligação entre cada vértice da malha e os bones que o influenciam, com pesos de 0 a 1.
3. Controles: os apetrechos que facilitam animar, como alvos de IK e bones de controle que não deformam nada.

Antes de chegar ao esqueleto, a malha precisa de topologia amigável a deformação, com quads e edge loops nas articulações. Se o seu modelo veio cheio de triângulos, vale passar por uma retopologia automática gratuita com o AutoRemesher primeiro.

Um detalhe que muda tudo: rig de jogo não é rig de cinema. Em cinema, o rig pode ter centenas de bones, músculos simulados e correções por shape key, porque tudo é renderizado offline. Em jogo, a engine calcula a deformação do personagem todo frame, em tempo real, para cada personagem na tela. Isso impõe limites práticos:

• Menos bones. Um personagem de jogo típico fica entre 30 e 70 bones de deformação. Dá para fazer muito com isso. Personagem de mobile ou multidão, menos ainda.
• Até 4 influências por vértice. Quase toda engine limita quantos bones podem afetar cada vértice (4 é o padrão em Godot e Unity). Se o seu weight paint usa mais, a engine descarta os pesos menores e a deformação muda em relação ao que você via no Blender.
• Só bones de deformação são exportados. Controles, IK e constraints viram animação "assada" (baked) no export. A engine recebe a posição final de cada bone por frame, não o mecanismo que gerou. Se você quer IK que roda em tempo real dentro do jogo, como o pé se ajustando ao chão na hora, isso é resolvido na engine e não no Blender: veja como montar a cinemática inversa (IK) na Godot para 2D.

Entender isso antes de começar evita o erro clássico de construir um rig cheio de truque que não sobrevive à exportação.

Montando o esqueleto no Blender

No Blender, o esqueleto é um objeto Armature. Você adiciona com Add > Armature, entra no Edit Mode e constrói os bones extrudando a partir do primeiro.

Hierarquia e ordem de construção

A hierarquia padrão de um humanoide parte do quadril, que é a raiz do movimento do corpo:

root (no chão, entre os pés)
└── hips
    ├── spine → chest → neck → head
    ├── thigh.L → shin.L → foot.L → toe.L
    └── thigh.R → shin.R → foot.R → toe.R
        (braços saem do chest: shoulder → upper_arm → forearm → hand)

O bone root no chão merece explicação, porque iniciante sempre pula ele. É um bone extra, pai de tudo, parado na origem. Ele serve para a engine saber onde o personagem "está" de verdade, e é essencial para root motion: a técnica em que o deslocamento da animação (uma esquiva, um ataque que avança) move o personagem no mundo do jogo em vez de só mover a malha e deixar a cápsula de colisão para trás.

Boas práticas que economizam horas depois:

• Modele e rigue em T-pose ou A-pose. Braços abertos, pernas levemente afastadas. Facilita o weight paint e o retargeting de animação depois.
• Nomeie com sufixo .L e .R (upper_arm.L, upper_arm.R). O Blender entende esses sufixos e espelha pose e weight paint automaticamente. Construa só o lado esquerdo e use Armature > Symmetrize.
• Posicione as juntas onde o corpo dobra de verdade. O bone do joelho começa onde o joelho dobra, não no meio da coxa. Errar isso não tem weight paint que salve.
• Dê uma leve dobra ao joelho e cotovelo na pose de descanso. IK precisa saber para qual lado a junta dobra, e uma perna 100% reta deixa isso ambíguo.

Ligando a malha ao esqueleto

Com o esqueleto pronto, selecione a malha, depois a armature (a ordem importa), e use Ctrl+P > Armature Deform > With Automatic Weights. O Blender cria um modificador Armature na malha, um vertex group por bone, e calcula pesos iniciais baseado na distância de cada vértice a cada bone.

Esses pesos automáticos acertam uns 80% num personagem bem modelado. Os outros 20% são o weight paint manual, e é onde a qualidade do rig se decide.

Weight paint: onde o rig vira bom ou ruim

Weight paint é pintar, vértice por vértice, o quanto cada bone influencia a malha. Peso 1.0 (vermelho) significa que o vértice segue o bone completamente; peso 0 (azul), que ignora. Nas regiões de transição, como o meio do antebraço, os pesos se dividem entre dois bones e a malha dobra suavemente.

O fluxo de trabalho que funciona: entre no Pose Mode, rotacione um bone para uma pose extrema (braço para baixo, perna para frente), e olhe onde a malha quebra. Aí, com a armature em Pose Mode e a malha em Weight Paint Mode, você corrige pintando enquanto vê a deformação ao vivo. Pose, pinta, testa, repete.

As regiões problemáticas são sempre as mesmas:

• Axila e ombro. A região mais difícil de qualquer rig humanoide. O automatic weights costuma deixar o peito sendo puxado quando o braço desce. Reduza a influência do upper_arm no torso.
• Virilha e quadril. Levantar uma perna não pode arrastar a outra. Se arrasta, a coxa esquerda está com peso em vértices da direita.
• Cotovelo e joelho por dentro. Tendem a colapsar em dobras fortes. Distribuir a transição de peso ao longo de 2 ou 3 loops de vértices (em vez de um corte seco) já melhora muito.
• Dedos. Peso vazando de um dedo para o vizinho. Mexeu o indicador, o médio veio junto.

Três ferramentas resolvem a maior parte do trabalho: o pincel Add com força baixa para construir influência aos poucos, o Subtract para remover vazamento, e o Blur para suavizar transições. E uma regra de ouro para jogo: mantenha o Auto Normalize ligado na barra lateral do Weight Paint. Ele garante que os pesos de cada vértice somem 1.0, que é o que a engine espera.

Antes de exportar, rode também Weights > Limit Total com limite 4. Isso corta as influências excedentes ainda no Blender, onde você vê o resultado, em vez de deixar a engine cortar sem avisar.

IK, FK e bones de controle

Mesmo num rig de jogo, vale adicionar controles básicos para animar com sanidade. Os dois modos de manipular uma cadeia de bones:

• FK (Forward Kinematics): você rotaciona cada bone na ordem, do ombro ao pulso. Bom para arcos naturais, como o balanço do braço numa caminhada.
• IK (Inverse Kinematics): você move um alvo (a mão, o pé) e o Blender calcula a rotação do resto da cadeia. Indispensável para pés, que precisam ficar plantados no chão enquanto o quadril se move.

Na prática mínima: crie um bone de alvo para cada pé, desconectado da cadeia da perna, e adicione um constraint Inverse Kinematics no shin apontando para ele, com chain length 2. Adicione também um pole target para controlar a direção do joelho. Esses bones de controle não deformam a malha, então desmarque a opção Deform deles no painel de propriedades do bone. No export, a animação que eles geram é assada nos bones de deformação, e eles próprios podem ficar de fora.

Exportando com animação para a engine

Aqui é onde rigs que pareciam perfeitos quebram. O formato que eu recomendo hoje é glTF (.glb): é aberto, é o formato que o Blender e o Godot tratam como cidadão de primeira classe, e a Unity importa bem com o pacote oficial. FBX continua sendo o padrão histórico da indústria e funciona, mas o exportador do Blender é uma reimplementação do formato fechado da Autodesk, e problemas de escala e orientação são mais comuns nele.

O checklist antes de exportar, na ordem:

1. Aplique as transformações. Selecione malha e armature, Ctrl+A > All Transforms. Escala diferente de 1.0 ou rotação não aplicada na armature é a causa número um de personagem gigante, minúsculo ou deitado na engine.
2. Cada animação em uma Action separada, com nome limpo: idle, walk, run, jump. Esses nomes chegam na engine exatamente assim.
3. Empurre cada Action para a NLA (botão Push Down no Action Editor). O exportador glTF usa as faixas da NLA para saber quais animações incluir.
4. No diálogo de export glTF, em Animation, deixe o modo de baking ativo para constraints virarem keyframes nos bones de deformação.

Importando no Godot

Arraste o .glb para o projeto e o Godot importa a cena com a malha, o Skeleton3D e um AnimationPlayer com cada Action virando uma animação. Instancie no seu personagem e toque:

extends CharacterBody3D

@onready var anim: AnimationPlayer = $modelo/AnimationPlayer

func _physics_process(delta: float) -> void:
    # velocity vem do seu código de movimento.
    if not is_on_floor():
        anim.play("jump")
    elif velocity.length() > 0.1:
        anim.play("walk")
    else:
        anim.play("idle")

O play() do AnimationPlayer já ignora a chamada se a animação pedida é a que está tocando, então esse código não reinicia o "walk" a cada frame. Para transições suaves entre animações, o passo seguinte é um AnimationTree com state machine, mas isso é assunto para outro artigo.

Um ajuste que quase ninguém conhece: animações que devem repetir (idle, walk, run) precisam de loop, e o glTF não carrega essa informação. No Blender, adicione -loop ao final do nome da Action (walk-loop) e o Godot ativa o loop automaticamente no import. A alternativa é marcar na aba Import do editor, animação por animação.

Blend entre animações com AnimationTree

Trocar de animação com anim.play("walk") funciona, mas o corte é seco: a perna some de uma pose e aparece na outra. Pra caminhada virar corrida sem solavanco, o próximo nó é o AnimationTree, que mistura duas ou mais animações por peso em vez de cortar entre elas.

O caso mais comum num personagem de jogo é um BlendSpace1D: um eixo de 0 a 1 onde 0 é idle, o meio é walk e o topo é run. Você alimenta esse eixo com a velocidade atual e a engine interpola as três animações sozinha.

extends CharacterBody3D

@onready var tree: AnimationTree = $AnimationTree

@export var run_speed: float = 6.0

func _ready() -> void:
    tree.active = true

func _physics_process(_delta: float) -> void:
    var speed: float = velocity.length()
    # normaliza a velocidade pro eixo 0..1 do BlendSpace
    var blend: float = clampf(speed / run_speed, 0.0, 1.0)
    tree.set("parameters/locomotion/blend_position", blend)

O caminho parameters/locomotion/blend_position é o nome do nó de blend dentro da árvore (aqui chamei de locomotion). Ele aparece no editor do AnimationTree quando você monta o BlendSpace1D. Mudar esse parâmetro por código é o que liga o movimento do personagem à mistura de animação, sem você escrever a interpolação na mão.

Pra ações que não são contínuas, como pular ou atacar, o blend por velocidade não serve: aí você quer uma transição explícita entre estados. Esse é o território da máquina de estados, e o AnimationNodeStateMachine resolve isso dentro da própria árvore. Montar os estados, as transições e as condições é o assunto do guia de AnimationTree e a máquina de animação na Godot, e a mesma lógica aparece no código de movimento quando você organiza o personagem com uma máquina de estados (FSM).

Um detalhe que depende do rigging lá de cima: o blend só fica suave se as animações compartilham o mesmo esqueleto e a mesma pose de referência. Rig com bones nomeados de forma diferente entre dois modelos não mistura, e é por isso que padronizar nome de bone e T-pose desde o começo paga tão bem na hora de animar.

Os erros que mais aparecem (e a causa real)

• Personagem deitado ou rotacionado 90 graus: rotação não aplicada na armature, ou confusão de eixo up entre ferramentas. Ctrl+A antes de exportar.
• Malha esticando como chiclete ao animar: vértices com peso em bone errado, ou vértices órfãos sem peso nenhum sendo arrastados pelo peso default.
• Deformação diferente entre Blender e engine: mais de 4 influências por vértice. Limit Total resolve.
• Animação anda no Blender mas desliza na engine: o deslocamento está no bone errado. Movimento de raiz vai no bone root; se está nos hips, a engine não sabe extrair.
• Animações sumindo no export: Actions não empurradas para a NLA, ou órfãs sem usuário que o Blender descartou ao salvar. O botão de escudo (fake user) no Action Editor protege contra isso.

Fechando

Rigging recompensa método, não talento. Esqueleto com juntas no lugar certo e nomes espelhados, automatic weights como ponto de partida, weight paint manual nas quatro regiões problemáticas, Limit Total em 4, transformações aplicadas, Actions na NLA. Cada passo é simples; o que derruba as pessoas é pular um deles e debugar o sintoma três etapas depois.

Meu conselho prático: não comece pelo seu personagem principal. Pegue uma malha simples, um boneco low poly de cilindros, e rigue ele do zero até estar andando dentro da engine. O ciclo completo em pequeno ensina mais que dez tutoriais, e quando você for rigar o personagem de verdade, os erros de export já vão ser velhos conhecidos.