deeptwins-cesium-engine 0.1.2 → 0.1.4

package/Build/Workers/createGroundPolylineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 0.0.42
+ * Version 0.1.4
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,190 +25,243 @@
 
 import {
   WebMercatorProjection_default
-} from "./chunk-R2LIFXV3.js";
+} from "./chunk-QGISLKCW.js";
 import {
   ArcType_default
-} from "./chunk-ZMDUYETO.js";
+} from "./chunk-UXJ6J5L7.js";
 import {
   EncodedCartesian3_default
-} from "./chunk-L4IR5U4G.js";
+} from "./chunk-5ISZ6NJD.js";
 import {
   EllipsoidGeodesic_default
-} from "./chunk-2JVMMMWT.js";
+} from "./chunk-KLUL2SOE.js";
 import {
   arrayRemoveDuplicates_default
-} from "./chunk-PHWZFJR5.js";
+} from "./chunk-FWYDLSVQ.js";
 import {
   EllipsoidRhumbLine_default
-} from "./chunk-27NG6PQR.js";
+} from "./chunk-BVMRWGOK.js";
 import {
   IntersectionTests_default
-} from "./chunk-R5PZXG56.js";
+} from "./chunk-BE2N56VZ.js";
 import {
   Plane_default
-} from "./chunk-7B5XGQRN.js";
+} from "./chunk-KOTWWQN7.js";
 import {
   GeometryAttribute_default,
   Geometry_default
-} from "./chunk-NXWEFAZJ.js";
+} from "./chunk-7AMRE57Q.js";
 import {
   BoundingSphere_default,
   GeographicProjection_default
-} from "./chunk-XUCXZZE5.js";
+} from "./chunk-ODZYB26X.js";
+import "./chunk-ANOA7E7F.js";
 import {
   Quaternion_default,
   Rectangle_default,
   Resource_default,
   buildModuleUrl_default
-} from "./chunk-R4W6IRJZ.js";
+} from "./chunk-BR3BPM64.js";
+import "./chunk-OEHJY463.js";
 import {
   ComponentDatatype_default
-} from "./chunk-YTNCIBPQ.js";
+} from "./chunk-C5BO2JCG.js";
+import "./chunk-D3QIW4DH.js";
+import "./chunk-T27NNXEU.js";
 import {
   Cartesian2_default,
-  Cartesian3_default,
   Cartographic_default,
-  Ellipsoid_default,
+  Ellipsoid_default
+} from "./chunk-M6IXKBC7.js";
+import {
+  Cartesian3_default,
+  Frozen_default,
   Matrix3_default
-} from "./chunk-ZW52HXFN.js";
+} from "./chunk-J4PISUNT.js";
 import {
   Math_default
-} from "./chunk-HSJSUPQV.js";
-import "./chunk-RZQLZIUI.js";
-import "./chunk-I73Q3AG7.js";
-import {
-  defaultValue_default
-} from "./chunk-ATLWOZFF.js";
+} from "./chunk-VQH2YXO2.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-PN3GIZ5Q.js";
+} from "./chunk-KWV6ZTF4.js";
 import {
   defined_default
-} from "./chunk-JKLMRPKK.js";
+} from "./chunk-MRMNELAH.js";
 
 // packages/engine/Source/Core/GeographicTilingScheme.js
