@hztxi/cesium-engine 25.0.2 → 25.0.3

package/Build/Workers/chunk-4L4ZXXL7.js

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.0
+ *
+ * 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 {
+  Matrix4_default
+} from "./chunk-ZSWY7UNG.js";
+import {
+  Frozen_default
+} from "./chunk-76HD3HYN.js";
+import {
+  DeveloperError_default
+} from "./chunk-UDKEO3UF.js";
+import {
+  defined_default
+} from "./chunk-NYQSZLRF.js";
+
+// packages/engine/Source/Core/GeometryInstance.js
+function GeometryInstance(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  if (!defined_default(options.geometry)) {
+    throw new DeveloperError_default("options.geometry is required.");
+  }
+  this.geometry = options.geometry;
+  this.modelMatrix = Matrix4_default.clone(options.modelMatrix ?? Matrix4_default.IDENTITY);
+  this.id = options.id;
+  this.pickPrimitive = options.pickPrimitive;
+  this.attributes = options.attributes ?? {};
+  this.westHemisphereGeometry = void 0;
+  this.eastHemisphereGeometry = void 0;
+}
+var GeometryInstance_default = GeometryInstance;
+
+export {
+  GeometryInstance_default
+};

package/Build/Workers/chunk-4QK5RZ5I.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.0
+ *
+ * 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 {
+  Cartesian4_default,
+  Matrix4_default
+} from "./chunk-ZSWY7UNG.js";
+import {
+  Cartesian3_default
+} from "./chunk-76HD3HYN.js";
+import {
+  Math_default
+} from "./chunk-TA3PH4Q7.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-UDKEO3UF.js";
+import {
+  defined_default
+} from "./chunk-NYQSZLRF.js";
+
+// packages/engine/Source/Core/Plane.js
+function Plane(normal, distance) {
+  Check_default.typeOf.object("normal", normal);
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  Check_default.typeOf.number("distance", distance);
+  this.normal = Cartesian3_default.clone(normal);
+  this.distance = distance;
+}
+Plane.fromPointNormal = function(point, normal, result) {
+  Check_default.typeOf.object("point", point);
+  Check_default.typeOf.object("normal", normal);
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  const distance = -Cartesian3_default.dot(normal, point);
+  if (!defined_default(result)) {
+    return new Plane(normal, distance);
+  }
+  Cartesian3_default.clone(normal, result.normal);
+  result.distance = distance;
+  return result;
+};
+var scratchNormal = new Cartesian3_default();
+Plane.fromCartesian4 = function(coefficients, result) {
+  Check_default.typeOf.object("coefficients", coefficients);
+  const normal = Cartesian3_default.fromCartesian4(coefficients, scratchNormal);
+  const distance = coefficients.w;
+  if (!Math_default.equalsEpsilon(
+    Cartesian3_default.magnitude(normal),
+    1,
+    Math_default.EPSILON6
+  )) {
+    throw new DeveloperError_default("normal must be normalized.");
+  }
+  if (!defined_default(result)) {
+    return new Plane(normal, distance);
+  }
+  Cartesian3_default.clone(normal, result.normal);
+  result.distance = distance;
+  return result;
+};
+Plane.getPointDistance = function(plane, point) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("point", point);
+  return Cartesian3_default.dot(plane.normal, point) + plane.distance;
+};
+var scratchCartesian = new Cartesian3_default();
+Plane.projectPointOntoPlane = function(plane, point, result) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("point", point);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  const pointDistance = Plane.getPointDistance(plane, point);
+  const scaledNormal = Cartesian3_default.multiplyByScalar(
+    plane.normal,
+    pointDistance,
+    scratchCartesian
+  );
+  return Cartesian3_default.subtract(point, scaledNormal, result);
+};
+var scratchInverseTranspose = new Matrix4_default();
+var scratchPlaneCartesian4 = new Cartesian4_default();
+var scratchTransformNormal = new Cartesian3_default();
+Plane.transform = function(plane, transform, result) {
+  Check_default.typeOf.object("plane", plane);
+  Check_default.typeOf.object("transform", transform);
+  const normal = plane.normal;
+  const distance = plane.distance;
+  const inverseTranspose = Matrix4_default.inverseTranspose(
+    transform,
+    scratchInverseTranspose
+  );
+  let planeAsCartesian4 = Cartesian4_default.fromElements(
+    normal.x,
+    normal.y,
+    normal.z,
+    distance,
+    scratchPlaneCartesian4
+  );
+  planeAsCartesian4 = Matrix4_default.multiplyByVector(
+    inverseTranspose,
+    planeAsCartesian4,
+    planeAsCartesian4
+  );
+  const transformedNormal = Cartesian3_default.fromCartesian4(
+    planeAsCartesian4,
+    scratchTransformNormal
+  );
+  planeAsCartesian4 = Cartesian4_default.divideByScalar(
+    planeAsCartesian4,
+    Cartesian3_default.magnitude(transformedNormal),
+    planeAsCartesian4
+  );
+  return Plane.fromCartesian4(planeAsCartesian4, result);
+};
+Plane.clone = function(plane, result) {
+  Check_default.typeOf.object("plane", plane);
+  if (!defined_default(result)) {
+    return new Plane(plane.normal, plane.distance);
+  }
+  Cartesian3_default.clone(plane.normal, result.normal);
+  result.distance = plane.distance;
+  return result;
+};
+Plane.equals = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  return left.distance === right.distance && Cartesian3_default.equals(left.normal, right.normal);
+};
+Plane.ORIGIN_XY_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Z, 0));
+Plane.ORIGIN_YZ_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_X, 0));
+Plane.ORIGIN_ZX_PLANE = Object.freeze(new Plane(Cartesian3_default.UNIT_Y, 0));
+var Plane_default = Plane;
+
+export {
+  Plane_default
+};

