Um modelo animado GLB ou GLTF armazena geometria e dados de animação em vez de uma pasta de imagens prontas. Para criar miniaturas ou uma sequência de quadros, você precisa avaliar a animação do modelo em timestamps específicos e renderizar cada cena resultante em uma imagem. Este tutorial explica como renderizar quadros de animação GLB em Python usando Aspose.3D for Python via .NET. Você carregará um modelo animado, selecionará um clipe, amostrará sua linha do tempo e salvará cada quadro como uma imagem PNG numerada. Você pode usar as imagens resultantes como pré‑visualizações do modelo ou como entrada para um fluxo de trabalho separado de sequência de imagens.

Instalar Aspose.3D for Python via .NET

Instale o pacote usando pip:

pip install aspose-3d

Você também precisará:

  • Um arquivo .glb animado ou um arquivo .gltf com seus buffers e texturas acompanhantes.
  • Um ambiente de renderização compatível com os requisitos de hardware do Aspose.3D. Veja os requisitos do sistema.
  • Uma posição de câmera que mantenha o objeto animado visível ao longo da linha do tempo amostrada.

Renderizar um clipe de animação como quadros PNG

Salve o código a seguir como render_glb_animation_frames.py e execute‑o a partir da pasta que contém animated_model.glb.

import hashlib
import math
from pathlib import Path

import aspose.threed as a3d
from aspose.pydrawing import Color, Size
from aspose.pydrawing.imaging import ImageFormat
from aspose.threed.entities import Camera
from aspose.threed.utilities import Vector3

INPUT_FILE = Path("animated_model.glb")
OUTPUT_DIR = Path("frames")
FRAMES_PER_SECOND = 5
IMAGE_WIDTH = 800
IMAGE_HEIGHT = 600

def main():
    if not INPUT_FILE.is_file():
        raise FileNotFoundError(f"Input model not found: {INPUT_FILE}")

scene = a3d.Scene.from_file(str(INPUT_FILE))
    clips = list(scene.animation_clips)
    if not clips:
        raise RuntimeError("The input model has no animation clips.")

clip = clips[0]
    duration = float(clip.stop - clip.start)
    if duration <= 0:
        raise ValueError("The selected animation has no positive time range.")

# Use the same camera position for every frame.
    camera = Camera()
    camera_node = scene.root_node.create_child_node("PreviewCamera", camera)
    camera_node.transform.translation = Vector3(3, 2, 6)
    camera.look_at = Vector3.ORIGIN

options = a3d.ImageRenderOptions()
    options.background_color = Color.white
    options.asset_directories.append(str(INPUT_FILE.resolve().parent))

OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    frame_count = max(1, math.ceil(duration * FRAMES_PER_SECOND))
    hashes = set()

for frame_index in range(frame_count):
        timestamp = float(clip.start) + frame_index / FRAMES_PER_SECOND
        clip.apply_to(timestamp)

frame_path = OUTPUT_DIR / f"frame_{frame_index:04d}.png"
        scene.render(
            camera,
            str(frame_path),
            Size(IMAGE_WIDTH, IMAGE_HEIGHT),
            ImageFormat.png,
            options,
        )

if not frame_path.is_file() or frame_path.stat().st_size == 0:
            raise RuntimeError(f"Rendering did not create a usable PNG: {frame_path}")

hashes.add(hashlib.sha256(frame_path.read_bytes()).digest())
        print(f"Frame {frame_index + 1}/{frame_count}: {frame_path} at {timestamp:.3f}s")

if frame_count > 1 and len(hashes) == 1:
        print("WARNING: All PNG files are byte-identical. Check animation state and camera view.")

print(f"Created {frame_count} PNG file(s) in {OUTPUT_DIR}/")

if __name__ == "__main__":
    main()

Execute com:

python render_glb_animation_frames.py

Saída esperada: um diretório frames contendo imagens como frame_0000.png, frame_0001.png e frame_0002.png. Quando o renderizador captura corretamente os estados de animação aplicados, as imagens mostram o modelo em pontos sucessivos de sua animação.

Como o código de renderização de quadros funciona

Carregue a cena e selecione um clipe de animação

O método Scene.from_file() abre o modelo, enquanto scene.animation_clips fornece acesso aos clipes de animação que ele contém. O exemplo usa o primeiro clipe e lê suas propriedades start e stop para determinar o intervalo de tempo. Um modelo sem clipes de animação não pode gerar uma sequência animada por este método.

Para mais detalhes sobre seleção de clipes e transformações de nós, veja Carregar e Avaliar Animações GLB/GLTF em Python.

Amostre a linha do tempo em intervalos regulares

O script usa cinco amostras por segundo. Se o clipe durar dois segundos, ele solicita dez frames nos timestamps de 0.0 a 1.8 segundos quando o clipe começa em zero. Excluir o ponto final exato evita gerar um frame final redundante para animações que retornam à pose inicial.

O método clip.apply_to(timestamp) aplica o clipe de animação selecionado em cada timestamp. Ao contrário de avaliar uma única sequência de quadros‑chave, esta etapa tem como objetivo atualizar a cena animada antes que a imagem seja renderizada.

Renderizar a cena atualizada a partir de uma câmera

O exemplo adiciona uma câmera em uma posição fixa e chama scene.render() para cada quadro. Ele também define um tamanho de imagem de 800 × 600 pixels e um formato de saída PNG. Manter a câmera fixa facilita a inspeção das diferenças quadro a quadro.

O guia de renderização de cena do Aspose.3D mostra como salvar uma visualização 3D como uma imagem. Para sequências de animação, verifique se cada imagem reflete o timestamp pretendido. Se quadros sucessivos exibirem a mesma pose, verifique se o caminho de renderização está usando o estado animado atual.

Nomeie cada quadro PNG de forma consistente

O padrão frame_0000.png mantém as imagens em ordem quando classificadas pelo nome do arquivo. É adequado para gerar miniaturas de visualização ou passar a saída para uma sequência de imagens ou fluxo de trabalho de vídeo separado. O script não cria um vídeo nem um GIF animado.

O script também compara hashes de arquivos para avisar quando todos os arquivos de saída são byte‑idênticos. Hashes diferentes não provam, por si só, que a animação foi renderizada corretamente; inspecione quadros representativos lado a lado.

Obtenha uma Licença Temporária Gratuita

Você pode solicitar uma licença temporária gratuita de 30 dias para renderizar quadros de animação GLB e GLTF usando 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 o carregamento de modelos 3D animados, o trabalho com clipes de animação e a renderização de cenas 3D usando Aspose.3D for Python via .NET:

Conclusão

Você pode gerar imagens de quadros amostrando uma linha do tempo de animação e renderizando a cena em cada timestamp selecionado. Use os PNGs numerados para criar miniaturas, comparar poses ou preparar uma sequência de imagens para outra ferramenta. Se precisar de valores numéricos de animação em vez de imagens, consulte o tutorial de avaliação de keyframe. Para problemas de renderização, visite o forum de suporte do Aspose.3D.