@woosh/meep-engine 2.155.0 → 2.157.0

package/src/engine/asset/AssetRequest.d.ts

@@ -25,7 +25,7 @@ export class AssetRequest {
      *
      * @type {function(number, number): void}
      */
-    pogressCallback: (arg0: number, arg1: number) => void;
+    progressCallback: (arg0: number, arg1: number) => void;
     /**
      * Higher priority requests should be handled first
      * @type {number}

package/src/engine/asset/AssetRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetRequest.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetRequest.js"],"names":[],"mappings":"gCAEU,MAAM;;;;AAShB;IACI;;;;;;OAMG;IACH,+EAkCC;IAjCG;;;OAGG;IACH,sCAAsC;IACtC;;;OAGG;IACH,oCAAsC;IACtC;;;OAGG;IACH,wBAFmB,MAAM,QAAE,MAAM,KAAG,IAAI,CAED;IAEvC;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,yBAAiB;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEF;IAGlB,8BAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;CACJ"}
+{"version":3,"file":"AssetRequest.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetRequest.js"],"names":[],"mappings":"gCAEU,MAAM;;;;AAShB;IACI;;;;;;OAMG;IACH,+EAkCC;IAjCG;;;OAGG;IACH,sCAAsC;IACtC;;;OAGG;IACH,oCAAsC;IACtC;;;OAGG;IACH,yBAFmB,MAAM,QAAE,MAAM,KAAG,IAAI,CAEA;IAExC;;;OAGG;IACH,UAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,yBAAiB;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEF;IAGlB,8BAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;CACJ"}

package/src/engine/asset/AssetRequest.js

@@ -32,7 +32,7 @@ export class AssetRequest {
          *
          * @type {function(number, number): void}
          */
-        this.pogressCallback = progressCallback;
+        this.progressCallback = progressCallback;
 
         /**
          * Higher priority requests should be handled first

package/src/engine/asset/AssetRequestScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetRequestScope.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetRequestScope.js"],"names":[],"mappings":"AAEA;IAoCI;;;;OAIG;IACH,qBAHW,iBAAiB,EAAE,GAClB,iBAAiB,CAQ5B;IA9CD,WAAkB;IAElB,iBAAY;IAEZ;;;OAGG;IACH,SAFU,iBAAiB,EAAE,CAEjB;IAGZ,0BAsBC;IAeD,mBAGC;CAEJ;;gBAKS,SAAS,iBAAiB,CAAC"}
+{"version":3,"file":"AssetRequestScope.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetRequestScope.js"],"names":[],"mappings":"AAEA;IA2CI;;;;OAIG;IACH,qBAHW,iBAAiB,EAAE,GAClB,iBAAiB,CAQ5B;IArDD,WAAkB;IAElB,iBAAY;IAEZ;;;OAGG;IACH,SAFU,iBAAiB,EAAE,CAEjB;IAEZ;;;;OAIG;IACH,aAFU,mBAAiB,IAAI,CAEb;IAGlB,0BAsBC;IAeD,mBAGC;CAEJ;;gBAKS,SAAS,iBAAiB,CAAC"}

package/src/engine/asset/AssetRequestScope.js

@@ -11,6 +11,13 @@ export class AssetRequestScope {
      */
     sources = []
 
+    /**
+     * Asset being loaded under this scope. Set by the {@link AssetManager} on scopes it creates when
+     * dispatching a load; lets requests made by the loader be traced back to the load they belong to.
+     * @type {AssetDescription|null}
+     */
+    description = null
+
 
     get final_priority() {
         const sources = this.sources;

package/src/engine/asset/PendingAsset.d.ts

@@ -21,10 +21,41 @@ export class PendingAsset {
      */
     progress: BoundedValue;
     /**
-     *
+     * Lifecycle: Initial -> Queued -> Loading -> (Succeeded | Failed).
+     * Externally resolved assets (see {@link AssetManager#insertAsync}) go straight from Initial to a terminal state.
      * @type {AssetLoadState|number}
      */
     state: AssetLoadState | number;
+    /**
+     * Whether the manager may run a loader for this asset.
+     * False for assets whose resolution is supplied externally (see {@link AssetManager#insertAsync}).
+     * @type {boolean}
+     */
+    dispatchable: boolean;
+    /**
+     * Set when a resolution (success or failure) has been accepted; further resolution signals are ignored.
+     * Distinct from terminal {@link state} because a successful resolution involves asynchronous
+     * finalization (transform chain) before the state becomes terminal.
+     * @type {boolean}
+     */
+    resolution_claimed: boolean;
+    /**
+     * Scope under which the loader for this asset was invoked, identifies this load for nested requests.
+     * Null until the load is dispatched.
+     * @type {AssetRequestScope|null}
+     */
+    dispatch_scope: AssetRequestScope | null;
+    /**
+     * Descriptions of assets requested by the loader while servicing this load.
+     * Published as {@link Asset#dependencies} on successful resolution.
+     * @type {AssetDescription[]}
+     */
+    children: AssetDescription[];
+    /**
+     * Record a nested request made while servicing this load
+     * @param {AssetDescription} description
+     */
+    addChild(description: AssetDescription): void;
     /**
      * Returns aggregated priority of the pending asset based on highest priority of associated requests
      * @return {number}

package/src/engine/asset/PendingAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PendingAsset.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/PendingAsset.js"],"names":[],"mappings":"AAGA;IACI;;;;OAIG;IACH,2CAwBC;IAvBG;;;OAGG;IACH,8BAA8B;IAE9B;;;OAGG;IACH,UAFU,cAAc,CAEN;IAElB;;;OAGG;IACH,UAFU,YAAY,CAEgB;IAEtC;;;OAGG;IACH,OAFU,cAAc,GAAC,MAAM,CAEI;IAGvC;;;OAGG;IACH,uBAoBC;CACJ;yBA5DwB,kCAAkC;+BAC5B,qBAAqB"}
+{"version":3,"file":"PendingAsset.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/PendingAsset.js"],"names":[],"mappings":"AAGA;IACI;;;;OAIG;IACH,2CAsDC;IArDG;;;OAGG;IACH,8BAA8B;IAE9B;;;OAGG;IACH,UAFU,cAAc,CAEN;IAElB;;;OAGG;IACH,UAFU,YAAY,CAEgB;IAEtC;;;;OAIG;IACH,OAFU,cAAc,GAAC,MAAM,CAEI;IAEnC;;;;OAIG;IACH,cAFU,OAAO,CAEO;IAExB;;;;;OAKG;IACH,oBAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,gBAFU,oBAAkB,IAAI,CAEN;IAE1B;;;;OAIG;IACH,UAFU,kBAAkB,CAEV;IAGtB;;;OAGG;IACH,8CAYC;IAED;;;OAGG;IACH,uBAmBC;CACJ;yBA3GwB,kCAAkC;+BAC5B,qBAAqB"}

package/src/engine/asset/PendingAsset.js

@@ -1,61 +1,108 @@
-import BoundedValue from "../../core/model/BoundedValue.js";
-import { AssetLoadState } from "./AssetLoadState.js";
-
-export class PendingAsset {
-    /**
-     *
-     * @param {AssetDescription} description
-     * @constructor
-     */
-    constructor(description) {
-        /**
-         *
-         * @type {AssetDescription}
-         */
-        this.description = description;
-
-        /**
-         *
-         * @type {AssetRequest[]}
-         */
-        this.requests = [];
-
-        /**
-         *
-         * @type {BoundedValue}
-         */
-        this.progress = new BoundedValue(0, 0);
-
-        /**
-         *
-         * @type {AssetLoadState|number}
-         */
-        this.state = AssetLoadState.Initial;
-    }
-
-    /**
-     * Returns aggregated priority of the pending asset based on highest priority of associated requests
-     * @return {number}
-     */
-    get priority() {
-        const requests = this.requests;
-        const request_count = requests.length;
-
-        if (request_count === 0) {
-            return 0;
-        }
-
-        let max_priority = requests[0].priority;
-
-        for (let i = 1; i < request_count; i++) {
-            const request = requests[i];
-            const priority = request.scoped_priority;
-
-            if (priority > max_priority) {
-                max_priority = request;
-            }
-        }
-
-        return max_priority;
-    }
-}
+import BoundedValue from "../../core/model/BoundedValue.js";
+import { AssetLoadState } from "./AssetLoadState.js";
+
+export class PendingAsset {
+    /**
+     *
+     * @param {AssetDescription} description
+     * @constructor
+     */
+    constructor(description) {
+        /**
+         *
+         * @type {AssetDescription}
+         */
+        this.description = description;
+
+        /**
+         *
+         * @type {AssetRequest[]}
+         */
+        this.requests = [];
+
+        /**
+         *
+         * @type {BoundedValue}
+         */
+        this.progress = new BoundedValue(0, 0);
+
+        /**
+         * Lifecycle: Initial -> Queued -> Loading -> (Succeeded | Failed).
+         * Externally resolved assets (see {@link AssetManager#insertAsync}) go straight from Initial to a terminal state.
+         * @type {AssetLoadState|number}
+         */
+        this.state = AssetLoadState.Initial;
+
+        /**
+         * Whether the manager may run a loader for this asset.
+         * False for assets whose resolution is supplied externally (see {@link AssetManager#insertAsync}).
+         * @type {boolean}
+         */
+        this.dispatchable = true;
+
+        /**
+         * Set when a resolution (success or failure) has been accepted; further resolution signals are ignored.
+         * Distinct from terminal {@link state} because a successful resolution involves asynchronous
+         * finalization (transform chain) before the state becomes terminal.
+         * @type {boolean}
+         */
+        this.resolution_claimed = false;
+
+        /**
+         * Scope under which the loader for this asset was invoked, identifies this load for nested requests.
+         * Null until the load is dispatched.
+         * @type {AssetRequestScope|null}
+         */
+        this.dispatch_scope = null;
+
+        /**
+         * Descriptions of assets requested by the loader while servicing this load.
+         * Published as {@link Asset#dependencies} on successful resolution.
+         * @type {AssetDescription[]}
+         */
+        this.children = [];
+    }
+
+    /**
+     * Record a nested request made while servicing this load
+     * @param {AssetDescription} description
+     */
+    addChild(description) {
+        const children = this.children;
+        const n = children.length;
+
+        for (let i = 0; i < n; i++) {
+            if (children[i].equals(description)) {
+                // already recorded
+                return;
+            }
+        }
+
+        children.push(description);
+    }
+
+    /**
+     * Returns aggregated priority of the pending asset based on highest priority of associated requests
+     * @return {number}
+     */
+    get priority() {
+        const requests = this.requests;
+        const request_count = requests.length;
+
+        if (request_count === 0) {
+            return 0;
+        }
+
+        let max_priority = requests[0].scoped_priority;
+
+        for (let i = 1; i < request_count; i++) {
+            const priority = requests[i].scoped_priority;
+
+            if (priority > max_priority) {
+                max_priority = priority;
+            }
+        }
+
+        return max_priority;
+    }
+}

package/src/engine/asset/loaders/ArrayBufferLoader.js

@@ -116,7 +116,7 @@ export class ArrayBufferLoader extends AssetLoader {
 
         const headers = new Headers();
 
-        const request = new Request(path, {
+        const request = new Request(this.resolvePath(path), {
             credentials: coc.kind === CrossOriginKind.UseCredentials ? 'include' : 'same-origin',
             headers: headers
         });
@@ -157,7 +157,7 @@ export class ArrayBufferLoader extends AssetLoader {
             function () {
                 return arrayBuffer;
             },
-            arrayBuffer.byteSize
+            arrayBuffer.byteLength
         );
 
         success(asset);

package/src/engine/asset/loaders/AssetLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/AssetLoader.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IACI;;;OAGG;IACH,2BAAoB;IAEpB;;;OAGG;IACH,SAFU,GAAG,CAEE;IAEf;;;;OAIG;IACH,0CAFW,GAAG,iBAKb;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,qCALW,MAAM,wDAOhB;CACJ"}
+{"version":3,"file":"AssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/AssetLoader.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IACI;;;OAGG;IACH,2BAAoB;IAEpB;;;OAGG;IACH,SAFU,GAAG,CAEE;IAEf;;;;OAIG;IACH,0CAFW,GAAG,iBAKb;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,qCALW,MAAM,wDAOhB;CACJ"}

package/src/engine/asset/loaders/AssetLoader.js

@@ -33,9 +33,26 @@ export class AssetLoader {
     }
 
     /**
-     *
-     * @param {AssetRequestScope} scope
+     * Resolves a caller-facing asset path to the path used for actual network retrieval.
+     * Apply at the fetch boundary; paths passed back to the manager (nested requests) stay un-resolved.
      * @param {string} path
+     * @returns {string}
+     * @see AssetManager#resolveNetworkPath
+     */
+    resolvePath(path) {
+        return this.assetManager !== null ? this.assetManager.resolveNetworkPath(path) : path;
+    }
+
+    /**
+     * Loads the asset for the given path.
+     *
+     * Exactly one of `success`/`failure` must eventually be invoked. The recommended shape is an
+     * `async` method that calls `success(asset)` — the manager treats a returned promise's rejection
+     * as a failure, so any throw (including from nested {@link AssetManager#promise} requests) is
+     * propagated instead of hanging the request.
+     *
+     * @param {AssetRequestScope} scope identifies this load; pass it on to any nested manager requests
+     * @param {string} path caller-facing path, see {@link resolvePath} for network retrieval
      * @param {function(asset:Asset)} success
      * @param {function} failure
      * @param {function(current:number, total:number)} progress

package/src/engine/asset/loaders/GLTFAssetLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GLTFAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/GLTFAssetLoader.js"],"names":[],"mappings":"AAuIA;IAEI,cAyDC;IArDG,2BAAsC;IAatC,mBAAoB;IAEpB;;;;;OAKG;IACH,gCAAoC;IAEpC;;;;;OAKG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,yBAIE;IAGF;;;;OAIG;IACH,wBAIE;IAGN;;;OAGG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,oDAOC;IAED;;;;OAIG;IACH,gCAsCC;IAGD,6EAkKC;CACJ;4BAja2B,kBAAkB;4BAnBlB,2CAA2C;2BAC5C,0CAA0C"}
+{"version":3,"file":"GLTFAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/GLTFAssetLoader.js"],"names":[],"mappings":"AAuIA;IAEI,cAyDC;IArDG,2BAAsC;IAatC,mBAAoB;IAEpB;;;;;OAKG;IACH,gCAAoC;IAEpC;;;;;OAKG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,yBAIE;IAGF;;;;OAIG;IACH,wBAIE;IAGN;;;OAGG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,oDAOC;IAED;;;;OAIG;IACH,gCAsCC;IAGD;;;;OAIG;IACH,sBAiCC;IAED;;;;;OAKG;IACH,uBAgHC;IAED,6EAWC;CACJ;4BA1a2B,kBAAkB;4BAnBlB,2CAA2C;2BAC5C,0CAA0C"}

package/src/engine/asset/loaders/GLTFAssetLoader.js

@@ -273,164 +273,173 @@ export class GLTFAssetLoader extends AssetLoader {
     }
 
 
-    load(scope, path, success, failure, progress) {
-        const loader = this.loader;
-        const texture_cache = this.__texture_cache;
+    /**
+     *
+     * @param {THREE.Mesh|THREE.SkinnedMesh} mesh
+     * @private
+     */
+    async __processMesh(mesh) {
+        let geometry = mesh.geometry;
 
+        if (geometry === undefined) {
+            throw new Error(`No geometry found`);
+        }
 
-        /**
-         *
-         * @param {THREE.Mesh|THREE.SkinnedMesh} mesh
-         */
-        const processMesh = async (mesh) => {
-            let geometry = mesh.geometry;
+        if (this.__enable_geometry_cache) {
+            // replace geometry
+            geometry = this.__geometry_cache.ensure(geometry);
+            mesh.geometry = geometry;
+        }
 
-            if (geometry === undefined) {
-                throw new Error(`No geometry found`);
-            }
+        if (this.__enable_texture_cache) {
+            // replace textures from cache
+            replace_material_textures_from_cache(mesh.material, this.__texture_cache);
+        }
 
-            if (this.__enable_geometry_cache) {
-                // replace geometry
-                geometry = this.__geometry_cache.ensure(geometry);
-                mesh.geometry = geometry;
-            }
+        const isSkinned = mesh.isSkinnedMesh === true;
 
-            if (this.__enable_texture_cache) {
-                // replace textures from cache
-                replace_material_textures_from_cache(mesh.material, texture_cache);
-            }
 
-            const isSkinned = mesh.isSkinnedMesh === true;
+        if (isSkinned) {
+            // this used to be done inside SkinnedMesh constructor in thee.js prior to r99
+            mesh.normalizeSkinWeights();
 
+            //compute bounding box and sphere for the mesh, do it using the skeleton data
+            computeSkinnedMeshBoundingVolumes(mesh);
+        } else {
 
-            if (isSkinned) {
-                // this used to be done inside SkinnedMesh constructor in thee.js prior to r99
-                mesh.normalizeSkinWeights();
+            ensureGeometryBoundingBox(geometry);
+            ensureGeometryBoundingSphere(geometry);
+        }
 
-                //compute bounding box and sphere for the mesh, do it using the skeleton data
-                computeSkinnedMeshBoundingVolumes(mesh);
-            } else {
+    }
 
-                ensureGeometryBoundingBox(geometry);
-                ensureGeometryBoundingSphere(geometry);
-            }
+    /**
+     * Build the engine asset from a parsed GLTF payload
+     * @param {Object} gltf
+     * @returns {Promise<Asset>}
+     * @private
+     */
+    async __process_gltf(gltf) {
+        const scene = gltf.scene;
 
+        scene.updateMatrixWorld();
+
+        /**
+         * {Array.<THREE.Object3D>}
+         */
+        const children = scene.children;
+
+        if (children.length === 0) {
+            throw new Error("Scene is empty");
         }
 
 
-        loader.load(path, async (gltf) => {
-            const scene = gltf.scene;
+        let root = scene;
 
-            scene.updateMatrixWorld();
+        if (children.length === 1 && isMesh(children[0])) {
+            // scene only contains a single mesh, use that directly
+            root = children[0];
+        }
 
-            /**
-             * {Array.<THREE.Object3D>}
-             */
-            const children = scene.children;
+        traverseThreeObject(root, this.__prepareObjectMaterial, this);
 
-            if (children.length === 0) {
-                failure("Scene is empty");
-                return;
-            }
+        const root_transform = new Transform();
 
+        // extract root transform
+        const has_root_transform = transferRootTransform(root, root_transform);
 
-            let root = scene;
+        // clear transform on the root element
+        root.position.set(0, 0, 0);
+        root.rotation.set(0, 0, 0);
+        root.scale.set(1, 1, 1);
 
-            if (children.length === 1 && isMesh(children[0])) {
-                // scene only contains a single mesh, use that directly
-                root = children[0];
+        /**
+         *
+         * @param {THREE.Object3D} o
+         * @returns {Promise<void>}
+         */
+        const process_object = async (o) => {
+            o.updateMatrix();
+
+            prepareObject(o);
+
+            if (isMesh(o)) {
+                await this.__processMesh(o);
             }
+        };
 
-            traverseThreeObject(root, this.__prepareObjectMaterial, this);
 
-            const root_transform = new Transform();
+        await async_traverse_three_object(root, process_object);
 
-            // extract root transform
-            const has_root_transform = transferRootTransform(root, root_transform);
 
-            // clear transform on the root element
-            root.position.set(0, 0, 0);
-            root.rotation.set(0, 0, 0);
-            root.scale.set(1, 1, 1);
+        // compute object bounding sphere
+        root.boundingSphere = computeObjectBoundingSphere(root);
 
-            /**
-             *
-             * @param {THREE.Object3D} o
-             * @returns {Promise<void>}
-             */
-            async function process_object(o) {
-                o.updateMatrix();
+        // compute bounding box
+        const boundingBox = new AABB3(0, 0, 0, 0, 0, 0);
+        three_computeObjectBoundingBox(root, boundingBox);
 
-                prepareObject(o);
 
-                if (isMesh(o)) {
-                    processMesh(o);
-                }
-            }
+        /**
+         *
+         * @returns {THREE.Object3D}
+         */
+        function assetFactory() {
+            const result = cloneObject3D(root);
 
+            result.castShadow = true;
+            result.receiveShadow = false;
 
-            await async_traverse_three_object(root, process_object);
+            if (asset.animations !== undefined) {
+                //animations are present
+                result.animations = asset.animations;
+            }
+
+            // Copy bounding sphere
+            result.boundingSphere = root.boundingSphere;
 
+            return result;
+        }
 
-            // compute object bounding sphere
-            root.boundingSphere = computeObjectBoundingSphere(root);
+        const byteSize = 1;
 
-            // compute bounding box
-            const boundingBox = new AABB3(0, 0, 0, 0, 0, 0);
-            three_computeObjectBoundingBox(root, boundingBox);
+        const asset = new Asset(assetFactory, byteSize);
+        asset.boundingBox = boundingBox;
+        asset.has_root_transform = has_root_transform;
+        asset.root_transform = root_transform;
 
+        // remember GLTF metadata
+        asset.gltf = gltf;
 
+        if (gltf.animations !== undefined) {
             /**
              *
-             * @returns {THREE.Object3D}
+             * @type {AnimationClip[]}
              */
-            function assetFactory() {
-                const result = cloneObject3D(root);
-
-                result.castShadow = true;
-                result.receiveShadow = false;
-
-                if (asset.animations !== undefined) {
-                    //animations are present
-                    result.animations = asset.animations;
+            const animations = gltf.animations;
+
+            //validate and optimize animations
+            const animation_count = animations.length;
+            for (let i = 0; i < animation_count; i++) {
+                const animation = animations[i];
+                if (animation.validate()) {
+                    animationOptimizer.optimize(animation);
                 }
+            }
 
-                // Copy bounding sphere
-                result.boundingSphere = root.boundingSphere;
+            asset.animations = animations;
+        }
 
-                return result;
-            }
+        return asset;
+    }
 
-            const byteSize = 1;
-
-            const asset = new Asset(assetFactory, byteSize);
-            asset.boundingBox = boundingBox;
-            asset.has_root_transform = has_root_transform;
-            asset.root_transform = root_transform;
-
-            // remember GLTF metadata
-            asset.gltf = gltf;
-
-            if (gltf.animations !== undefined) {
-                /**
-                 *
-                 * @type {AnimationClip[]}
-                 */
-                const animations = gltf.animations;
-
-                //validate and optimize animations
-                const animation_count = animations.length;
-                for (let i = 0; i < animation_count; i++) {
-                    const animation = animations[i];
-                    if (animation.validate()) {
-                        animationOptimizer.optimize(animation);
-                    }
-                }
+    load(scope, path, success, failure, progress) {
 
-                asset.animations = animations;
-            }
+        this.loader.load(this.resolvePath(path), (gltf) => {
+
+            // route any processing exception to failure instead of losing it in an unobserved promise
+            this.__process_gltf(gltf).then(success, failure);
 
-            success(asset);
         }, function (xhr) {
             //dispatch progress callback
             progress(xhr.loaded, xhr.total);

package/src/engine/asset/loaders/JavascriptAssetLoader.d.ts

@@ -1,6 +1,6 @@
 export class JavascriptAssetLoader extends AssetLoader<any, any> {
     constructor();
-    load(scope: any, path: any, success: any, failure: any, progress: any): void;
+    load(scope: any, path: any, success: any, failure: any, progress: any): Promise<void>;
 }
 import { AssetLoader } from "./AssetLoader.js";
 //# sourceMappingURL=JavascriptAssetLoader.d.ts.map

package/src/engine/asset/loaders/JavascriptAssetLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JavascriptAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/JavascriptAssetLoader.js"],"names":[],"mappings":"AAqBA;;IAEI,6EAsBC;CACJ;4BA9C2B,kBAAkB"}
+{"version":3,"file":"JavascriptAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/JavascriptAssetLoader.js"],"names":[],"mappings":"AAqBA;;IAEI,sFAMC;CACJ;4BA9B2B,kBAAkB"}