Descripción general de la habilitación de animaciones en tu app

Configura la compilación

Configurar la compilación para habilitar la animación en tu app implica modificar el archivo build.gradle y, luego, importar animaciones a tu proyecto.

  1. Actualiza la build.gradle de tu app para admitir un modelo de animación importado que se pueda renderizar. Para ello, agrega la dependencia de animación de Sceneform:

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

  2. Importa y obtén una vista previa de tus archivos de animación *.fbx para obtener un archivo *.sfb que contenga el modelo importado.

Cómo usar animaciones durante el tiempo de ejecución

Usa las operaciones del entorno de ejecución para lo siguiente:

Cómo crear una animación que se pueda renderizar

En el entorno de ejecución, usa ModelRenderable.Builder para cargar *.sfb y adjuntarlo a un nodo de la escena, como lo harías con cualquier 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);

Obtén acceso a los datos de la animación

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

Cómo acceder a animaciones basadas en diferentes metadatos

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

Para recuperar una instancia de datos de animación, usa los métodos ModelRenderable.getAnimationData():

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

Cómo controlar la reproducción

Crea un ModelAnimator para controlar la reproducción.

ModelAnimator andyAnimator = new ModelAnimator(danceData, andyRenderable);

Usa start() para reproducir la animación. Se detendrá automáticamente al final.

andyAnimator.start();

Para repetir indefinidamente la animación, usa setRepeatCount().

andyAnimator.setRepeatCount(<number of repeats>)

(Opcional) Agrega operaciones de animación de propiedades

El ModelAnimator extiende la clase Animator de Android, lo que permite interacciones más enriquecidas, como bucles, que responden a eventos e interpoladores no lineales.

Uso de SkeletonNode para identificar y adjuntar modelos a los huesos

Cuando trabajes con un renderizado que contenga huesos, conecta los nodos a la clase SkeletonNode para acceder a huesos individuales del esqueleto. Esto te permite "adjuntar" objetos a los huesos o controlar su posición.

Mientras se reproduce la animación, SkeletonNode actualiza cada fotograma a la posición, la escala y la orientación del nodo adjunto. Establecer la posición, la escala o la rotación del nodo conectado anulará el hueso hasta la próxima vez que la animación lo actualice.

En la muestra de Animación, esto se hace adjuntando un Node que contiene un modelo de un sombrero al hueso de la "cabeza" de Andy. Cuando Andy está animado, el sombrero permanece en su cabeza.

Acceso a información sobre los huesos

Para acceder a la información sobre los huesos en un ModelRenderable, usa los métodos getBoneCount(), getBoneName() o 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();

Trabaja con SkeletonNode

La clase SkeletonNode expone el esqueleto de un modelo para adjuntar nodos a huesos específicos.

Para usar SkeletonNode, crea una instancia nueva y configura el que se puede procesar en el que contiene un modelo con un esqueleto.

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

Para adjuntar un renderizado a un hueso específico, primero crea un nodo nuevo y adjúntalo al hueso. Agrega el nodo que contiene la renderización como elemento secundario del primer nodo. A fin de garantizar que no se utilicen la escala y la rotación del hueso para establecer la transformación relativa de los nodos, asegúrate de restablecer la escala y la posición del segundo nodo.

 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();