@babylonjs/loaders 9.26.1 → 9.27.0

package/glTF/2.0/glTFLoader.pure.d.ts

@@ -362,10 +362,11 @@ export declare class GLTFLoader implements IGLTFLoader {
      * @internal
      */
     _loadTextureAsync(context: string, texture: ITexture, assign?: (babylonTexture: BaseTexture) => void): Promise<BaseTexture>;
+    private _trackTexture;
     /**
      * @internal
      */
-    _createTextureAsync(context: string, sampler: ISampler, image: IImage, assign?: (babylonTexture: BaseTexture) => void, textureLoaderOptions?: unknown, useSRGBBuffer?: boolean): Promise<BaseTexture>;
+    _createTextureAsync(context: string, sampler: ISampler, image: IImage, assign?: (babylonTexture: BaseTexture) => void, textureLoaderOptions?: unknown, useSRGBBuffer?: boolean, sourceTexture?: ITexture): Promise<BaseTexture>;
     private _loadSampler;
     /**
      * Loads a glTF image.
@@ -403,7 +404,7 @@ export declare class GLTFLoader implements IGLTFLoader {
     private _forEachExtensions;
     private _applyExtensions;
     private _extensionsOnLoading;
-    private _extensionsOnReady;
+    private _extensionsOnReadyAsync;
     private _extensionsLoadSceneAsync;
     private _extensionsLoadNodeAsync;
     private _extensionsLoadCameraAsync;

package/glTF/2.0/glTFLoader.pure.js

@@ -405,7 +405,7 @@ export class GLTFLoader {
             if (this._parent.compileShadowGenerators) {
                 promises.push(this._compileShadowGeneratorsAsync());
             }
-            const resultPromise = Promise.all(promises).then(() => {
+            const resultPromise = Promise.all(promises).then(async () => {
                 if (this._rootBabylonMesh && this._rootBabylonMesh !== this._parent.customRootNode) {
                     this._rootBabylonMesh.setEnabled(true);
                 }
@@ -422,7 +422,7 @@ export class GLTFLoader {
                 for (const adapter of Array.from(this._materialAdapters)) {
                     this._completePromises.push(adapter.finalizeAsync(this));
                 }
-                this._extensionsOnReady();
+                await this._extensionsOnReadyAsync();
                 this._parent._setState(GLTFLoaderState.READY);
                 if (!this._skipStartAnimationStep) {
                     this._startAnimations();
@@ -2061,7 +2061,13 @@ export class GLTFLoader {
     loadTextureInfoAsync(context, textureInfo, assign = () => { }) {
         const extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
         if (extensionPromise) {
-            return extensionPromise;
+            return extensionPromise.then((babylonTexture) => {
+                const texture = this._gltf.textures?.[textureInfo.index];
+                if (texture) {
+                    this._trackTexture(texture, babylonTexture);
+                }
+                return babylonTexture;
+            });
         }
         this.logOpen(`${context}`);
         if (textureInfo.texCoord >= 6) {
@@ -2082,21 +2088,49 @@ export class GLTFLoader {
      * @internal
      */
     _loadTextureAsync(context, texture, assign = () => { }) {
-        const extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
+        const trackAndAssign = (babylonTexture) => {
+            this._trackTexture(texture, babylonTexture);
+            assign(babylonTexture);
+        };
+        const extensionPromise = this._extensionsLoadTextureAsync(context, texture, trackAndAssign);
         if (extensionPromise) {
             return extensionPromise;
         }
         this.logOpen(`${context} ${texture.name || ""}`);
         const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._gltf.samplers, texture.sampler);
         const image = ArrayItem.Get(`${context}/source`, this._gltf.images, texture.source);
-        const promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
+        const promise = this._createTextureAsync(context, sampler, image, trackAndAssign, undefined, !texture._textureInfo.nonColorData, texture);
         this.logClose();
         return promise;
     }
+    _trackTexture(texture, babylonTexture, imageIndex, samplerIndex) {
+        texture._babylonTextures || (texture._babylonTextures = []);
+        if (!texture._babylonTextures.includes(babylonTexture)) {
+            texture._babylonTextures.push(babylonTexture);
+        }
+        texture._babylonTextureSources || (texture._babylonTextureSources = []);
+        const existing = texture._babylonTextureSources.find((source) => source.babylonTexture === babylonTexture);
+        const fallback = texture._babylonTextureSources[texture._babylonTextureSources.length - 1];
+        const resolvedImageIndex = imageIndex ?? existing?.imageIndex ?? fallback?.imageIndex;
+        if (resolvedImageIndex === undefined) {
+            return;
+        }
+        if (existing) {
+            existing.imageIndex = resolvedImageIndex;
+            existing.samplerIndex = samplerIndex ?? existing.samplerIndex ?? fallback?.samplerIndex;
+        }
+        else {
+            texture._babylonTextureSources.push({
+                babylonTexture,
+                imageIndex: resolvedImageIndex,
+                samplerIndex: samplerIndex ?? fallback?.samplerIndex,
+            });
+        }
+    }
     /**
      * @internal
      */
-    _createTextureAsync(context, sampler, image, assign = () => { }, textureLoaderOptions, useSRGBBuffer) {
+    _createTextureAsync(context, sampler, image, assign = () => { }, textureLoaderOptions, useSRGBBuffer, sourceTexture) {
         const samplerData = this._loadSampler(`/samplers/${sampler.index}`, sampler);
         const promises = new Array();
         const deferred = new Deferred();
@@ -2120,6 +2154,9 @@ export class GLTFLoader {
             useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,
         };
         const babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
+        if (sourceTexture) {
+            this._trackTexture(sourceTexture, babylonTexture, image.index, sampler.index >= 0 ? sampler.index : undefined);
+        }
         babylonTexture._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         promises.push(deferred.promise);
@@ -2424,8 +2461,13 @@ export class GLTFLoader {
     _extensionsOnLoading() {
         this._forEachExtensions((extension) => extension.onLoading && extension.onLoading());
     }
-    _extensionsOnReady() {
-        this._forEachExtensions((extension) => extension.onReady && extension.onReady());
+    async _extensionsOnReadyAsync() {
+        for (const extension of this._extensions) {
+            if (extension.enabled && extension.onReady) {
+                // eslint-disable-next-line no-await-in-loop -- extension order can define readiness dependencies
+                await extension.onReady();
+            }
+        }
     }
     _extensionsLoadSceneAsync(context, scene) {
         return this._applyExtensions(scene, "loadScene", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));