-function GeographicTilingScheme(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  this._ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
-  this._rectangle = defaultValue_default(options.rectangle, Rectangle_default.MAX_VALUE);
-  this._projection = new GeographicProjection_default(this._ellipsoid);
-  this._numberOfLevelZeroTilesX = defaultValue_default(
-    options.numberOfLevelZeroTilesX,
-    2
-  );
-  this._numberOfLevelZeroTilesY = defaultValue_default(
-    options.numberOfLevelZeroTilesY,
-    1
-  );
-}
-Object.defineProperties(GeographicTilingScheme.prototype, {
+var GeographicTilingScheme = class {
+  /**
+   * @param {object} [options] Object with the following properties:
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The ellipsoid whose surface is being tiled. Defaults to
+   * the default ellipsoid.
+   * @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the tiling scheme.
+   * @param {number} [options.numberOfLevelZeroTilesX=2] The number of tiles in the X direction at level zero of
+   * the tile tree.
+   * @param {number} [options.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
+   * the tile tree.
+   */
+  constructor(options) {
+    options = options ?? Frozen_default.EMPTY_OBJECT;
+    this._ellipsoid = options.ellipsoid ?? Ellipsoid_default.default;
+    this._rectangle = options.rectangle ?? Rectangle_default.MAX_VALUE;
+    this._projection = new GeographicProjection_default(this._ellipsoid);
+    this._numberOfLevelZeroTilesX = options.numberOfLevelZeroTilesX ?? 2;
+    this._numberOfLevelZeroTilesY = options.numberOfLevelZeroTilesY ?? 1;
+  }
   /**
    * Gets the ellipsoid that is tiled by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {Ellipsoid}
    */
-  ellipsoid: {
-    get: function() {
-      return this._ellipsoid;
-    }
-  },
+  get ellipsoid() {
+    return this._ellipsoid;
+  }
   /**
    * Gets the rectangle, in radians, covered by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {Rectangle}
    */
-  rectangle: {
-    get: function() {
-      return this._rectangle;
-    }
-  },
+  get rectangle() {
+    return this._rectangle;
+  }
   /**
    * Gets the map projection used by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {MapProjection}
    */
-  projection: {
-    get: function() {
-      return this._projection;
-    }
-  }
-});
-GeographicTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
-  return this._numberOfLevelZeroTilesX << level;
-};
-GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
-  return this._numberOfLevelZeroTilesY << level;
-};
-GeographicTilingScheme.prototype.rectangleToNativeRectangle = function(rectangle, result) {
-  Check_default.defined("rectangle", rectangle);
-  const west = Math_default.toDegrees(rectangle.west);
-  const south = Math_default.toDegrees(rectangle.south);
-  const east = Math_default.toDegrees(rectangle.east);
-  const north = Math_default.toDegrees(rectangle.north);
-  if (!defined_default(result)) {
-    return new Rectangle_default(west, south, east, north);
+  get projection() {
+    return this._projection;
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-GeographicTilingScheme.prototype.tileXYToNativeRectangle = function(x, y, level, result) {
-  const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
-  rectangleRadians.west = Math_default.toDegrees(rectangleRadians.west);
-  rectangleRadians.south = Math_default.toDegrees(rectangleRadians.south);
-  rectangleRadians.east = Math_default.toDegrees(rectangleRadians.east);
-  rectangleRadians.north = Math_default.toDegrees(rectangleRadians.north);
-  return rectangleRadians;
-};
-GeographicTilingScheme.prototype.tileXYToRectangle = function(x, y, level, result) {
-  const rectangle = this._rectangle;
-  const xTiles = this.getNumberOfXTilesAtLevel(level);
-  const yTiles = this.getNumberOfYTilesAtLevel(level);
-  const xTileWidth = rectangle.width / xTiles;
-  const west = x * xTileWidth + rectangle.west;
-  const east = (x + 1) * xTileWidth + rectangle.west;
-  const yTileHeight = rectangle.height / yTiles;
-  const north = rectangle.north - y * yTileHeight;
-  const south = rectangle.north - (y + 1) * yTileHeight;
-  if (!defined_default(result)) {
-    result = new Rectangle_default(west, south, east, north);
+  /**
+   * Gets the total number of tiles in the X direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the X direction at the given level.
+   */
+  getNumberOfXTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesX << level;
   }
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-GeographicTilingScheme.prototype.positionToTileXY = function(position, level, result) {
-  const rectangle = this._rectangle;
-  if (!Rectangle_default.contains(rectangle, position)) {
-    return void 0;
+  /**
+   * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the Y direction at the given level.
+   */
+  getNumberOfYTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesY << level;
   }
-  const xTiles = this.getNumberOfXTilesAtLevel(level);
-  const yTiles = this.getNumberOfYTilesAtLevel(level);
-  const xTileWidth = rectangle.width / xTiles;
-  const yTileHeight = rectangle.height / yTiles;
-  let longitude = position.longitude;
-  if (rectangle.east < rectangle.west) {
-    longitude += Math_default.TWO_PI;
+  /**
+   * Transforms a rectangle specified in geodetic radians to the native coordinate system
+   * of this tiling scheme.
+   *
+   * @param {Rectangle} rectangle The rectangle to transform.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the native rectangle if 'result'
+   *          is undefined.
+   */
+  rectangleToNativeRectangle(rectangle, result) {
+    Check_default.defined("rectangle", rectangle);
+    const west = Math_default.toDegrees(rectangle.west);
+    const south = Math_default.toDegrees(rectangle.south);
+    const east = Math_default.toDegrees(rectangle.east);
+    const north = Math_default.toDegrees(rectangle.north);
+    if (!defined_default(result)) {
+      return new Rectangle_default(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  let xTileCoordinate = (longitude - rectangle.west) / xTileWidth | 0;
-  if (xTileCoordinate >= xTiles) {
-    xTileCoordinate = xTiles - 1;
+  /**
+   * Converts tile x, y coordinates and level to a rectangle expressed in the native coordinates
+   * of the tiling scheme.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToNativeRectangle(x, y, level, result) {
+    const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
+    rectangleRadians.west = Math_default.toDegrees(rectangleRadians.west);
+    rectangleRadians.south = Math_default.toDegrees(rectangleRadians.south);
+    rectangleRadians.east = Math_default.toDegrees(rectangleRadians.east);
+    rectangleRadians.north = Math_default.toDegrees(rectangleRadians.north);
+    return rectangleRadians;
   }
-  let yTileCoordinate = (rectangle.north - position.latitude) / yTileHeight | 0;
-  if (yTileCoordinate >= yTiles) {
-    yTileCoordinate = yTiles - 1;
+  /**
+   * Converts tile x, y coordinates and level to a cartographic rectangle in radians.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToRectangle(x, y, level, result) {
+    const rectangle = this._rectangle;
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
+    const xTileWidth = rectangle.width / xTiles;
+    const west = x * xTileWidth + rectangle.west;
+    const east = (x + 1) * xTileWidth + rectangle.west;
+    const yTileHeight = rectangle.height / yTiles;
+    const north = rectangle.north - y * yTileHeight;
+    const south = rectangle.north - (y + 1) * yTileHeight;
+    if (!defined_default(result)) {
+      result = new Rectangle_default(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
-  if (!defined_default(result)) {
-    return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
+  /**
+   * Calculates the tile x, y coordinates of the tile containing
+   * a given cartographic position.
+   *
+   * @param {Cartographic} position The position.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Cartesian2} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
+   *          if 'result' is undefined.
+   */
+  positionToTileXY(position, level, result) {
+    const rectangle = this._rectangle;
+    if (!Rectangle_default.contains(rectangle, position)) {
+      return void 0;
+    }
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
+    const xTileWidth = rectangle.width / xTiles;
+    const yTileHeight = rectangle.height / yTiles;
+    let longitude = position.longitude;
+    if (rectangle.east < rectangle.west) {
+      longitude += Math_default.TWO_PI;
+    }
+    let xTileCoordinate = (longitude - rectangle.west) / xTileWidth | 0;
+    if (xTileCoordinate >= xTiles) {
+      xTileCoordinate = xTiles - 1;
+    }
+    let yTileCoordinate = (rectangle.north - position.latitude) / yTileHeight | 0;
+    if (yTileCoordinate >= yTiles) {
+      yTileCoordinate = yTiles - 1;
+    }
+    if (!defined_default(result)) {
+      return new Cartesian2_default(xTileCoordinate, yTileCoordinate);
+    }
+    result.x = xTileCoordinate;
+    result.y = yTileCoordinate;
+    return result;
   }
-  result.x = xTileCoordinate;
-  result.y = yTileCoordinate;
-  return result;
 };
 var GeographicTilingScheme_default = GeographicTilingScheme;
 
@@ -248,7 +301,7 @@ ApproximateTerrainHeights.getMinimumMaximumHeights = function(rectangle, ellipso
       "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
     );
   }
-  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  ellipsoid = ellipsoid ?? Ellipsoid_default.default;
   const xyLevel = getTileXYLevel(rectangle);
   let minTerrainHeight = ApproximateTerrainHeights._defaultMinTerrainHeight;
   let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
@@ -302,7 +355,7 @@ ApproximateTerrainHeights.getBoundingSphere = function(rectangle, ellipsoid) {
       "You must call ApproximateTerrainHeights.initialize and wait for the promise to resolve before using this function"
     );
   }
-  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  ellipsoid = ellipsoid ?? Ellipsoid_default.default;
   const xyLevel = getTileXYLevel(rectangle);
   let maxTerrainHeight = ApproximateTerrainHeights._defaultMaxTerrainHeight;
   if (defined_default(xyLevel)) {
@@ -407,7 +460,7 @@ var MITER_BREAK_LARGE = Math.cos(Math_default.toRadians(150));
 var WALL_INITIAL_MIN_HEIGHT = 0;
 var WALL_INITIAL_MAX_HEIGHT = 1e3;
 function GroundPolylineGeometry(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  options = options ?? Frozen_default.EMPTY_OBJECT;
   const positions = options.positions;
   if (!defined_default(positions) || positions.length < 2) {
     throw new DeveloperError_default("At least two positions are required.");
@@ -417,11 +470,11 @@ function GroundPolylineGeometry(options) {
       "Valid options for arcType are ArcType.GEODESIC and ArcType.RHUMB."
     );
   }
-  this.width = defaultValue_default(options.width, 1);
+  this.width = options.width ?? 1;
   this._positions = positions;
-  this.granularity = defaultValue_default(options.granularity, 9999);
-  this.loop = defaultValue_default(options.loop, false);
-  this.arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
+  this.granularity = options.granularity ?? 9999;
+  this.loop = options.loop ?? false;
+  this.arcType = options.arcType ?? ArcType_default.GEODESIC;
   this._ellipsoid = Ellipsoid_default.default;
   this._projectionIndex = 0;
   this._workerName = "createGroundPolylineGeometry";
@@ -533,7 +586,7 @@ function getPosition(ellipsoid, cartographic, height, result) {
 GroundPolylineGeometry.pack = function(value, array, startingIndex) {
   Check_default.typeOf.object("value", value);
   Check_default.defined("array", array);
-  let index = defaultValue_default(startingIndex, 0);
+  let index = startingIndex ?? 0;
   const positions = value._positions;
   const positionsLength = positions.length;
   array[index++] = positionsLength;
@@ -553,7 +606,7 @@ GroundPolylineGeometry.pack = function(value, array, startingIndex) {
 };
 GroundPolylineGeometry.unpack = function(array, startingIndex, result) {
   Check_default.defined("array", array);
-  let index = defaultValue_default(startingIndex, 0);
+  let index = startingIndex ?? 0;
   const positionsLength = array[index++];
   const positions = new Array(positionsLength);
   for (let i = 0; i < positionsLength; i++) {

package/Build/Workers/createPlaneGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 0.0.42
+ * Version 0.1.4
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,42 +25,43 @@
 
 import {
   VertexFormat_default
-} from "./chunk-EYSYQ2R6.js";
+} from "./chunk-OZ3CQDO3.js";
 import {
   GeometryAttributes_default
-} from "./chunk-MG4EVQH2.js";
+} from "./chunk-OMMRNMXF.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-NXWEFAZJ.js";
+} from "./chunk-7AMRE57Q.js";
 import {
   BoundingSphere_default
-} from "./chunk-XUCXZZE5.js";
-import "./chunk-R4W6IRJZ.js";
+} from "./chunk-ODZYB26X.js";
+import "./chunk-ANOA7E7F.js";
+import "./chunk-BR3BPM64.js";
+import "./chunk-OEHJY463.js";
 import {
   ComponentDatatype_default
-} from "./chunk-YTNCIBPQ.js";
+} from "./chunk-C5BO2JCG.js";
+import "./chunk-D3QIW4DH.js";
+import "./chunk-T27NNXEU.js";
+import "./chunk-M6IXKBC7.js";
 import {
-  Cartesian3_default
-} from "./chunk-ZW52HXFN.js";
-import "./chunk-HSJSUPQV.js";
-import "./chunk-RZQLZIUI.js";
-import "./chunk-I73Q3AG7.js";
-import {
-  defaultValue_default
-} from "./chunk-ATLWOZFF.js";
+  Cartesian3_default,
+  Frozen_default
+} from "./chunk-J4PISUNT.js";
+import "./chunk-VQH2YXO2.js";
 import {
   Check_default
-} from "./chunk-PN3GIZ5Q.js";
+} from "./chunk-KWV6ZTF4.js";
 import {
   defined_default
-} from "./chunk-JKLMRPKK.js";
+} from "./chunk-MRMNELAH.js";
 
 // packages/engine/Source/Core/PlaneGeometry.js
 function PlaneGeometry(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  const vertexFormat = options.vertexFormat ?? VertexFormat_default.DEFAULT;
   this._vertexFormat = vertexFormat;
   this._workerName = "createPlaneGeometry";
 }
@@ -68,7 +69,7 @@ PlaneGeometry.packedLength = VertexFormat_default.packedLength;
 PlaneGeometry.pack = function(value, array, startingIndex) {
   Check_default.typeOf.object("value", value);
   Check_default.defined("array", array);
-  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = startingIndex ?? 0;
   VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
   return array;
 };
@@ -78,7 +79,7 @@ var scratchOptions = {
 };
 PlaneGeometry.unpack = function(array, startingIndex, result) {
   Check_default.defined("array", array);
-  startingIndex = defaultValue_default(startingIndex, 0);
+  startingIndex = startingIndex ?? 0;
   const vertexFormat = VertexFormat_default.unpack(
     array,
     startingIndex,

package/Build/Workers/createPlaneOutlineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 0.0.42
+ * Version 0.1.4
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,32 +25,34 @@
 
 import {
   GeometryAttributes_default
-} from "./chunk-MG4EVQH2.js";
+} from "./chunk-OMMRNMXF.js";
 import {
   GeometryAttribute_default,
   Geometry_default,
   PrimitiveType_default
-} from "./chunk-NXWEFAZJ.js";
+} from "./chunk-7AMRE57Q.js";
 import {
   BoundingSphere_default
-} from "./chunk-XUCXZZE5.js";
-import "./chunk-R4W6IRJZ.js";
+} from "./chunk-ODZYB26X.js";
+import "./chunk-ANOA7E7F.js";
+import "./chunk-BR3BPM64.js";
+import "./chunk-OEHJY463.js";
 import {
   ComponentDatatype_default
-} from "./chunk-YTNCIBPQ.js";
+} from "./chunk-C5BO2JCG.js";
+import "./chunk-D3QIW4DH.js";
+import "./chunk-T27NNXEU.js";
+import "./chunk-M6IXKBC7.js";
 import {
   Cartesian3_default
-} from "./chunk-ZW52HXFN.js";
-import "./chunk-HSJSUPQV.js";
-import "./chunk-RZQLZIUI.js";
-import "./chunk-I73Q3AG7.js";
-import "./chunk-ATLWOZFF.js";
+} from "./chunk-J4PISUNT.js";
+import "./chunk-VQH2YXO2.js";
 import {
   Check_default
-} from "./chunk-PN3GIZ5Q.js";
+} from "./chunk-KWV6ZTF4.js";
 import {
   defined_default
-} from "./chunk-JKLMRPKK.js";
+} from "./chunk-MRMNELAH.js";
 
 // packages/engine/Source/Core/PlaneOutlineGeometry.js
 function PlaneOutlineGeometry() {