@combeenation/3d-viewer 6.2.0 → 6.2.1

package/package.json

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

package/src/api/classes/viewer.ts

@@ -65,6 +65,15 @@ export class Viewer extends EventBroadcaster {
 
   static version = buildInfo.version;
 
+  // these are constants for calculating the camera settings, depending on the bounding box size of the meshes to zoom
+  // the algorithms and constant values are directly taken from the BabylonJS repository
+  private static readonly _autofocusConstants = {
+    minZ: 100,
+    wheelPrecision: 100,
+    panningSensibility: 5000,
+    pinchPrecision: 200,
+  };
+
   /**
    * Help function for automatically creating a valid Spec from a list of variant names and dedicated GLB/Babylon URLs.
    * This data is most likely coming from babylon assets from the Combeenation system but other sources are also valid.
@@ -461,12 +470,40 @@ export class Viewer extends EventBroadcaster {
     // get bounding box of all visible meshes, this is the base for the autofocus algorithm
     const boundingBox = await this.calculateBoundingBox(exclude);
 
-    // focus the helper camera and set the calculated camera data to the real camera
-    const helperCamera = this.getFocusedHelperCamera(boundingBox, settings);
-    await this.applyFocusedHelperCameraData(activeCamera, helperCamera, settings);
+    const radius = boundingBox.getBoundingInfo().boundingSphere.radius;
+    const center = boundingBox.getBoundingInfo().boundingSphere.center;
+    const diameter = radius * 2;
+
+    // set lower radius limit on edge of bounding sphere to make sure that we can't dive into the meshes
+    activeCamera.lowerRadiusLimit = radius;
 
-    // remove the helper camera
-    helperCamera.dispose();
+    // additional settings
+    // constants for division are taken directly from BabylonJS repository
+    activeCamera.minZ = Math.min(radius / Viewer._autofocusConstants.minZ, 1);
+    if (settings?.adjustWheelPrecision !== false) {
+      activeCamera.wheelPrecision = Viewer._autofocusConstants.wheelPrecision / radius;
+    }
+    if (settings?.adjustPanningSensibility !== false) {
+      activeCamera.panningSensibility = Viewer._autofocusConstants.panningSensibility / diameter;
+    }
+    if (settings?.adjustPinchPrecision !== false) {
+      activeCamera.pinchPrecision = Viewer._autofocusConstants.pinchPrecision / radius;
+    }
+
+    const radiusFactor = settings?.radiusFactor ?? 1;
+    const alpha = (settings?.alpha ?? -90) * (Math.PI / 180);
+    const beta = (settings?.beta ?? 90) * (Math.PI / 180);
+
+    const newCameraPosition = {
+      alpha: alpha,
+      beta: beta,
+      // this calculation is a bit "simplified", as it doesn't consider the viewport ratio or the frustum angle
+      // but it's also done this way in the BabylonJs repository, so it should be fine for us
+      radius: diameter * radiusFactor,
+      target: center,
+    };
+
+    await this.animationManager.animateToPlacement(activeCamera, newCameraPosition, settings?.animation);
   }
 
   /**
@@ -629,7 +666,10 @@ export class Viewer extends EventBroadcaster {
     const setupJson = SpecStorage.get<SetupJson>('setup');
     const instances: VariantInstance[] = [];
     for (const instanceDefinition of setupJson.instances) {
-      if (instanceDefinition.lazy) {
+      // don't create the instance right away if `lazy` is set, register it for later creation (on first usage) instead
+      // however if the variant should be `visible` by default, `lazy` loading doesn't make sense and should therefore
+      // be overruled by the `visible` flag
+      if (instanceDefinition.lazy && instanceDefinition.parameters?.visible !== true) {
         this.variantInstances.register(instanceDefinition);
         continue;
       }
@@ -643,78 +683,4 @@ export class Viewer extends EventBroadcaster {
     }
     return instances;
   }
-
-  /**
-   * Help function for focusing a helper camera exactly onto the given bounding box
-   */
-  private getFocusedHelperCamera(boundingBox: Mesh, settings?: AutofocusSettings): ArcRotateCamera {
-    // use helper camera to get some default values and set the values of the real camera accordingly
-    const helperCamera = new ArcRotateCamera(
-      '__helper_camera__',
-      0, // camera angles will be overwritten after the target has been set
-      0,
-      0, // radius will be calculated, so we can set to 0 here
-      Vector3.Zero(),
-      this.scene
-    );
-    // this is required for automatically calculating the `lowerRadiusLimit`, so that we don't "dive" into meshes
-    // see https://doc.babylonjs.com/divingDeeper/behaviors/cameraBehaviors#framing-behavior
-    helperCamera.useFramingBehavior = true;
-
-    // `minZ` is the camera distance beyond which the mesh will be clipped
-    // this should be very low, but can't be zero
-    // a good value seems to be 1% of the bounding box size (= radius), whereas the value shouldn't go above 1, which is
-    // also the default value
-    const radius = boundingBox.getBoundingInfo().boundingSphere.radius;
-    helperCamera.minZ = Math.min(radius / 100, 1);
-
-    // set desired camera data, these won't be changed by the autofocus function!
-    // default values should focus the element exactly from the front (= XY Plane)
-    helperCamera.setTarget(boundingBox, true);
-    helperCamera.alpha = (settings?.alpha ?? -90) * (Math.PI / 180);
-    helperCamera.beta = (settings?.beta ?? 90) * (Math.PI / 180);
-
-    // finally zoom to the bounding box
-    // also apply a zoom factor, this adjusts the borders around the model in the viewport
-    helperCamera.zoomOnFactor = settings?.radiusFactor || 1;
-    helperCamera.zoomOn([boundingBox], true);
-
-    return helperCamera;
-  }
-
-  /**
-   * Help function for applying the relevant data of the focused helper camera to the real camera
-   */
-  private async applyFocusedHelperCameraData(
-    activeCamera: ArcRotateCamera,
-    helperCamera: ArcRotateCamera,
-    settings?: AutofocusSettings
-  ) {
-    // limits
-    activeCamera.minZ = helperCamera.minZ;
-    activeCamera.maxZ = helperCamera.maxZ;
-    activeCamera.lowerRadiusLimit = helperCamera.lowerRadiusLimit;
-    activeCamera.upperRadiusLimit = helperCamera.upperRadiusLimit;
-
-    // additional settings
-    if (settings?.adjustWheelPrecision !== false) {
-      activeCamera.wheelPrecision = helperCamera.wheelPrecision;
-    }
-    if (settings?.adjustPanningSensibility !== false) {
-      activeCamera.panningSensibility = helperCamera.panningSensibility;
-    }
-    if (settings?.adjustPinchPrecision !== false) {
-      activeCamera.pinchPrecision = helperCamera.pinchPrecision;
-    }
-
-    // finally move the camera
-    // do this at last, so that all camera settings are already considered
-    const newCameraPosition: PlacementDefinition = {
-      alpha: helperCamera.alpha,
-      beta: helperCamera.beta,
-      radius: helperCamera.radius,
-      target: helperCamera.target,
-    };
-    await this.animationManager.animateToPlacement(activeCamera, newCameraPosition, settings?.animation);
-  }
 }