Avaliando animações em um arquivo GLB ou GLTF permite inspecionar como objetos 3D se movem, giram e escalam ao longo do tempo sem renderizar a cena. Você pode usar essa abordagem para analisar dados de animação, verificar movimentos ou exportar transformações para processamento adicional. Neste tutorial, você carregará um modelo GLB animado, inspecionará seus clipes, avaliará cinco marcadores de tempo e exportará as transformações dos nós para CSV.

Carregar e avaliar animações GLB em Python

Um clipe de animação contém dados de animação associados a uma cena. Seus tempos de início e fim definem o período que você pode avaliar. O fluxo de trabalho consiste em carregar um modelo, selecionar um clipe de animação, aplicá‑lo em momentos específicos, inspecionar os nós da cena e exportar suas transformações.

Instalar Aspose.3D for Python via .NET

Instale Aspose.3D for Python via .NET, que fornece a API de avaliação de animação usada aqui:

pip install aspose-3d==26.10.0

Consulte a documentação de instalação para mais detalhes.

Avaliar animação e exportar transformações de nós

O exemplo de código a seguir avalia o primeiro clipe de animação em cinco timestamps distribuídos uniformemente e salva a translação, rotação e escala locais de cada nó em animation_transforms.csv.

import csv
import aspose.threed as a3d

INPUT_FILE = "animated_model.glb"
OUTPUT_FILE = "animation_transforms.csv"
FRAME_COUNT = 5

def get_nodes(root):
    """Recursively collect all nodes in the scene."""
    nodes = [root]

for child in root.child_nodes:
        nodes.extend(get_nodes(child))

return nodes

# Load the animated model
scene = a3d.Scene.from_file(INPUT_FILE)

# Retrieve animation clips
clips = list(scene.animation_clips)

if not clips:
    raise RuntimeError("No animation clips found.")

print(f"Found {len(clips)} animation clip(s).")

for i, item in enumerate(clips):
    print(
        f"{i}: {item.name} "
        f"({item.start:.3f} to {item.stop:.3f} seconds)"
    )

# Select the first clip and collect scene nodes
clip = clips[0]
nodes = get_nodes(scene.root_node)

print(f"\nEvaluating: {clip.name}")
print(f"Scene nodes: {len(nodes)}")

records = []

for i in range(FRAME_COUNT):
    time = float(
        clip.start +
        (clip.stop - clip.start) * i / (FRAME_COUNT - 1)
    )

# Apply animation at the requested time
    clip.apply_to(time)

print(f"\nTimestamp: {time:.3f}s")

for index, node in enumerate(nodes):
        transform = node.transform

translation = str(transform.translation)
        rotation = str(transform.rotation)
        scaling = str(transform.scaling)

records.append([
            time,
            index,
            node.name or "(unnamed)",
            translation,
            rotation,
            scaling
        ])

print(
            f"  {node.name or '(unnamed)'}: "
            f"position={translation}, "
            f"rotation={rotation}"
        )

# Write evaluated transformations to CSV
with open(
    OUTPUT_FILE, "w", newline="", encoding="utf-8"
) as file:
    writer = csv.writer(file)

writer.writerow([
        "Time",
        "Node Index",
        "Node Name",
        "Translation",
        "Rotation",
        "Scaling"
    ])

writer.writerows(records)

print(f"\nSaved animation data to {OUTPUT_FILE}")

Como funciona a avaliação de animação

Carregue a cena GLB e recupere seus clipes

Scene.from_file() carrega o modelo GLB ou GLTF. A coleção scene.animation_clips fornece os clipes disponíveis:

scene = a3d.Scene.from_file("animated_model.glb")
clips = list(scene.animation_clips)

Cada clipe expõe um nome e um intervalo de tempo em segundos através de name, start e stop. Veja a referência da API AnimationClip.

Aplicar a animação em marcos de tempo específicos

A operação central é clip.apply_to(time). Para o clipe de exemplo, cuja duração é aproximadamente 3.708 segundos, os cinco timestamps são:

AmostraTempo (segundos)
10.000
20.927
31.854
42.781
53.708

Você pode alterar FRAME_COUNT para coletar mais amostras. Essas amostras são estados de animação avaliados, não quadros de imagem renderizados.

Ler translação, rotação e escala

Depois de aplicar o recorte, o script percorre todos os nós da cena e lê:

  • transform.translation: a posição local do nó.
  • transform.rotation: a rotação local do nó.
  • transform.scaling: a escala local do nó.

Estas são transformações locais, não necessariamente coordenadas no espaço mundial. As transformações do nó pai também afetam a posição final de um nó na cena. Nós sem animação podem manter os mesmos valores em cada marca de tempo.

Saída CSV da animação

O script cria animation_transforms.csv. Para o exemplo fornecido, o console começa com:

Found 1 animation clip(s).
0: Animation_1 (0.000 to 3.708 seconds)

Evaluating: Animation_1

O CSV contém uma linha por nó de cena em cada timestamp amostrado e estas colunas:

ColunaDescrição
TempoCarimbo de tempo de avaliação em segundos
Índice do NóÍndice do nó na travessia recursiva
Nome do NóNome do nó da cena
TranslaçãoPosição local no carimbo de tempo
RotaçãoRotação local no carimbo de tempo
EscalaEscala local no carimbo de tempo

Você pode abrir o CSV em um aplicativo de planilha ou analisá‑lo com Python para comparar as transformações ao longo do clipe.

O que verificar ao avaliar animações

Múltiplos clipes. Este exemplo avalia clips[0]. Para avaliar outra animação, escolha um índice diferente ou recupere um clipe pelo nome usando scene.get_animation_clip(name).

Resolução de amostragem. Cinco marcadores de tempo fornecem uma visão geral básica, mas podem perder movimentos rápidos. Aumente FRAME_COUNT ou escolha horários específicos para inspecionar mais detalhes.

Esqueletos e alvos de morph. Nem todos os efeitos de animação aparecem como alterações na translação, rotação ou escala local de um nó. Este fluxo de trabalho CSV não captura todos os tipos de deformação esquelética ou de morph-target.

Dependências GLTF. Arquivos .gltf baseados em texto podem referenciar buffers e texturas externas. Mantenha esses arquivos nos caminhos relativos esperados.

Avaliar animações GLB requer uma GPU?

Este exemplo não invoca Scene.render() ou o backend de renderização Vulkan. Ele avalia propriedades de animação e grava dados CSV em vez de gerar imagens. A renderização do Aspose.3D tem requisitos de hardware separados, que não se aplicam ao fluxo de trabalho apenas CSV deste exemplo.

Obtenha uma Licença Temporária Gratuita

Você pode solicitar uma licença temporária gratuita de 30 dias para avaliar o Aspose.3D for Python via .NET sem limitações de avaliação. Para aplicar a licença em sua aplicação Python, siga o guia de licenciamento do Aspose.3D.

Recursos de Aprendizagem Gratuitos

Explore os recursos a seguir para aprender mais sobre como trabalhar com modelos 3D, animações e formatos de arquivo suportados usando Aspose.3D for Python via .NET:

Conclusão

Aspose.3D for Python via .NET 26.10 permite que você avalie clipes de animação GLB e GLTF em tempos selecionados com AnimationClip.apply_to(). Ao ler as transformações dos nós após cada avaliação, você pode inspecionar o movimento e exportar dados de animação estruturados sem renderizar o modelo. Adapte o exemplo para avaliar clipes adicionais, aumentar a frequência de amostragem ou analisar nós selecionados.

Leia Mais