deeptwins-cesium-engine 0.0.3 → 0.0.4

package/Build/Workers/chunk-VXIA6U3E.js

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.29
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// packages/engine/Source/Core/defined.js
+function defined(value) {
+  return value !== void 0 && value !== null;
+}
+var defined_default = defined;
+
+export {
+  __require,
+  __glob,
+  __commonJS,
+  __toESM,
+  defined_default
+};

package/Build/Workers/chunk-WKTTAMO3.js

@@ -0,0 +1,305 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.29
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  Quaternion_default
+} from "./chunk-FKKSB7ZT.js";
+import {
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-DGMXFRAL.js";
+import {
+  Math_default
+} from "./chunk-NN52QO5J.js";
+
+// packages/engine/Source/Core/EllipseGeometryLibrary.js
+var EllipseGeometryLibrary = {};
+var rotAxis = new Cartesian3_default();
+var tempVec = new Cartesian3_default();
+var unitQuat = new Quaternion_default();
+var rotMtx = new Matrix3_default();
+function pointOnEllipsoid(theta, rotation, northVec, eastVec, aSqr, ab, bSqr, mag, unitPos, result) {
+  const azimuth = theta + rotation;
+  Cartesian3_default.multiplyByScalar(eastVec, Math.cos(azimuth), rotAxis);
+  Cartesian3_default.multiplyByScalar(northVec, Math.sin(azimuth), tempVec);
+  Cartesian3_default.add(rotAxis, tempVec, rotAxis);
+  let cosThetaSquared = Math.cos(theta);
+  cosThetaSquared = cosThetaSquared * cosThetaSquared;
+  let sinThetaSquared = Math.sin(theta);
+  sinThetaSquared = sinThetaSquared * sinThetaSquared;
+  const radius = ab / Math.sqrt(bSqr * cosThetaSquared + aSqr * sinThetaSquared);
+  const angle = radius / mag;
+  Quaternion_default.fromAxisAngle(rotAxis, angle, unitQuat);
+  Matrix3_default.fromQuaternion(unitQuat, rotMtx);
+  Matrix3_default.multiplyByVector(rotMtx, unitPos, result);
+  Cartesian3_default.normalize(result, result);
+  Cartesian3_default.multiplyByScalar(result, mag, result);
+  return result;
+}
+var scratchCartesian1 = new Cartesian3_default();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartesian3 = new Cartesian3_default();
+var scratchNormal = new Cartesian3_default();
+EllipseGeometryLibrary.raisePositionsToHeight = function(positions, options, extrude) {
+  const ellipsoid = options.ellipsoid;
+  const height = options.height;
+  const extrudedHeight = options.extrudedHeight;
+  const size = extrude ? positions.length / 3 * 2 : positions.length / 3;
+  const finalPositions = new Float64Array(size * 3);
+  const length = positions.length;
+  const bottomOffset = extrude ? length : 0;
+  for (let i = 0; i < length; i += 3) {
+    const i1 = i + 1;
+    const i2 = i + 2;
+    const position = Cartesian3_default.fromArray(positions, i, scratchCartesian1);
+    ellipsoid.scaleToGeodeticSurface(position, position);
+    const extrudedPosition = Cartesian3_default.clone(position, scratchCartesian2);
+    const normal = ellipsoid.geodeticSurfaceNormal(position, scratchNormal);
+    const scaledNormal = Cartesian3_default.multiplyByScalar(
+      normal,
+      height,
+      scratchCartesian3
+    );
+    Cartesian3_default.add(position, scaledNormal, position);
+    if (extrude) {
+      Cartesian3_default.multiplyByScalar(normal, extrudedHeight, scaledNormal);
+      Cartesian3_default.add(extrudedPosition, scaledNormal, extrudedPosition);
+      finalPositions[i + bottomOffset] = extrudedPosition.x;
+      finalPositions[i1 + bottomOffset] = extrudedPosition.y;
+      finalPositions[i2 + bottomOffset] = extrudedPosition.z;
+    }
+    finalPositions[i] = position.x;
+    finalPositions[i1] = position.y;
+    finalPositions[i2] = position.z;
+  }
+  return finalPositions;
+};
+var unitPosScratch = new Cartesian3_default();
+var eastVecScratch = new Cartesian3_default();
+var northVecScratch = new Cartesian3_default();
+EllipseGeometryLibrary.computeEllipsePositions = function(options, addFillPositions, addEdgePositions) {
+  const semiMinorAxis = options.semiMinorAxis;
+  const semiMajorAxis = options.semiMajorAxis;
+  const rotation = options.rotation;
+  const center = options.center;
+  const granularity = options.granularity * 8;
+  const aSqr = semiMinorAxis * semiMinorAxis;
+  const bSqr = semiMajorAxis * semiMajorAxis;
+  const ab = semiMajorAxis * semiMinorAxis;
+  const mag = Cartesian3_default.magnitude(center);
+  const unitPos = Cartesian3_default.normalize(center, unitPosScratch);
+  let eastVec = Cartesian3_default.cross(Cartesian3_default.UNIT_Z, center, eastVecScratch);
+  eastVec = Cartesian3_default.normalize(eastVec, eastVec);
+  const northVec = Cartesian3_default.cross(unitPos, eastVec, northVecScratch);
+  let numPts = 1 + Math.ceil(Math_default.PI_OVER_TWO / granularity);
+  const deltaTheta = Math_default.PI_OVER_TWO / (numPts - 1);
+  let theta = Math_default.PI_OVER_TWO - numPts * deltaTheta;
+  if (theta < 0) {
+    numPts -= Math.ceil(Math.abs(theta) / deltaTheta);
+  }
+  const size = 2 * (numPts * (numPts + 2));
+  const positions = addFillPositions ? new Array(size * 3) : void 0;
+  let positionIndex = 0;
+  let position = scratchCartesian1;
+  let reflectedPosition = scratchCartesian2;
+  const outerPositionsLength = numPts * 4 * 3;
+  let outerRightIndex = outerPositionsLength - 1;
+  let outerLeftIndex = 0;
+  const outerPositions = addEdgePositions ? new Array(outerPositionsLength) : void 0;
+  let i;
+  let j;
+  let numInterior;
+  let t;
+  let interiorPosition;
+  theta = Math_default.PI_OVER_TWO;
+  position = pointOnEllipsoid(
+    theta,
+    rotation,
+    northVec,
+    eastVec,
+    aSqr,
+    ab,
+    bSqr,
+    mag,
+    unitPos,
+    position
+  );
+  if (addFillPositions) {
+    positions[positionIndex++] = position.x;
+    positions[positionIndex++] = position.y;
+    positions[positionIndex++] = position.z;
+  }
+  if (addEdgePositions) {
+    outerPositions[outerRightIndex--] = position.z;
+    outerPositions[outerRightIndex--] = position.y;
+    outerPositions[outerRightIndex--] = position.x;
+  }
+  theta = Math_default.PI_OVER_TWO - deltaTheta;
+  for (i = 1; i < numPts + 1; ++i) {
+    position = pointOnEllipsoid(
+      theta,
+      rotation,
+      northVec,
+      eastVec,
+      aSqr,
+      ab,
+      bSqr,
+      mag,
+      unitPos,
+      position
+    );
+    reflectedPosition = pointOnEllipsoid(
+      Math.PI - theta,
+      rotation,
+      northVec,
+      eastVec,
+      aSqr,
+      ab,
+      bSqr,
+      mag,
+      unitPos,
+      reflectedPosition
+    );
+    if (addFillPositions) {
+      positions[positionIndex++] = position.x;
+      positions[positionIndex++] = position.y;
+      positions[positionIndex++] = position.z;
+      numInterior = 2 * i + 2;
+      for (j = 1; j < numInterior - 1; ++j) {
+        t = j / (numInterior - 1);
+        interiorPosition = Cartesian3_default.lerp(
+          position,
+          reflectedPosition,
+          t,
+          scratchCartesian3
+        );
+        positions[positionIndex++] = interiorPosition.x;
+        positions[positionIndex++] = interiorPosition.y;
+        positions[positionIndex++] = interiorPosition.z;
+      }
+      positions[positionIndex++] = reflectedPosition.x;
+      positions[positionIndex++] = reflectedPosition.y;
+      positions[positionIndex++] = reflectedPosition.z;
+    }
+    if (addEdgePositions) {
+      outerPositions[outerRightIndex--] = position.z;
+      outerPositions[outerRightIndex--] = position.y;
+      outerPositions[outerRightIndex--] = position.x;
+      outerPositions[outerLeftIndex++] = reflectedPosition.x;
+      outerPositions[outerLeftIndex++] = reflectedPosition.y;
+      outerPositions[outerLeftIndex++] = reflectedPosition.z;
+    }
+    theta = Math_default.PI_OVER_TWO - (i + 1) * deltaTheta;
+  }
+  for (i = numPts; i > 1; --i) {
+    theta = Math_default.PI_OVER_TWO - (i - 1) * deltaTheta;
+    position = pointOnEllipsoid(
+      -theta,
+      rotation,
+      northVec,
+      eastVec,
+      aSqr,
+      ab,
+      bSqr,
+      mag,
+      unitPos,
+      position
+    );
+    reflectedPosition = pointOnEllipsoid(
+      theta + Math.PI,
+      rotation,
+      northVec,
+      eastVec,
+      aSqr,
+      ab,
+      bSqr,
+      mag,
+      unitPos,
+      reflectedPosition
+    );
+    if (addFillPositions) {
+      positions[positionIndex++] = position.x;
+      positions[positionIndex++] = position.y;
+      positions[positionIndex++] = position.z;
+      numInterior = 2 * (i - 1) + 2;
+      for (j = 1; j < numInterior - 1; ++j) {
+        t = j / (numInterior - 1);
+        interiorPosition = Cartesian3_default.lerp(
+          position,
+          reflectedPosition,
+          t,
+          scratchCartesian3
+        );
+        positions[positionIndex++] = interiorPosition.x;
+        positions[positionIndex++] = interiorPosition.y;
+        positions[positionIndex++] = interiorPosition.z;
+      }
+      positions[positionIndex++] = reflectedPosition.x;
+      positions[positionIndex++] = reflectedPosition.y;
+      positions[positionIndex++] = reflectedPosition.z;
+    }
+    if (addEdgePositions) {
+      outerPositions[outerRightIndex--] = position.z;
+      outerPositions[outerRightIndex--] = position.y;
+      outerPositions[outerRightIndex--] = position.x;
+      outerPositions[outerLeftIndex++] = reflectedPosition.x;
+      outerPositions[outerLeftIndex++] = reflectedPosition.y;
+      outerPositions[outerLeftIndex++] = reflectedPosition.z;
+    }
+  }
+  theta = Math_default.PI_OVER_TWO;
+  position = pointOnEllipsoid(
+    -theta,
+    rotation,
+    northVec,
+    eastVec,
+    aSqr,
+    ab,
+    bSqr,
+    mag,
+    unitPos,
+    position
+  );
+  const r = {};
+  if (addFillPositions) {
+    positions[positionIndex++] = position.x;
+    positions[positionIndex++] = position.y;
+    positions[positionIndex++] = position.z;
+    r.positions = positions;
+    r.numPts = numPts;
+  }
+  if (addEdgePositions) {
+    outerPositions[outerRightIndex--] = position.z;
+    outerPositions[outerRightIndex--] = position.y;
+    outerPositions[outerRightIndex--] = position.x;
+    r.outerPositions = outerPositions;
+  }
+  return r;
+};
+var EllipseGeometryLibrary_default = EllipseGeometryLibrary;
+
+export {
+  EllipseGeometryLibrary_default
+};

package/Build/Workers/chunk-WMMHNRGJ.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.29
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  PolylinePipeline_default
+} from "./chunk-63UAUZT6.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-BU67FVEG.js";
+import {
+  Cartographic_default
+} from "./chunk-ZB5XJVWP.js";
+import {
+  Cartesian3_default
+} from "./chunk-DGMXFRAL.js";
+import {
+  Math_default
+} from "./chunk-NN52QO5J.js";
+import {
+  defined_default
+} from "./chunk-VXIA6U3E.js";
+
+// packages/engine/Source/Core/WallGeometryLibrary.js
+var WallGeometryLibrary = {};
+function latLonEquals(c0, c1) {
+  return Math_default.equalsEpsilon(c0.latitude, c1.latitude, Math_default.EPSILON10) && Math_default.equalsEpsilon(c0.longitude, c1.longitude, Math_default.EPSILON10);
+}
+var scratchCartographic1 = new Cartographic_default();
+var scratchCartographic2 = new Cartographic_default();
+function removeDuplicates(ellipsoid, positions, topHeights, bottomHeights) {
+  positions = arrayRemoveDuplicates_default(positions, Cartesian3_default.equalsEpsilon);
+  const length = positions.length;
+  if (length < 2) {
+    return;
+  }
+  const hasBottomHeights = defined_default(bottomHeights);
+  const hasTopHeights = defined_default(topHeights);
+  const cleanedPositions = new Array(length);
+  const cleanedTopHeights = new Array(length);
+  const cleanedBottomHeights = new Array(length);
+  const v0 = positions[0];
+  cleanedPositions[0] = v0;
+  const c0 = ellipsoid.cartesianToCartographic(v0, scratchCartographic1);
+  if (hasTopHeights) {
+    c0.height = topHeights[0];
+  }
+  cleanedTopHeights[0] = c0.height;
+  if (hasBottomHeights) {
+    cleanedBottomHeights[0] = bottomHeights[0];
+  } else {
+    cleanedBottomHeights[0] = 0;
+  }
+  const startTopHeight = cleanedTopHeights[0];
+  const startBottomHeight = cleanedBottomHeights[0];
+  let hasAllSameHeights = startTopHeight === startBottomHeight;
+  let index = 1;
+  for (let i = 1; i < length; ++i) {
+    const v1 = positions[i];
+    const c1 = ellipsoid.cartesianToCartographic(v1, scratchCartographic2);
+    if (hasTopHeights) {
+      c1.height = topHeights[i];
+    }
+    hasAllSameHeights = hasAllSameHeights && c1.height === 0;
+    if (!latLonEquals(c0, c1)) {
+      cleanedPositions[index] = v1;
+      cleanedTopHeights[index] = c1.height;
+      if (hasBottomHeights) {
+        cleanedBottomHeights[index] = bottomHeights[i];
+      } else {
+        cleanedBottomHeights[index] = 0;
+      }
+      hasAllSameHeights = hasAllSameHeights && cleanedTopHeights[index] === cleanedBottomHeights[index];
+      Cartographic_default.clone(c1, c0);
+      ++index;
+    } else if (c0.height < c1.height) {
+      cleanedTopHeights[index - 1] = c1.height;
+    }
+  }
+  if (hasAllSameHeights || index < 2) {
+    return;
+  }
+  cleanedPositions.length = index;
+  cleanedTopHeights.length = index;
+  cleanedBottomHeights.length = index;
+  return {
+    positions: cleanedPositions,
+    topHeights: cleanedTopHeights,
+    bottomHeights: cleanedBottomHeights
+  };
+}
+var positionsArrayScratch = new Array(2);
+var heightsArrayScratch = new Array(2);
+var generateArcOptionsScratch = {
+  positions: void 0,
+  height: void 0,
+  granularity: void 0,
+  ellipsoid: void 0
+};
+WallGeometryLibrary.computePositions = function(ellipsoid, wallPositions, maximumHeights, minimumHeights, granularity, duplicateCorners) {
+  const o = removeDuplicates(
+    ellipsoid,
+    wallPositions,
+    maximumHeights,
+    minimumHeights
+  );
+  if (!defined_default(o)) {
+    return;
+  }
+  wallPositions = o.positions;
+  maximumHeights = o.topHeights;
+  minimumHeights = o.bottomHeights;
+  const length = wallPositions.length;
+  const numCorners = length - 2;
+  let topPositions;
+  let bottomPositions;
+  const minDistance = Math_default.chordLength(
+    granularity,
+    ellipsoid.maximumRadius
+  );
+  const generateArcOptions = generateArcOptionsScratch;
+  generateArcOptions.minDistance = minDistance;
+  generateArcOptions.ellipsoid = ellipsoid;
+  if (duplicateCorners) {
+    let count = 0;
+    let i;
+    for (i = 0; i < length - 1; i++) {
+      count += PolylinePipeline_default.numberOfPoints(
+        wallPositions[i],
+        wallPositions[i + 1],
+        minDistance
+      ) + 1;
+    }
+    topPositions = new Float64Array(count * 3);
+    bottomPositions = new Float64Array(count * 3);
+    const generateArcPositions = positionsArrayScratch;
+    const generateArcHeights = heightsArrayScratch;
+    generateArcOptions.positions = generateArcPositions;
+    generateArcOptions.height = generateArcHeights;
+    let offset = 0;
+    for (i = 0; i < length - 1; i++) {
+      generateArcPositions[0] = wallPositions[i];
+      generateArcPositions[1] = wallPositions[i + 1];
+      generateArcHeights[0] = maximumHeights[i];
+      generateArcHeights[1] = maximumHeights[i + 1];
+      const pos = PolylinePipeline_default.generateArc(generateArcOptions);
+      topPositions.set(pos, offset);
+      generateArcHeights[0] = minimumHeights[i];
+      generateArcHeights[1] = minimumHeights[i + 1];
+      bottomPositions.set(
+        PolylinePipeline_default.generateArc(generateArcOptions),
+        offset
+      );
+      offset += pos.length;
+    }
+  } else {
+    generateArcOptions.positions = wallPositions;
+    generateArcOptions.height = maximumHeights;
+    topPositions = new Float64Array(
+      PolylinePipeline_default.generateArc(generateArcOptions)
+    );
+    generateArcOptions.height = minimumHeights;
+    bottomPositions = new Float64Array(
+      PolylinePipeline_default.generateArc(generateArcOptions)
+    );
+  }
+  return {
+    bottomPositions,
+    topPositions,
+    numCorners
+  };
+};
+var WallGeometryLibrary_default = WallGeometryLibrary;
+
+export {
+  WallGeometryLibrary_default
+};

package/Build/Workers/chunk-WY6ZUQRU.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.29
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+
+// packages/engine/Source/Core/ArcType.js
+var ArcType = {
+  /**
+   * Straight line that does not conform to the surface of the ellipsoid.
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * Follow geodesic path.
+   *
+   * @type {number}
+   * @constant
+   */
+  GEODESIC: 1,
+  /**
+   * Follow rhumb or loxodrome path.
+   *
+   * @type {number}
+   * @constant
+   */
+  RHUMB: 2
+};
+var ArcType_default = Object.freeze(ArcType);
+
+export {
+  ArcType_default
+};