@vertexvis/viewer 0.13.1 → 0.13.2-canary.2

package/dist/cjs/{scene-d420fd26.js → scene-23535fc0.js}

@@ -3,9 +3,9 @@
  */
 'use strict';
 
-const browser_esm = require('./browser.esm-31b03292.js');
-const bundle_esm = require('./bundle.esm-dc0a8361.js');
-const streamAttributes = require('./streamAttributes-d6236448.js');
+const browser_esm = require('./browser.esm-c51162f8.js');
+const bundle_esm = require('./bundle.esm-1b8b1f36.js');
+const streamAttributes = require('./streamAttributes-f13c1a96.js');
 
 const defaultColor = {
   opacity: 100,
@@ -169,6 +169,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 = browser_esm.uri.parse(urn);
@@ -459,7 +466,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: streamAttributes.toProtobuf(options.flyTo.data) });
     }
     case 'bounding-box': {
       return Object.assign(Object.assign({}, payload), { boundingBox: {
@@ -593,32 +600,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) {
+  fitCameraToBoundingBox(boundingBox, fovVertical, viewVector) {
     const radius = 1.1 *
       bundle_esm.vector3.magnitude(bundle_esm.vector3.subtract(boundingBox.max, bundle_esm.boundingBox.center(boundingBox)));
     // 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 = bundle_esm.vector3.scale(distance, bundle_esm.vector3.normalize(this.viewVector()));
+    const vvec = bundle_esm.vector3.scale(distance, bundle_esm.vector3.normalize(viewVector));
     const lookAt = bundle_esm.boundingBox.center(boundingBox);
     const position = bundle_esm.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
@@ -626,12 +628,11 @@ class Camera {
    *
    * @param boundingBox - The bounding box to determine distance from.
    */
-  distanceToBoundingBoxCenter(boundingBox) {
-    const box = boundingBox || this.boundingBox;
-    const boundingBoxCenter = bundle_esm.boundingBox.center(box);
-    const cameraToCenter = bundle_esm.vector3.subtract(this.position, boundingBoxCenter);
-    const distanceToCenterAlongViewVec = Math.abs(bundle_esm.vector3.dot(bundle_esm.vector3.subtract(this.lookAt, this.position), cameraToCenter)) / bundle_esm.vector3.magnitude(bundle_esm.vector3.subtract(this.lookAt, this.position));
-    return distanceToCenterAlongViewVec;
+  signedDistanceToBoundingBoxCenter(boundingBox) {
+    const { position, viewVector } = streamAttributes.withPositionAndViewVector(this.data);
+    const boundingBoxCenter = bundle_esm.boundingBox.center(boundingBox !== null && boundingBox !== void 0 ? boundingBox : this.boundingBox);
+    const cameraToCenter = bundle_esm.vector3.subtract(boundingBoxCenter, position);
+    return (bundle_esm.vector3.dot(viewVector, cameraToCenter) / bundle_esm.vector3.magnitude(viewVector));
   }
   /**
    * Specifies that the next render of the camera will be repositioned to one of
@@ -642,26 +643,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: bundle_esm.vector3.add(this.position, delta),
-      lookAt: bundle_esm.vector3.add(this.lookAt, delta),
-    });
-  }
   viewAll() {
     return this.fitToBoundingBox(this.boundingBox);
   }
@@ -693,7 +682,7 @@ class Camera {
       }
       else {
         this.stream.replaceCamera({
-          camera: this.data,
+          camera: streamAttributes.toProtobuf(this.data),
           frameCorrelationId: { value: corrId },
         });
         return new CameraRenderResult(this.stream, this.decodeFrame, {
@@ -713,22 +702,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: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
-      lookAt: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
-      up: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm.vector3.origin()),
-    });
+    return this.rotateAroundAxisAtPoint(angleInRadians, this.data.lookAt, axis);
   }
   /**
    * Updates the `position` and `up` vectors of the camera to the given standard
@@ -744,20 +718,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 streamAttributes.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 };
@@ -778,36 +738,66 @@ class Camera {
   computeClippingPlanes(camera) {
     return streamAttributes.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: bundle_esm.vector3.add(this.position, delta),
+      lookAt: bundle_esm.vector3.add(this.lookAt, delta),
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    return this.update({
+      position: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
+      lookAt: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
+      up: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm.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 streamAttributes.FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovY);
+  }
+  get viewVector() {
     return bundle_esm.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.
@@ -819,16 +809,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 = bundle_esm.vector3.add(this.lookAt, delta);
+    return this.update({
+      viewVector: bundle_esm.vector3.subtract(updatedLookAt, bundle_esm.vector3.add(this.position, delta)),
+      lookAt: updatedLookAt,
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    const newLookAt = bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
+    const newUp = bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm.vector3.origin());
+    const newViewVector = bundle_esm.vector3.subtract(bundle_esm.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 streamAttributes.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 bundle_esm.vector3.add(this.lookAt, bundle_esm.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);
+  }
 }
 
 /**
@@ -1235,12 +1313,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, bundle_esm.dimensions.aspectRatio(this.viewport()), data, this.frame.scene.boundingBox, this.decodeFrame);
+    if (scene.camera instanceof streamAttributes.FrameOrthographicCamera) {
+      return new OrthographicCamera(this.stream, bundle_esm.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 streamAttributes.FramePerspectiveCamera) {
+      return new PerspectiveCamera(this.stream, bundle_esm.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;