@rtzh/engine 0.0.8 → 0.0.10

package/Build/Workers/chunk-GNGZG6C6.js

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.11
+ *
+ * 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 {
+  Intersect_default
+} from "./chunk-HFCJLXTG.js";
+import {
+  Cartesian3_default
+} from "./chunk-JFLJS4QU.js";
+import {
+  Check_default
+} from "./chunk-CGAHG2LR.js";
+import {
+  defined_default
+} from "./chunk-FARHIBOA.js";
+
+// packages/engine/Source/Core/AxisAlignedBoundingBox.js
+function AxisAlignedBoundingBox(minimum, maximum, center) {
+  this.minimum = Cartesian3_default.clone(minimum ?? Cartesian3_default.ZERO);
+  this.maximum = Cartesian3_default.clone(maximum ?? Cartesian3_default.ZERO);
+  if (!defined_default(center)) {
+    center = Cartesian3_default.midpoint(this.minimum, this.maximum, new Cartesian3_default());
+  } else {
+    center = Cartesian3_default.clone(center);
+  }
+  this.center = center;
+}
+AxisAlignedBoundingBox.fromCorners = function(minimum, maximum, result) {
+  Check_default.defined("minimum", minimum);
+  Check_default.defined("maximum", maximum);
+  if (!defined_default(result)) {
+    result = new AxisAlignedBoundingBox();
+  }
+  result.minimum = Cartesian3_default.clone(minimum, result.minimum);
+  result.maximum = Cartesian3_default.clone(maximum, result.maximum);
+  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
+  return result;
+};
+AxisAlignedBoundingBox.fromPoints = function(positions, result) {
+  if (!defined_default(result)) {
+    result = new AxisAlignedBoundingBox();
+  }
+  if (!defined_default(positions) || positions.length === 0) {
+    result.minimum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.minimum);
+    result.maximum = Cartesian3_default.clone(Cartesian3_default.ZERO, result.maximum);
+    result.center = Cartesian3_default.clone(Cartesian3_default.ZERO, result.center);
+    return result;
+  }
+  let minimumX = positions[0].x;
+  let minimumY = positions[0].y;
+  let minimumZ = positions[0].z;
+  let maximumX = positions[0].x;
+  let maximumY = positions[0].y;
+  let maximumZ = positions[0].z;
+  const length = positions.length;
+  for (let i = 1; i < length; i++) {
+    const p = positions[i];
+    const x = p.x;
+    const y = p.y;
+    const z = p.z;
+    minimumX = Math.min(x, minimumX);
+    maximumX = Math.max(x, maximumX);
+    minimumY = Math.min(y, minimumY);
+    maximumY = Math.max(y, maximumY);
+    minimumZ = Math.min(z, minimumZ);
+    maximumZ = Math.max(z, maximumZ);
+  }
+  const minimum = result.minimum;
+  minimum.x = minimumX;
+  minimum.y = minimumY;
+  minimum.z = minimumZ;
+  const maximum = result.maximum;
+  maximum.x = maximumX;
+  maximum.y = maximumY;
+  maximum.z = maximumZ;
+  result.center = Cartesian3_default.midpoint(minimum, maximum, result.center);
+  return result;
+};
+AxisAlignedBoundingBox.clone = function(box, result) {
+  if (!defined_default(box)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    return new AxisAlignedBoundingBox(box.minimum, box.maximum, box.center);
+  }
+  result.minimum = Cartesian3_default.clone(box.minimum, result.minimum);
+  result.maximum = Cartesian3_default.clone(box.maximum, result.maximum);
+  result.center = Cartesian3_default.clone(box.center, result.center);
+  return result;
+};
+AxisAlignedBoundingBox.equals = function(left, right) {
+  return left === right || defined_default(left) && defined_default(right) && Cartesian3_default.equals(left.center, right.center) && Cartesian3_default.equals(left.minimum, right.minimum) && Cartesian3_default.equals(left.maximum, right.maximum);
+};
+var intersectScratch = new Cartesian3_default();
+AxisAlignedBoundingBox.intersectPlane = function(box, plane) {
+  Check_default.defined("box", box);
+  Check_default.defined("plane", plane);
+  intersectScratch = Cartesian3_default.subtract(
+    box.maximum,
+    box.minimum,
+    intersectScratch
+  );
+  const h = Cartesian3_default.multiplyByScalar(
+    intersectScratch,
+    0.5,
+    intersectScratch
+  );
+  const normal = plane.normal;
+  const e = h.x * Math.abs(normal.x) + h.y * Math.abs(normal.y) + h.z * Math.abs(normal.z);
+  const s = Cartesian3_default.dot(box.center, normal) + plane.distance;
+  if (s - e > 0) {
+    return Intersect_default.INSIDE;
+  }
+  if (s + e < 0) {
+    return Intersect_default.OUTSIDE;
+  }
+  return Intersect_default.INTERSECTING;
+};
+AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox = function(box, other) {
+  Check_default.defined("box", box);
+  Check_default.defined("other", other);
+  return box.minimum.x <= other.maximum.x && box.maximum.x >= other.minimum.x && box.minimum.y <= other.maximum.y && box.maximum.y >= other.minimum.y && box.minimum.z <= other.maximum.z && box.maximum.z >= other.minimum.z;
+};
+AxisAlignedBoundingBox.prototype.clone = function(result) {
+  return AxisAlignedBoundingBox.clone(this, result);
+};
+AxisAlignedBoundingBox.prototype.intersectPlane = function(plane) {
+  return AxisAlignedBoundingBox.intersectPlane(this, plane);
+};
+AxisAlignedBoundingBox.prototype.intersectAxisAlignedBoundingBox = function(other) {
+  return AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox(this, other);
+};
+AxisAlignedBoundingBox.prototype.equals = function(right) {
+  return AxisAlignedBoundingBox.equals(this, right);
+};
+var AxisAlignedBoundingBox_default = AxisAlignedBoundingBox;
+
+export {
+  AxisAlignedBoundingBox_default
+};

package/Build/Workers/chunk-GPWELPVQ.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.9
+ *
+ * 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-BYTLHM7N.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-ASGXCLGL.js";
+import {
+  Cartographic_default
+} from "./chunk-SPPYSEH2.js";
+import {
+  Cartesian3_default
+} from "./chunk-CR6BZUQC.js";
+import {
+  Math_default
+} from "./chunk-4SZJ3KRD.js";
+import {
+  defined_default
+} from "./chunk-L33HPENB.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
+};