Return animation groups when calling SceneLoader.ImportMesh

Viewer/src/model/modelLoader.ts

@@ -43,7 +43,7 @@ export class ModelLoader {
         let base = modelConfiguration.root || Tools.GetFolderPath(modelConfiguration.url);
         let plugin = modelConfiguration.loader;
 
-        model.loader = SceneLoader.ImportMesh(undefined, base, filename, this._viewer.scene, (meshes, particleSystems, skeletons) => {
+        model.loader = SceneLoader.ImportMesh(undefined, base, filename, this._viewer.scene, (meshes, particleSystems, skeletons, animationGroups) => {
             meshes.forEach(mesh => {
                 Tags.AddTagsTo(mesh, "viewerMesh");
             });
@@ -51,6 +51,10 @@ export class ModelLoader {
             model.particleSystems = particleSystems;
             model.skeletons = skeletons;
 
+            for (const animationGroup of animationGroups) {
+                model.addAnimationGroup(animationGroup);
+            }
+
             model.initAnimations();
             model.onLoadedObservable.notifyObserversWithPromise(model);
         }, (progressEvent) => {
@@ -63,10 +67,7 @@ export class ModelLoader {
 
         if (model.loader.name === "gltf") {
             let gltfLoader = (<GLTFFileLoader>model.loader);
-            gltfLoader.animationStartMode = 0;
-            gltfLoader.onAnimationGroupLoaded = ag => {
-                model.addAnimationGroup(ag);
-            }
+            gltfLoader.animationStartMode = BABYLON.GLTFLoaderAnimationStartMode.NONE;
         }
 
         model.loadId = this._loadId++;

loaders/src/glTF/1.0/babylon.glTFLoader.ts

@@ -1573,7 +1573,6 @@ module BABYLON.GLTF1 {
         public onMeshLoadedObservable = new Observable<AbstractMesh>();
         public onTextureLoadedObservable = new Observable<BaseTexture>();
         public onMaterialLoadedObservable = new Observable<Material>();
-        public onAnimationGroupLoadedObservable = new Observable<AnimationGroup>();
         public onCompleteObservable = new Observable<IGLTFLoader>();
         public onExtensionLoadedObservable = new Observable<IGLTFLoaderExtension>();
 
@@ -1582,7 +1581,7 @@ module BABYLON.GLTF1 {
         public dispose(): void {}
         // #endregion
 
-        private _importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress?: (event: SceneLoaderProgressEvent) => void, onError?: (message: string) => void): boolean {
+        private _importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], skeletons: Skeleton[]) => void, onProgress?: (event: SceneLoaderProgressEvent) => void, onError?: (message: string) => void): boolean {
             scene.useRightHandedSystem = true;
 
             GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, gltfRuntime => {
@@ -1632,26 +1631,27 @@ module BABYLON.GLTF1 {
                         postLoad(gltfRuntime);
 
                         if (!GLTFFileLoader.IncrementalLoading && onSuccess) {
-                            onSuccess(meshes, [], skeletons);
+                            onSuccess(meshes, skeletons);
                         }
                     });
                 }, onProgress);
 
                 if (GLTFFileLoader.IncrementalLoading && onSuccess) {
-                    onSuccess(meshes, [], skeletons);
+                    onSuccess(meshes, skeletons);
                 }
             }, onError);
 
             return true;
         }
 
-        public importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[] }> {
+        public importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[], animationGroups: AnimationGroup[] }> {
             return new Promise((resolve, reject) => {
-                this._importMeshAsync(meshesNames, scene, data, rootUrl, (meshes, particleSystems, skeletons) => {
+                this._importMeshAsync(meshesNames, scene, data, rootUrl, (meshes, skeletons) => {
                     resolve({
                         meshes: meshes,
-                        particleSystems: particleSystems,
-                        skeletons: skeletons
+                        particleSystems: [],
+                        skeletons: skeletons,
+                        animationGroups: []
                     });
                 }, onProgress, message => {
                     reject(new Error(message));

loaders/src/glTF/2.0/babylon.glTFLoader.ts

@@ -60,7 +60,6 @@ module BABYLON.GLTF2 {
         public readonly onMeshLoadedObservable = new Observable<AbstractMesh>();
         public readonly onTextureLoadedObservable = new Observable<BaseTexture>();
         public readonly onMaterialLoadedObservable = new Observable<Material>();
-        public readonly onAnimationGroupLoadedObservable = new Observable<AnimationGroup>();
         public readonly onExtensionLoadedObservable = new Observable<IGLTFLoaderExtension>();
         public readonly onCompleteObservable = new Observable<IGLTFLoader>();
 
@@ -81,7 +80,7 @@ module BABYLON.GLTF2 {
             this._clear();
         }
 
-        public importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[] }> {
+        public importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[], animationGroups: AnimationGroup[] }> {
             return Promise.resolve().then(() => {
                 let nodes: Nullable<Array<ILoaderNode>> = null;
 
@@ -111,6 +110,7 @@ module BABYLON.GLTF2 {
                         meshes: this._getMeshes(),
                         particleSystems: [],
                         skeletons: this._getSkeletons(),
+                        animationGroups: this._getAnimationGroups()
                     };
                 });
             });
@@ -363,25 +363,38 @@ module BABYLON.GLTF2 {
             return skeletons;
         }
 
-        private _startAnimations(): void {
+        private _getAnimationGroups(): AnimationGroup[] {
+            const animationGroups = new Array<AnimationGroup>();
+
             const animations = this._gltf.animations;
-            if (!animations) {
-                return;
+            if (animations) {
+                for (const animation of animations) {
+                    if (animation._babylonAnimationGroup) {
+                        animationGroups.push(animation._babylonAnimationGroup);
+                    }
+                }
             }
 
+            return animationGroups;
+        }
+
+        private _startAnimations(): void {
             switch (this.animationStartMode) {
                 case GLTFLoaderAnimationStartMode.NONE: {
                     // do nothing
                     break;
                 }
                 case GLTFLoaderAnimationStartMode.FIRST: {
-                    const animation = animations[0];
-                    animation._babylonAnimationGroup!.start(true);
+                    const babylonAnimationGroups = this._getAnimationGroups();
+                    if (babylonAnimationGroups.length !== 0) {
+                        babylonAnimationGroups[0].start(true);
+                    }
                     break;
                 }
                 case GLTFLoaderAnimationStartMode.ALL: {
-                    for (const animation of animations) {
-                        animation._babylonAnimationGroup!.start(true);
+                    const babylonAnimationGroups = this._getAnimationGroups();
+                    for (const babylonAnimationGroup of babylonAnimationGroups) {
+                        babylonAnimationGroup.start(true);
                     }
                     break;
                 }
@@ -722,6 +735,8 @@ module BABYLON.GLTF2 {
                     babylonMesh.skeleton = skin._babylonSkeleton!;
                 });
 
+                // Ignore the TRS of skinned nodes.
+                // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
                 node._babylonMesh!.parent = this._rootBabylonMesh;
                 node._babylonMesh!.position = Vector3.Zero();
                 node._babylonMesh!.rotationQuaternion = Quaternion.Identity();
@@ -836,8 +851,6 @@ module BABYLON.GLTF2 {
                 promises.push(this._loadAnimationChannelAsync(`${context}/channels/${channel._index}`, context, animation, channel, babylonAnimationGroup));
             }
 
-            this.onAnimationGroupLoadedObservable.notifyObservers(babylonAnimationGroup);
-
             return Promise.all(promises).then(() => {
                 babylonAnimationGroup.normalize();
             });
@@ -845,7 +858,13 @@ module BABYLON.GLTF2 {
 
         private _loadAnimationChannelAsync(context: string, animationContext: string, animation: ILoaderAnimation, channel: ILoaderAnimationChannel, babylonAnimationGroup: AnimationGroup): Promise<void> {
             const targetNode = GLTFLoader._GetProperty(`${context}/target/node`, this._gltf.nodes, channel.target.node);
-            if (!targetNode._babylonMesh || targetNode.skin != undefined) {
+            if (!targetNode._babylonMesh) {
+                return Promise.resolve();
+            }
+
+            // Ignore animations targeting TRS of skinned nodes.
+            // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
+            if (targetNode.skin != undefined && channel.target.path !== AnimationChannelTargetPath.WEIGHTS) {
                 return Promise.resolve();
             }
 
@@ -962,10 +981,13 @@ module BABYLON.GLTF2 {
                             outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined
                         })));
 
+                        const multiTarget = new AnimationMultiTarget();
                         this._forEachPrimitive(targetNode, babylonMesh => {
                             const morphTarget = babylonMesh.morphTargetManager!.getTarget(targetIndex);
-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, morphTarget);
+                            multiTarget.subTargets.push(morphTarget);
                         });
+
+                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, multiTarget);
                     }
                 }
                 else {
@@ -974,9 +996,11 @@ module BABYLON.GLTF2 {
                     babylonAnimation.setKeys(keys);
 
                     if (targetNode._babylonAnimationTargets) {
+                        const multiTarget = new AnimationMultiTarget();
                         for (const target of targetNode._babylonAnimationTargets) {
-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, target);
+                            multiTarget.subTargets.push(target);
                         }
+                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, multiTarget);
                     }
                 }
             });

loaders/src/glTF/2.0/babylon.glTFLoaderUtilities.ts

@@ -18,4 +18,32 @@ module BABYLON.GLTF2 {
             }
         }
     }
+
+    export class AnimationMultiTarget {
+        public subTargets = new Array<any>();
+
+        public set position(value: Vector3) {
+            for (const subTarget of this.subTargets) {
+                subTarget.position = value;
+            }
+        }
+
+        public set rotationQuaternion(value: Quaternion) {
+            for (const subTarget of this.subTargets) {
+                subTarget.rotationQuaternion = value;
+            }
+        }
+
+        public set scaling(value: Vector3) {
+            for (const subTarget of this.subTargets) {
+                subTarget.scaling = value;
+            }
+        }
+
+        public set influence(value: number) {
+            for (const subTarget of this.subTargets) {
+                subTarget.influence = value;
+            }
+        }
+    }
 }

loaders/src/glTF/babylon.glTFFileLoader.ts

@@ -63,14 +63,13 @@ module BABYLON {
         onMeshLoadedObservable: Observable<AbstractMesh>;
         onTextureLoadedObservable: Observable<BaseTexture>;
         onMaterialLoadedObservable: Observable<Material>;
-        onAnimationGroupLoadedObservable: Observable<AnimationGroup>;
         onCompleteObservable: Observable<IGLTFLoader>;
         onDisposeObservable: Observable<IGLTFLoader>;
         onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
 
         state: Nullable<GLTFLoaderState>;
 
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[] }>;
+        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[], animationGroups: AnimationGroup[] }>;
         loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<void>;
     }
 
