@cesium/engine 3.0.2 → 5.0.0

package/Build/Workers/chunk-AQQGAFKX.js

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.110
+ *
+ * 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 {
+  OrientedBoundingBox_default
+} from "./chunk-FOOYJER7.js";
+import {
+  Cartesian2_default
+} from "./chunk-MYDS6HBL.js";
+import {
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-HIDSEUWS.js";
+import {
+  Check_default
+} from "./chunk-6EHT6GS3.js";
+
+// packages/engine/Source/Core/CoplanarPolygonGeometryLibrary.js
+var CoplanarPolygonGeometryLibrary = {};
+var scratchIntersectionPoint = new Cartesian3_default();
+var scratchXAxis = new Cartesian3_default();
+var scratchYAxis = new Cartesian3_default();
+var scratchZAxis = new Cartesian3_default();
+var obbScratch = new OrientedBoundingBox_default();
+CoplanarPolygonGeometryLibrary.validOutline = function(positions) {
+  Check_default.defined("positions", positions);
+  const orientedBoundingBox = OrientedBoundingBox_default.fromPoints(
+    positions,
+    obbScratch
+  );
+  const halfAxes = orientedBoundingBox.halfAxes;
+  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis);
+  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis);
+  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis);
+  const xMag = Cartesian3_default.magnitude(xAxis);
+  const yMag = Cartesian3_default.magnitude(yAxis);
+  const zMag = Cartesian3_default.magnitude(zAxis);
+  return !(xMag === 0 && (yMag === 0 || zMag === 0) || yMag === 0 && zMag === 0);
+};
+CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments = function(positions, centerResult, planeAxis1Result, planeAxis2Result) {
+  Check_default.defined("positions", positions);
+  Check_default.defined("centerResult", centerResult);
+  Check_default.defined("planeAxis1Result", planeAxis1Result);
+  Check_default.defined("planeAxis2Result", planeAxis2Result);
+  const orientedBoundingBox = OrientedBoundingBox_default.fromPoints(
+    positions,
+    obbScratch
+  );
+  const halfAxes = orientedBoundingBox.halfAxes;
+  const xAxis = Matrix3_default.getColumn(halfAxes, 0, scratchXAxis);
+  const yAxis = Matrix3_default.getColumn(halfAxes, 1, scratchYAxis);
+  const zAxis = Matrix3_default.getColumn(halfAxes, 2, scratchZAxis);
+  const xMag = Cartesian3_default.magnitude(xAxis);
+  const yMag = Cartesian3_default.magnitude(yAxis);
+  const zMag = Cartesian3_default.magnitude(zAxis);
+  const min = Math.min(xMag, yMag, zMag);
+  if (xMag === 0 && (yMag === 0 || zMag === 0) || yMag === 0 && zMag === 0) {
+    return false;
+  }
+  let planeAxis1;
+  let planeAxis2;
+  if (min === yMag || min === zMag) {
+    planeAxis1 = xAxis;
+  }
+  if (min === xMag) {
+    planeAxis1 = yAxis;
+  } else if (min === zMag) {
+    planeAxis2 = yAxis;
+  }
+  if (min === xMag || min === yMag) {
+    planeAxis2 = zAxis;
+  }
+  Cartesian3_default.normalize(planeAxis1, planeAxis1Result);
+  Cartesian3_default.normalize(planeAxis2, planeAxis2Result);
+  Cartesian3_default.clone(orientedBoundingBox.center, centerResult);
+  return true;
+};
+function projectTo2D(position, center, axis1, axis2, result) {
+  const v = Cartesian3_default.subtract(position, center, scratchIntersectionPoint);
+  const x = Cartesian3_default.dot(axis1, v);
+  const y = Cartesian3_default.dot(axis2, v);
+  return Cartesian2_default.fromElements(x, y, result);
+}
+CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction = function(center, axis1, axis2) {
+  return function(positions) {
+    const positionResults = new Array(positions.length);
+    for (let i = 0; i < positions.length; i++) {
+      positionResults[i] = projectTo2D(positions[i], center, axis1, axis2);
+    }
+    return positionResults;
+  };
+};
+CoplanarPolygonGeometryLibrary.createProjectPointTo2DFunction = function(center, axis1, axis2) {
+  return function(position, result) {
+    return projectTo2D(position, center, axis1, axis2, result);
+  };
+};
+var CoplanarPolygonGeometryLibrary_default = CoplanarPolygonGeometryLibrary;
+
+export {
+  CoplanarPolygonGeometryLibrary_default
+};

