Présentation de l'activation des animations dans votre application

Configurer la compilation

Configurer la compilation pour activer les animations dans votre application implique de modifier le fichier build.gradle et d'importer des animations dans votre projet.

  1. Mettez à jour votre app build.gradle pour qu'il accepte un modèle d'animation importé rendu, en ajoutant la dépendance de l'animation Sceneform:

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

  2. Importez et prévisualisez vos fichiers d'animation *.fbx pour obtenir un fichier *.sfb contenant le modèle importé.

Utiliser des animations au moment de l'exécution

Utilisez les opérations d'exécution pour:

Créer un rendu d'animation

Au moment de l'exécution, utilisez ModelRenderable.Builder pour charger *.sfb et l'associer à un nœud de la scène, comme vous le feriez avec n'importe quelle 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);

Accéder aux données de l'animation

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

Accéder aux animations en fonction de différentes métadonnées

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

Pour récupérer une instance de données d'animation, utilisez les méthodes ModelRenderable.getAnimationData():

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

Contrôler la lecture

Créez un ModelAnimator pour contrôler la lecture.

ModelAnimator andyAnimator = new ModelAnimator(danceData, andyRenderable);

Utilisez start() pour lire l'animation. Elle s'arrêtera automatiquement à la fin.

andyAnimator.start();

Pour lire l'animation en boucle, utilisez setRepeatCount().

andyAnimator.setRepeatCount(<number of repeats>)

(Facultatif) Ajouter des opérations d'animation des propriétés

ModelAnimator étend la classe Animator d'Android, qui permet des interactions plus riches telles que la boucle, la réponse à des événements et les interpolateurs non linéaires.

Utiliser SkeletonNode pour identifier et associer des modèles à des os

Lorsque vous travaillez avec un rendu pouvant contenir des os, utilisez la classe SkeletonNode pour accéder à des os individuels du squelette en associant des nœuds aux os. Cela vous permet d'attacher des objets à des os ou de contrôler leur position.

Pendant la lecture de l'animation, la position, l'échelle et l'orientation du nœud associé sont mises à jour par SkeletonNode à chaque image. Définir la position, l'échelle ou la rotation du nœud associé remplacera l'os jusqu'à la mise à jour suivante de l'os par l'animation.

Dans l'exemple Animation, cela se fait en attachant un Node contenant un modèle de chapeau sur l'os de la "tête" d'Andy. Lorsqu'Andy est animé, le chapeau reste sur sa tête.

Accéder aux informations sur les os

Pour accéder aux informations sur les os d'un objet ModelRenderable, utilisez les méthodes 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();

Utiliser des SkeletonNode

La classe SkeletonNode expose le squelette d'un modèle afin de rattacher les nœuds à des os spécifiques.

Pour utiliser SkeletonNode, créez une instanciation de cet élément et définissez-le sur le rendu qui contient un modèle avec un squelette.

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

Pour associer un rendu à un os spécifique, commencez par créer un nœud et associez-le à l'os. Ajoutez le nœud contenant le rendu en tant qu'enfant du premier nœud. Pour vous assurer que l'échelle et la rotation de l'os ne sont pas utilisées pour définir la transformation relative des nœuds, veillez à réinitialiser l'échelle et la position du deuxième nœud.

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