@cesium/engine 3.0.1 → 4.0.0

package/Build/Workers/AxisAlignedBoundingBox-4bfd84f3.js

@@ -1,258 +0,0 @@
-define(['exports', './Matrix3-41c58dde', './Check-6ede7e26', './defaultValue-fe22d8c0', './Transforms-e2d4a55a'], (function (exports, Matrix3, Check, defaultValue, Transforms) { 'use strict';
-
-  /**
-   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
-   * @alias AxisAlignedBoundingBox
-   * @constructor
-   *
-   * @param {Cartesian3} [minimum=Cartesian3.ZERO] The minimum point along the x, y, and z axes.
-   * @param {Cartesian3} [maximum=Cartesian3.ZERO] The maximum point along the x, y, and z axes.
-   * @param {Cartesian3} [center] The center of the box; automatically computed if not supplied.
-   *
-   * @see BoundingSphere
-   * @see BoundingRectangle
-   */
-  function AxisAlignedBoundingBox(minimum, maximum, center) {
-    /**
-     * The minimum point defining the bounding box.
-     * @type {Cartesian3}
-     * @default {@link Cartesian3.ZERO}
-     */
-    this.minimum = Matrix3.Cartesian3.clone(defaultValue.defaultValue(minimum, Matrix3.Cartesian3.ZERO));
-
-    /**
-     * The maximum point defining the bounding box.
-     * @type {Cartesian3}
-     * @default {@link Cartesian3.ZERO}
-     */
-    this.maximum = Matrix3.Cartesian3.clone(defaultValue.defaultValue(maximum, Matrix3.Cartesian3.ZERO));
-
-    // If center was not defined, compute it.
-    if (!defaultValue.defined(center)) {
-      center = Matrix3.Cartesian3.midpoint(this.minimum, this.maximum, new Matrix3.Cartesian3());
-    } else {
-      center = Matrix3.Cartesian3.clone(center);
-    }
-
-    /**
-     * The center point of the bounding box.
-     * @type {Cartesian3}
-     */
-    this.center = center;
-  }
-
-  /**
-   * Creates an instance of an AxisAlignedBoundingBox from its corners.
-   *
-   * @param {Cartesian3} minimum The minimum point along the x, y, and z axes.
-   * @param {Cartesian3} maximum The maximum point along the x, y, and z axes.
-   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
-   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
-   *
-   * @example
-   * // Compute an axis aligned bounding box from the two corners.
-   * const box = Cesium.AxisAlignedBoundingBox.fromCorners(new Cesium.Cartesian3(-1, -1, -1), new Cesium.Cartesian3(1, 1, 1));
-   */
-  AxisAlignedBoundingBox.fromCorners = function (minimum, maximum, result) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.defined("minimum", minimum);
-    Check.Check.defined("maximum", maximum);
-    //>>includeEnd('debug');
-
-    if (!defaultValue.defined(result)) {
-      result = new AxisAlignedBoundingBox();
-    }
-
-    result.minimum = Matrix3.Cartesian3.clone(minimum, result.minimum);
-    result.maximum = Matrix3.Cartesian3.clone(maximum, result.maximum);
-    result.center = Matrix3.Cartesian3.midpoint(minimum, maximum, result.center);
-
-    return result;
-  };
-
-  /**
-   * Computes an instance of an AxisAlignedBoundingBox. The box is determined by
-   * finding the points spaced the farthest apart on the x, y, and z axes.
-   *
-   * @param {Cartesian3[]} positions List of points that the bounding box will enclose.  Each point must have a <code>x</code>, <code>y</code>, and <code>z</code> properties.
-   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
-   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
-   *
-   * @example
-   * // Compute an axis aligned bounding box enclosing two points.
-   * const box = Cesium.AxisAlignedBoundingBox.fromPoints([new Cesium.Cartesian3(2, 0, 0), new Cesium.Cartesian3(-2, 0, 0)]);
-   */
-  AxisAlignedBoundingBox.fromPoints = function (positions, result) {
-    if (!defaultValue.defined(result)) {
-      result = new AxisAlignedBoundingBox();
-    }
-
-    if (!defaultValue.defined(positions) || positions.length === 0) {
-      result.minimum = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.minimum);
-      result.maximum = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.maximum);
-      result.center = Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, result.center);
-      return result;
-    }
-
-    let minimumX = positions[0].x;
-    let minimumY = positions[0].y;
-    let minimumZ = positions[0].z;
-
-    let maximumX = positions[0].x;
-    let maximumY = positions[0].y;
-    let maximumZ = positions[0].z;
-
-    const length = positions.length;
-    for (let i = 1; i < length; i++) {
-      const p = positions[i];
-      const x = p.x;
-      const y = p.y;
-      const z = p.z;
-
-      minimumX = Math.min(x, minimumX);
-      maximumX = Math.max(x, maximumX);
-      minimumY = Math.min(y, minimumY);
-      maximumY = Math.max(y, maximumY);
-      minimumZ = Math.min(z, minimumZ);
-      maximumZ = Math.max(z, maximumZ);
-    }
-
-    const minimum = result.minimum;
-    minimum.x = minimumX;
-    minimum.y = minimumY;
-    minimum.z = minimumZ;
-
-    const maximum = result.maximum;
-    maximum.x = maximumX;
-    maximum.y = maximumY;
-    maximum.z = maximumZ;
-
-    result.center = Matrix3.Cartesian3.midpoint(minimum, maximum, result.center);
-
-    return result;
-  };
-
-  /**
-   * Duplicates a AxisAlignedBoundingBox instance.
-   *
-   * @param {AxisAlignedBoundingBox} box The bounding box to duplicate.
-   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
-   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if none was provided. (Returns undefined if box is undefined)
-   */
-  AxisAlignedBoundingBox.clone = function (box, result) {
-    if (!defaultValue.defined(box)) {
-      return undefined;
-    }
-
-    if (!defaultValue.defined(result)) {
-      return new AxisAlignedBoundingBox(box.minimum, box.maximum, box.center);
-    }
-
-    result.minimum = Matrix3.Cartesian3.clone(box.minimum, result.minimum);
-    result.maximum = Matrix3.Cartesian3.clone(box.maximum, result.maximum);
-    result.center = Matrix3.Cartesian3.clone(box.center, result.center);
-    return result;
-  };
-
-  /**
-   * Compares the provided AxisAlignedBoundingBox componentwise and returns
-   * <code>true</code> if they are equal, <code>false</code> otherwise.
-   *
-   * @param {AxisAlignedBoundingBox} [left] The first AxisAlignedBoundingBox.
-   * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox.
-   * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
-   */
-  AxisAlignedBoundingBox.equals = function (left, right) {
-    return (
-      left === right ||
-      (defaultValue.defined(left) &&
-        defaultValue.defined(right) &&
-        Matrix3.Cartesian3.equals(left.center, right.center) &&
-        Matrix3.Cartesian3.equals(left.minimum, right.minimum) &&
-        Matrix3.Cartesian3.equals(left.maximum, right.maximum))
-    );
-  };
-
-  let intersectScratch = new Matrix3.Cartesian3();
-  /**
-   * Determines which side of a plane a box is located.
-   *
-   * @param {AxisAlignedBoundingBox} box The bounding box to test.
-   * @param {Plane} plane The plane to test against.
-   * @returns {Intersect} {@link Intersect.INSIDE} if the entire box is on the side of the plane
-   *                      the normal is pointing, {@link Intersect.OUTSIDE} if the entire box is
-   *                      on the opposite side, and {@link Intersect.INTERSECTING} if the box
-   *                      intersects the plane.
-   */
-  AxisAlignedBoundingBox.intersectPlane = function (box, plane) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.defined("box", box);
-    Check.Check.defined("plane", plane);
-    //>>includeEnd('debug');
-
-    intersectScratch = Matrix3.Cartesian3.subtract(
-      box.maximum,
-      box.minimum,
-      intersectScratch
-    );
-    const h = Matrix3.Cartesian3.multiplyByScalar(
-      intersectScratch,
-      0.5,
-      intersectScratch
-    ); //The positive half diagonal
-    const normal = plane.normal;
-    const e =
-      h.x * Math.abs(normal.x) +
-      h.y * Math.abs(normal.y) +
-      h.z * Math.abs(normal.z);
-    const s = Matrix3.Cartesian3.dot(box.center, normal) + plane.distance; //signed distance from center
-
-    if (s - e > 0) {
-      return Transforms.Intersect.INSIDE;
-    }
-
-    if (s + e < 0) {
-      //Not in front because normals point inward
-      return Transforms.Intersect.OUTSIDE;
-    }
-
-    return Transforms.Intersect.INTERSECTING;
-  };
-
-  /**
-   * Duplicates this AxisAlignedBoundingBox instance.
-   *
-   * @param {AxisAlignedBoundingBox} [result] The object onto which to store the result.
-   * @returns {AxisAlignedBoundingBox} The modified result parameter or a new AxisAlignedBoundingBox instance if one was not provided.
-   */
-  AxisAlignedBoundingBox.prototype.clone = function (result) {
-    return AxisAlignedBoundingBox.clone(this, result);
-  };
-
-  /**
-   * Determines which side of a plane this box is located.
-   *
-   * @param {Plane} plane The plane to test against.
-   * @returns {Intersect} {@link Intersect.INSIDE} if the entire box is on the side of the plane
-   *                      the normal is pointing, {@link Intersect.OUTSIDE} if the entire box is
-   *                      on the opposite side, and {@link Intersect.INTERSECTING} if the box
-   *                      intersects the plane.
-   */
-  AxisAlignedBoundingBox.prototype.intersectPlane = function (plane) {
-    return AxisAlignedBoundingBox.intersectPlane(this, plane);
-  };
-
-  /**
-   * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
-   * <code>true</code> if they are equal, <code>false</code> otherwise.
-   *
-   * @param {AxisAlignedBoundingBox} [right] The right hand side AxisAlignedBoundingBox.
-   * @returns {boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
-   */
-  AxisAlignedBoundingBox.prototype.equals = function (right) {
-    return AxisAlignedBoundingBox.equals(this, right);
-  };
-
-  exports.AxisAlignedBoundingBox = AxisAlignedBoundingBox;
-
-}));

