@hztxi/cesium-engine 25.0.1 → 25.0.2

package/Build/Workers/chunk-EJES53XD.js

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.2
+ *
+ * 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 {
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-RGNURFR5.js";
+import {
+  Cartesian3_default
+} from "./chunk-VDJVNJXW.js";
+import {
+  Math_default
+} from "./chunk-KGNDVO6V.js";
+import {
+  DeveloperError_default
+} from "./chunk-N4ECLSTH.js";
+import {
+  defined_default
+} from "./chunk-27UNFKLP.js";
+
+// packages/engine/Source/Core/WebMercatorProjection.js
+var WebMercatorProjection = class _WebMercatorProjection {
+  /**
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
+   */
+  constructor(ellipsoid) {
+    this._ellipsoid = ellipsoid ?? Ellipsoid_default.WGS84;
+    this._semimajorAxis = this._ellipsoid.maximumRadius;
+    this._oneOverSemimajorAxis = 1 / this._semimajorAxis;
+  }
+  /**
+   * Gets the {@link Ellipsoid}.
+   *
+   * @type {Ellipsoid}
+   * @readonly
+   */
+  get ellipsoid() {
+    return this._ellipsoid;
+  }
+  /**
+   * Converts a Mercator angle, in the range -PI to PI, to a geodetic latitude
+   * in the range -PI/2 to PI/2.
+   *
+   * @param {number} mercatorAngle The angle to convert.
+   * @returns {number} The geodetic latitude in radians.
+   */
+  static mercatorAngleToGeodeticLatitude(mercatorAngle) {
+    return Math_default.PI_OVER_TWO - 2 * Math.atan(Math.exp(-mercatorAngle));
+  }
+  /**
+   * Converts a geodetic latitude in radians, in the range -PI/2 to PI/2, to a Mercator
+   * angle in the range -PI to PI.
+   *
+   * @param {number} latitude The geodetic latitude in radians.
+   * @returns {number} The Mercator angle.
+   */
+  static geodeticLatitudeToMercatorAngle(latitude) {
+    if (latitude > _WebMercatorProjection.MaximumLatitude) {
+      latitude = _WebMercatorProjection.MaximumLatitude;
+    } else if (latitude < -_WebMercatorProjection.MaximumLatitude) {
+      latitude = -_WebMercatorProjection.MaximumLatitude;
+    }
+    const sinLatitude = Math.sin(latitude);
+    return 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
+  }
+  /**
+   * Converts geodetic ellipsoid coordinates, in radians, to the equivalent Web Mercator
+   * X, Y, Z coordinates expressed in meters and returned in a {@link Cartesian3}.  The height
+   * is copied unmodified to the Z coordinate.
+   *
+   * @param {Cartographic} cartographic The cartographic coordinates in radians.
+   * @param {Cartesian3} [result] The instance to which to copy the result, or undefined if a
+   *        new instance should be created.
+   * @returns {Cartesian3} The equivalent web mercator X, Y, Z coordinates, in meters.
+   */
+  project(cartographic, result) {
+    const semimajorAxis = this._semimajorAxis;
+    const x = cartographic.longitude * semimajorAxis;
+    const y = _WebMercatorProjection.geodeticLatitudeToMercatorAngle(
+      cartographic.latitude
+    ) * semimajorAxis;
+    const z = cartographic.height;
+    if (!defined_default(result)) {
+      return new Cartesian3_default(x, y, z);
+    }
+    result.x = x;
+    result.y = y;
+    result.z = z;
+    return result;
+  }
+  /**
+   * Converts Web Mercator X, Y coordinates, expressed in meters, to a {@link Cartographic}
+   * containing geodetic ellipsoid coordinates.  The Z coordinate is copied unmodified to the
+   * height.
+   *
+   * @param {Cartesian3} cartesian The web mercator Cartesian position to unrproject with height (z) in meters.
+   * @param {Cartographic} [result] The instance to which to copy the result, or undefined if a
+   *        new instance should be created.
+   * @returns {Cartographic} The equivalent cartographic coordinates.
+   */
+  unproject(cartesian, result) {
+    if (!defined_default(cartesian)) {
+      throw new DeveloperError_default("cartesian is required");
+    }
+    const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+    const longitude = cartesian.x * oneOverEarthSemimajorAxis;
+    const latitude = _WebMercatorProjection.mercatorAngleToGeodeticLatitude(
+      cartesian.y * oneOverEarthSemimajorAxis
+    );
+    const height = cartesian.z;
+    if (!defined_default(result)) {
+      return new Cartographic_default(longitude, latitude, height);
+    }
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = height;
+    return result;
+  }
+};
+WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI);
+var WebMercatorProjection_default = WebMercatorProjection;
+
+export {
+  WebMercatorProjection_default
+};

