@combeenation/3d-viewer 6.1.0 → 6.2.0

package/dist/lib-cjs/api/manager/sceneManager.js

@@ -1,131 +1,131 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SceneManager = void 0;
-const event_1 = require("../classes/event");
-const parameter_1 = require("../classes/parameter");
-const parameterObservable_1 = require("../classes/parameterObservable");
-const specStorage_1 = require("../store/specStorage");
-const babylonHelper_1 = require("../util/babylonHelper");
-const resourceHelper_1 = require("../util/resourceHelper");
-const textureLoadManager_1 = require("./textureLoadManager");
-const lodash_es_1 = require("lodash-es");
-class SceneManager extends parameterObservable_1.ParameterObservable {
-    /**
-     * Constructor.
-     */
-    constructor(scene) {
-        super();
-        this.scene = scene;
-        this._parameterObservers = new Map();
-        this._textureLoadManager = null;
-        this._textureLoadManager = textureLoadManager_1.TextureLoadManager.create(scene);
-        this.addParameterObservers();
-    }
-    /**
-     * Creates a {@link SceneManager} based on given BabylonJS scene.
-     */
-    static create(scene) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sceneManager = new SceneManager(scene);
-            yield sceneManager.bootstrapParameters(specStorage_1.SpecStorage.get('scene.parameters'));
-            return sceneManager;
-        });
-    }
-    /**
-     * The active `Camera`.
-     */
-    get activeCamera() {
-        if (!this.scene.activeCamera) {
-            throw new Error('Scene has no active camera.');
-        }
-        return this.scene.activeCamera;
-    }
-    /**
-     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
-     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
-     *
-     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
-     */
-    commitParameters(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!parameters) {
-                parameters = {};
-            }
-            const oldParameters = (0, lodash_es_1.cloneDeep)(this.parameters);
-            (0, lodash_es_1.merge)(this.parameters, parameters);
-            // handle parameter observers
-            let observerPromises = [];
-            for (const parameter in this.parameters) {
-                const oldParameterValue = oldParameters[parameter];
-                const newParameterValue = this.parameters[parameter];
-                this.assertParameter(parameter_1.Parameter.declarations, parameter, newParameterValue);
-                if (oldParameterValue === newParameterValue) {
-                    continue;
-                }
-                // parameter changed
-                const parameterObservers = (0, resourceHelper_1.mergeMaps)(this._parameterObservers, this.parameterObservers);
-                if (parameterObservers.has(parameter)) {
-                    const observers = parameterObservers.get(parameter);
-                    observerPromises = (0, lodash_es_1.concat)(observerPromises, observers.map(observer => {
-                        const observerResult = observer(this, oldParameterValue, newParameterValue);
-                        const observerPromise = Promise.resolve(observerResult);
-                        observerPromise.then(() => {
-                            this.broadcastEvent(event_1.Event.SCENE_PARAMETER_COMMITTED, this, parameter, oldParameterValue, newParameterValue);
-                        });
-                        return observerPromise;
-                    }));
-                }
-            }
-            yield Promise.all(observerPromises);
-            return this;
-        });
-    }
-    addParameterObservers() {
-        const handleEnvParamChange = (manager, oldValue, newValue) => {
-            const params = {
-                color: manager.parameters[parameter_1.Parameter.ENVIRONMENT_COLOR],
-                intensity: manager.parameters[parameter_1.Parameter.ENVIRONMENT_INTENSITY],
-                env: manager.parameters[parameter_1.Parameter.ENVIRONMENT],
-                background: manager.parameters[parameter_1.Parameter.ENVIRONMENT_BACKGROUND],
-                rotation: manager.parameters[parameter_1.Parameter.ENVIRONMENT_ROTATION],
-                useDefault: manager.parameters[parameter_1.Parameter.ENVIRONMENT_USEDEFAULT],
-            };
-            const envDef = {
-                environmentColor: params.color ? parameter_1.Parameter.parseColor(params.color) : undefined,
-                environmentIntensity: params.intensity !== undefined ? parameter_1.Parameter.parseNumber(params.intensity) : undefined,
-                environment: params.env ? params.env : undefined,
-                environmentBackground: params.background ? params.background : undefined,
-                environmentRotation: params.rotation !== undefined ? parameter_1.Parameter.parseNumber(params.rotation) : undefined,
-                environmentUseDefault: params.useDefault ? parameter_1.Parameter.parseBoolean(params.useDefault) : undefined,
-            };
-            (0, babylonHelper_1.changeEnvironment)(manager.scene, envDef);
-        };
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_COLOR, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_ROTATION, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_USEDEFAULT, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_BACKGROUND, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_INTENSITY, [handleEnvParamChange]);
-        return this;
-    }
-    /**
-     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
-     */
-    bootstrapParameters(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.commitParameters((0, lodash_es_1.merge)((0, lodash_es_1.cloneDeep)(this.parameters), parameters));
-            return this;
-        });
-    }
-}
-exports.SceneManager = SceneManager;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneManager = void 0;
+const event_1 = require("../classes/event");
+const parameter_1 = require("../classes/parameter");
+const parameterObservable_1 = require("../classes/parameterObservable");
+const specStorage_1 = require("../store/specStorage");
+const babylonHelper_1 = require("../util/babylonHelper");
+const resourceHelper_1 = require("../util/resourceHelper");
+const textureLoadManager_1 = require("./textureLoadManager");
+const lodash_es_1 = require("lodash-es");
+class SceneManager extends parameterObservable_1.ParameterObservable {
+    /**
+     * Constructor.
+     */
+    constructor(scene) {
+        super();
+        this.scene = scene;
+        this._parameterObservers = new Map();
+        this._textureLoadManager = null;
+        this._textureLoadManager = textureLoadManager_1.TextureLoadManager.create(scene);
+        this.addParameterObservers();
+    }
+    /**
+     * Creates a {@link SceneManager} based on given BabylonJS scene.
+     */
+    static create(scene) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sceneManager = new SceneManager(scene);
+            yield sceneManager.bootstrapParameters(specStorage_1.SpecStorage.get('scene.parameters'));
+            return sceneManager;
+        });
+    }
+    /**
+     * The active `Camera`.
+     */
+    get activeCamera() {
+        if (!this.scene.activeCamera) {
+            throw new Error('Scene has no active camera.');
+        }
+        return this.scene.activeCamera;
+    }
+    /**
+     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
+     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+     *
+     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!parameters) {
+                parameters = {};
+            }
+            const oldParameters = (0, lodash_es_1.cloneDeep)(this.parameters);
+            (0, lodash_es_1.merge)(this.parameters, parameters);
+            // handle parameter observers
+            let observerPromises = [];
+            for (const parameter in this.parameters) {
+                const oldParameterValue = oldParameters[parameter];
+                const newParameterValue = this.parameters[parameter];
+                this.assertParameter(parameter_1.Parameter.declarations, parameter, newParameterValue);
+                if (oldParameterValue === newParameterValue) {
+                    continue;
+                }
+                // parameter changed
+                const parameterObservers = (0, resourceHelper_1.mergeMaps)(this._parameterObservers, this.parameterObservers);
+                if (parameterObservers.has(parameter)) {
+                    const observers = parameterObservers.get(parameter);
+                    observerPromises = (0, lodash_es_1.concat)(observerPromises, observers.map(observer => {
+                        const observerResult = observer(this, oldParameterValue, newParameterValue);
+                        const observerPromise = Promise.resolve(observerResult);
+                        observerPromise.then(() => {
+                            this.broadcastEvent(event_1.Event.SCENE_PARAMETER_COMMITTED, this, parameter, oldParameterValue, newParameterValue);
+                        });
+                        return observerPromise;
+                    }));
+                }
+            }
+            yield Promise.all(observerPromises);
+            return this;
+        });
+    }
+    addParameterObservers() {
+        const handleEnvParamChange = (manager, oldValue, newValue) => {
+            const params = {
+                color: manager.parameters[parameter_1.Parameter.ENVIRONMENT_COLOR],
+                intensity: manager.parameters[parameter_1.Parameter.ENVIRONMENT_INTENSITY],
+                env: manager.parameters[parameter_1.Parameter.ENVIRONMENT],
+                background: manager.parameters[parameter_1.Parameter.ENVIRONMENT_BACKGROUND],
+                rotation: manager.parameters[parameter_1.Parameter.ENVIRONMENT_ROTATION],
+                useDefault: manager.parameters[parameter_1.Parameter.ENVIRONMENT_USEDEFAULT],
+            };
+            const envDef = {
+                environmentColor: params.color ? parameter_1.Parameter.parseColor(params.color) : undefined,
+                environmentIntensity: params.intensity !== undefined ? parameter_1.Parameter.parseNumber(params.intensity) : undefined,
+                environment: params.env ? params.env : undefined,
+                environmentBackground: params.background ? params.background : undefined,
+                environmentRotation: params.rotation !== undefined ? parameter_1.Parameter.parseNumber(params.rotation) : undefined,
+                environmentUseDefault: params.useDefault ? parameter_1.Parameter.parseBoolean(params.useDefault) : undefined,
+            };
+            (0, babylonHelper_1.changeEnvironment)(manager.scene, envDef);
+        };
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_COLOR, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_ROTATION, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_USEDEFAULT, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_BACKGROUND, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_INTENSITY, [handleEnvParamChange]);
+        return this;
+    }
+    /**
+     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+     */
+    bootstrapParameters(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.commitParameters((0, lodash_es_1.merge)((0, lodash_es_1.cloneDeep)(this.parameters), parameters));
+            return this;
+        });
+    }
+}
+exports.SceneManager = SceneManager;
 //# sourceMappingURL=sceneManager.js.map

