@babylonjs/loaders 9.8.0 → 9.9.1

package/glTF/2.0/glTFLoader.js

@@ -106,13 +106,19 @@ export function LoadBoundingInfoFromPositionAccessor(accessor) {
  */
 export class GLTFLoader {
     /**
-     * Test if the given material is of the same type as the one used by the loader
+     * Test if the given material is an instance of any PBR material type known to this loader.
      * @param material The material to test
-     * @returns true if the material is of the same type, false otherwise
+     * @returns true if the material matches one of the loaded PBR implementations
      */
     isMatchingMaterialType(material) {
-        if (material && this._pbrMaterialImpl) {
-            return material instanceof this._pbrMaterialImpl.materialClass;
+        if (!material) {
+            return false;
+        }
+        const materialImpls = Array.from(this._pbrMaterialImpls.values());
+        for (const impl of materialImpls) {
+            if (material instanceof impl.materialClass) {
+                return true;
+            }
         }
         return false;
     }
@@ -204,8 +210,13 @@ export class GLTFLoader {
         this._postSceneLoadActions = new Array();
         this._materialAdapterCache = new WeakMap();
         this._materialAdapters = new Set();
-        /** @internal */
-        this._pbrMaterialImpl = null;
+        /**
+         * Loaded PBR material implementations, keyed by their identifier (e.g. "pbr", "openpbr").
+         * Only populated after the load has started and only for the types actually needed by the asset.
+         * Empty when PBR materials are disabled (skipMaterials).
+         * @internal
+         */
+        this._pbrMaterialImpls = new Map();
         this._parent = parent;
     }
     /**
@@ -217,10 +228,14 @@ export class GLTFLoader {
     _getOrCreateMaterialAdapter(material) {
         let adapter = this._materialAdapterCache.get(material);
         if (!adapter) {
-            if (this._pbrMaterialImpl) {
-                adapter = new this._pbrMaterialImpl.adapterClass(material);
+            const materialImpls = Array.from(this._pbrMaterialImpls.values());
+            for (const impl of materialImpls) {
+                if (material instanceof impl.materialClass) {
+                    adapter = new impl.adapterClass(material);
+                    break;
+                }
             }
-            else {
+            if (!adapter) {
                 throw new Error(`Appropriate material adapter class not found`);
             }
             const createdAdapter = adapter;
@@ -304,20 +319,35 @@ 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.isExtensionUsed("KHR_materials_openpbr")) {
-                    this._pbrMaterialImpl = {
-                        materialClass: (await import("@babylonjs/core/Materials/PBR/openpbrMaterial.js")).OpenPBRMaterial,
-                        adapterClass: (await import("./openpbrMaterialLoadingAdapter.js")).OpenPBRMaterialLoadingAdapter,
-                    };
+            if (!this.parent.skipMaterials) {
+                const needsOpenPBR = this.parent.useOpenPBR || this.isExtensionUsed("KHR_materials_openpbr");
+                let needsPBR = false;
+                if (!this.parent.useOpenPBR) {
+                    // PBR is needed when useOpenPBR is turned off.
+                    needsPBR = true;
                 }
-                else {
-                    this._pbrMaterialImpl = {
-                        materialClass: (await import("@babylonjs/core/Materials/PBR/pbrMaterial.js")).PBRMaterial,
-                        adapterClass: (await import("./pbrMaterialLoadingAdapter.js")).PBRMaterialLoadingAdapter,
-                    };
+                else if (this._gltf.materials?.length && this._gltf.materials.some((m) => !m.extensions?.["KHR_materials_openpbr"])) {
+                    // PBR is needed if there is at least one material that does not use the KHR_materials_openpbr extension (i.e. relies on the default PBR implementation).
+                    needsPBR = true;
                 }
+                const implPromises = [];
+                if (needsOpenPBR && !this._pbrMaterialImpls.has("openpbr")) {
+                    implPromises.push(Promise.all([import("@babylonjs/core/Materials/PBR/openpbrMaterial.js"), import("./openpbrMaterialLoadingAdapter.js")]).then(([{ OpenPBRMaterial: openPBRMaterialClass }, { OpenPBRMaterialLoadingAdapter: openPBRAdapterClass }]) => {
+                        this._pbrMaterialImpls.set("openpbr", {
+                            materialClass: openPBRMaterialClass,
+                            adapterClass: openPBRAdapterClass,
+                        });
+                    }));
+                }
+                if (needsPBR && !this._pbrMaterialImpls.has("pbr")) {
+                    implPromises.push(Promise.all([import("@babylonjs/core/Materials/PBR/pbrMaterial.js"), import("./pbrMaterialLoadingAdapter.js")]).then(([{ PBRMaterial: pbrMaterialClass }, { PBRMaterialLoadingAdapter: pbrAdapterClass }]) => {
+                        this._pbrMaterialImpls.set("pbr", {
+                            materialClass: pbrMaterialClass,
+                            adapterClass: pbrAdapterClass,
+                        });
+                    }));
+                }
+                await Promise.all(implPromises);
             }
             const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;
             const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;
@@ -867,7 +897,7 @@ export class GLTFLoader {
                 if (primitive.material == undefined) {
                     let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
                     if (!babylonMaterial) {
-                        babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
+                        babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode, this._getDefaultImpl());
                         this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
                         this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
                     }
@@ -1803,16 +1833,52 @@ export class GLTFLoader {
             return babylonData.babylonMaterial;
         });
     }
-    _createDefaultMaterial(name, babylonDrawMode) {
-        if (!this._pbrMaterialImpl) {
-            throw new Error("PBR Material class not loaded");
+    /**
+     * Selects the appropriate PBR material implementation for a given glTF material.
+     * Uses OpenPBR when the material carries a "KHR_materials_openpbr" extension or when
+     * the loader-level `useOpenPBR` flag is set; falls back to standard PBR otherwise.
+     * @param material The glTF material
+     * @returns The matching loaded implementation
+     */
+    _selectImplForGltfMaterial(material) {
+        if (this.parent.useOpenPBR || material.extensions?.["KHR_materials_openpbr"]) {
+            const impl = this._pbrMaterialImpls.get("openpbr");
+            if (impl) {
+                return impl;
+            }
+        }
+        const impl = this._pbrMaterialImpls.get("pbr");
+        if (impl) {
+            return impl;
         }
+        throw new Error("No PBR material implementation loaded");
+    }
+    /**
+     * Returns the default PBR material implementation used when there is no per-material
+     * selection context (e.g. when creating the built-in default material for primitives
+     * that have no glTF material assigned).  Prefers OpenPBR when `useOpenPBR` is set.
+     * @returns The default loaded implementation
+     */
+    _getDefaultImpl() {
+        if (this.parent.useOpenPBR) {
+            const impl = this._pbrMaterialImpls.get("openpbr");
+            if (impl) {
+                return impl;
+            }
+        }
+        const impl = this._pbrMaterialImpls.get("pbr") ?? this._pbrMaterialImpls.values().next().value;
+        if (impl) {
+            return impl;
+        }
+        throw new Error("No PBR material implementation loaded");
+    }
+    _createDefaultMaterial(name, babylonDrawMode, impl) {
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        const babylonMaterial = new this._pbrMaterialImpl.materialClass(name, this._babylonScene);
+        const babylonMaterial = new impl.materialClass(name, this._babylonScene);
         babylonMaterial._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         babylonMaterial.fillMode = babylonDrawMode;
-        babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_OPAQUE;
+        babylonMaterial.transparencyMode = impl.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);
@@ -1835,7 +1901,7 @@ export class GLTFLoader {
             return extensionMaterial;
         }
         const name = material.name || `material${material.index}`;
-        const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
+        const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode, this._selectImplForGltfMaterial(material));
         return babylonMaterial;
     }
     /**
@@ -1925,7 +1991,7 @@ export class GLTFLoader {
      * @param babylonMaterial The Babylon material
      */
     loadMaterialAlphaProperties(context, material, babylonMaterial) {
-        if (!this._pbrMaterialImpl) {
+        if (this._pbrMaterialImpls.size === 0) {
             throw new Error(`${context}: Material type not supported`);
         }
         const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
@@ -1933,12 +1999,12 @@ export class GLTFLoader {
         const alphaMode = material.alphaMode || "OPAQUE" /* MaterialAlphaMode.OPAQUE */;
         switch (alphaMode) {
             case "OPAQUE" /* MaterialAlphaMode.OPAQUE */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_OPAQUE;
+                babylonMaterial.transparencyMode = Material.MATERIAL_OPAQUE;
                 babylonMaterial.alpha = 1.0; // Force alpha to 1.0 for opaque mode.
                 break;
             }
             case "MASK" /* MaterialAlphaMode.MASK */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_ALPHATEST;
+                babylonMaterial.transparencyMode = Material.MATERIAL_ALPHATEST;
                 adapter.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;
                 if (baseColorTexture) {
                     baseColorTexture.hasAlpha = true;
@@ -1946,7 +2012,7 @@ export class GLTFLoader {
                 break;
             }
             case "BLEND" /* MaterialAlphaMode.BLEND */: {
-                babylonMaterial.transparencyMode = this._pbrMaterialImpl.materialClass.MATERIAL_ALPHABLEND;
+                babylonMaterial.transparencyMode = Material.MATERIAL_ALPHABLEND;
                 if (baseColorTexture) {
                     baseColorTexture.hasAlpha = true;
                     adapter.useAlphaFromBaseColorTexture = true;