package/Build/Workers/BoundingRectangle-5fd6403a.js

@@ -1,369 +0,0 @@
-define(['exports', './Matrix2-e1298525', './Matrix3-41c58dde', './Check-6ede7e26', './defaultValue-fe22d8c0', './Transforms-e2d4a55a'], (function (exports, Matrix2, Matrix3, Check, defaultValue, Transforms) { 'use strict';
-
-  /**
-   * A bounding rectangle given by a corner, width and height.
-   * @alias BoundingRectangle
-   * @constructor
-   *
-   * @param {number} [x=0.0] The x coordinate of the rectangle.
-   * @param {number} [y=0.0] The y coordinate of the rectangle.
-   * @param {number} [width=0.0] The width of the rectangle.
-   * @param {number} [height=0.0] The height of the rectangle.
-   *
-   * @see BoundingSphere
-   * @see Packable
-   */
-  function BoundingRectangle(x, y, width, height) {
-    /**
-     * The x coordinate of the rectangle.
-     * @type {number}
-     * @default 0.0
-     */
-    this.x = defaultValue.defaultValue(x, 0.0);
-
-    /**
-     * The y coordinate of the rectangle.
-     * @type {number}
-     * @default 0.0
-     */
-    this.y = defaultValue.defaultValue(y, 0.0);
-
-    /**
-     * The width of the rectangle.
-     * @type {number}
-     * @default 0.0
-     */
-    this.width = defaultValue.defaultValue(width, 0.0);
-
-    /**
-     * The height of the rectangle.
-     * @type {number}
-     * @default 0.0
-     */
-    this.height = defaultValue.defaultValue(height, 0.0);
-  }
-
-  /**
-   * The number of elements used to pack the object into an array.
-   * @type {number}
-   */
-  BoundingRectangle.packedLength = 4;
-
-  /**
-   * Stores the provided instance into the provided array.
-   *
-   * @param {BoundingRectangle} value The value to pack.
-   * @param {number[]} array The array to pack into.
-   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
-   *
-   * @returns {number[]} The array that was packed into
-   */
-  BoundingRectangle.pack = function (value, array, startingIndex) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("value", value);
-    Check.Check.defined("array", array);
-    //>>includeEnd('debug');
-
-    startingIndex = defaultValue.defaultValue(startingIndex, 0);
-
-    array[startingIndex++] = value.x;
-    array[startingIndex++] = value.y;
-    array[startingIndex++] = value.width;
-    array[startingIndex] = value.height;
-
-    return array;
-  };
-
-  /**
-   * Retrieves an instance from a packed array.
-   *
-   * @param {number[]} array The packed array.
-   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
-   * @param {BoundingRectangle} [result] The object into which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.unpack = function (array, startingIndex, result) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.defined("array", array);
-    //>>includeEnd('debug');
-
-    startingIndex = defaultValue.defaultValue(startingIndex, 0);
-
-    if (!defaultValue.defined(result)) {
-      result = new BoundingRectangle();
-    }
-    result.x = array[startingIndex++];
-    result.y = array[startingIndex++];
-    result.width = array[startingIndex++];
-    result.height = array[startingIndex];
-    return result;
-  };
-
-  /**
-   * Computes a bounding rectangle enclosing the list of 2D points.
-   * The rectangle is oriented with the corner at the bottom left.
-   *
-   * @param {Cartesian2[]} positions List of points that the bounding rectangle will enclose.  Each point must have <code>x</code> and <code>y</code> properties.
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.fromPoints = function (positions, result) {
-    if (!defaultValue.defined(result)) {
-      result = new BoundingRectangle();
-    }
-
-    if (!defaultValue.defined(positions) || positions.length === 0) {
-      result.x = 0;
-      result.y = 0;
-      result.width = 0;
-      result.height = 0;
-      return result;
-    }
-
-    const length = positions.length;
-
-    let minimumX = positions[0].x;
-    let minimumY = positions[0].y;
-
-    let maximumX = positions[0].x;
-    let maximumY = positions[0].y;
-
-    for (let i = 1; i < length; i++) {
-      const p = positions[i];
-      const x = p.x;
-      const y = p.y;
-
-      minimumX = Math.min(x, minimumX);
-      maximumX = Math.max(x, maximumX);
-      minimumY = Math.min(y, minimumY);
-      maximumY = Math.max(y, maximumY);
-    }
-
-    result.x = minimumX;
-    result.y = minimumY;
-    result.width = maximumX - minimumX;
-    result.height = maximumY - minimumY;
-    return result;
-  };
-
-  const defaultProjection = new Transforms.GeographicProjection();
-  const fromRectangleLowerLeft = new Matrix3.Cartographic();
-  const fromRectangleUpperRight = new Matrix3.Cartographic();
-  /**
-   * Computes a bounding rectangle from a rectangle.
-   *
-   * @param {Rectangle} rectangle The valid rectangle used to create a bounding rectangle.
-   * @param {object} [projection=GeographicProjection] The projection used to project the rectangle into 2D.
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.fromRectangle = function (rectangle, projection, result) {
-    if (!defaultValue.defined(result)) {
-      result = new BoundingRectangle();
-    }
-
-    if (!defaultValue.defined(rectangle)) {
-      result.x = 0;
-      result.y = 0;
-      result.width = 0;
-      result.height = 0;
-      return result;
-    }
-
-    projection = defaultValue.defaultValue(projection, defaultProjection);
-
-    const lowerLeft = projection.project(
-      Matrix2.Rectangle.southwest(rectangle, fromRectangleLowerLeft)
-    );
-    const upperRight = projection.project(
-      Matrix2.Rectangle.northeast(rectangle, fromRectangleUpperRight)
-    );
-
-    Matrix2.Cartesian2.subtract(upperRight, lowerLeft, upperRight);
-
-    result.x = lowerLeft.x;
-    result.y = lowerLeft.y;
-    result.width = upperRight.x;
-    result.height = upperRight.y;
-    return result;
-  };
-
-  /**
-   * Duplicates a BoundingRectangle instance.
-   *
-   * @param {BoundingRectangle} rectangle The bounding rectangle to duplicate.
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided. (Returns undefined if rectangle is undefined)
-   */
-  BoundingRectangle.clone = function (rectangle, result) {
-    if (!defaultValue.defined(rectangle)) {
-      return undefined;
-    }
-
-    if (!defaultValue.defined(result)) {
-      return new BoundingRectangle(
-        rectangle.x,
-        rectangle.y,
-        rectangle.width,
-        rectangle.height
-      );
-    }
-
-    result.x = rectangle.x;
-    result.y = rectangle.y;
-    result.width = rectangle.width;
-    result.height = rectangle.height;
-    return result;
-  };
-
-  /**
-   * Computes a bounding rectangle that is the union of the left and right bounding rectangles.
-   *
-   * @param {BoundingRectangle} left A rectangle to enclose in bounding rectangle.
-   * @param {BoundingRectangle} right A rectangle to enclose in a bounding rectangle.
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.union = function (left, right, result) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("left", left);
-    Check.Check.typeOf.object("right", right);
-    //>>includeEnd('debug');
-
-    if (!defaultValue.defined(result)) {
-      result = new BoundingRectangle();
-    }
-
-    const lowerLeftX = Math.min(left.x, right.x);
-    const lowerLeftY = Math.min(left.y, right.y);
-    const upperRightX = Math.max(left.x + left.width, right.x + right.width);
-    const upperRightY = Math.max(left.y + left.height, right.y + right.height);
-
-    result.x = lowerLeftX;
-    result.y = lowerLeftY;
-    result.width = upperRightX - lowerLeftX;
-    result.height = upperRightY - lowerLeftY;
-    return result;
-  };
-
-  /**
-   * Computes a bounding rectangle by enlarging the provided rectangle until it contains the provided point.
-   *
-   * @param {BoundingRectangle} rectangle A rectangle to expand.
-   * @param {Cartesian2} point A point to enclose in a bounding rectangle.
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.expand = function (rectangle, point, result) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("rectangle", rectangle);
-    Check.Check.typeOf.object("point", point);
-    //>>includeEnd('debug');
-
-    result = BoundingRectangle.clone(rectangle, result);
-
-    const width = point.x - result.x;
-    const height = point.y - result.y;
-
-    if (width > result.width) {
-      result.width = width;
-    } else if (width < 0) {
-      result.width -= width;
-      result.x = point.x;
-    }
-
-    if (height > result.height) {
-      result.height = height;
-    } else if (height < 0) {
-      result.height -= height;
-      result.y = point.y;
-    }
-
-    return result;
-  };
-
-  /**
-   * Determines if two rectangles intersect.
-   *
-   * @param {BoundingRectangle} left A rectangle to check for intersection.
-   * @param {BoundingRectangle} right The other rectangle to check for intersection.
-   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
-   */
-  BoundingRectangle.intersect = function (left, right) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("left", left);
-    Check.Check.typeOf.object("right", right);
-    //>>includeEnd('debug');
-
-    const leftX = left.x;
-    const leftY = left.y;
-    const rightX = right.x;
-    const rightY = right.y;
-    if (
-      !(
-        leftX > rightX + right.width ||
-        leftX + left.width < rightX ||
-        leftY + left.height < rightY ||
-        leftY > rightY + right.height
-      )
-    ) {
-      return Transforms.Intersect.INTERSECTING;
-    }
-
-    return Transforms.Intersect.OUTSIDE;
-  };
-
-  /**
-   * Compares the provided BoundingRectangles componentwise and returns
-   * <code>true</code> if they are equal, <code>false</code> otherwise.
-   *
-   * @param {BoundingRectangle} [left] The first BoundingRectangle.
-   * @param {BoundingRectangle} [right] The second BoundingRectangle.
-   * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
-   */
-  BoundingRectangle.equals = function (left, right) {
-    return (
-      left === right ||
-      (defaultValue.defined(left) &&
-        defaultValue.defined(right) &&
-        left.x === right.x &&
-        left.y === right.y &&
-        left.width === right.width &&
-        left.height === right.height)
-    );
-  };
-
-  /**
-   * Duplicates this BoundingRectangle instance.
-   *
-   * @param {BoundingRectangle} [result] The object onto which to store the result.
-   * @returns {BoundingRectangle} The modified result parameter or a new BoundingRectangle instance if one was not provided.
-   */
-  BoundingRectangle.prototype.clone = function (result) {
-    return BoundingRectangle.clone(this, result);
-  };
-
-  /**
-   * Determines if this rectangle intersects with another.
-   *
-   * @param {BoundingRectangle} right A rectangle to check for intersection.
-   * @returns {Intersect} <code>Intersect.INTERSECTING</code> if the rectangles intersect, <code>Intersect.OUTSIDE</code> otherwise.
-   */
-  BoundingRectangle.prototype.intersect = function (right) {
-    return BoundingRectangle.intersect(this, right);
-  };
-
-  /**
-   * Compares this BoundingRectangle against the provided BoundingRectangle componentwise and returns
-   * <code>true</code> if they are equal, <code>false</code> otherwise.
-   *
-   * @param {BoundingRectangle} [right] The right hand side BoundingRectangle.
-   * @returns {boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
-   */
-  BoundingRectangle.prototype.equals = function (right) {
-    return BoundingRectangle.equals(this, right);
-  };
-
-  exports.BoundingRectangle = BoundingRectangle;
-
-}));