package/dist/lib-cjs/api/manager/textureLoadManager.d.ts

@@ -1,22 +1,22 @@
-import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { Scene as BabylonScene } from '@babylonjs/core/scene';
-/**
- * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
- * {@link Event.TEXTURE_LOADING_END} events.
- */
-export declare class TextureLoadManager extends EventBroadcaster {
-    scene: BabylonScene;
-    private readonly _loadingTextures;
-    private _readyStatePollingIntervalMs;
-    private _readyStatePollingId;
-    private constructor();
-    static create(scene: BabylonScene): TextureLoadManager;
-    private startReadyStatePollingIfNeeded;
-    private endReadyStatePollingIfNeeded;
-    /**
-     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
-     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
-     */
-    private checkLoadingTexturesState;
-    private onTextureAdded;
-}
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+/**
+ * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
+ * {@link Event.TEXTURE_LOADING_END} events.
+ */
+export declare class TextureLoadManager extends EventBroadcaster {
+    scene: BabylonScene;
+    private readonly _loadingTextures;
+    private _readyStatePollingIntervalMs;
+    private _readyStatePollingId;
+    private constructor();
+    static create(scene: BabylonScene): TextureLoadManager;
+    private startReadyStatePollingIfNeeded;
+    private endReadyStatePollingIfNeeded;
+    /**
+     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
+     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
+     */
+    private checkLoadingTexturesState;
+    private onTextureAdded;
+}

