@vertexvis/viewer 0.18.0 → 0.18.1-testing.0

package/dist/esm/index.js

@@ -2,7 +2,7 @@
  * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
 export { c as ColorMaterial, l as LoadableResource, S as Scene, a as SynchronizedClock } from './scene-2e0df828.js';
-export { S as SceneTreeController } from './controller-1f6c87ab.js';
+export { S as SceneTreeController } from './controller-ea698f9b.js';
 export { f as fromNodeProto, i as isLoadedRow } from './row-6d4f9dcc.js';
 export { C as CursorManager, b as boxQueryCursor, l as labelPinCursor, m as measurementCursor, a as measurementWithArrowCursor, p as pinCursor } from './cursors-74998736.js';
 export { M as MeasurementController, a as MeasurementEntity } from './entities-c1acb573.js';

package/dist/esm/index.mjs

@@ -2,7 +2,7 @@
  * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
 export { c as ColorMaterial, l as LoadableResource, S as Scene, a as SynchronizedClock } from './scene-2e0df828.js';
-export { S as SceneTreeController } from './controller-1f6c87ab.js';
+export { S as SceneTreeController } from './controller-ea698f9b.js';
 export { f as fromNodeProto, i as isLoadedRow } from './row-6d4f9dcc.js';
 export { C as CursorManager, b as boxQueryCursor, l as labelPinCursor, m as measurementCursor, a as measurementWithArrowCursor, p as pinCursor } from './cursors-74998736.js';
 export { M as MeasurementController, a as MeasurementEntity } from './entities-c1acb573.js';

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

@@ -3,8 +3,8 @@
  */
 import { h, F as Fragment, r as registerInstance, c as createEvent, f as forceUpdate, H as Host, g as getElement } from './index-fd7d7b68.js';
 import { o as __rest } from './bundle.esm-92fd4246.js';
-import { a as SceneTreeAPIClient_1, w as webSocketSubscriptionTransportFactory, S as SceneTreeController, b as SceneTreeErrorDetails, c as SceneTreeErrorCode } from './controller-1f6c87ab.js';
-import { p as parseConfig } from './config-65fd1bba.js';
+import { a as SceneTreeAPIClient_1, w as webSocketSubscriptionTransportFactory, S as SceneTreeController, b as SceneTreeErrorDetails, c as SceneTreeErrorCode } from './controller-ea698f9b.js';
+import { p as parseConfig } from './config-2b2e3f66.js';
 import { g as getSceneTreeContainsElement } from './dom-758547c9.js';
 import { i as isLoadedRow } from './row-6d4f9dcc.js';
 import './wrappers_pb-975c7885.js';

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

@@ -4,7 +4,7 @@
 import { r as registerInstance, h, H as Host } from './index-fd7d7b68.js';
 import { s as scene_view_api_pb } from './mapper-bdfe63be.js';
 import { a as grpcWebClient_umd } from './wrappers_pb-975c7885.js';
-import { p as parseConfig } from './config-65fd1bba.js';
+import { p as parseConfig } from './config-2b2e3f66.js';
 import { a as MeasurementEntity, M as MeasurementController } from './entities-c1acb573.js';
 import './streamAttributes-eb15cb1f.js';
 import { M as MeasurementModel } from './model-a54addfd.js';

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

@@ -3,7 +3,7 @@
  */
 import { h, F as Fragment, r as registerInstance } from './index-fd7d7b68.js';
 import { p as point, m as matrix4, v as vector3 } from './bundle.esm-92fd4246.js';
-import './controller-1f6c87ab.js';
+import './controller-ea698f9b.js';
 import './cursors-74998736.js';
 import './mapper-bdfe63be.js';
 import './wrappers_pb-975c7885.js';

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

@@ -6,7 +6,7 @@ import { p as point, v as vector3, c as angle, f as plane, r as ray, b as boundi
 import { t as toProtoDuration, p as protoToDate, a as StreamApi, S as StreamRequestError, c as currentDateAsProtoTimestamp, W as WebSocketClientImpl } from './bundle.esm-5a5f6362.js';
 import { E as EventDispatcher, m as mapper, c as color, o as objects, u as uri, a as async, b as uuid } from './browser.esm-595bfe2f.js';
 import { c as classnames } from './index-ab0ec8dc.js';
-import { p as parseConfig } from './config-65fd1bba.js';
+import { p as parseConfig } from './config-2b2e3f66.js';
 import { C as CursorManager } from './cursors-74998736.js';
 import { g as getMouseClientPosition, c as cssCursor } from './dom-c86a0050.js';
 import { c as ImageLoadError, C as CustomError, W as WebsocketConnectionError, S as SceneRenderError, V as ViewerInitializationError, d as InteractionHandlerError, e as ComponentInitializationError } from './errors-a8d2dbd3.js';
@@ -563,40 +563,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$1 = viewport.transformPointToRay(point, frame.image, frameCam);
-      if (this.zoomData == null) {
-        const fallbackPlane = plane.fromNormalAndCoplanarPoint(dir, cam.lookAt);
-        const fallbackPt = ray.intersectPlane(ray$1, 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 = plane.fromNormalAndCoplanarPoint(dir, hitPt);
-        this.zoomData = { hitPt, hitPlane };
-      }
-      if (this.zoomData != null) {
-        const { hitPt, hitPlane } = this.zoomData;
-        const distance = vector3.distance(camera.position, hitPt);
-        const epsilon = (6 * distance * delta) / viewport.height;
-        const position = ray.at(ray$1, epsilon);
-        const lookAt = plane.projectPoint(hitPlane, position);
-        const newCamera = camera.update({ position, lookAt });
-        const newDistance = 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
@@ -848,6 +814,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);
@@ -875,6 +842,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$1 = viewport.transformPointToRay(point, frame.image, frameCam);
+      if (this.zoomData == null) {
+        const fallbackPlane = plane.fromNormalAndCoplanarPoint(dir, cam.lookAt);
+        const fallbackPt = ray.intersectPlane(ray$1, 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 = 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$1, this.zoomData);
+        if (isPastHitPlane && !keepCurrent) {
+          const viewVectorRay = ray.create({
+            origin: position,
+            direction: vector3.normalize(camera.viewVector),
+          });
+          return camera.update({
+            position,
+            lookAt: ray.at(viewVectorRay, distance),
+          });
+        }
+        else if (!keepCurrent) {
+          return camera.update({
+            position,
+            lookAt: plane.projectPoint(hitPlane, position),
+          });
+        }
+      }
+      return camera;
+    });
+  }
   async transformCamera(t) {
     var _a;
     if (this.isInteracting()) {
@@ -896,6 +905,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 = vector3.distance(camera.position, hitPt);
+    const actualDistance = Math.max(minDistance, expectedDistance);
+    const epsilon = (6 * actualDistance * delta) / viewport.height;
+    const expectedPosition = ray.at(pointRay, epsilon);
+    const expectedViewVector = ray.create({
+      origin: expectedPosition,
+      direction: vector3.normalize(camera.viewVector),
+    });
+    const expectedIntersection = ray.intersectPlane(expectedViewVector, hitPlane);
+    if (expectedIntersection == null &&
+      config.useMinimumPerspectiveZoomDistance) {
+      const minDistanceEpsilon = (6 * minDistance * delta) / viewport.height;
+      const position = 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(vector3.dot(vector3.normalize(camera.viewVector), vector3.right()));
+    const absDotY = Math.abs(vector3.dot(vector3.normalize(camera.viewVector), vector3.up()));
+    const absDotZ = Math.abs(vector3.dot(vector3.normalize(camera.viewVector), 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 {