@vertexvis/viewer 0.13.1 → 0.13.2-canary.2

package/dist/esm/{scene-2c2460d5.js → scene-2d8bdccc.js}

@@ -1,9 +1,9 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { c as color, u as uri, a as async, b as uuid } from './browser.esm-59e914f6.js';
-import { v as vector3, b as boundingBox, p as point, d as dimensions } from './bundle.esm-d899b2d5.js';
-import { v as vertexvis, t as toProtoDuration, c as FramePerspectiveCamera, f as fromBoundingBoxAndLookAtCamera } from './streamAttributes-d623bb60.js';
+import { c as color, u as uri, a as async, b as uuid } from './browser.esm-48f051a3.js';
+import { v as vector3, b as boundingBox, p as point, d as dimensions } from './bundle.esm-df3a8a42.js';
+import { v as vertexvis, t as toProtoDuration, f as toProtobuf, d as FramePerspectiveCamera, c as FrameOrthographicCamera, w as withPositionAndViewVector, g as fromBoundingBoxAndLookAtCamera } from './streamAttributes-87a3605c.js';
 
 const defaultColor = {
   opacity: 100,
@@ -167,6 +167,13 @@ class InvalidArgumentError extends CustomError {
     Object.setPrototypeOf(this, InvalidArgumentError.prototype);
   }
 }
