@onerjs/loaders 8.46.6 → 8.46.9

package/glTF/2.0/glTFLoader.js

@@ -202,6 +202,7 @@ export class GLTFLoader {
         this._defaultBabylonMaterialData = {};
         this._postSceneLoadActions = new Array();
         this._materialAdapterCache = new WeakMap();
+        this._materialAdapters = new Set();
         /** @internal */
         this._pbrMaterialImpl = null;
         this._parent = parent;
@@ -221,7 +222,9 @@ export class GLTFLoader {
             else {
                 throw new Error(`Appropriate material adapter class not found`);
             }
-            this._materialAdapterCache.set(material, adapter);
+            const createdAdapter = adapter;
+            this._materialAdapterCache.set(material, createdAdapter);
+            this._materialAdapters.add(createdAdapter);
         }
         return adapter;
     }
@@ -234,6 +237,10 @@ export class GLTFLoader {
         this._completePromises.length = 0;
         this._extensions.forEach((extension) => extension.dispose && extension.dispose());
         this._extensions.length = 0;
+        for (const adapter of Array.from(this._materialAdapters)) {
+            adapter.finalize?.();
+        }
+        this._materialAdapters.clear();
         this._gltf = null; // TODO
         this._bin = null;
         this._babylonScene = null; // TODO
@@ -246,7 +253,6 @@ export class GLTFLoader {
      * @internal
      */
     async importMeshAsync(meshesNames, scene, container, data, rootUrl, onProgress, fileName = "") {
-        // eslint-disable-next-line github/no-then
         return await Promise.resolve().then(async () => {
             this._babylonScene = scene;
             this._assetContainer = container;
@@ -496,7 +502,6 @@ export class GLTFLoader {
         if (this._parent.customRootNode !== undefined) {
             this._rootBabylonMesh = this._parent.customRootNode;
             return {
-                // eslint-disable-next-line @typescript-eslint/naming-convention
                 _babylonTransformNode: this._rootBabylonMesh === null ? undefined : this._rootBabylonMesh,
                 index: -1,
             };
@@ -508,7 +513,6 @@ export class GLTFLoader {
         this._babylonScene._blockEntityCollection = false;
         this._rootBabylonMesh.setEnabled(false);
         const rootNode = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
             _babylonTransformNode: this._rootBabylonMesh,
             index: -1,
         };
@@ -544,7 +548,6 @@ export class GLTFLoader {
      * @param scene The glTF scene property
      * @returns A promise that resolves when the load is complete
      */
-    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async
     loadSceneAsync(context, scene) {
         const extensionPromise = this._extensionsLoadSceneAsync(context, scene);
         if (extensionPromise) {
@@ -677,7 +680,6 @@ export class GLTFLoader {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
      */
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     loadNodeAsync(context, node, assign = () => { }) {
         const extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
         if (extensionPromise) {
@@ -791,7 +793,6 @@ export class GLTFLoader {
             return node._babylonTransformNode;
         });
     }
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     _loadMeshAsync(context, node, mesh, assign) {
         const primitives = mesh.primitives;
         if (!primitives || !primitives.length) {
@@ -839,7 +840,6 @@ export class GLTFLoader {
      * @param assign A function called synchronously after parsing the glTF properties
      * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
      */
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     _loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
         const extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
         if (extensionPromise) {
@@ -917,7 +917,6 @@ export class GLTFLoader {
             return babylonAbstractMesh;
         });
     }
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     _loadVertexDataAsync(context, primitive, babylonMesh) {
         const extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
         if (extensionPromise) {
@@ -1009,7 +1008,6 @@ export class GLTFLoader {
             // TODO: tell the target whether it has positions, normals, tangents
         }
     }
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     _loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry) {
         if (!primitive.targets || !this._parent.loadMorphTargets) {
             return Promise.resolve();
@@ -1139,7 +1137,6 @@ export class GLTFLoader {
             babylonNode.setPivotPoint(Vector3.FromArray(node.pivotPoint));
         }
     }
-    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax
     _loadSkinAsync(context, node, skin, assign) {
         if (!this._parent.loadSkins) {
             return Promise.resolve();
@@ -2362,66 +2359,51 @@ export class GLTFLoader {
     _extensionsOnReady() {
         this._forEachExtensions((extension) => extension.onReady && extension.onReady());
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadSceneAsync(context, scene) {
         return this._applyExtensions(scene, "loadScene", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadNodeAsync(context, node, assign) {
         return this._applyExtensions(node, "loadNode", (extension) => extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadCameraAsync(context, camera, assign) {
         return this._applyExtensions(camera, "loadCamera", (extension) => extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadVertexDataAsync(context, primitive, babylonMesh) {
         return this._applyExtensions(primitive, "loadVertexData", (extension) => extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
         return this._applyExtensions(primitive, "loadMeshPrimitive", (extension) => extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign) {
         return this._applyExtensions(material, "loadMaterial", (extension) => extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign));
     }
     _extensionsCreateMaterial(context, material, babylonDrawMode) {
         return this._applyExtensions(material, "createMaterial", (extension) => extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial) {
         return this._applyExtensions(material, "loadMaterialProperties", (extension) => extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadTextureInfoAsync(context, textureInfo, assign) {
         return this._applyExtensions(textureInfo, "loadTextureInfo", (extension) => extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadTextureAsync(context, texture, assign) {
         return this._applyExtensions(texture, "loadTexture", (extension) => extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadAnimationAsync(context, animation) {
         return this._applyExtensions(animation, "loadAnimation", (extension) => extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
         return this._applyExtensions(animation, "loadAnimationChannel", (extension) => extension._loadAnimationChannelAsync && extension._loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadSkinAsync(context, node, skin) {
         return this._applyExtensions(skin, "loadSkin", (extension) => extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadUriAsync(context, property, uri) {
         return this._applyExtensions(property, "loadUri", (extension) => extension._loadUriAsync && extension._loadUriAsync(context, property, uri));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadBufferViewAsync(context, bufferView) {
         return this._applyExtensions(bufferView, "loadBufferView", (extension) => extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView));
     }
-    // eslint-disable-next-line no-restricted-syntax
     _extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength) {
         return this._applyExtensions(buffer, "loadBuffer", (extension) => extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength));
     }
@@ -2433,7 +2415,7 @@ export class GLTFLoader {
      * @param actionAsync The action to run
      * @returns The promise returned by actionAsync or null if the extension does not exist
      */
-    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     static LoadExtensionAsync(context, property, extensionName, actionAsync) {
         if (!property.extensions) {
             return null;
@@ -2453,7 +2435,7 @@ export class GLTFLoader {
      * @param actionAsync The action to run
      * @returns The promise returned by actionAsync or null if the extra does not exist
      */
-    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     static LoadExtraAsync(context, property, extensionName, actionAsync) {
         if (!property.extras) {
             return null;