package/dist/lib-cjs/api/manager/textureLoadManager.js

@@ -1,98 +1,98 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextureLoadManager = void 0;
-const event_1 = require("../classes/event");
-const eventBroadcaster_1 = require("../classes/eventBroadcaster");
-const babylonHelper_1 = require("../util/babylonHelper");
-const resourceHelper_1 = require("../util/resourceHelper");
-/**
- * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
- * {@link Event.TEXTURE_LOADING_END} events.
- */
-class TextureLoadManager extends eventBroadcaster_1.EventBroadcaster {
-    constructor(scene) {
-        super();
-        this.scene = scene;
-        // We're keeping track of all "loading textures" in this map ourselves instead of relying on information from
-        // `scene.textures` as that proved to be rather unreliable for our use cases.
-        // E.g. see this forums post for some more information:
-        // https://forum.babylonjs.com/t/using-scene-createdefaultenvironment-removes-textures-from-scene/35267
-        this._loadingTextures = new Map();
-        // Whenever we fire the {@link Event.TEXTURE_LOADING_START} event, we're starting a polling service which checks all
-        // x ms if all awaited textures are in "ready state" or not.
-        // This is basically just an additional safety net in addition to our `onLoadObservable`s and was added to prevent
-        // situations where a {@link Event.TEXTURE_LOADING_START} event is fired without an accompanying
-        // {@link Event.TEXTURE_LOADING_END} as that is a situation which can lead to load masks being endlessly shown in a
-        // cfgr.
-        // In theory this shouldn't be necessary, but we've already discovered some quirks and inconsistent behavior around
-        // the texture load observables etc. and I felt more save with this safety net in place.
-        this._readyStatePollingIntervalMs = 200;
-        this._readyStatePollingId = 0;
-        this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
-    }
-    static create(scene) {
-        const loadMgr = new TextureLoadManager(scene);
-        return loadMgr;
-    }
-    startReadyStatePollingIfNeeded() {
-        if (!this._readyStatePollingId) {
-            this._readyStatePollingId = window.setInterval(() => this.checkLoadingTexturesState(), this._readyStatePollingIntervalMs);
-        }
-    }
-    endReadyStatePollingIfNeeded() {
-        if (this._readyStatePollingId) {
-            window.clearInterval(this._readyStatePollingId);
-            this._readyStatePollingId = 0;
-        }
-    }
-    /**
-     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
-     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
-     */
-    checkLoadingTexturesState() {
-        const allTexturesReadyBefore = !this._loadingTextures.size;
-        if (allTexturesReadyBefore)
-            return;
-        // Remove textures which are in "ready state" from the map
-        for (const [id, texture] of this._loadingTextures) {
-            if (texture.isReady())
-                this._loadingTextures.delete(id);
-        }
-        const allTexturesReadyAfter = !this._loadingTextures.size;
-        if (allTexturesReadyAfter) {
-            this.broadcastEvent(event_1.Event.TEXTURE_LOADING_END);
-            this.endReadyStatePollingIfNeeded();
-        }
-    }
-    onTextureAdded(texture) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Workaround:
-            // The texture object is not fully created when the "added observable" is called. E.g. the function
-            // `onLoadObservable` is not there at that point.
-            // More details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/4
-            yield (0, resourceHelper_1.sleep)(0);
-            // Some textures are already in "ready state" after the sleep -> We don't care for them anymore as well as for
-            // textures which don't come with an `onLoadObservable` (i.e. not of class {@link Texture}).
-            if (texture.isReady() || !(0, babylonHelper_1.isTextureWithOnLoadObservable)(texture))
-                return;
-            const noCurrentLoadingTextures = !this._loadingTextures.size;
-            if (noCurrentLoadingTextures) {
-                this.broadcastEvent(event_1.Event.TEXTURE_LOADING_START);
-                this.startReadyStatePollingIfNeeded();
-            }
-            this._loadingTextures.set(texture.uniqueId, texture);
-            texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
-        });
-    }
-}
-exports.TextureLoadManager = TextureLoadManager;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextureLoadManager = void 0;
+const event_1 = require("../classes/event");
+const eventBroadcaster_1 = require("../classes/eventBroadcaster");
+const babylonHelper_1 = require("../util/babylonHelper");
+const resourceHelper_1 = require("../util/resourceHelper");
+/**
+ * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
+ * {@link Event.TEXTURE_LOADING_END} events.
+ */
+class TextureLoadManager extends eventBroadcaster_1.EventBroadcaster {
+    constructor(scene) {
+        super();
+        this.scene = scene;
+        // We're keeping track of all "loading textures" in this map ourselves instead of relying on information from
+        // `scene.textures` as that proved to be rather unreliable for our use cases.
+        // E.g. see this forums post for some more information:
+        // https://forum.babylonjs.com/t/using-scene-createdefaultenvironment-removes-textures-from-scene/35267
+        this._loadingTextures = new Map();
+        // Whenever we fire the {@link Event.TEXTURE_LOADING_START} event, we're starting a polling service which checks all
+        // x ms if all awaited textures are in "ready state" or not.
+        // This is basically just an additional safety net in addition to our `onLoadObservable`s and was added to prevent
+        // situations where a {@link Event.TEXTURE_LOADING_START} event is fired without an accompanying
+        // {@link Event.TEXTURE_LOADING_END} as that is a situation which can lead to load masks being endlessly shown in a
+        // cfgr.
+        // In theory this shouldn't be necessary, but we've already discovered some quirks and inconsistent behavior around
+        // the texture load observables etc. and I felt more save with this safety net in place.
+        this._readyStatePollingIntervalMs = 200;
+        this._readyStatePollingId = 0;
+        this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
+    }
+    static create(scene) {
+        const loadMgr = new TextureLoadManager(scene);
+        return loadMgr;
+    }
+    startReadyStatePollingIfNeeded() {
+        if (!this._readyStatePollingId) {
+            this._readyStatePollingId = window.setInterval(() => this.checkLoadingTexturesState(), this._readyStatePollingIntervalMs);
+        }
+    }
+    endReadyStatePollingIfNeeded() {
+        if (this._readyStatePollingId) {
+            window.clearInterval(this._readyStatePollingId);
+            this._readyStatePollingId = 0;
+        }
+    }
+    /**
+     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
+     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
+     */
+    checkLoadingTexturesState() {
+        const allTexturesReadyBefore = !this._loadingTextures.size;
+        if (allTexturesReadyBefore)
+            return;
+        // Remove textures which are in "ready state" from the map
+        for (const [id, texture] of this._loadingTextures) {
+            if (texture.isReady())
+                this._loadingTextures.delete(id);
+        }
+        const allTexturesReadyAfter = !this._loadingTextures.size;
+        if (allTexturesReadyAfter) {
+            this.broadcastEvent(event_1.Event.TEXTURE_LOADING_END);
+            this.endReadyStatePollingIfNeeded();
+        }
+    }
+    onTextureAdded(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Workaround:
+            // The texture object is not fully created when the "added observable" is called. E.g. the function
+            // `onLoadObservable` is not there at that point.
+            // More details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/4
+            yield (0, resourceHelper_1.sleep)(0);
+            // Some textures are already in "ready state" after the sleep -> We don't care for them anymore as well as for
+            // textures which don't come with an `onLoadObservable` (i.e. not of class {@link Texture}).
+            if (texture.isReady() || !(0, babylonHelper_1.isTextureWithOnLoadObservable)(texture))
+                return;
+            const noCurrentLoadingTextures = !this._loadingTextures.size;
+            if (noCurrentLoadingTextures) {
+                this.broadcastEvent(event_1.Event.TEXTURE_LOADING_START);
+                this.startReadyStatePollingIfNeeded();
+            }
+            this._loadingTextures.set(texture.uniqueId, texture);
+            texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
+        });
+    }
+}
+exports.TextureLoadManager = TextureLoadManager;
 //# sourceMappingURL=textureLoadManager.js.map