@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Build/Workers/chunk-XLQZNQ4Z.js

@@ -0,0 +1,163 @@
+/**
+ * @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 {
+  defined_default
+} from "./chunk-PCL3Y7H5.js";
+
+// packages/engine/Source/Core/DeveloperError.js
+function DeveloperError(message) {
+  this.name = "DeveloperError";
+  this.message = message;
+  let stack;
+  try {
+    throw new Error();
+  } catch (e) {
+    stack = e.stack;
+  }
+  this.stack = stack;
+}
+if (defined_default(Object.create)) {
+  DeveloperError.prototype = Object.create(Error.prototype);
+  DeveloperError.prototype.constructor = DeveloperError;
+}
+DeveloperError.prototype.toString = function() {
+  let str = `${this.name}: ${this.message}`;
+  if (defined_default(this.stack)) {
+    str += `
+${this.stack.toString()}`;
+  }
+  return str;
+};
+DeveloperError.throwInstantiationError = function() {
+  throw new DeveloperError(
+    "This function defines an interface and should not be called directly."
+  );
+};
+var DeveloperError_default = DeveloperError;
+
+// packages/engine/Source/Core/Check.js
+var Check = {};
+Check.typeOf = {};
+function getUndefinedErrorMessage(name) {
+  return `${name} is required, actual value was undefined`;
+}
+function getFailedTypeErrorMessage(actual, expected, name) {
+  return `Expected ${name} to be typeof ${expected}, actual typeof was ${actual}`;
+}
+Check.defined = function(name, test) {
+  if (!defined_default(test)) {
+    throw new DeveloperError_default(getUndefinedErrorMessage(name));
+  }
+};
+Check.typeOf.func = function(name, test) {
+  if (typeof test !== "function") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "function", name)
+    );
+  }
+};
+Check.typeOf.string = function(name, test) {
+  if (typeof test !== "string") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "string", name)
+    );
+  }
+};
+Check.typeOf.number = function(name, test) {
+  if (typeof test !== "number") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "number", name)
+    );
+  }
+};
+Check.typeOf.number.lessThan = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test >= limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be less than ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.lessThanOrEquals = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test > limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be less than or equal to ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.greaterThan = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test <= limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be greater than ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.number.greaterThanOrEquals = function(name, test, limit) {
+  Check.typeOf.number(name, test);
+  if (test < limit) {
+    throw new DeveloperError_default(
+      `Expected ${name} to be greater than or equal to ${limit}, actual value was ${test}`
+    );
+  }
+};
+Check.typeOf.object = function(name, test) {
+  if (typeof test !== "object") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "object", name)
+    );
+  }
+};
+Check.typeOf.bool = function(name, test) {
+  if (typeof test !== "boolean") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "boolean", name)
+    );
+  }
+};
+Check.typeOf.bigint = function(name, test) {
+  if (typeof test !== "bigint") {
+    throw new DeveloperError_default(
+      getFailedTypeErrorMessage(typeof test, "bigint", name)
+    );
+  }
+};
+Check.typeOf.number.equals = function(name1, name2, test1, test2) {
+  Check.typeOf.number(name1, test1);
+  Check.typeOf.number(name2, test2);
+  if (test1 !== test2) {
+    throw new DeveloperError_default(
+      `${name1} must be equal to ${name2}, the actual values are ${test1} and ${test2}`
+    );
+  }
+};
+var Check_default = Check;
+
+export {
+  DeveloperError_default,
+  Check_default
+};

package/Build/Workers/chunk-XZ6HDXKM.js

@@ -0,0 +1,76 @@
+/**
+ * @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 {
+  Cartographic_default
+} from "./chunk-DXD7OPSP.js";
+import {
+  Cartesian3_default
+} from "./chunk-ML7OMD72.js";
+import {
+  DeveloperError_default
+} from "./chunk-XLQZNQ4Z.js";
+import {
+  defined_default
+} from "./chunk-PCL3Y7H5.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-Y7KVUJEB.js

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.141.7
+ *
+ * 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 {
+  GeographicProjection_default
+} from "./chunk-CDLPLYLV.js";
+import {
+  Intersect_default
+} from "./chunk-QIOOTLWN.js";
+import {
+  Rectangle_default
+} from "./chunk-FV4OWDV4.js";
+import {
+  Cartesian2_default,
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-7AMVPXZY.js";
+import {
+  Check_default
+} from "./chunk-ESQGFRLZ.js";
+import {
+  defined_default
+} from "./chunk-KEJKMITY.js";
+
+// packages/engine/Source/Core/BoundingRectangle.js
+function BoundingRectangle(x, y, width, height) {
+  this.x = x ?? 0;
+  this.y = y ?? 0;
+  this.width = width ?? 0;
+  this.height = height ?? 0;
+}
+BoundingRectangle.packedLength = 4;
+BoundingRectangle.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.defined("array", array);
+  startingIndex = startingIndex ?? 0;
+  array[startingIndex++] = value.x;
+  array[startingIndex++] = value.y;
+  array[startingIndex++] = value.width;
+  array[startingIndex] = value.height;
+  return array;
+};
+BoundingRectangle.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = startingIndex ?? 0;
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  result.x = array[startingIndex++];
+  result.y = array[startingIndex++];
+  result.width = array[startingIndex++];
+  result.height = array[startingIndex];
+  return result;
+};
+BoundingRectangle.fromPoints = function(positions, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(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;
+};
+var defaultProjection = new GeographicProjection_default();
+var fromRectangleLowerLeft = new Cartographic_default();
+var fromRectangleUpperRight = new Cartographic_default();
+BoundingRectangle.fromRectangle = function(rectangle, projection, result) {
+  if (!defined_default(result)) {
+    result = new BoundingRectangle();
+  }
+  if (!defined_default(rectangle)) {
+    result.x = 0;
+    result.y = 0;
+    result.width = 0;
+    result.height = 0;
+    return result;
+  }
+  defaultProjection._ellipsoid = Ellipsoid_default.default;
+  projection = projection ?? defaultProjection;
+  const lowerLeft = projection.project(
+    Rectangle_default.southwest(rectangle, fromRectangleLowerLeft)
+  );
+  const upperRight = projection.project(
+    Rectangle_default.northeast(rectangle, fromRectangleUpperRight)
+  );
+  Cartesian2_default.subtract(upperRight, lowerLeft, upperRight);
+  result.x = lowerLeft.x;
+  result.y = lowerLeft.y;
+  result.width = upperRight.x;
+  result.height = upperRight.y;
+  return result;
+};
+BoundingRectangle.clone = function(rectangle, result) {
+  if (!defined_default(rectangle)) {
+    return void 0;
+  }
+  if (!defined_default(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;
+};
+BoundingRectangle.union = function(left, right, result) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  if (!defined_default(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;
+};
+BoundingRectangle.expand = function(rectangle, point, result) {
+  Check_default.typeOf.object("rectangle", rectangle);
+  Check_default.typeOf.object("point", point);
+  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;
+};
+BoundingRectangle.intersect = function(left, right) {
+  Check_default.typeOf.object("left", left);
+  Check_default.typeOf.object("right", right);
+  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 Intersect_default.INTERSECTING;
+  }
+  return Intersect_default.OUTSIDE;
+};
+BoundingRectangle.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && left.x === right.x && left.y === right.y && left.width === right.width && left.height === right.height;
+};
+BoundingRectangle.prototype.clone = function(result) {
+  return BoundingRectangle.clone(this, result);
+};
+BoundingRectangle.prototype.intersect = function(right) {
+  return BoundingRectangle.intersect(this, right);
+};
+BoundingRectangle.prototype.equals = function(right) {
+  return BoundingRectangle.equals(this, right);
+};
+var BoundingRectangle_default = BoundingRectangle;
+
+export {
+  BoundingRectangle_default
+};