@@ -172,19 +171,6 @@ module BABYLON {
         }
 
         /**
-         * Raised when the loader creates an animation group after parsing the glTF properties of the animation.
-         */
-        public readonly onAnimationGroupLoadedObservable = new Observable<AnimationGroup>();
-
-        private _onAnimationGroupLoadedObserver: Nullable<Observer<AnimationGroup>>;
-        public set onAnimationGroupLoaded(callback: (animationGroup: AnimationGroup) => void) {
-            if (this._onAnimationGroupLoadedObserver) {
-                this.onAnimationGroupLoadedObservable.remove(this._onAnimationGroupLoadedObserver);
-            }
-            this._onAnimationGroupLoadedObserver = this.onAnimationGroupLoadedObservable.add(callback);
-        }
-
-        /**
          * Raised when the asset is completely loaded, immediately before the loader is disposed.
          * For assets with LODs, raised when all of the LODs are complete.
          * For assets without LODs, raised when the model is complete, immediately after onSuccess.
@@ -273,7 +259,7 @@ module BABYLON {
             this.onDisposeObservable.clear();
         }
 
-        public importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[] }> {
+        public importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{ meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[], animationGroups: AnimationGroup[] }> {
             return Promise.resolve().then(() => {
                 const loaderData = this._parse(data);
                 this._loader = this._getLoader(loaderData);
@@ -294,10 +280,11 @@ module BABYLON {
                 const loaderData = this._parse(data);
                 this._loader = this._getLoader(loaderData);
                 return this._loader.importMeshAsync(null, scene, loaderData, rootUrl, onProgress).then(result => {
-                    var container = new AssetContainer(scene);
+                    const container = new AssetContainer(scene);
                     Array.prototype.push.apply(container.meshes, result.meshes);
                     Array.prototype.push.apply(container.particleSystems, result.particleSystems);
                     Array.prototype.push.apply(container.skeletons, result.skeletons);
+                    Array.prototype.push.apply(container.animationGroups, result.animationGroups);
                     container.removeAllFromScene();
                     return container;
                 });
@@ -373,7 +360,6 @@ module BABYLON {
             loader.onTextureLoadedObservable.add(texture => this.onTextureLoadedObservable.notifyObservers(texture));
             loader.onMaterialLoadedObservable.add(material => this.onMaterialLoadedObservable.notifyObservers(material));
             loader.onExtensionLoadedObservable.add(extension => this.onExtensionLoadedObservable.notifyObservers(extension));
-            loader.onAnimationGroupLoadedObservable.add(animationGroup => this.onAnimationGroupLoadedObservable.notifyObservers(animationGroup));
 
             loader.onCompleteObservable.add(() => {
                 this.onMeshLoadedObservable.clear();

src/babylon.assetContainer.ts

@@ -28,6 +28,10 @@ module BABYLON {
          */
         public animations = new Array<Animation>();
         /**
+         * AnimationGroups to keep.
+         */
+        public animationGroups = new Array<AnimationGroup>();
+        /**
          * MultiMaterials to keep.
          */
         public multiMaterials = new Array<MultiMaterial>();