package/Build/Workers/chunk-FEMEGP72.js

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.2
+ *
+ * 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 {
+  Math_default
+} from "./chunk-KGNDVO6V.js";
+import {
+  Check_default
+} from "./chunk-N4ECLSTH.js";
+import {
+  defined_default
+} from "./chunk-27UNFKLP.js";
+
+// packages/engine/Source/Core/arrayRemoveDuplicates.js
+var removeDuplicatesEpsilon = Math_default.EPSILON10;
+function arrayRemoveDuplicates(values, equalsEpsilon, wrapAround, removedIndices) {
+  Check_default.defined("equalsEpsilon", equalsEpsilon);
+  if (!defined_default(values)) {
+    return void 0;
+  }
+  wrapAround = wrapAround ?? false;
+  const storeRemovedIndices = defined_default(removedIndices);
+  const length = values.length;
+  if (length < 2) {
+    return values;
+  }
+  let i;
+  let v0 = values[0];
+  let v1;
+  let cleanedValues;
+  let lastCleanIndex = 0;
+  let removedIndexLCI = -1;
+  for (i = 1; i < length; ++i) {
+    v1 = values[i];
+    if (equalsEpsilon(v0, v1, removeDuplicatesEpsilon)) {
+      if (!defined_default(cleanedValues)) {
+        cleanedValues = values.slice(0, i);
+        lastCleanIndex = i - 1;
+        removedIndexLCI = 0;
+      }
+      if (storeRemovedIndices) {
+        removedIndices.push(i);
+      }
+    } else {
+      if (defined_default(cleanedValues)) {
+        cleanedValues.push(v1);
+        lastCleanIndex = i;
+        if (storeRemovedIndices) {
+          removedIndexLCI = removedIndices.length;
+        }
+      }
+      v0 = v1;
+    }
+  }
+  if (wrapAround && equalsEpsilon(values[0], values[length - 1], removeDuplicatesEpsilon)) {
+    if (storeRemovedIndices) {
+      if (defined_default(cleanedValues)) {
+        removedIndices.splice(removedIndexLCI, 0, lastCleanIndex);
+      } else {
+        removedIndices.push(length - 1);
+      }
+    }
+    if (defined_default(cleanedValues)) {
+      cleanedValues.length -= 1;
+    } else {
+      cleanedValues = values.slice(0, -1);
+    }
+  }
+  return defined_default(cleanedValues) ? cleanedValues : values;
+}
+var arrayRemoveDuplicates_default = arrayRemoveDuplicates;
+
+export {
+  arrayRemoveDuplicates_default
+};

