Visão geral da ativação de animações no seu app

Como configurar o build

A configuração do build para ativar a animação no app envolve a modificação do arquivo build.gradle e a importação de animações para seu projeto.

  1. Atualize o build.gradle do app's para oferecer compatibilidade com um modelo de animação importado importado, adicionando a dependência da animação Sceneform:

     dependencies {
     …
     // Support for animated model renderables.
     implementation "com.google.ar.sceneform:animation:1.15.0"
     }

  2. Importe e visualize seus arquivos de animação *.fbx para acessar um arquivo *.sfb que contém o modelo importado.

Como usar animações no momento da execução

Use as operações de ambiente de execução para:

Como criar uma animação que pode ser renderizada

No momento da execução, use ModelRenderable.Builder para carregar o *.sfb e anexe-o a um nó na cena, como você faria com qualquer ModelRenderable:

  // Create the ModelRenderable.
  ModelRenderable.builder()
      .setSource(this, R.raw.andy)
      .build()
      .thenAccept(renderable -> andyRenderable = renderable)
      .exceptionally(
          throwable -> {
          Log.e(TAG, "Unable to load Renderable.", throwable);
          return null;
      });

  // Attach the ModelRenderable to the node in the scene.
  Node andyNode = new Node();
  andyNode.setParent(arFragment.getArSceneView().getScene());
  andyNode.setRenderable(andyRenderable);

Tenha acesso aos dados da animação

// Get the animation data called "andy_dance" from the `andyRenderable`.
AnimationData danceData = andyRenderable.getAnimationData("andy_dance");

Como acessar animações com base em metadados diferentes

     // Get the animation name.
     danceData.getName();

Para recuperar uma instância de dados de animação, use os métodos ModelRenderable.getAnimationData():

     // Access animations by index.
     numAnimations = andyRenderable.getAnimationDataCount();
     danceData = andyRenderable.getAnimationData(0);

Controlar a reprodução

Crie um ModelAnimator para controlar a reprodução.

ModelAnimator andyAnimator = new ModelAnimator(danceData, andyRenderable);

Use start() para reproduzir a animação. Ele será interrompido automaticamente no final.

andyAnimator.start();

Para repetir a animação, use setRepeatCount()

andyAnimator.setRepeatCount(<number of repeats>)

(Opcional) Adicionar operações de animação de propriedade

O ModelAnimator estende a classe Animator do Android, o que permite interações mais avançadas, como looping, resposta a eventos e interpoladores não lineares.

Como usar SkeletonNode para identificar e anexar modelos a ossos

Ao trabalhar com uma renderização contendo ossos, use a classe SkeletonNode para ter acesso a ossos individuais no esqueleto anexando nós aos ossos. Isso permite “anexar” objetos a ossos ou controlar a posição deles.

Enquanto a animação está em exibição, a posição, a escala e a orientação do nó anexado são atualizadas pelo SkeletonNode a cada frame. Definir a posição, a escala ou a rotação do nó anexado modificará o osso até a próxima vez que o osso for atualizado pela animação.

No exemplo de Animação, isso é feito anexando um Node que contém um modelo de um chapéu ao osso da "cabeça" de Andy. Quando Andy é animado, o chapéu permanece na cabeça dele.

Como acessar informações sobre ossos

Para acessar informações sobre ossos em um ModelRenderable, use os métodos getBoneCount(), getBoneName() ou getBoneParent():

// Get the number of bones in the model’s skeleton.
andyRenderable.getBoneCount();

// Get the names of the bones in the model’s skeleton.
andyRenderable.getBoneName();

// Get the hierarchy of the bones in the model’s skeleton.
andyRenderable.getBoneParent();

Como trabalhar com SkeletonNode

A classe SkeletonNode expõe o esqueleto de um modelo para anexar nós a ossos específicos.

Para usar SkeletonNode, crie uma nova instanciação dele e defina o renderizável para o renderable que contenha um modelo com um esqueleto.

 andyWithSkeleton = new SkeletonNode();
 andyWithSkeleton.setRenderable(andyRenderable);
 andyWithSkeleton.setParent(scene);

Para anexar um elemento de renderização a um osso específico, primeiro crie um novo nó e anexe-o ao osso. Adicione o nó que contém o elemento de renderização como um filho do primeiro nó. Para garantir que a escala e a rotação do osso não sejam usadas para definir a transformação relativa dos nós, certifique-se de redefinir a escala e a posição do segundo nó.

 hatNode = new Node();
 Node boneNode = new Node();
 boneNode.setParent(andy);
 andy.setBoneAttachment(HAT_BONE_NAME, boneNode);
 hatNode.setRenderable(hatRenderable);
 hatNode.setParent(boneNode);
 hatNode.setWorldScale(Vector3.one());
 hatNode.setWorldRotation(Quaternion.identity());
 Vector3 pos = hatNode.getWorldPosition();