package/Build/Workers/chunk-CROU4RHL.js

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.110
+ *
+ * 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-4HN3N5SE.js";
+import {
+  WebGLConstants_default
+} from "./chunk-TXYJOVQK.js";
+import {
+  DeveloperError_default
+} from "./chunk-6EHT6GS3.js";
+import {
+  defined_default
+} from "./chunk-TXOGSFHZ.js";
+
+// packages/engine/Source/Core/IndexDatatype.js
+var IndexDatatype = {
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
+};
+IndexDatatype.getSizeInBytes = function(indexDatatype) {
+  switch (indexDatatype) {
+    case IndexDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+  }
+  throw new DeveloperError_default(
+    "indexDatatype is required and must be a valid IndexDatatype constant."
+  );
+};
+IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
+  switch (sizeInBytes) {
+    case 2:
+      return IndexDatatype.UNSIGNED_SHORT;
+    case 4:
+      return IndexDatatype.UNSIGNED_INT;
+    case 1:
+      return IndexDatatype.UNSIGNED_BYTE;
+    default:
+      throw new DeveloperError_default(
+        "Size in bytes cannot be mapped to an IndexDatatype"
+      );
+  }
+};
+IndexDatatype.validate = function(indexDatatype) {
+  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
+};
+IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(indicesLengthOrArray);
+  }
+  return new Uint16Array(indicesLengthOrArray);
+};
+IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (!defined_default(sourceArray)) {
+    throw new DeveloperError_default("sourceArray is required.");
+  }
+  if (!defined_default(byteOffset)) {
+    throw new DeveloperError_default("byteOffset is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(sourceArray, byteOffset, length);
+  }
+  return new Uint16Array(sourceArray, byteOffset, length);
+};
+IndexDatatype.fromTypedArray = function(array) {
+  if (array instanceof Uint8Array) {
+    return IndexDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Uint16Array) {
+    return IndexDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Uint32Array) {
+    return IndexDatatype.UNSIGNED_INT;
+  }
+  throw new DeveloperError_default(
+    "array must be a Uint8Array, Uint16Array, or Uint32Array."
+  );
+};
+var IndexDatatype_default = Object.freeze(IndexDatatype);
+
+export {
+  IndexDatatype_default
+};

package/Build/Workers/chunk-CTJCECTX.js

