@vertexvis/viewer 0.23.6-canary.8 → 0.23.6-testing.0

package/dist/components/vertex-viewer.js

@@ -749,14 +749,72 @@ class InteractionApi {
    *  values zoom out.
    */
   async zoomCamera(delta) {
-    return this.transformCamera(({ camera, viewport }) => {
-      const vv = camera.viewVector;
-      const v = vector3.normalize(vv);
-      const distance = vector3.magnitude(vv);
-      const epsilon = (3 * distance * delta) / viewport.height;
-      const position = vector3.add(camera.position, vector3.scale(epsilon, v));
-      const newCamera = camera.update({ position });
-      return newCamera;
+    return this.transformCamera(({ camera, viewport, frame, boundingBox: boundingBox$1 }) => {
+      if (viewport != null && frame != null) {
+        const isPerspective = camera === null || camera === void 0 ? void 0 : camera.toFrameCamera().isPerspective();
+        if (isPerspective) {
+          const vv = camera.viewVector;
+          // Calculate the unit-less scalar determining the amount to zoom. The delta parameter
+          // is scaled by the viewport height because if the viewport is larger, then the
+          // user should have to perform a bigger action to zoom the model the same amount.
+          // Note that delta and viewport.height both have units of pixels. Further, the
+          // 3 multiplier was chosen to match the desired zoom speed.
+          const distance = vector3.magnitude(vv);
+          const relativeDeltaToViewportHeight = 3 * distance * (delta / viewport.height);
+          // Scale the current viewVector by the scalar calculated above to determine how to adjust the camera position
+          const v = vector3.normalize(vv);
+          const positionChange = vector3.scale(relativeDeltaToViewportHeight, v);
+          // Calculate the new camera position
+          const position = vector3.add(camera.position, positionChange);
+          // Update the camera with the new position
+          const newCamera = camera.update({ position });
+          return newCamera;
+        }
+        else {
+          // Retrieve properties of the current camera
+          const orthographicCamera = camera;
+          const frameCam = camera.toFrameCamera();
+          const dir = frameCam.direction;
+          const ray$1 = viewport.transformPointToRay(viewport.center, frame.image, frameCam);
+          // Calculate the unit-less scalar determining the amount to zoom. The delta parameter
+          // is scaled by the viewport height because if the viewport is larger, then the
+          // user should have to perform a bigger action to zoom the model the same amount.
+          // Note that delta and viewport.height both have units of pixels. Further, the
+          // 4 multiplier was chosen to match the desired zoom speed.
+          const relativeDeltaToViewportHeight = 4 * (delta / viewport.height);
+          // Calculate the fovHeight after performing the zoom. zoomedFovHeight has the
+          // same units of camera.fovHeight (the world units). The new fovHeight
+          // has a minimum value, which is a function of the size of the bounding box,
+          // which ensures the new fovHeight is a positive, non-zero number.
+          const minimumFovHeight = vector3.magnitude(boundingBox.diagonal(boundingBox$1)) * 1e-5;
+          const zoomedFovHeight = Math.max(minimumFovHeight, orthographicCamera.fovHeight * (1 - relativeDeltaToViewportHeight));
+          // Calculate the plane and point to zoom relative to
+          const planeToZoomRelativeTo = plane.fromNormalAndCoplanarPoint(dir, frameCam.lookAt);
+          const pointToZoomRelativeTo = ray.intersectPlane(ray$1, planeToZoomRelativeTo);
+          if (pointToZoomRelativeTo != null) {
+            // Project the current look at point onto the zoom plane
+            const projectedLookAt = plane.projectPoint(planeToZoomRelativeTo, orthographicCamera.lookAt);
+            // Calculate the vector to determine how to adjust the camera's look at point.
+            // Ensure that the viewVector is scaled to the expected length in order to
+            // ensure other camera calculations are correct, for example, the occlusion
+            // calculations for pins.
+            const fovHeightRelativeChange = (orthographicCamera.fovHeight - zoomedFovHeight) /
+              orthographicCamera.fovHeight;
+            const lookAtChangeVector = vector3.scale(fovHeightRelativeChange, vector3.subtract(pointToZoomRelativeTo, projectedLookAt));
+            // Calculate the camera's new look at point
+            const updatedLookAt = vector3.add(orthographicCamera.lookAt, lookAtChangeVector);
+            // Update the orthographic camera
+            // Note rotationPoint should match lookAt after a zoom interaction
+            const newCamera = camera.update({
+              lookAt: updatedLookAt,
+              rotationPoint: updatedLookAt,
+              fovHeight: zoomedFovHeight,
+            });
+            return newCamera;
+          }
+        }
+      }
+      return camera;
     });
   }
   /**
@@ -946,7 +1004,7 @@ class InteractionApiOrthographic extends InteractionApi {
     });
   }
   async zoomCameraToPoint(point$1, delta) {
-    return this.transformCamera(({ camera, viewport, frame, depthBuffer, boundingBox }) => {
+    return this.transformCamera(({ camera, viewport, frame, depthBuffer, boundingBox: boundingBox$1 }) => {
       if (this.orthographicZoomData == null ||
         point.distance(point$1, this.orthographicZoomData.startingScreenPt) > 2) {
         const frameCam = camera.toFrameCamera();
@@ -970,17 +1028,33 @@ class InteractionApiOrthographic extends InteractionApi {
       }
       if (this.orthographicZoomData != null) {
         const { hitPt, hitPlane } = this.orthographicZoomData;
-        // The 4 multiplier was chosen to match the desired zoom speed
-        const relativeDelta = 4 * (camera.fovHeight / viewport.height) * delta;
-        const fovHeight = Math.max(1, camera.fovHeight - relativeDelta);
+        // Calculate the unit-less scalar determining the amount to zoom. The delta parameter
+        // is scaled by the viewport height because if the viewport is larger, then the
+        // user should have to perform a bigger action to zoom the model the same amount.
+        // Note that delta and viewport.height both have units of pixels. Further, the
+        // 4 multiplier was chosen to match the desired zoom speed.
+        const relativeDeltaToViewportHeight = 4 * (delta / viewport.height);
+        // Calculate the fovHeight after performing the zoom. zoomedFovHeight has the
+        // same units of camera.fovHeight (the world units). The new fovHeight
+        // has a minimum value, which is a function of the size of the bounding box,
+        // which ensures the new fovHeight is a positive, non-zero number.
+        const minimumFovHeight = vector3.magnitude(boundingBox.diagonal(boundingBox$1)) * 1e-5;
+        const zoomedFovHeight = Math.max(minimumFovHeight, camera.fovHeight * (1 - relativeDeltaToViewportHeight));
+        // Calculate the vector to determine how to adjust the camera's look at point.
+        // Ensure that the viewVector is scaled to the expected length in order to
+        // ensure other camera calculations are correct, for example, the occlusion
+        // calculations for pins.
         const projectedLookAt = plane.projectPoint(hitPlane, camera.lookAt);
-        const diff = vector3.scale((camera.fovHeight - fovHeight) / camera.fovHeight, vector3.subtract(hitPt, projectedLookAt));
-        // rotationPoint should match lookAt after a zoom interaction
-        const updatedLookAt = vector3.add(camera.lookAt, diff);
+        const fovHeightRelativeChange = (camera.fovHeight - zoomedFovHeight) / camera.fovHeight;
+        const lookAtChangeVector = vector3.scale(fovHeightRelativeChange, vector3.subtract(hitPt, projectedLookAt));
+        // Calculate the camera's new look at point
+        const updatedLookAt = vector3.add(camera.lookAt, lookAtChangeVector);
+        // Return the updated camera
+        // Note rotationPoint should match lookAt after a zoom interaction
         return camera.update({
           lookAt: updatedLookAt,
           rotationPoint: updatedLookAt,
-          fovHeight: Math.max(1, camera.fovHeight - relativeDelta),
+          fovHeight: zoomedFovHeight,
         });
       }
       return camera;