package/Build/Workers/chunk-4RWSLDVO.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.144.0
+ *
+ * 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-7ZYD7GL6.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-AW3UT5RP.js";
+import {
+  Cartographic_default
+} from "./chunk-UTOYFI3Q.js";
+import {
+  Cartesian3_default
+} from "./chunk-SJZMU3OS.js";
+import {
+  Math_default
+} from "./chunk-2ZYMQXBB.js";
+import {
+  defined_default
+} from "./chunk-NYQSZLRF.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-53HFLKT5.js

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.3
+ *
+ * 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
+} from "./chunk-ILUFUAF3.js";
+import {
+  Cartesian3_default
+} from "./chunk-ILX5N5QR.js";
+import {
+  DeveloperError_default
+} from "./chunk-MVBEMXN4.js";
+import {
+  defined_default
+} from "./chunk-2RC5GQMH.js";
+
+// packages/engine/Source/Core/VerticalExaggeration.js
+var VerticalExaggeration = {};
+VerticalExaggeration.getHeight = function(height, scale, relativeHeight) {
+  if (!Number.isFinite(scale)) {
+    throw new DeveloperError_default("scale must be a finite number.");
+  }
+  if (!Number.isFinite(relativeHeight)) {
+    throw new DeveloperError_default("relativeHeight must be a finite number.");
+  }
+  return (height - relativeHeight) * scale + relativeHeight;
+};
+var scratchCartographic = new Cartographic_default();
+VerticalExaggeration.getPosition = function(position, ellipsoid, verticalExaggeration, verticalExaggerationRelativeHeight, result) {
+  const cartographic = ellipsoid.cartesianToCartographic(
+    position,
+    scratchCartographic
+  );
+  if (!defined_default(cartographic)) {
+    return Cartesian3_default.clone(position, result);
+  }
+  const newHeight = VerticalExaggeration.getHeight(
+    cartographic.height,
+    verticalExaggeration,
+    verticalExaggerationRelativeHeight
+  );
+  return Cartesian3_default.fromRadians(
+    cartographic.longitude,
+    cartographic.latitude,
+    newHeight,
+    ellipsoid,
+    result
+  );
+};
+var VerticalExaggeration_default = VerticalExaggeration;
+
+export {
+  VerticalExaggeration_default
+};

package/Build/Workers/chunk-5DJBLQEH.js

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.3
+ *
+ * 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
+};
+Object.freeze(ArcType);
+var ArcType_default = ArcType;
+
+export {
+  ArcType_default
+};