Animationen in der App aktivieren

Build konfigurieren

Wenn Sie den Build zum Aktivieren der Animation in Ihrer Anwendung konfigurieren, müssen Sie die Datei build.gradle ändern und Animationen in Ihr Projekt importieren.

  1. Aktualisieren Sie die build.gradle Ihrer App so, dass ein importiertes Animationsmodell unterstützt wird, indem Sie die Sceneform-Animationsabhängigkeit hinzufügen:

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

  2. Importieren und zeigen Sie eine Vorschau der *.fbx-Animationsdateien an, um eine *.sfb-Datei mit dem importierten Modell zu erhalten.

Animationen zur Laufzeit verwenden

Mit Laufzeitvorgängen haben Sie folgende Möglichkeiten:

Rendering einer Animation erstellen

Verwenden Sie zur Laufzeit ModelRenderable.Builder, um *.sfb zu laden und an einen Knoten in der Szene anzuhängen, so wie Sie es von jedem ModelRenderable machen würden:

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

Zugriff auf die Animationsdaten

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

Auf Animationen basierend auf verschiedenen Metadaten zugreifen

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

Verwenden Sie die Methoden ModelRenderable.getAnimationData(), um eine Instanz von Animationsdaten abzurufen:

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

Wiedergabe steuern

Erstelle ein ModelAnimator-Element, um die Wiedergabe zu steuern.

ModelAnimator andyAnimator = new ModelAnimator(danceData, andyRenderable);

Verwende start(), um die Animation wiederzugeben. Sie wird am Ende automatisch beendet.

andyAnimator.start();

Wenn Sie die Animation als Schleife wiedergeben möchten, verwenden Sie setRepeatCount()

andyAnimator.setRepeatCount(<number of repeats>)

Optional: Property-Animationsvorgänge hinzufügen

ModelAnimator erweitert die Android-Klasse Animator, die umfangreichere Interaktionen wie Loop, das Beantworten von Ereignissen und nicht lineare Interpolatoren ermöglicht.

Modelle mit SkeletonNode zum Identifizieren und Anhängen von Knochen verwenden

Wenn du mit einem Rendering arbeitest, das Knochen enthält, verwende die Klasse SkeletonNode, um auf einzelne Knochen im Skeleton zuzugreifen, indem du Knoten an die Knochen anhängt. Dadurch kannst du Objekte an Knochen anhängen oder ihre Position steuern.

Während der Animation werden die Position, die Skalierung und die Ausrichtung des angehängten Knotens durch SkeletonNode für jeden Frame aktualisiert. Wenn Sie die Position, Skalierung oder Drehung des angehängten Knotens festlegen, wird der Knochen überschrieben, bis er das nächste Mal durch die Animation aktualisiert wird.

Im Beispiel einer Animation wird dazu ein Node mit einem Hutmodell an den Knochen von Andys Kopf „angebunden“. Wenn Andy animiert ist, bleibt der Hut auf dem Kopf.

Zugriff auf Informationen zu Knochen

Verwenden Sie die Methoden getBoneCount(), getBoneName() oder getBoneParent(), um auf Knochendaten in einem ModelRenderable zuzugreifen:

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

Mit SkeletonNode arbeiten

Die Klasse SkeletonNode macht das Skelett eines Modells sichtbar, um Knoten an bestimmte Knochen anzuhängen.

Wenn Sie SkeletonNode verwenden möchten, erstellen Sie eine neue Instanziierung davon und legen Sie das Renderable auf das Rendering fest, das ein Modell mit einem Skelett enthält.

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

Erstellen Sie zuerst einen neuen Knoten und hängen Sie ihn an diesen an. Fügen Sie den Knoten mit dem gerenderten Element als untergeordnetes Element des ersten Knotens hinzu. Damit der Maßstab und die Drehung des Knochens nicht zum Festlegen der relativen Transformation der Knoten verwendet werden, müssen Sie die Skalierung und Position des zweiten Knotens zurücksetzen.

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