@onerjs/loaders 8.51.5 → 8.51.7

package/glTF/2.0/glTFLoader.js

@@ -11,6 +11,7 @@ import { Material } from "@onerjs/core/Materials/material.js";
 import { Texture } from "@onerjs/core/Materials/Textures/texture.js";
 import { TransformNode } from "@onerjs/core/Meshes/transformNode.js";
 import { Buffer, VertexBuffer } from "@onerjs/core/Buffers/buffer.js";
+import { VertexBufferForEach, VertexBufferGetTypeByteLength } from "@onerjs/core/Buffers/buffer.pure.js";
 import { Geometry } from "@onerjs/core/Meshes/geometry.js";
 import { AbstractMesh } from "@onerjs/core/Meshes/abstractMesh.js";
 import { Mesh } from "@onerjs/core/Meshes/mesh.js";
@@ -106,13 +107,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;
     }
@@ -182,8 +189,6 @@ export class GLTFLoader {
     constructor(parent) {
         /** @internal */
         this._completePromises = new Array();
-        /** AbortController used to cancel in-flight finalizeAsync() calls when dispose() is called. */
-        this._finalizeController = null;
         /** @internal */
         this._assetContainer = null;
         /** Storage */
@@ -195,6 +200,7 @@ export class GLTFLoader {
         /** @internal */
         this._skipStartAnimationStep = false;
         this._extensions = new Array();
+        /** @internal */
         this._disposed = false;
         this._rootUrl = null;
         this._fileName = null;
@@ -205,8 +211,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;
     }
     /**
@@ -218,10 +229,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;
@@ -236,8 +251,6 @@ export class GLTFLoader {
             return;
         }
         this._disposed = true;
-        this._finalizeController?.abort();
-        this._finalizeController = null;
         this._completePromises.length = 0;
         this._extensions.forEach((extension) => extension.dispose && extension.dispose());
         this._extensions.length = 0;
@@ -307,20 +320,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("@onerjs/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("@onerjs/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("@onerjs/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("@onerjs/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]}`;
@@ -380,25 +408,10 @@ export class GLTFLoader {
                     }
                 }
                 // Finalize all material adapters. finalizeAsync() may return a Promise for async
-                // work (e.g. GPU texture processing); push any such promises into
-                // _completePromises so they are awaited before the COMPLETE state is reached.
-                // Fall back to the deprecated finalize() for third-party adapters that have not
-                // yet migrated, logging a warning so authors know to update.
-                // An AbortController is created here and aborted in dispose() so that adapters
-                // can detect mid-flight disposal and clean up intermediate resources early.
-                this._finalizeController = new AbortController();
-                const finalizeSignal = this._finalizeController.signal;
+                // work (e.g. GPU texture processing); any returned Promise is pushed into
+                // _completePromises so it is awaited before the COMPLETE state is reached.
                 for (const adapter of Array.from(this._materialAdapters)) {
-                    if (adapter.finalizeAsync) {
-                        const finalizePromise = adapter.finalizeAsync(finalizeSignal);
-                        if (finalizePromise) {
-                            this._completePromises.push(finalizePromise);
-                        }
-                    }
-                    else if (adapter.finalize) {
-                        Logger.Warn("GLTFLoader: IMaterialLoadingAdapter.finalize() is deprecated. Implement finalizeAsync() instead.");
-                        adapter.finalize();
-                    }
+                    this._completePromises.push(adapter.finalizeAsync(this));
                 }
                 this._extensionsOnReady();
                 this._parent._setState(GLTFLoaderState.READY);
@@ -907,7 +920,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;
                     }
@@ -1652,7 +1665,7 @@ export class GLTFLoader {
             return accessor._data;
         }
         const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
-        const byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);
+        const byteStride = numComponents * VertexBufferGetTypeByteLength(accessor.componentType);
         const length = numComponents * accessor.count;
         if (accessor.bufferView == undefined) {
             accessor._data = Promise.resolve(new constructor(length));
@@ -1665,7 +1678,7 @@ export class GLTFLoader {
                 }
                 else {
                     const typedArray = new constructor(length);
-                    VertexBuffer.ForEach(data, accessor.byteOffset || 0, bufferView.byteStride || byteStride, numComponents, accessor.componentType, typedArray.length, accessor.normalized || false, (value, index) => {
+                    VertexBufferForEach(data, accessor.byteOffset || 0, bufferView.byteStride || byteStride, numComponents, accessor.componentType, typedArray.length, accessor.normalized || false, (value, index) => {
                         typedArray[index] = value;
                     });
                     return typedArray;
@@ -1691,7 +1704,7 @@ export class GLTFLoader {
                     else {
                         const sparseData = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);
                         values = new constructor(sparseLength);
-                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {
+                        VertexBufferForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {
                             values[index] = value;
                         });
                     }
@@ -1850,16 +1863,52 @@ export class GLTFLoader {
         await babylonData.promise;
         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);
@@ -1882,7 +1931,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;
     }
     /**
@@ -1972,7 +2021,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);
@@ -1980,12 +2029,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;
@@ -1993,7 +2042,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;
@@ -2249,7 +2298,7 @@ export class GLTFLoader {
         const buffer = bufferView.buffer;
         byteOffset = bufferView.byteOffset + (byteOffset || 0);
         const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, componentType);
-        const componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);
+        const componentTypeLength = VertexBufferGetTypeByteLength(componentType);
         if (byteOffset % componentTypeLength !== 0) {
             // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.
             Logger.Warn(`${context}: Copying buffer as byte offset (${byteOffset}) is not a multiple of component type byte length (${componentTypeLength})`);