Cinemática Inversa (IK) na Godot 4 para 2D

Se voce ja animou um personagem 2D e sofreu para fazer o pe encostar direito num degrau, ou para o braco mirar exatamente onde o mouse aponta, o que faltava era cinemática inversa (IK) na Godot. Em vez de girar cada osso na mao ate a ponta cair no lugar certo, voce declara onde a ponta do membro deve ficar e deixa a matematica calcular as rotacoes. Neste tutorial voce vai entender o que e IK, montar um esqueleto com Skeleton2D e Bone2D, resolver o caso mais util (duas juntas) com trigonometria tipada em GDScript e, por fim, mover um alvo por codigo para o membro seguir sozinho.

O foco aqui e 2D, mas o raciocinio e o mesmo que aparece em rigs mais pesados. Se depois voce quiser levar isso para tres dimensoes, vale ver como funciona o rigging de personagem 3D, porque a ideia de cadeia de ossos e alvo se repete.

O que e cinemática inversa (IK) na Godot e quando usar

Um membro animado e uma cadeia de ossos ligados. A base fica fixa (o ombro, o quadril) e cada osso seguinte pendura no anterior. Quando voce controla os angulos de cada osso diretamente, isso e cinematica direta, ou FK (Forward Kinematics): voce empurra a rotacao para frente na cadeia e ve onde a ponta para.

Cinematica inversa e o caminho contrario. Voce fornece a posicao desejada da ponta (o alvo, ou target) e o algoritmo resolve, de tras para frente, quais angulos cada osso precisa ter para a ponta encostar ali. Dai o nome inversa.

Na pratica, IK 2D brilha em situacoes assim:

• Pe no chao irregular. O personagem anda por um terreno com degraus e rampas. Em vez de uma animacao unica de caminhada que fura o piso, voce lanca um raycast do quadril para baixo, pega o ponto do chao e usa IK para o pe pousar exatamente ali.
• Mira de braco. Um atirador top-down ou plataforma precisa que o braco (e a arma) apontem para o cursor ou para o inimigo mais proximo. O alvo e a posicao do mouse, e o braco gira para segui-lo em tempo real.
• Mao que agarra um objeto. A mao precisa alcancar uma alavanca, uma borda de plataforma, a maca de um pomar. O objeto e o alvo.

O ponto comum e que o destino muda em tempo real e nao da para pre-animar cada variacao. Ai IK paga o investimento.

FK versus IK na pratica

Vale fixar a diferenca com um exemplo concreto de braco de dois ossos: bracoSuperior (do ombro ao cotovelo) e antebraco (do cotovelo a mao).

Com FK, para a mao chegar num ponto voce ajustaria na tentativa e erro: gira o ombro uns 30 graus, o cotovelo uns 40, testa, corrige. Funciona para poses fixas de animacao, mas e insuportavel se o alvo se move.

Com IK, voce passa a posicao da mao desejada e recebe os dois angulos prontos. O ombro aponta na direcao geral do alvo (com uma correcao), e o cotovelo dobra o tanto exato para o comprimento fechar. Quanto mais longe o alvo, mais o braco estica; quando o alvo esta perto, o cotovelo dobra mais.

Os dois nao sao rivais. O comum e animar o corpo em FK (a caminhada, o tronco) e aplicar IK so nos membros que precisam grudar em algo do mundo.

Montando o Skeleton2D com Bone2D

O esqueleto 2D da Godot 4 usa dois nos: Skeleton2D, que e o controlador da cadeia, e Bone2D, cada osso individual. Os Bone2D entram como filhos encadeados dentro do Skeleton2D.

Monte assim na cena, para o exemplo do braco:

Skeleton2D
└── BoneOmbro (Bone2D)
    └── BoneCotovelo (Bone2D)
        └── BonePonta (Bone2D)

Alguns detalhes que economizam dor de cabeca:

• Cada Bone2D tem uma propriedade Length (comprimento) e um Bone Angle, ajustaveis no inspetor. O comprimento define ate onde o osso vai; o proximo osso deve comecar na ponta do anterior.
• Posicione BoneOmbro no ombro, BoneCotovelo na distancia do comprimento do braco superior, e BonePonta como marcador da mao.
• Depois de posicionar, use o botao de esqueleto na barra de ferramentas do editor (o icone que aparece com o Skeleton2D selecionado) e escolha Set Rest Pose para gravar essa pose como a pose de descanso. E dela que os calculos partem.

