@onerjs/loaders 8.27.3 → 8.27.5

package/glTF/2.0/glTFLoader.js

@@ -192,9 +192,7 @@ export class GLTFLoader {
         this._postSceneLoadActions = new Array();
         this._materialAdapterCache = new WeakMap();
         /** @internal */
-        this._pbrMaterialClass = null;
-        /** @internal */
-        this._pbrMaterialAdapterClass = null;
+        this._pbrMaterialImpl = null;
         this._parent = parent;
     }
     /**
@@ -206,8 +204,8 @@ export class GLTFLoader {
     _getOrCreateMaterialAdapter(material) {
         let adapter = this._materialAdapterCache.get(material);
         if (!adapter) {
-            if (this._pbrMaterialAdapterClass) {
-                adapter = new this._pbrMaterialAdapterClass(material);
+            if (this._pbrMaterialImpl) {
+                adapter = new this._pbrMaterialImpl.adapterClass(material);
             }
             else {
                 throw new Error(`Appropriate material adapter class not found`);
@@ -291,6 +289,21 @@ export class GLTFLoader {
             this._fileName = fileName;
             this._allMaterialsDirtyRequired = false;
             await this._loadExtensionsAsync();
+            // NOTE: Explicitly check _pbrMaterialImpl for null as a value of false means don't use PBR materials at all.
+            if (!this.parent.skipMaterials && this._pbrMaterialImpl == null) {
+                if (this.parent.useOpenPBR) {
+                    this._pbrMaterialImpl = {
+                        materialClass: (await import("@onerjs/core/Materials/PBR/openPbrMaterial.js")).OpenPBRMaterial,
+                        adapterClass: (await import("./openPbrMaterialLoadingAdapter.js")).OpenPBRMaterialLoadingAdapter,
+                    };
+                }
+                else {
+                    this._pbrMaterialImpl = {
+                        materialClass: (await import("@onerjs/core/Materials/PBR/pbrMaterial.js")).PBRMaterial,
+                        adapterClass: (await import("./pbrMaterialLoadingAdapter.js")).PBRMaterialLoadingAdapter,
+                    };
+                }
+            }
             const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;
             const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;
             this._parent._startPerformanceCounter(loadingToReadyCounterName);
@@ -849,28 +862,24 @@ export class GLTFLoader {
                     this._babylonScene._blockEntityCollection = false;
                 });
             }));
-            const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
-            if (primitive.material == undefined) {
-                const babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
-                if (!babylonMaterial) {
-                    promises.push((async () => {
-                        await this._ensurePbrMaterialClassesAsync();
-                        const created = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
-                        this._parent.onMaterialLoadedObservable.notifyObservers(created);
-                        this._defaultBabylonMaterialData[babylonDrawMode] = created;
-                        babylonMesh.material = created;
-                    })());
+            if (!this.parent.skipMaterials) {
+                const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
+                if (primitive.material == undefined) {
+                    let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
+                    if (!babylonMaterial) {
+                        babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
+                        this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
+                        this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
+                    }
+                    babylonMesh.material = babylonMaterial;
                 }
                 else {
-                    babylonMesh.material = babylonMaterial;
+                    const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);
+                    promises.push(this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {
+                        babylonMesh.material = babylonMaterial;
+                    }));
                 }
             }
-            else if (!this.parent.skipMaterials) {
-                const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);
-                promises.push(this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {
-                    babylonMesh.material = babylonMaterial;
-                }));
-            }
             promise = Promise.all(promises);
             if (shouldInstance) {
                 primitive._instanceData = {
@@ -1766,37 +1775,16 @@ export class GLTFLoader {
     /**
      * @internal
      */
