@combeenation/3d-viewer 6.1.0-beta1 → 6.1.0-rc1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@combeenation/3d-viewer",
-  "version": "6.1.0-beta1",
+  "version": "6.1.0-rc1",
   "description": "Combeenation 3D Viewer",
   "homepage": "https://github.com/Combeenation/3d-viewer#readme",
   "bugs": {

package/src/api/classes/variant.ts

@@ -752,20 +752,12 @@ export class Variant extends Parameterizable {
       const elIsHiddenViaParams = elVisibleParamValueParsed === false;
       if (paramShowsVariant && elIsHiddenViaParams) continue;
 
-      // To discuss: Is this a viable solution or is it too hacky to apply the elements material param, when the param
-      //             at hand is actually the visible param?
       // Fixes https://combeenation.youtrack.cloud/issue/CB-7809
       // Apply element material before showing the element to prevent loading of the elements "original" material which
       // is never shown when "overwritten" by elements material param.
       const elMaterialParamPath = DottedPath.create([element.name, Parameter.MATERIAL]).toString();
       const elMaterialParamValue = this.inheritedParameters[elMaterialParamPath];
       if (paramShowsVariant && elMaterialParamValue) {
-        // To discuss: Should we rather use `this.commitParametersToElements` here?
-        //             I'm not really sure about the actual differences, both seem to do the job 🤷‍♂️
-        // To discuss: Should we actively `await` this (as is) or should we also push the resulting promise into the
-        //             `promises` array as dome some lines below?
-        //             I wasn't sure whether not awaiting this could result in "not guaranteed application order" of
-        //             new visibility & material param value...
         await element.commitParameter(Parameter.MATERIAL, elMaterialParamValue);
       }
 

package/src/api/manager/textureLoadManager.ts

@@ -1,6 +1,6 @@
 import { Event } from '../classes/event';
 import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { isFullyInitializedTexture } from '../util/babylonHelper';
+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';
@@ -20,7 +20,7 @@ export class TextureLoadManager extends EventBroadcaster {
   // 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_EVENT} as that is a situation which can lead to load masks being endlessly shown in a
+  // {@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.
@@ -29,7 +29,7 @@ export class TextureLoadManager extends EventBroadcaster {
 
   private constructor(public scene: BabylonScene) {
     super();
-    this.scene.onNewTextureAddedObservable.add(this.onTextureAdded.bind(this));
+    this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
   }
 
   public static create(scene: BabylonScene): TextureLoadManager {
@@ -40,7 +40,7 @@ export class TextureLoadManager extends EventBroadcaster {
   private startReadyStatePollingIfNeeded() {
     if (!this._readyStatePollingId) {
       this._readyStatePollingId = window.setInterval(
-        this.checkLoadingTexturesState.bind(this),
+        () => this.checkLoadingTexturesState(),
         this._readyStatePollingIntervalMs
       );
     }
@@ -55,7 +55,7 @@ export class TextureLoadManager extends EventBroadcaster {
 
   /**
    * 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. "not ready").
+   * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
    */
   private checkLoadingTexturesState() {
     const allTexturesReadyBefore = !this._loadingTextures.size;
@@ -75,21 +75,21 @@ export class TextureLoadManager extends EventBroadcaster {
 
   private async onTextureAdded(texture: BaseTexture) {
     // Workaround:
-    // The texture object is not fully created when the added observable is called. E.g. the function
+    // 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() || !isFullyInitializedTexture(texture)) return;
+    if (texture.isReady() || !isTextureWithOnLoadObservable(texture)) return;
 
-    const noCurrentLoadingTextures = this._loadingTextures.size <= 0;
+    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: Texture) => this.checkLoadingTexturesState());
+    texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
   }
 }

package/src/api/util/babylonHelper.ts

@@ -18,6 +18,7 @@ import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
 import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
 import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { Observable } from '@babylonjs/core/Misc/observable';
 import { Tools } from '@babylonjs/core/Misc/tools';
 import { Node } from '@babylonjs/core/node';
 import { Scene } from '@babylonjs/core/scene';
@@ -614,20 +615,24 @@ const getClientRectFromMesh = function (mesh: AbstractMesh, scene: Scene, canvas
   } as ClientRect;
 };
 
+type BaseTextureWithOnLoadObservable = BaseTexture & {
+  onLoadObservable: Observable<BaseTexture>;
+};
+
 /**
- * This type guard does not only check whether the given `BaseTexture` is of subtype `Texture`, but also whether it has
- * been fully initialized or not.
+ * This type guard checks whether the given `BaseTextures` is any of its subtypes which comes with an
+ * `onLoadObservable`.
  *
- * See the following for more details on why "is fully initialized" makes a difference in this regard:
- * https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/4
+ * !!! Timing of when this function is called is important !!!
+ * See the following for more details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/6
  */
-const isFullyInitializedTexture = function (texture: BaseTexture): texture is Texture {
-  return !!(texture as Texture).onLoadObservable;
+const isTextureWithOnLoadObservable = function (texture: BaseTexture): texture is BaseTextureWithOnLoadObservable {
+  return !!(texture as BaseTextureWithOnLoadObservable).onLoadObservable;
 };
 
 export {
   getRootNode,
-  isFullyInitializedTexture,
+  isTextureWithOnLoadObservable,
   mapToDottedNodes,
   getDottedPathForNode,
   cloneTransformNode,