@@ -63,6 +67,10 @@ module BABYLON {
          * Sounds to keep.
          */
         public sounds = new Array<Sound>();
+        /**
+         * Textures to keep.
+         */
+        public textures = new Array<Texture>();
     }
 
     /**
@@ -100,6 +108,10 @@ module BABYLON {
          */
         public animations = new Array<Animation>();
         /**
+         * AnimationGroups populated in the container.
+         */
+        public animationGroups = new Array<AnimationGroup>();
+        /**
          * MultiMaterials populated in the container.
          */
         public multiMaterials = new Array<MultiMaterial>();
@@ -135,6 +147,10 @@ module BABYLON {
          * Sounds populated in the container.
          */
         public sounds = new Array<Sound>();
+        /**
+         * Textures populated in the container.
+         */
+        public textures = new Array<Texture>();
 
         /**
          * Instantiates an AssetContainer.
@@ -166,6 +182,9 @@ module BABYLON {
             this.animations.forEach((o) => {
                 this.scene.addAnimation(o);
             });
+            this.animationGroups.forEach((o) => {
+                this.scene.addAnimationGroup(o);
+            });
             this.multiMaterials.forEach((o) => {
                 this.scene.addMultiMaterial(o);
             });
@@ -192,6 +211,9 @@ module BABYLON {
                 o.autoplay = true;
                 this.scene.mainSoundTrack.AddSound(o);
             });
+            this.textures.forEach((o) => {
+                this.scene.addTexture
+            });
         }
 
         /**
@@ -216,6 +238,9 @@ module BABYLON {
             this.animations.forEach((o) => {
                 this.scene.removeAnimation(o);
             });
+            this.animationGroups.forEach((o) => {
+                this.scene.removeAnimationGroup(o);
+            });
             this.multiMaterials.forEach((o) => {
                 this.scene.removeMultiMaterial(o);
             });
@@ -242,6 +267,9 @@ module BABYLON {
                 o.autoplay = false;
                 this.scene.mainSoundTrack.RemoveSound(o);
             });
+            this.textures.forEach((o) => {
+                this.scene.removeTexture(o);
+            });
         }
 
         private _moveAssets<T>(sourceAssets: T[], targetAssets: T[], keepAssets: T[]): void {
@@ -276,6 +304,7 @@ module BABYLON {
             this._moveAssets(this.scene.materials, this.materials, keepAssets.materials);
             this._moveAssets(this.scene._actionManagers, this.actionManagers, keepAssets.actionManagers);
             this._moveAssets(this.scene.animations, this.animations, keepAssets.animations);
+            this._moveAssets(this.scene.animationGroups, this.animationGroups, keepAssets.animationGroups);
             this._moveAssets(this.scene.lensFlareSystems, this.lensFlareSystems, keepAssets.lensFlareSystems);
             this._moveAssets(this.scene.lights, this.lights, keepAssets.lights);
             this._moveAssets(this.scene.morphTargetManagers, this.morphTargetManagers, keepAssets.morphTargetManagers);
@@ -284,6 +313,7 @@ module BABYLON {
             this._moveAssets(this.scene.particleSystems, this.particleSystems, keepAssets.particleSystems);
             this._moveAssets(this.scene.mainSoundTrack.soundCollection, this.sounds, keepAssets.sounds);
             this._moveAssets(this.scene.transformNodes, this.transformNodes, keepAssets.transformNodes);
+            this._moveAssets(this.scene.textures, this.textures, keepAssets.textures);
 
             this.removeAllFromScene();
         }

src/babylon.scene.ts

@@ -2539,6 +2539,19 @@
             return index;
         }
 
+        /**
+         * Removes the given animation group from this scene.
+         * @param toRemove The animation group to remove
+         * @returns The index of the removed animation group
+         */
+        public removeAnimationGroup(toRemove: AnimationGroup): number {
+            var index = this.animationGroups.indexOf(toRemove);
+            if (index !== -1) {
+                this.animationGroups.splice(index, 1);
+            }
+            return index;
+        }
+
         public removeMultiMaterial(toRemove: MultiMaterial): number {
             var index = this.multiMaterials.indexOf(toRemove);
             if (index !== -1) {
@@ -2571,6 +2584,19 @@
             return index;
         }
 
+        /**
+         * Removes the given texture from this scene.
+         * @param toRemove The texture to remove
+         * @returns The index of the removed texture
+         */
+        public removeTexture(toRemove: BaseTexture): number {
+            var index = this.textures.indexOf(toRemove);
+            if (index !== -1) {
+                this.textures.splice(index, 1);
+            }
+            return index;
+        }
+
         public addLight(newLight: Light): void {
             this.lights.push(newLight);
             this.sortLightsByPriority();
@@ -2609,6 +2635,14 @@
             this.animations.push(newAnimation);
         }
 
+        /**
+         * Adds the given animation group to this scene.
+         * @param newAnimationGroup The animation group to add
+         */
+        public addAnimationGroup(newAnimationGroup: AnimationGroup): void {
+            this.animationGroups.push(newAnimationGroup);
+        }
+
         public addMultiMaterial(newMultiMaterial: MultiMaterial): void {
             this.multiMaterials.push(newMultiMaterial);
         }
@@ -2634,6 +2668,14 @@
         }
 
         /**
+         * Adds the given texture to this scene.
+         * @param newTexture The texture to add
+         */
+        public addTexture(newTexture: BaseTexture): void {
+            this.textures.push(newTexture);
+        }
+
+        /**
          * Switch active camera
          * @param {Camera} newCamera - new active camera
          * @param {boolean} attachControl - call attachControl for the new active camera (default: true)

tests/unit/babylon/src/Loading/babylon.sceneLoader.tests.ts

@@ -62,6 +62,7 @@ describe('Babylon Scene Loader', function () {
                 expect(result.meshes.length, "meshes.length").to.equal(scene.meshes.length);
                 expect(result.particleSystems.length, "particleSystems.length").to.equal(0);
                 expect(result.skeletons.length, "skeletons.length").to.equal(0);
+                expect(result.animationGroups.length, "animationGroups.length").to.equal(0);
             });
         });
 
@@ -205,9 +206,7 @@ describe('Babylon Scene Loader', function () {
         it('Load Alien', () => {
             const scene = new BABYLON.Scene(subject);
             return BABYLON.SceneLoader.ImportMeshAsync(null, "/Playground/scenes/Alien/", "Alien.gltf", scene).then(result => {
-                expect(result.skeletons.length, "skeletons.length").to.equal(scene.skeletons.length);
-
-                const mapping = {
+                const skeletonsMapping = {
                     "AlienHead": "skeleton0",
                     "Collar": "skeleton1",
                     "LeftEye": "skeleton2",
@@ -218,10 +217,29 @@ describe('Babylon Scene Loader', function () {
                     "Teeth": "skeleton1",
                 };
 
-                for (const meshName in mapping) {
-                    const skeletonName = mapping[meshName];
+                expect(scene.skeletons, "scene.skeletons").to.have.lengthOf(4);
+                expect(result.skeletons, "skeletons").to.have.lengthOf(4);
+
+                for (const meshName in skeletonsMapping) {
+                    const skeletonName = skeletonsMapping[meshName];
                     expect(scene.getMeshByName(meshName).skeleton.name, `skeleton name of mesh '${meshName}'`).to.equal(skeletonName);
                 }
+
+                const alienHeadMesh = scene.getMeshByName("AlienHead") as BABYLON.Mesh;
+                expect(alienHeadMesh.morphTargetManager.numTargets, "alienHeadMesh.morphTargetManager.numTargets").to.equal(2);
+
+                expect(scene.animationGroups, "scene.animationGroups").to.have.lengthOf(1);
+                expect(result.animationGroups, "animationGroups").to.have.lengthOf(1);
+
+                const animationGroup = result.animationGroups[0];
+                expect(animationGroup.name, "animationGroup.name").to.equal("TwoTargetBlend");
+                expect(animationGroup.targetedAnimations, "animationGroup.targetedAnimations").to.have.lengthOf(7);
+                const influenceAnimations = animationGroup.targetedAnimations.filter(_ => _.animation.targetProperty === "influence");
+                expect(influenceAnimations, "influenceAnimations").to.have.lengthOf(2);
+                const rotationAnimations = animationGroup.targetedAnimations.filter(_ => _.animation.targetProperty === "rotationQuaternion");
+                expect(rotationAnimations, "rotationAnimations").to.have.lengthOf(4);
+                const positionAnimations = animationGroup.targetedAnimations.filter(_ => _.animation.targetProperty === "position");
+                expect(positionAnimations, "positionAnimations").to.have.lengthOf(1);
             });
         });