+class InvalidCameraError extends CustomError {
+  constructor(message, e) {
+    super(message, e);
+    // Allows for `instanceof` checks.
+    Object.setPrototypeOf(this, InvalidCameraError.prototype);
+  }
+}
 
 function fromUrn(urn) {
   const uri$1 = uri.parse(urn);
@@ -457,7 +464,7 @@ function buildFlyToOperation(frameCorrelationId, options, animation) {
         }) });
     }
     case 'camera': {
-      return Object.assign(Object.assign({}, payload), { camera: options.flyTo.data });
+      return Object.assign(Object.assign({}, payload), { camera: toProtobuf(options.flyTo.data) });
     }
     case 'bounding-box': {
       return Object.assign(Object.assign({}, payload), { boundingBox: {
@@ -591,32 +598,27 @@ class FlyToExecutor {
  * a new instance of the class with the updated properties.
  */
 class Camera {
-  constructor(stream, aspect, data, boundingBox, decodeFrame) {
+  constructor(stream, aspect, data, boundingBox, decodeFrame, flyToOptions) {
     this.stream = stream;
     this.aspect = aspect;
     this.data = data;
     this.boundingBox = boundingBox;
     this.decodeFrame = decodeFrame;
+    this.flyToOptions = flyToOptions;
   }
-  /**
-   * Updates the position of the camera such that the given bounding box will
-   * be contained within the camera's view.
-   *
-   * @param boundingBox The bounding box to position to.
-   */
-  fitToBoundingBox(boundingBox$1) {
+  fitCameraToBoundingBox(boundingBox$1, fovVertical, viewVector) {
     const radius = 1.1 *
       vector3.magnitude(vector3.subtract(boundingBox$1.max, boundingBox.center(boundingBox$1)));
     // ratio of the height of the frustum to the distance along the view vector
-    let hOverD = Math.tan(this.fovY * PI_OVER_360);
-    if (this.aspectRatio < 1.0) {
-      hOverD *= this.aspectRatio;
+    let hOverD = Math.tan(fovVertical * PI_OVER_360);
+    if (this.aspect < 1.0) {
+      hOverD *= this.aspect;
     }
     const distance = Math.abs(radius / hOverD);
-    const vvec = vector3.scale(distance, vector3.normalize(this.viewVector()));
+    const vvec = vector3.scale(distance, vector3.normalize(viewVector));
     const lookAt = boundingBox.center(boundingBox$1);
     const position = vector3.subtract(lookAt, vvec);
-    return this.update({ lookAt, position });
+    return this.update({ lookAt, position, viewVector: vvec });
   }
   /**
    * Returns the distance from the camera's position to the center
@@ -624,12 +626,11 @@ class Camera {
    *
    * @param boundingBox - The bounding box to determine distance from.
    */
-  distanceToBoundingBoxCenter(boundingBox$1) {
-    const box = boundingBox$1 || this.boundingBox;
-    const boundingBoxCenter = boundingBox.center(box);
-    const cameraToCenter = vector3.subtract(this.position, boundingBoxCenter);
-    const distanceToCenterAlongViewVec = Math.abs(vector3.dot(vector3.subtract(this.lookAt, this.position), cameraToCenter)) / vector3.magnitude(vector3.subtract(this.lookAt, this.position));
-    return distanceToCenterAlongViewVec;
+  signedDistanceToBoundingBoxCenter(boundingBox$1) {
+    const { position, viewVector } = withPositionAndViewVector(this.data);
+    const boundingBoxCenter = boundingBox.center(boundingBox$1 !== null && boundingBox$1 !== void 0 ? boundingBox$1 : this.boundingBox);
+    const cameraToCenter = vector3.subtract(boundingBoxCenter, position);
+    return (vector3.dot(viewVector, cameraToCenter) / vector3.magnitude(viewVector));
   }
   /**
    * Specifies that the next render of the camera will be repositioned to one of
@@ -640,26 +641,14 @@ class Camera {
    */
   flyTo(paramsOrQuery) {
     if (typeof paramsOrQuery !== 'function') {
-      this.flyToOptions = { flyTo: this.buildFlyToType(paramsOrQuery) };
-      return this;
+      return this.updateFlyToOptions({
+        flyTo: this.buildFlyToType(paramsOrQuery),
+      });
     }
     else {
-      this.flyToOptions = paramsOrQuery(new FlyToExecutor()).build();
-      return this;
+      return this.updateFlyToOptions(paramsOrQuery(new FlyToExecutor()).build());
     }
   }
-  /**
-   * Shifts the position of the camera by the given delta.
-   *
-   * @param delta The number of units to shift the camera on the X, Y, and Z
-   * axis.
-   */
-  moveBy(delta) {
-    return this.update({
-      position: vector3.add(this.position, delta),
-      lookAt: vector3.add(this.lookAt, delta),
-    });
-  }
   viewAll() {
     return this.fitToBoundingBox(this.boundingBox);
   }
@@ -691,7 +680,7 @@ class Camera {
       }
       else {
         this.stream.replaceCamera({
-          camera: this.data,
+          camera: toProtobuf(this.data),
           frameCorrelationId: { value: corrId },
         });
         return new CameraRenderResult(this.stream, this.decodeFrame, {
@@ -711,22 +700,7 @@ class Camera {
    * @param axis A normalized vector to rotate around.
    */
   rotateAroundAxis(angleInRadians, axis) {
-    return this.rotateAroundAxisAtPoint(angleInRadians, this.lookAt, axis);
-  }
-  /**
-   * Repositions the camera by rotating its current position around an axis
-   * defined at a specific world point.
-   *
-   * @param angleInRadians The angle, in radians, to rotate.
-   * @param point The point in world space to place the axis at.
-   * @param axis A normalized vector to rotate around.
-   */
-  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
-    return this.update({
-      position: vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
-      lookAt: vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
-      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
-    });
+    return this.rotateAroundAxisAtPoint(angleInRadians, this.data.lookAt, axis);
   }
   /**
    * Updates the `position` and `up` vectors of the camera to the given standard
@@ -742,20 +716,6 @@ class Camera {
       up: standardView.up,
     });
   }
-  /**
-   * Updates the `position`, `lookAt` and/or `up` vectors of the camera.
-   *
-   * @param camera The values to update the camera to.
-   */
-  update(camera) {
-    return new Camera(this.stream, this.aspectRatio, Object.assign(Object.assign({}, this.data), camera), this.boundingBox, this.decodeFrame);
-  }
-  /**
-   * Returns a `FramePerspectiveCamera` representation.
-   */
-  toFrameCamera() {
-    return new FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovY);
-  }
   buildFlyToType(options) {
     if (options.boundingBox != null) {
       return { type: 'bounding-box', data: options.boundingBox };
@@ -776,36 +736,66 @@ class Camera {
   computeClippingPlanes(camera) {
     return fromBoundingBoxAndLookAtCamera(this.boundingBox, camera);
   }
+}
+class PerspectiveCamera extends Camera {
+  constructor(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions) {
+    super(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions);
+    this.perspectiveData = perspectiveData;
+  }
   /**
-   * Returns the view vector for the camera, which is the direction between the
-   * `position` and `lookAt` vectors.
+   * Shifts the position of the camera by the given delta.
+   *
+   * @param delta The number of units to shift the camera on the X, Y, and Z
+   * axis.
    */
-  viewVector() {
+  moveBy(delta) {
+    return this.update({
+      position: vector3.add(this.position, delta),
+      lookAt: vector3.add(this.lookAt, delta),
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    return this.update({
+      position: vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
+      lookAt: vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
+      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
+    });
+  }
+  fitToBoundingBox(boundingBox) {
+    return super.fitCameraToBoundingBox(boundingBox, this.fovY, this.viewVector);
+  }
+  update(camera) {
+    return new PerspectiveCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.perspectiveData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
+  }
+  toFrameCamera() {
+    return new FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovY);
+  }
+  get viewVector() {
     return vector3.subtract(this.lookAt, this.position);
   }
   /**
    * The position vector for the camera, in world space coordinates.
    */
   get position() {
-    return Object.assign({}, this.data.position);
+    return Object.assign({}, this.perspectiveData.position);
   }
   /**
    * A normalized vector representing the up direction.
    */
   get up() {
-    return Object.assign({}, this.data.up);
+    return Object.assign({}, this.perspectiveData.up);
   }
   /**
    * A vector, in world space coordinates, of where the camera is pointed at.
    */
   get lookAt() {
-    return Object.assign({}, this.data.lookAt);
+    return Object.assign({}, this.perspectiveData.lookAt);
   }
   /**
    * The camera's field of view.
    */
   get fovY() {
-    return 45;
+    return this.perspectiveData.fovY;
   }
   /**
    * The aspect ratio of the camera.
@@ -817,16 +807,104 @@ class Camera {
    * The camera's near clipping plane.
    */
   get near() {
-    const { near } = this.computeClippingPlanes(this.data);
+    const { near } = this.computeClippingPlanes(this.perspectiveData);
     return near;
   }
   /**
    * The camera's far clipping plane.
    */
   get far() {
-    const { far } = this.computeClippingPlanes(this.data);
+    const { far } = this.computeClippingPlanes(this.perspectiveData);
     return far;
   }
+  updateFlyToOptions(flyToOptions) {
+    return new PerspectiveCamera(this.stream, this.aspect, this.perspectiveData, this.boundingBox, this.decodeFrame, flyToOptions);
+  }
+}
+class OrthographicCamera extends Camera {
+  constructor(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions) {
+    super(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions);
+    this.orthographicData = orthographicData;
+  }
+  /**
+   * Shifts the position of the camera by the given delta.
+   *
+   * @param delta The number of units to shift the camera on the X, Y, and Z
+   * axis.
+   */
+  moveBy(delta) {
+    const updatedLookAt = vector3.add(this.lookAt, delta);
+    return this.update({
+      viewVector: vector3.subtract(updatedLookAt, vector3.add(this.position, delta)),
+      lookAt: updatedLookAt,
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    const newLookAt = vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
+    const newUp = vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin());
+    const newViewVector = vector3.subtract(vector3.rotateAboutAxis(angleInRadians, this.position, axis, point), newLookAt);
+    return this.update({
+      viewVector: newViewVector,
+      lookAt: newLookAt,
+      up: newUp,
+    });
+  }
+  fitToBoundingBox(boundingBox) {
+    return super.fitCameraToBoundingBox(boundingBox, this.fovHeight, this.viewVector);
+  }
+  update(camera) {
+    return new OrthographicCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.orthographicData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
+  }
+  toFrameCamera() {
+    return new FrameOrthographicCamera(this.viewVector, this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovHeight);
+  }
+  get viewVector() {
+    return Object.assign({}, this.orthographicData.viewVector);
+  }
+  get position() {
+    return vector3.add(this.lookAt, vector3.negate(this.viewVector));
+  }
+  /**
+   * A normalized vector representing the up direction.
+   */
+  get up() {
+    return Object.assign({}, this.orthographicData.up);
+  }
+  /**
+   * A vector, in world space coordinates, of where the camera is pointed at.
+   */
+  get lookAt() {
+    return Object.assign({}, this.orthographicData.lookAt);
+  }
+  /**
+   * The camera's field of view.
+   */
+  get fovHeight() {
+    return this.orthographicData.fovHeight;
+  }
+  /**
+   * The aspect ratio of the camera.
+   */
+  get aspectRatio() {
+    return this.aspect;
+  }
+  /**
+   * The camera's near clipping plane.
+   */
+  get near() {
+    const { near } = this.computeClippingPlanes(this.orthographicData);
+    return near;
+  }
+  /**
+   * The camera's far clipping plane.
+   */
+  get far() {
+    const { far } = this.computeClippingPlanes(this.orthographicData);
+    return far;
+  }
+  updateFlyToOptions(flyToOptions) {
+    return new OrthographicCamera(this.stream, this.aspect, this.orthographicData, this.boundingBox, this.decodeFrame, flyToOptions);
+  }
 }
 
 /**
@@ -1233,12 +1311,25 @@ class Scene {
    */
   camera() {
     const { scene } = this.frame;
-    const data = {
-      position: scene.camera.position,
-      lookAt: scene.camera.lookAt,
-      up: scene.camera.up,
-    };
-    return new Camera(this.stream, dimensions.aspectRatio(this.viewport()), data, this.frame.scene.boundingBox, this.decodeFrame);
+    if (scene.camera instanceof FrameOrthographicCamera) {
+      return new OrthographicCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
+        viewVector: scene.camera.viewVector,
+        lookAt: scene.camera.lookAt,
+        up: scene.camera.up,
+        fovHeight: scene.camera.fovHeight,
+      }, this.frame.scene.boundingBox, this.decodeFrame);
+    }
+    else if (scene.camera instanceof FramePerspectiveCamera) {
+      return new PerspectiveCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
+        position: scene.camera.position,
+        lookAt: scene.camera.lookAt,
+        up: scene.camera.up,
+        fovY: scene.camera.fovY,
+      }, this.frame.scene.boundingBox, this.decodeFrame);
+    }
+    else {
+      throw new InvalidCameraError('Cannot retrieve camera. Scene has an unknown or invalid camera type.');
+    }
   }
   boundingBox() {
     return this.frame.scene.boundingBox;