@combeenation/3d-viewer 7.1.3 → 8.1.0-alpha1

package/src/api/manager/textureLoadManager.ts

@@ -1,95 +1,95 @@
-import { Event } from '../classes/event';
-import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { isTextureWithOnLoadObservable } from '../util/babylonHelper';
-import { sleep } from '../util/resourceHelper';
-import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
-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 class TextureLoadManager extends EventBroadcaster {
-  // 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
-  private readonly _loadingTextures: Map<number, BaseTexture> = 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.
-  private _readyStatePollingIntervalMs = 200;
-  private _readyStatePollingId = 0;
-
-  private constructor(public scene: BabylonScene) {
-    super();
-    this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
-  }
-
-  public static create(scene: BabylonScene): TextureLoadManager {
-    const loadMgr = new TextureLoadManager(scene);
-    return loadMgr;
-  }
-
-  private startReadyStatePollingIfNeeded() {
-    if (!this._readyStatePollingId) {
-      this._readyStatePollingId = window.setInterval(
-        () => this.checkLoadingTexturesState(),
-        this._readyStatePollingIntervalMs
-      );
-    }
-  }
-
-  private 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").
-   */
-  private 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.TEXTURE_LOADING_END);
-      this.endReadyStatePollingIfNeeded();
-    }
-  }
-
-  private async onTextureAdded(texture: BaseTexture) {
-    // 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
-    await 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() || !isTextureWithOnLoadObservable(texture)) return;
-
-    const noCurrentLoadingTextures = !this._loadingTextures.size;
-    if (noCurrentLoadingTextures) {
-      this.broadcastEvent(Event.TEXTURE_LOADING_START);
-      this.startReadyStatePollingIfNeeded();
-    }
-    this._loadingTextures.set(texture.uniqueId, texture);
-    texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
-  }
-}
+import { Event } from '../classes/event';
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { isTextureWithOnLoadObservable } from '../util/babylonHelper';
+import { sleep } from '../util/resourceHelper';
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+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 class TextureLoadManager extends EventBroadcaster {
+  // 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
+  private readonly _loadingTextures: Map<number, BaseTexture> = 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.
+  private _readyStatePollingIntervalMs = 200;
+  private _readyStatePollingId = 0;
+
+  private constructor(public scene: BabylonScene) {
+    super();
+    this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
+  }
+
+  public static create(scene: BabylonScene): TextureLoadManager {
+    const loadMgr = new TextureLoadManager(scene);
+    return loadMgr;
+  }
+
+  private startReadyStatePollingIfNeeded() {
+    if (!this._readyStatePollingId) {
+      this._readyStatePollingId = window.setInterval(
+        () => this.checkLoadingTexturesState(),
+        this._readyStatePollingIntervalMs
+      );
+    }
+  }
+
+  private 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").
+   */
+  private 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.TEXTURE_LOADING_END);
+      this.endReadyStatePollingIfNeeded();
+    }
+  }
+
+  private async onTextureAdded(texture: BaseTexture) {
+    // 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
+    await 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() || !isTextureWithOnLoadObservable(texture)) return;
+
+    const noCurrentLoadingTextures = !this._loadingTextures.size;
+    if (noCurrentLoadingTextures) {
+      this.broadcastEvent(Event.TEXTURE_LOADING_START);
+      this.startReadyStatePollingIfNeeded();
+    }
+    this._loadingTextures.set(texture.uniqueId, texture);
+    texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
+  }
+}