Para o membro deformar um sprite de verdade voce usaria um Polygon2D com pesos de osso, mas para aprender IK nao precisamos disso ainda. Vamos primeiro fazer os ossos girarem certo; a arte segue os ossos depois.

Crie tambem um Marker2D na cena, fora do esqueleto, chamado Alvo. Ele e o ponto que a ponta do membro vai perseguir.

Resolvendo o IK de duas juntas com trigonometria

Aqui esta a parte de verdade. Duas juntas (two bone IK) e o caso mais usado porque cobre braco e perna humanoides, e tem solucao fechada: da para calcular os dois angulos direto, sem iteracao, usando a lei dos cossenos.

A ideia geometrica: voce tem dois comprimentos fixos, l1 (osso de cima) e l2 (osso de baixo). O alvo esta a uma distancia d da base. Isso forma um triangulo com lados l1, l2 e d. A lei dos cossenos da o angulo interno de cada vertice do triangulo. Com esses angulos mais o atan2 (que aponta a base para o alvo), voce monta a rotacao final de cada osso.

Coloque este script num Node2D raiz da cena que tenha acesso ao esqueleto e ao alvo:

extends Node2D

@onready var bone_ombro: Bone2D = $Skeleton2D/BoneOmbro
@onready var bone_cotovelo: Bone2D = $Skeleton2D/BoneOmbro/BoneCotovelo
@onready var alvo: Marker2D = $Alvo

# Comprimentos dos dois ossos, em pixels.
# Use o mesmo valor que voce definiu no Length de cada Bone2D.
var l1: float = 80.0
var l2: float = 70.0

# Dobra do cotovelo: 1.0 dobra para um lado, -1.0 para o outro.
var lado: float = 1.0

func _process(_delta: float) -> void:
    resolver_ik(alvo.global_position)

func resolver_ik(destino: Vector2) -> void:
    # Vetor da base (ombro) ate o alvo, em coordenadas globais.
    var base: Vector2 = bone_ombro.global_position
    var para_alvo: Vector2 = destino - base
    var d: float = para_alvo.length()

    # Impede que o alvo fique alem do alcance do braco esticado
    # ou dentro de uma distancia impossivel de fechar.
    d = clampf(d, absf(l1 - l2) + 0.001, l1 + l2 - 0.001)

    # Angulo da base ate o alvo no espaco global.
    var ang_para_alvo: float = para_alvo.angle()

    # Lei dos cossenos para o angulo no ombro (entre l1 e a linha ate o alvo).
    var cos_ombro: float = (l1 * l1 + d * d - l2 * l2) / (2.0 * l1 * d)
    var ang_ombro: float = acos(clampf(cos_ombro, -1.0, 1.0))

    # Lei dos cossenos para o angulo interno no cotovelo (entre l1 e l2).
    var cos_cotovelo: float = (l1 * l1 + l2 * l2 - d * d) / (2.0 * l1 * l2)
    var ang_cotovelo: float = acos(clampf(cos_cotovelo, -1.0, 1.0))

    # Rotacao global do osso de cima: aponta para o alvo e abre o angulo do ombro.
    var rot_ombro: float = ang_para_alvo - ang_ombro * lado

    # O osso de baixo dobra em relacao ao de cima. PI e o braco esticado (180 graus);
    # quanto menor o angulo interno, mais o cotovelo fecha.
    var rot_cotovelo: float = (PI - ang_cotovelo) * lado

    # global_rotation posiciona o osso de cima no mundo.
    bone_ombro.global_rotation = rot_ombro
    # O cotovelo e filho: sua rotation e relativa ao pai, entao aplicamos o incremento.
    bone_cotovelo.rotation = rot_cotovelo

O que cada bloco faz, em portugues claro:

1. para_alvo e o vetor que vai do ombro ate o alvo. Seu comprimento d e a distancia que o triangulo precisa fechar.
2. O clampf no d evita dois casos que quebram a lei dos cossenos: alvo longe demais (braco nao alcanca, d maior que l1 + l2) e alvo perto demais. Prender d mantem o argumento do acos dentro de -1 a 1.
3. acos devolve o angulo cujo cosseno voce passou. Ainda assim colocamos outro clampf dentro do acos por seguranca contra erro de ponto flutuante.
4. atan2 esta escondido dentro de para_alvo.angle(), que ja calcula o angulo do vetor. E ele que faz a base apontar para o alvo antes de aplicar a abertura do triangulo.
5. lado inverte a dobra do cotovelo. Se o joelho ou cotovelo estiver dobrando para o lado errado, troque 1.0 por -1.0.

Esse codigo e 100% real e roda em qualquer Godot 4, porque so depende de trigonometria e das propriedades global_rotation e rotation do Bone2D. Nada de metodo magico de engine.

Movendo o alvo por codigo para o membro seguir

Ate agora o alvo e um Marker2D parado. A graca da IK aparece quando esse alvo se mexe. Dois cenarios rapidos.

Braco mirando o mouse. Basta grudar o alvo na posicao do cursor a cada frame:

func _process(_delta: float) -> void:
    alvo.global_position = get_global_mouse_position()
    resolver_ik(alvo.global_position)

Agora o braco aponta para onde voce mover o mouse, esticando quando o cursor esta longe e dobrando o cotovelo quando esta perto.

Pe grudando no chao irregular. Lance um raycast do quadril para baixo, pegue o ponto de colisao e mande o alvo (o pe) para la:

@onready var raio_chao: RayCast2D = $Skeleton2D/BoneQuadril/RayCastChao

func _process(_delta: float) -> void:
    if raio_chao.is_colliding():
        var ponto_chao: Vector2 = raio_chao.get_collision_point()
        alvo.global_position = ponto_chao
    resolver_ik(alvo.global_position)

Com o raycast configurado para bater no piso, o pe pousa na altura real do chao a cada frame, subindo em degraus e descendo em rampas sem furar o cenario. Esse mesmo padrao de "consultar o mundo fisico e reagir" tambem aparece quando voce quer um corpo desmontar de forma natural, o que da para explorar com o ragdoll com PhysicalBone3D.

Uma dica de estabilidade: se o pe tremer ao trocar de altura, suavize o alvo com um lerp em vez de teleportar direto para ponto_chao. Assim a transicao entre alturas fica continua.

A via visual pelos modificadores de esqueleto no editor

Se voce prefere clicar a digitar trigonometria, a Godot 4 tambem oferece nos de modificador de esqueleto direto no editor. Com o Skeleton2D selecionado na arvore da cena, use Add Node (o botao de adicionar filho) e procure pelos nos de modificacao de esqueleto 2D disponiveis na sua versao. Voce adiciona o modificador como filho do esqueleto, aponta ele para a cadeia de ossos e define um no de alvo na cena. O modificador resolve a IK a cada frame por conta propria, e voce so precisa mexer a posicao do alvo.

A vantagem da via visual e nao escrever matematica. A vantagem da via em codigo, que mostramos acima, e o controle total: voce decide o lado da dobra, o clamp de alcance, a suavizacao e pode misturar IK com FK como quiser. Como os nomes exatos desses modificadores mudam entre versoes menores da Godot 4, confie no menu Add Node da sua instalacao para ver o que esta disponivel; a abordagem trigonometrica continua valendo em qualquer versao caso o no nao esteja onde voce espera.

Vale lembrar que tudo aqui foi feito em GDScript. Se voce esta pesando qual linguagem usar no projeto e como isso afeta esse tipo de codigo de calculo por frame, deem uma olhada em C# vs GDScript na Godot para decidir com criterio.

Conclusao e proximo passo

Voce viu o que separa FK de IK, montou um Skeleton2D com Bone2D, resolveu o caso de duas juntas com a lei dos cossenos e o atan2 em GDScript tipado, e fez o membro perseguir um alvo movel para mira e para pe no chao. Esse trio (esqueleto, solver, alvo) e a base de praticamente todo sistema de IK 2D que voce vai encontrar.

O proximo passo natural e amarrar um Polygon2D com pesos de osso ao esqueleto para que a arte deforme junto, e depois combinar a IK do membro com uma animacao de caminhada em FK no AnimationPlayer. Comece pelo braco mirando o mouse, que da feedback imediato, e so entao parta para o pe no terreno, que exige o raycast e a suavizacao. Quando os dois ossos ja seguem o alvo com firmeza, o resto e polimento.