deeptwins-cesium-engine 0.0.37 → 0.0.39

package/Build/Workers/chunk-FL4PAMOR.js

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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-OGSJ5ZP6.js";
+import {
+  defaultValue_default
+} from "./chunk-UBCK7AIW.js";
+import {
+  Check_default
+} from "./chunk-IXVT26OF.js";
+import {
+  defined_default
+} from "./chunk-P76UBIMX.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 = defaultValue_default(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-FXZPZ42H.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.37
+ *
+ * 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-XUDMEXSI.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-O3PMNFMM.js";
+import {
+  Check_default
+} from "./chunk-ZQ7S66XP.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-GBACHWVF.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.37
+ *
+ * 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-X2PKPXPZ.js";
+import {
+  Cartesian3_default
+} from "./chunk-O3PMNFMM.js";
+import {
+  Math_default
+} from "./chunk-DVR6JMCT.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-ZQ7S66XP.js";
+import {
+  defined_default
+} from "./chunk-5C4JSXR6.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-GKTDHQWC.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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-PPJPELR6.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Matrix3_default
+} from "./chunk-ZPEGWBIN.js";
+import {
+  Check_default
+} from "./chunk-IXVT26OF.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-HBSMOYMV.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.38
+ *
+ * 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/GeometryOffsetAttribute.js
+var GeometryOffsetAttribute = {
+  NONE: 0,
+  TOP: 1,
+  ALL: 2
+};
+var GeometryOffsetAttribute_default = Object.freeze(GeometryOffsetAttribute);
+
+export {
+  GeometryOffsetAttribute_default
+};