-    async _ensurePbrMaterialClassesAsync() {
-        if (!this._pbrMaterialClass || !this._pbrMaterialAdapterClass) {
-            const openpbrExt = this._extensions.find((extension) => extension.name === "KHR_materials_openpbr");
-            if (this.parent.useOpenPBR || openpbrExt) {
-                const materialAdapterModule = await import("./openPbrMaterialLoadingAdapter.js");
-                this._pbrMaterialAdapterClass = materialAdapterModule.OpenPBRMaterialLoadingAdapter;
-                const materialModule = await import("@onerjs/core/Materials/PBR/openPbrMaterial.js");
-                this._pbrMaterialClass = materialModule.OpenPBRMaterial;
-            }
-            else {
-                const materialAdapterModule = await import("./pbrMaterialLoadingAdapter.js");
-                this._pbrMaterialAdapterClass = materialAdapterModule.PBRMaterialLoadingAdapter;
-                const materialModule = await import("@onerjs/core/Materials/PBR/pbrMaterial.js");
-                this._pbrMaterialClass = materialModule.PBRMaterial;
-            }
-        }
-    }
     async _loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign = () => { }) {
         const extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
         if (extensionPromise) {
             return await extensionPromise;
         }
-        // Ensure PBR/OpenPBR classes are available before creating materials
-        await this._ensurePbrMaterialClassesAsync();
         material._data = material._data || {};
         let babylonData = material._data[babylonDrawMode];
         if (!babylonData) {
             this.logOpen(`${context} ${material.name || ""}`);
             const babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
-            // Create the adapter for this material immediately after creation
-            this._getOrCreateMaterialAdapter(babylonMaterial);
             babylonData = {
                 babylonMaterial: babylonMaterial,
                 babylonMeshes: [],
@@ -1821,15 +1809,15 @@ export class GLTFLoader {
         return babylonData.babylonMaterial;
     }
     _createDefaultMaterial(name, babylonDrawMode) {
-        if (!this._pbrMaterialClass) {
+        if (!this._pbrMaterialImpl) {
             throw new Error("PBR Material class not loaded");
         }
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        const babylonMaterial = new this._pbrMaterialClass(name, this._babylonScene);
+        const babylonMaterial = new this._pbrMaterialImpl.materialClass(name, this._babylonScene);
         babylonMaterial._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         babylonMaterial.fillMode = babylonDrawMode;
-        babylonMaterial.transparencyMode = this._pbrMaterialClass.MATERIAL_OPAQUE;
+        babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_OPAQUE;
         // Create the material adapter and set some default properties.
         // We don't need to wait for the promise to resolve here.
         const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
@@ -1847,9 +1835,9 @@ export class GLTFLoader {
      * @returns The Babylon material
      */
     createMaterial(context, material, babylonDrawMode) {
-        const extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);
-        if (extensionPromise) {
-            return extensionPromise;
+        const extensionMaterial = this._extensionsCreateMaterial(context, material, babylonDrawMode);
+        if (extensionMaterial) {
+            return extensionMaterial;
         }
         const name = material.name || `material${material.index}`;
         const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
@@ -1942,7 +1930,7 @@ export class GLTFLoader {
      * @param babylonMaterial The Babylon material
      */
     loadMaterialAlphaProperties(context, material, babylonMaterial) {
-        if (!this._pbrMaterialClass) {
+        if (!this._pbrMaterialImpl) {
             throw new Error(`${context}: Material type not supported`);
         }
         const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
@@ -1950,12 +1938,12 @@ export class GLTFLoader {
         const alphaMode = material.alphaMode || "OPAQUE" /* MaterialAlphaMode.OPAQUE */;
         switch (alphaMode) {
             case "OPAQUE" /* MaterialAlphaMode.OPAQUE */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialClass.MATERIAL_OPAQUE;
+                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_OPAQUE;
                 babylonMaterial.alpha = 1.0; // Force alpha to 1.0 for opaque mode.
                 break;
             }
             case "MASK" /* MaterialAlphaMode.MASK */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialClass.MATERIAL_ALPHATEST;
+                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_ALPHATEST;
                 adapter.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;
                 if (baseColorTexture) {
                     baseColorTexture.hasAlpha = true;
@@ -1963,7 +1951,7 @@ export class GLTFLoader {
                 break;
             }
             case "BLEND" /* MaterialAlphaMode.BLEND */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialClass.MATERIAL_ALPHABLEND;
+                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_ALPHABLEND;
                 if (baseColorTexture) {
                     baseColorTexture.hasAlpha = true;
                     adapter.useAlphaFromBaseColorTexture = true;