@@ -0,0 +1,258 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.110
+ *
+ * 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 {
+  WebGLConstants_default
+} from "./chunk-TXYJOVQK.js";
+import {
+  defaultValue_default
+} from "./chunk-GPO47TW4.js";
+import {
+  DeveloperError_default
+} from "./chunk-6EHT6GS3.js";
+import {
+  defined_default
+} from "./chunk-TXOGSFHZ.js";
+
+// packages/engine/Source/Core/ComponentDatatype.js
+var ComponentDatatype = {
+  /**
+   * 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type
+   * of an element in <code>Int8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  BYTE: WebGLConstants_default.BYTE,
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit signed short corresponding to <code>SHORT</code> and the type
+   * of an element in <code>Int16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  SHORT: WebGLConstants_default.SHORT,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit signed int corresponding to <code>INT</code> and the type
+   * of an element in <code>Int32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  INT: WebGLConstants_default.INT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT,
+  /**
+   * 32-bit floating-point corresponding to <code>FLOAT</code> and the type
+   * of an element in <code>Float32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  FLOAT: WebGLConstants_default.FLOAT,
+  /**
+   * 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL;
+   * this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute})
+   * and the type of an element in <code>Float64Array</code>.
+   *
+   * @memberOf ComponentDatatype
+   *
+   * @type {number}
+   * @constant
+   * @default 0x140A
+   */
+  DOUBLE: WebGLConstants_default.DOUBLE
+};
+ComponentDatatype.getSizeInBytes = function(componentDatatype) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("value is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return Int8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.SHORT:
+      return Int16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.INT:
+      return Int32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.FLOAT:
+      return Float32Array.BYTES_PER_ELEMENT;
+    case ComponentDatatype.DOUBLE:
+      return Float64Array.BYTES_PER_ELEMENT;
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromTypedArray = function(array) {
+  if (array instanceof Int8Array) {
+    return ComponentDatatype.BYTE;
+  }
+  if (array instanceof Uint8Array) {
+    return ComponentDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Int16Array) {
+    return ComponentDatatype.SHORT;
+  }
+  if (array instanceof Uint16Array) {
+    return ComponentDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Int32Array) {
+    return ComponentDatatype.INT;
+  }
+  if (array instanceof Uint32Array) {
+    return ComponentDatatype.UNSIGNED_INT;
+  }
+  if (array instanceof Float32Array) {
+    return ComponentDatatype.FLOAT;
+  }
+  if (array instanceof Float64Array) {
+    return ComponentDatatype.DOUBLE;
+  }
+  throw new DeveloperError_default(
+    "array must be an Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, or Float64Array."
+  );
+};
+ComponentDatatype.validate = function(componentDatatype) {
+  return defined_default(componentDatatype) && (componentDatatype === ComponentDatatype.BYTE || componentDatatype === ComponentDatatype.UNSIGNED_BYTE || componentDatatype === ComponentDatatype.SHORT || componentDatatype === ComponentDatatype.UNSIGNED_SHORT || componentDatatype === ComponentDatatype.INT || componentDatatype === ComponentDatatype.UNSIGNED_INT || componentDatatype === ComponentDatatype.FLOAT || componentDatatype === ComponentDatatype.DOUBLE);
+};
+ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(valuesOrLength)) {
+    throw new DeveloperError_default("valuesOrLength is required.");
+  }
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(valuesOrLength);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(valuesOrLength);
+    case ComponentDatatype.INT:
+      return new Int32Array(valuesOrLength);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(valuesOrLength);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(valuesOrLength);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(valuesOrLength);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length) {
+  if (!defined_default(componentDatatype)) {
+    throw new DeveloperError_default("componentDatatype is required.");
+  }
+  if (!defined_default(buffer)) {
+    throw new DeveloperError_default("buffer is required.");
+  }
+  byteOffset = defaultValue_default(byteOffset, 0);
+  length = defaultValue_default(
+    length,
+    (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype)
+  );
+  switch (componentDatatype) {
+    case ComponentDatatype.BYTE:
+      return new Int8Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_BYTE:
+      return new Uint8Array(buffer, byteOffset, length);
+    case ComponentDatatype.SHORT:
+      return new Int16Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_SHORT:
+      return new Uint16Array(buffer, byteOffset, length);
+    case ComponentDatatype.INT:
+      return new Int32Array(buffer, byteOffset, length);
+    case ComponentDatatype.UNSIGNED_INT:
+      return new Uint32Array(buffer, byteOffset, length);
+    case ComponentDatatype.FLOAT:
+      return new Float32Array(buffer, byteOffset, length);
+    case ComponentDatatype.DOUBLE:
+      return new Float64Array(buffer, byteOffset, length);
+    default:
+      throw new DeveloperError_default("componentDatatype is not a valid value.");
+  }
+};
+ComponentDatatype.fromName = function(name) {
+  switch (name) {
+    case "BYTE":
+      return ComponentDatatype.BYTE;
+    case "UNSIGNED_BYTE":
+      return ComponentDatatype.UNSIGNED_BYTE;
+    case "SHORT":
+      return ComponentDatatype.SHORT;
+    case "UNSIGNED_SHORT":
+      return ComponentDatatype.UNSIGNED_SHORT;
+    case "INT":
+      return ComponentDatatype.INT;
+    case "UNSIGNED_INT":
+      return ComponentDatatype.UNSIGNED_INT;
+    case "FLOAT":
+      return ComponentDatatype.FLOAT;
+    case "DOUBLE":
+      return ComponentDatatype.DOUBLE;
+    default:
+      throw new DeveloperError_default("name is not a valid value.");
+  }
+};
+var ComponentDatatype_default = Object.freeze(ComponentDatatype);
+
+export {
+  ComponentDatatype_default
+};