package/Build/Workers/chunk-FPUTHLEQ.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.2
+ *
+ * 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 {
+  Math_default
+} from "./chunk-KGNDVO6V.js";
+
+// packages/engine/Source/Core/CylinderGeometryLibrary.js
+var CylinderGeometryLibrary = {};
+CylinderGeometryLibrary.computePositions = function(length, topRadius, bottomRadius, slices, fill) {
+  const topZ = length * 0.5;
+  const bottomZ = -topZ;
+  const twoSlice = slices + slices;
+  const size = fill ? 2 * twoSlice : twoSlice;
+  const positions = new Float64Array(size * 3);
+  let i;
+  let index = 0;
+  let tbIndex = 0;
+  const bottomOffset = fill ? twoSlice * 3 : 0;
+  const topOffset = fill ? (twoSlice + slices) * 3 : slices * 3;
+  for (i = 0; i < slices; i++) {
+    const angle = i / slices * Math_default.TWO_PI;
+    const x = Math.cos(angle);
+    const y = Math.sin(angle);
+    const bottomX = x * bottomRadius;
+    const bottomY = y * bottomRadius;
+    const topX = x * topRadius;
+    const topY = y * topRadius;
+    positions[tbIndex + bottomOffset] = bottomX;
+    positions[tbIndex + bottomOffset + 1] = bottomY;
+    positions[tbIndex + bottomOffset + 2] = bottomZ;
+    positions[tbIndex + topOffset] = topX;
+    positions[tbIndex + topOffset + 1] = topY;
+    positions[tbIndex + topOffset + 2] = topZ;
+    tbIndex += 3;
+    if (fill) {
+      positions[index++] = bottomX;
+      positions[index++] = bottomY;
+      positions[index++] = bottomZ;
+      positions[index++] = topX;
+      positions[index++] = topY;
+      positions[index++] = topZ;
+    }
+  }
+  return positions;
+};
+var CylinderGeometryLibrary_default = CylinderGeometryLibrary;
+
+export {
+  CylinderGeometryLibrary_default
+};

package/Build/Workers/chunk-FSGWPS5K.js

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.1
+ *
+ * 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 {
+  Cartesian3_default
+} from "./chunk-3EB75M2K.js";
+import {
+  Check_default
+} from "./chunk-6JM3OV5P.js";
+import {
+  defined_default
+} from "./chunk-AMW7Q4HY.js";
+
+// packages/engine/Source/Core/EncodedCartesian3.js
+function EncodedCartesian3() {
+  this.high = Cartesian3_default.clone(Cartesian3_default.ZERO);
+  this.low = Cartesian3_default.clone(Cartesian3_default.ZERO);
+}
+EncodedCartesian3.encode = function(value, result) {
+  Check_default.typeOf.number("value", value);
+  if (!defined_default(result)) {
+    result = {
+      high: 0,
+      low: 0
+    };
+  }
+  let doubleHigh;
+  if (value >= 0) {
+    doubleHigh = Math.floor(value / 65536) * 65536;
+    result.high = doubleHigh;
+    result.low = value - doubleHigh;
+  } else {
+    doubleHigh = Math.floor(-value / 65536) * 65536;
+    result.high = -doubleHigh;
+    result.low = value + doubleHigh;
+  }
+  return result;
+};
+var scratchEncode = {
+  high: 0,
+  low: 0
+};
+EncodedCartesian3.fromCartesian = function(cartesian, result) {
+  Check_default.typeOf.object("cartesian", cartesian);
+  if (!defined_default(result)) {
+    result = new EncodedCartesian3();
+  }
+  const high = result.high;
+  const low = result.low;
+  EncodedCartesian3.encode(cartesian.x, scratchEncode);
+  high.x = scratchEncode.high;
+  low.x = scratchEncode.low;
+  EncodedCartesian3.encode(cartesian.y, scratchEncode);
+  high.y = scratchEncode.high;
+  low.y = scratchEncode.low;
+  EncodedCartesian3.encode(cartesian.z, scratchEncode);
+  high.z = scratchEncode.high;
+  low.z = scratchEncode.low;
+  return result;
+};
+var encodedP = new EncodedCartesian3();
+EncodedCartesian3.writeElements = function(cartesian, cartesianArray, index) {
+  Check_default.defined("cartesianArray", cartesianArray);
+  Check_default.typeOf.number("index", index);
+  Check_default.typeOf.number.greaterThanOrEquals("index", index, 0);
+  EncodedCartesian3.fromCartesian(cartesian, encodedP);
+  const high = encodedP.high;
+  const low = encodedP.low;
+  cartesianArray[index] = high.x;
+  cartesianArray[index + 1] = high.y;
+  cartesianArray[index + 2] = high.z;
+  cartesianArray[index + 3] = low.x;
+  cartesianArray[index + 4] = low.y;
+  cartesianArray[index + 5] = low.z;
+};
+var EncodedCartesian3_default = EncodedCartesian3;
+
+export {
+  EncodedCartesian3_default
+};