@babylonjs/loaders 8.23.1 → 8.24.0

package/glTF/2.0/glTFLoader.js

@@ -24,6 +24,10 @@ import { registeredGLTFExtensions, registerGLTFExtension, unregisterGLTFExtensio
 import { GetMappingForKey } from "./Extensions/objectModelMapping.js";
 import { deepMerge } from "@babylonjs/core/Misc/deepMerger.js";
 import { GetTypedArrayConstructor } from "@babylonjs/core/Buffers/bufferUtils.js";
+import { Lazy } from "@babylonjs/core/Misc/lazy.js";
+// Caching these dynamic imports gives a surprising perf boost (compared to importing them directly each time).
+const LazyAnimationGroupModulePromise = new Lazy(() => import("@babylonjs/core/Animations/animationGroup.js"));
+const LazyLoaderAnimationModulePromise = new Lazy(() => import("./glTFLoaderAnimation.js"));
 export { GLTFFileLoader };
 /**
  * Helper class for working with arrays when loading the glTF asset
@@ -1262,6 +1266,7 @@ export class GLTFLoader {
         });
     }
     _loadAnimationsAsync() {
+        this._parent._startPerformanceCounter("Load animations");
         const animations = this._gltf.animations;
         if (!animations) {
             return Promise.resolve();
@@ -1276,7 +1281,9 @@ export class GLTFLoader {
                 }
             }));
         }
-        return Promise.all(promises).then(() => { });
+        return Promise.all(promises).then(() => {
+            this._parent._endPerformanceCounter("Load animations");
+        });
     }
     /**
      * Loads a glTF animation.
@@ -1285,12 +1292,13 @@ export class GLTFLoader {
      * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
      */
     loadAnimationAsync(context, animation) {
+        this._parent._startPerformanceCounter("Load animation");
         const promise = this._extensionsLoadAnimationAsync(context, animation);
         if (promise) {
             return promise;
         }
         // eslint-disable-next-line @typescript-eslint/naming-convention
-        return import("@babylonjs/core/Animations/animationGroup.js").then(({ AnimationGroup }) => {
+        return LazyAnimationGroupModulePromise.value.then(({ AnimationGroup }) => {
             this._babylonScene._blockEntityCollection = !!this._assetContainer;
             const babylonAnimationGroup = new AnimationGroup(animation.name || `animation${animation.index}`, this._babylonScene);
             babylonAnimationGroup._parentContainer = this._assetContainer;
@@ -1306,6 +1314,7 @@ export class GLTFLoader {
                     babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonTarget);
                 }));
             }
+            this._parent._endPerformanceCounter("Load animation");
             return Promise.all(promises).then(() => {
                 babylonAnimationGroup.normalize(0);
                 return babylonAnimationGroup;
@@ -1322,58 +1331,59 @@ export class GLTFLoader {
      * @param onLoad Called for each animation loaded
      * @returns A void promise that resolves when the load is complete
      */
-    async _loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
+    _loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
         const promise = this._extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad);
         if (promise) {
-            return await promise;
+            return promise;
         }
         if (channel.target.node == undefined) {
-            return await Promise.resolve();
+            return Promise.resolve();
         }
         const targetNode = ArrayItem.Get(`${context}/target/node`, this._gltf.nodes, channel.target.node);
         const channelTargetPath = channel.target.path;
         const pathIsWeights = channelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */;
         // Ignore animations that have no animation targets.
         if ((pathIsWeights && !targetNode._numMorphTargets) || (!pathIsWeights && !targetNode._babylonTransformNode)) {
-            return await Promise.resolve();
+            return Promise.resolve();
         }
         // Don't load node animations if disabled.
         if (!this._parent.loadNodeAnimations && !pathIsWeights && !targetNode._isJoint) {
-            return await Promise.resolve();
+            return Promise.resolve();
         }
         // async-load the animation sampler to provide the interpolation of the channelTargetPath
-        await import("./glTFLoaderAnimation.js");
-        let properties;
-        switch (channelTargetPath) {
-            case "translation" /* AnimationChannelTargetPath.TRANSLATION */: {
-                properties = GetMappingForKey("/nodes/{}/translation")?.interpolation;
-                break;
-            }
-            case "rotation" /* AnimationChannelTargetPath.ROTATION */: {
-                properties = GetMappingForKey("/nodes/{}/rotation")?.interpolation;
-                break;
-            }
-            case "scale" /* AnimationChannelTargetPath.SCALE */: {
-                properties = GetMappingForKey("/nodes/{}/scale")?.interpolation;
-                break;
-            }
-            case "weights" /* AnimationChannelTargetPath.WEIGHTS */: {
-                properties = GetMappingForKey("/nodes/{}/weights")?.interpolation;
-                break;
+        return LazyLoaderAnimationModulePromise.value.then(() => {
+            let properties;
+            switch (channelTargetPath) {
+                case "translation" /* AnimationChannelTargetPath.TRANSLATION */: {
+                    properties = GetMappingForKey("/nodes/{}/translation")?.interpolation;
+                    break;
+                }
+                case "rotation" /* AnimationChannelTargetPath.ROTATION */: {
+                    properties = GetMappingForKey("/nodes/{}/rotation")?.interpolation;
+                    break;
+                }
+                case "scale" /* AnimationChannelTargetPath.SCALE */: {
+                    properties = GetMappingForKey("/nodes/{}/scale")?.interpolation;
+                    break;
+                }
+                case "weights" /* AnimationChannelTargetPath.WEIGHTS */: {
+                    properties = GetMappingForKey("/nodes/{}/weights")?.interpolation;
+                    break;
+                }
+                default: {
+                    throw new Error(`${context}/target/path: Invalid value (${channel.target.path})`);
+                }
             }
-            default: {
-                throw new Error(`${context}/target/path: Invalid value (${channel.target.path})`);
+            // stay safe
+            if (!properties) {
+                throw new Error(`${context}/target/path: Could not find interpolation properties for target path (${channel.target.path})`);
             }
-        }
-        // stay safe
-        if (!properties) {
-            throw new Error(`${context}/target/path: Could not find interpolation properties for target path (${channel.target.path})`);
-        }
-        const targetInfo = {
-            object: targetNode,
-            info: properties,
-        };
-        return await this._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad);
+            const targetInfo = {
+                object: targetNode,
+                info: properties,
+            };
+            return this._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad);
+        });
     }
     /**
      * @hidden