@vertexvis/viewer 0.18.0 → 0.18.1-testing.0

package/dist/cjs/index.cjs.js

@@ -6,7 +6,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const scene = require('./scene-5f6d7efe.js');
-const controller = require('./controller-6914028a.js');
+const controller = require('./controller-ee852f01.js');
 const row = require('./row-8f1b8d84.js');
 const cursors = require('./cursors-5f6e27c0.js');
 const entities$1 = require('./entities-c40e141f.js');

package/dist/cjs/vertex-scene-tree.cjs.entry.js

@@ -7,8 +7,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-b99cd335.js');
 const bundle_esm = require('./bundle.esm-5847ff0b.js');
-const controller = require('./controller-6914028a.js');
-const config = require('./config-ee5af2fe.js');
+const controller = require('./controller-ee852f01.js');
+const config = require('./config-ace9f5d5.js');
 const dom = require('./dom-bf5bd243.js');
 const row = require('./row-8f1b8d84.js');
 require('./wrappers_pb-9ec12cf5.js');

package/dist/cjs/vertex-viewer-measurement-precise.cjs.entry.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const index = require('./index-b99cd335.js');
 const mapper = require('./mapper-60434e0b.js');
 const wrappers_pb = require('./wrappers_pb-9ec12cf5.js');
-const config = require('./config-ee5af2fe.js');
+const config = require('./config-ace9f5d5.js');
 const entities = require('./entities-c40e141f.js');
 require('./streamAttributes-eddf5b50.js');
 const model = require('./model-14424daa.js');

package/dist/cjs/vertex-viewer-pin-group.cjs.entry.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-b99cd335.js');
 const bundle_esm = require('./bundle.esm-5847ff0b.js');
-require('./controller-6914028a.js');
+require('./controller-ee852f01.js');
 require('./cursors-5f6e27c0.js');
 require('./mapper-60434e0b.js');
 require('./wrappers_pb-9ec12cf5.js');

package/dist/cjs/vertex-viewer.cjs.entry.js

@@ -10,7 +10,7 @@ const bundle_esm = require('./bundle.esm-5847ff0b.js');
 const bundle_esm$1 = require('./bundle.esm-f25c75c6.js');
 const browser_esm = require('./browser.esm-bf5e4488.js');
 const index$1 = require('./index-5e1feaea.js');
-const config = require('./config-ee5af2fe.js');
+const config = require('./config-ace9f5d5.js');
 const cursors = require('./cursors-5f6e27c0.js');
 const dom = require('./dom-1bbd070f.js');
 const errors = require('./errors-0829e369.js');
@@ -567,40 +567,6 @@ class InteractionApi {
       return newCamera;
     });
   }
-  async zoomCameraToPoint(point, delta) {
-    return this.transformCamera(({ camera, viewport, frame, depthBuffer }) => {
-      const cam = frame.scene.camera;
-      const dir = cam.direction;
-      const frameCam = camera.toFrameCamera();
-      const ray = viewport.transformPointToRay(point, frame.image, frameCam);
-      if (this.zoomData == null) {
-        const fallbackPlane = bundle_esm.plane.fromNormalAndCoplanarPoint(dir, cam.lookAt);
-        const fallbackPt = bundle_esm.ray.intersectPlane(ray, fallbackPlane);
-        if (fallbackPt == null) {
-          console.warn('Cannot determine fallback point for zoom. Ray does not intersect plane.');
-          return camera;
-        }
-        const hitPt = depthBuffer != null
-          ? this.getWorldPoint(point, depthBuffer, fallbackPt)
-          : fallbackPt;
-        const hitPlane = bundle_esm.plane.fromNormalAndCoplanarPoint(dir, hitPt);
-        this.zoomData = { hitPt, hitPlane };
-      }
-      if (this.zoomData != null) {
-        const { hitPt, hitPlane } = this.zoomData;
-        const distance = bundle_esm.vector3.distance(camera.position, hitPt);
-        const epsilon = (6 * distance * delta) / viewport.height;
-        const position = bundle_esm.ray.at(ray, epsilon);
-        const lookAt = bundle_esm.plane.projectPoint(hitPlane, position);
-        const newCamera = camera.update({ position, lookAt });
-        const newDistance = bundle_esm.vector3.distance(position, lookAt);
-        if (newDistance >= newCamera.near) {
-          return newCamera;
-        }
-      }
-      return camera;
-    });
-  }
   /**
    * Performs a pivot operation of the scene's camera, updating the lookAt
    * while maintaining the position, and requests a new image for the
@@ -852,6 +818,7 @@ class InteractionApiOrthographic extends InteractionApi {
   }
 }
 
+const CAMERA_MIN_ZOOM_SCALAR = 0.2;
 class InteractionApiPerspective extends InteractionApi {
   constructor(stream, cursors, getConfig, getScene, getFrame, getViewport, tapEmitter, doubleTapEmitter, longPressEmitter, interactionStartedEmitter, interactionFinishedEmitter) {
     super(stream, cursors, getConfig, getScene, getFrame, getViewport, tapEmitter, doubleTapEmitter, longPressEmitter, interactionStartedEmitter, interactionFinishedEmitter);
@@ -879,6 +846,48 @@ class InteractionApiPerspective extends InteractionApi {
       return camera.moveBy(offset);
     });
   }
+  async zoomCameraToPoint(point, delta) {
+    return this.transformCamera(({ camera, viewport, frame, depthBuffer, boundingBox }) => {
+      const cam = frame.scene.camera;
+      const dir = cam.direction;
+      const frameCam = camera.toFrameCamera();
+      const ray = viewport.transformPointToRay(point, frame.image, frameCam);
+      if (this.zoomData == null) {
+        const fallbackPlane = bundle_esm.plane.fromNormalAndCoplanarPoint(dir, cam.lookAt);
+        const fallbackPt = bundle_esm.ray.intersectPlane(ray, fallbackPlane);
+        if (fallbackPt == null) {
+          console.warn('Cannot determine fallback point for zoom. Ray does not intersect plane.');
+          return camera;
+        }
+        const hitPt = depthBuffer != null
+          ? this.getWorldPoint(point, depthBuffer, fallbackPt)
+          : fallbackPt;
+        const hitPlane = bundle_esm.plane.fromNormalAndCoplanarPoint(dir, hitPt);
+        this.zoomData = { hitPt, hitPlane };
+      }
+      if (this.zoomData != null) {
+        const { hitPlane } = this.zoomData;
+        const { position, distance, isPastHitPlane, keepCurrent } = this.computeZoomDistances(delta, camera, viewport, boundingBox, ray, this.zoomData);
+        if (isPastHitPlane && !keepCurrent) {
+          const viewVectorRay = bundle_esm.ray.create({
+            origin: position,
+            direction: bundle_esm.vector3.normalize(camera.viewVector),
+          });
+          return camera.update({
+            position,
+            lookAt: bundle_esm.ray.at(viewVectorRay, distance),
+          });
+        }
+        else if (!keepCurrent) {
+          return camera.update({
+            position,
+            lookAt: bundle_esm.plane.projectPoint(hitPlane, position),
+          });
+        }
+      }
+      return camera;
+    });
+  }
   async transformCamera(t) {
     var _a;
     if (this.isInteracting()) {
@@ -900,6 +909,65 @@ class InteractionApiPerspective extends InteractionApi {
       await ((_a = this.currentCamera) === null || _a === void 0 ? void 0 : _a.render());
     }
   }
+  computeZoomDistances(delta, camera, viewport, boundingBox, pointRay, zoomData) {
+    const config = this.getConfig();
+    const { hitPt, hitPlane } = zoomData;
+    const minDistance = config.useMinimumPerspectiveZoomDistance
+      ? this.computeZoomMinimumDistance(camera, boundingBox)
+      : -1;
+    const expectedDistance = bundle_esm.vector3.distance(camera.position, hitPt);
+    const actualDistance = Math.max(minDistance, expectedDistance);
+    const epsilon = (6 * actualDistance * delta) / viewport.height;
+    const expectedPosition = bundle_esm.ray.at(pointRay, epsilon);
+    const expectedViewVector = bundle_esm.ray.create({
+      origin: expectedPosition,
+      direction: bundle_esm.vector3.normalize(camera.viewVector),
+    });
+    const expectedIntersection = bundle_esm.ray.intersectPlane(expectedViewVector, hitPlane);
+    if (expectedIntersection == null &&
+      config.useMinimumPerspectiveZoomDistance) {
+      const minDistanceEpsilon = (6 * minDistance * delta) / viewport.height;
+      const position = bundle_esm.ray.at(pointRay, minDistanceEpsilon);
+      return {
+        position,
+        distance: minDistance,
+        isPastHitPlane: true,
+        keepCurrent: false,
+      };
+    }
+    else if (expectedIntersection == null) {
+      return {
+        position: camera.position,
+        distance: actualDistance,
+        isPastHitPlane: true,
+        keepCurrent: true,
+      };
+    }
+    return {
+      position: expectedPosition,
+      distance: actualDistance,
+      isPastHitPlane: false,
+      keepCurrent: false,
+    };
+  }
+  computeZoomMinimumDistance(camera, boundingBox) {
+    const xLength = Math.abs(boundingBox.min.x) + Math.abs(boundingBox.max.x);
+    const yLength = Math.abs(boundingBox.min.y) + Math.abs(boundingBox.max.y);
+    const zLength = Math.abs(boundingBox.min.z) + Math.abs(boundingBox.max.z);
+    const maxLength = Math.max(xLength, yLength, zLength);
+    const absDotX = Math.abs(bundle_esm.vector3.dot(bundle_esm.vector3.normalize(camera.viewVector), bundle_esm.vector3.right()));
+    const absDotY = Math.abs(bundle_esm.vector3.dot(bundle_esm.vector3.normalize(camera.viewVector), bundle_esm.vector3.up()));
+    const absDotZ = Math.abs(bundle_esm.vector3.dot(bundle_esm.vector3.normalize(camera.viewVector), bundle_esm.vector3.back()));
+    const scaledLengthX = xLength * absDotX;
+    const scaledLengthY = yLength * absDotY;
+    const scaledLengthZ = zLength * absDotZ;
+    const relevanceLengthX = maxLength / xLength;
+    const relevanceLengthY = maxLength / yLength;
+    const relevanceLengthZ = maxLength / zLength;
+    return (((scaledLengthX + scaledLengthY + scaledLengthZ) /
+      (relevanceLengthX + relevanceLengthY + relevanceLengthZ)) *
+      CAMERA_MIN_ZOOM_SCALAR);
+  }
 }
 
 class FlyToPositionKeyInteraction {