deeptwins-cesium-engine 0.1.2 → 0.1.4

package/Build/Workers/chunk-6VZ7VB2Q.js

@@ -0,0 +1,241 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.1.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 {
+  GeographicProjection_default
+} from "./chunk-UXIFNEA3.js";
+import {
+  Matrix2_default,
+  Rectangle_default
+} from "./chunk-AHCZ757M.js";
+import {
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-KMBLKQCC.js";
+import {
+  Cartesian3_default
+} from "./chunk-45VV4SBO.js";
+import {
+  Math_default
+} from "./chunk-QQHVOJW6.js";
+import {
+  DeveloperError_default
+} from "./chunk-6EJMTDQJ.js";
+import {
+  defined_default
+} from "./chunk-EXTMZJXB.js";
+
+// packages/engine/Source/Core/RectangleGeometryLibrary.js
+var cos = Math.cos;
+var sin = Math.sin;
+var sqrt = Math.sqrt;
+var RectangleGeometryLibrary = {};
+RectangleGeometryLibrary.computePosition = function(computedOptions, ellipsoid, computeST, row, col, position, st) {
+  const radiiSquared = ellipsoid.radiiSquared;
+  const nwCorner = computedOptions.nwCorner;
+  const rectangle = computedOptions.boundingRectangle;
+  let stLatitude = nwCorner.latitude - computedOptions.granYCos * row + col * computedOptions.granXSin;
+  const cosLatitude = cos(stLatitude);
+  const nZ = sin(stLatitude);
+  const kZ = radiiSquared.z * nZ;
+  let stLongitude = nwCorner.longitude + row * computedOptions.granYSin + col * computedOptions.granXCos;
+  const nX = cosLatitude * cos(stLongitude);
+  const nY = cosLatitude * sin(stLongitude);
+  const kX = radiiSquared.x * nX;
+  const kY = radiiSquared.y * nY;
+  const gamma = sqrt(kX * nX + kY * nY + kZ * nZ);
+  position.x = kX / gamma;
+  position.y = kY / gamma;
+  position.z = kZ / gamma;
+  if (computeST) {
+    const stNwCorner = computedOptions.stNwCorner;
+    if (defined_default(stNwCorner)) {
+      stLatitude = stNwCorner.latitude - computedOptions.stGranYCos * row + col * computedOptions.stGranXSin;
+      stLongitude = stNwCorner.longitude + row * computedOptions.stGranYSin + col * computedOptions.stGranXCos;
+      st.x = (stLongitude - computedOptions.stWest) * computedOptions.lonScalar;
+      st.y = (stLatitude - computedOptions.stSouth) * computedOptions.latScalar;
+    } else {
+      st.x = (stLongitude - rectangle.west) * computedOptions.lonScalar;
+      st.y = (stLatitude - rectangle.south) * computedOptions.latScalar;
+    }
+  }
+};
+var rotationMatrixScratch = new Matrix2_default();
+var nwCartesian = new Cartesian3_default();
+var centerScratch = new Cartographic_default();
+var centerCartesian = new Cartesian3_default();
+var proj = new GeographicProjection_default();
+function getRotationOptions(nwCorner, rotation, granularityX, granularityY, center, width, height) {
+  const cosRotation = Math.cos(rotation);
+  const granYCos = granularityY * cosRotation;
+  const granXCos = granularityX * cosRotation;
+  const sinRotation = Math.sin(rotation);
+  const granYSin = granularityY * sinRotation;
+  const granXSin = granularityX * sinRotation;
+  proj._ellipsoid = Ellipsoid_default.default;
+  nwCartesian = proj.project(nwCorner, nwCartesian);
+  nwCartesian = Cartesian3_default.subtract(nwCartesian, centerCartesian, nwCartesian);
+  const rotationMatrix = Matrix2_default.fromRotation(rotation, rotationMatrixScratch);
+  nwCartesian = Matrix2_default.multiplyByVector(
+    rotationMatrix,
+    nwCartesian,
+    nwCartesian
+  );
+  nwCartesian = Cartesian3_default.add(nwCartesian, centerCartesian, nwCartesian);
+  nwCorner = proj.unproject(nwCartesian, nwCorner);
+  width -= 1;
+  height -= 1;
+  const latitude = nwCorner.latitude;
+  const latitude0 = latitude + width * granXSin;
+  const latitude1 = latitude - granYCos * height;
+  const latitude2 = latitude - granYCos * height + width * granXSin;
+  const north = Math.max(latitude, latitude0, latitude1, latitude2);
+  const south = Math.min(latitude, latitude0, latitude1, latitude2);
+  const longitude = nwCorner.longitude;
+  const longitude0 = longitude + width * granXCos;
+  const longitude1 = longitude + height * granYSin;
+  const longitude2 = longitude + height * granYSin + width * granXCos;
+  const east = Math.max(longitude, longitude0, longitude1, longitude2);
+  const west = Math.min(longitude, longitude0, longitude1, longitude2);
+  return {
+    north,
+    south,
+    east,
+    west,
+    granYCos,
+    granYSin,
+    granXCos,
+    granXSin,
+    nwCorner
+  };
+}
+RectangleGeometryLibrary.computeOptions = function(rectangle, granularity, rotation, stRotation, boundingRectangleScratch, nwCornerResult, stNwCornerResult) {
+  let east = rectangle.east;
+  let west = rectangle.west;
+  let north = rectangle.north;
+  let south = rectangle.south;
+  let northCap = false;
+  let southCap = false;
+  if (north === Math_default.PI_OVER_TWO) {
+    northCap = true;
+  }
+  if (south === -Math_default.PI_OVER_TWO) {
+    southCap = true;
+  }
+  let dx;
+  const dy = north - south;
+  if (west > east) {
+    dx = Math_default.TWO_PI - west + east;
+  } else {
+    dx = east - west;
+  }
+  const width = Math.ceil(dx / granularity) + 1;
+  const height = Math.ceil(dy / granularity) + 1;
+  const granularityX = dx / (width - 1);
+  const granularityY = dy / (height - 1);
+  const nwCorner = Rectangle_default.northwest(rectangle, nwCornerResult);
+  const center = Rectangle_default.center(rectangle, centerScratch);
+  if (rotation !== 0 || stRotation !== 0) {
+    if (center.longitude < nwCorner.longitude) {
+      center.longitude += Math_default.TWO_PI;
+    }
+    proj._ellipsoid = Ellipsoid_default.default;
+    centerCartesian = proj.project(center, centerCartesian);
+  }
+  const granYCos = granularityY;
+  const granXCos = granularityX;
+  const granYSin = 0;
+  const granXSin = 0;
+  const boundingRectangle = Rectangle_default.clone(
+    rectangle,
+    boundingRectangleScratch
+  );
+  const computedOptions = {
+    granYCos,
+    granYSin,
+    granXCos,
+    granXSin,
+    nwCorner,
+    boundingRectangle,
+    width,
+    height,
+    northCap,
+    southCap
+  };
+  if (rotation !== 0) {
+    const rotationOptions = getRotationOptions(
+      nwCorner,
+      rotation,
+      granularityX,
+      granularityY,
+      center,
+      width,
+      height
+    );
+    north = rotationOptions.north;
+    south = rotationOptions.south;
+    east = rotationOptions.east;
+    west = rotationOptions.west;
+    if (north < -Math_default.PI_OVER_TWO || north > Math_default.PI_OVER_TWO || south < -Math_default.PI_OVER_TWO || south > Math_default.PI_OVER_TWO) {
+      throw new DeveloperError_default(
+        "Rotated rectangle is invalid.  It crosses over either the north or south pole."
+      );
+    }
+    computedOptions.granYCos = rotationOptions.granYCos;
+    computedOptions.granYSin = rotationOptions.granYSin;
+    computedOptions.granXCos = rotationOptions.granXCos;
+    computedOptions.granXSin = rotationOptions.granXSin;
+    boundingRectangle.north = north;
+    boundingRectangle.south = south;
+    boundingRectangle.east = east;
+    boundingRectangle.west = west;
+  }
+  if (stRotation !== 0) {
+    rotation = rotation - stRotation;
+    const stNwCorner = Rectangle_default.northwest(boundingRectangle, stNwCornerResult);
+    const stRotationOptions = getRotationOptions(
+      stNwCorner,
+      rotation,
+      granularityX,
+      granularityY,
+      center,
+      width,
+      height
+    );
+    computedOptions.stGranYCos = stRotationOptions.granYCos;
+    computedOptions.stGranXCos = stRotationOptions.granXCos;
+    computedOptions.stGranYSin = stRotationOptions.granYSin;
+    computedOptions.stGranXSin = stRotationOptions.granXSin;
+    computedOptions.stNwCorner = stNwCorner;
+    computedOptions.stWest = stRotationOptions.west;
+    computedOptions.stSouth = stRotationOptions.south;
+  }
+  return computedOptions;
+};
+var RectangleGeometryLibrary_default = RectangleGeometryLibrary;
+
+export {
+  RectangleGeometryLibrary_default
+};

package/Build/Workers/chunk-7AMRE57Q.js

@@ -0,0 +1,301 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.1.4
+ *
+ * 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 {
+  Matrix2_default,
+  Quaternion_default,
+  Rectangle_default,
+  Transforms_default
+} from "./chunk-BR3BPM64.js";
+import {
+  Matrix4_default
+} from "./chunk-OEHJY463.js";
+import {
+  WebGLConstants_default
+} from "./chunk-D3QIW4DH.js";
+import {
+  Cartesian2_default,
+  Cartographic_default
+} from "./chunk-M6IXKBC7.js";
+import {
+  Cartesian3_default,
+  Frozen_default,
+  Matrix3_default
+} from "./chunk-J4PISUNT.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-KWV6ZTF4.js";
+import {
+  defined_default
+} from "./chunk-MRMNELAH.js";
+
+// packages/engine/Source/Core/GeometryType.js
+var GeometryType = {
+  NONE: 0,
+  TRIANGLES: 1,
+  LINES: 2,
+  POLYLINES: 3
+};
+Object.freeze(GeometryType);
+var GeometryType_default = GeometryType;
+
+// packages/engine/Source/Core/PrimitiveType.js
+var PrimitiveType = {
+  /**
+   * Points primitive where each vertex (or index) is a separate point.
+   *
+   * @type {number}
+   * @constant
+   */
+  POINTS: WebGLConstants_default.POINTS,
+  /**
+   * Lines primitive where each two vertices (or indices) is a line segment.  Line segments are not necessarily connected.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINES: WebGLConstants_default.LINES,
+  /**
+   * Line loop primitive where each vertex (or index) after the first connects a line to
+   * the previous vertex, and the last vertex implicitly connects to the first.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINE_LOOP: WebGLConstants_default.LINE_LOOP,
+  /**
+   * Line strip primitive where each vertex (or index) after the first connects a line to the previous vertex.
+   *
+   * @type {number}
+   * @constant
+   */
+  LINE_STRIP: WebGLConstants_default.LINE_STRIP,
+  /**
+   * Triangles primitive where each three vertices (or indices) is a triangle.  Triangles do not necessarily share edges.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLES: WebGLConstants_default.TRIANGLES,
+  /**
+   * Triangle strip primitive where each vertex (or index) after the first two connect to
+   * the previous two vertices forming a triangle.  For example, this can be used to model a wall.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLE_STRIP: WebGLConstants_default.TRIANGLE_STRIP,
+  /**
+   * Triangle fan primitive where each vertex (or index) after the first two connect to
+   * the previous vertex and the first vertex forming a triangle.  For example, this can be used
+   * to model a cone or circle.
+   *
+   * @type {number}
+   * @constant
+   */
+  TRIANGLE_FAN: WebGLConstants_default.TRIANGLE_FAN
+};
+PrimitiveType.isLines = function(primitiveType) {
+  return primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP;
+};
+PrimitiveType.isTriangles = function(primitiveType) {
+  return primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
+};
+PrimitiveType.validate = function(primitiveType) {
+  return primitiveType === PrimitiveType.POINTS || primitiveType === PrimitiveType.LINES || primitiveType === PrimitiveType.LINE_LOOP || primitiveType === PrimitiveType.LINE_STRIP || primitiveType === PrimitiveType.TRIANGLES || primitiveType === PrimitiveType.TRIANGLE_STRIP || primitiveType === PrimitiveType.TRIANGLE_FAN;
+};
+Object.freeze(PrimitiveType);
+var PrimitiveType_default = PrimitiveType;
+
+// packages/engine/Source/Core/Geometry.js
+function Geometry(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  Check_default.typeOf.object("options.attributes", options.attributes);
+  this.attributes = options.attributes;
+  this.indices = options.indices;
+  this.primitiveType = options.primitiveType ?? PrimitiveType_default.TRIANGLES;
+  this.boundingSphere = options.boundingSphere;
+  this.geometryType = options.geometryType ?? GeometryType_default.NONE;
+  this.boundingSphereCV = options.boundingSphereCV;
+  this.offsetAttribute = options.offsetAttribute;
+}
+Geometry.computeNumberOfVertices = function(geometry) {
+  Check_default.typeOf.object("geometry", geometry);
+  let numberOfVertices = -1;
+  for (const property in geometry.attributes) {
+    if (geometry.attributes.hasOwnProperty(property) && defined_default(geometry.attributes[property]) && defined_default(geometry.attributes[property].values)) {
+      const attribute = geometry.attributes[property];
+      const num = attribute.values.length / attribute.componentsPerAttribute;
+      if (numberOfVertices !== num && numberOfVertices !== -1) {
+        throw new DeveloperError_default(
+          "All attribute lists must have the same number of attributes."
+        );
+      }
+      numberOfVertices = num;
+    }
+  }
+  return numberOfVertices;
+};
+var rectangleCenterScratch = new Cartographic_default();
+var enuCenterScratch = new Cartesian3_default();
+var fixedFrameToEnuScratch = new Matrix4_default();
+var boundingRectanglePointsCartographicScratch = [
+  new Cartographic_default(),
+  new Cartographic_default(),
+  new Cartographic_default()
+];
+var boundingRectanglePointsEnuScratch = [
+  new Cartesian2_default(),
+  new Cartesian2_default(),
+  new Cartesian2_default()
+];
+var points2DScratch = [new Cartesian2_default(), new Cartesian2_default(), new Cartesian2_default()];
+var pointEnuScratch = new Cartesian3_default();
+var enuRotationScratch = new Quaternion_default();
+var enuRotationMatrixScratch = new Matrix4_default();
+var rotation2DScratch = new Matrix2_default();
+Geometry._textureCoordinateRotationPoints = function(positions, stRotation, ellipsoid, boundingRectangle) {
+  let i;
+  const rectangleCenter = Rectangle_default.center(
+    boundingRectangle,
+    rectangleCenterScratch
+  );
+  const enuCenter = Cartographic_default.toCartesian(
+    rectangleCenter,
+    ellipsoid,
+    enuCenterScratch
+  );
+  const enuToFixedFrame = Transforms_default.eastNorthUpToFixedFrame(
+    enuCenter,
+    ellipsoid,
+    fixedFrameToEnuScratch
+  );
+  const fixedFrameToEnu = Matrix4_default.inverse(
+    enuToFixedFrame,
+    fixedFrameToEnuScratch
+  );
+  const boundingPointsEnu = boundingRectanglePointsEnuScratch;
+  const boundingPointsCarto = boundingRectanglePointsCartographicScratch;
+  boundingPointsCarto[0].longitude = boundingRectangle.west;
+  boundingPointsCarto[0].latitude = boundingRectangle.south;
+  boundingPointsCarto[1].longitude = boundingRectangle.west;
+  boundingPointsCarto[1].latitude = boundingRectangle.north;
+  boundingPointsCarto[2].longitude = boundingRectangle.east;
+  boundingPointsCarto[2].latitude = boundingRectangle.south;
+  let posEnu = pointEnuScratch;
+  for (i = 0; i < 3; i++) {
+    Cartographic_default.toCartesian(boundingPointsCarto[i], ellipsoid, posEnu);
+    posEnu = Matrix4_default.multiplyByPointAsVector(fixedFrameToEnu, posEnu, posEnu);
+    boundingPointsEnu[i].x = posEnu.x;
+    boundingPointsEnu[i].y = posEnu.y;
+  }
+  const rotation = Quaternion_default.fromAxisAngle(
+    Cartesian3_default.UNIT_Z,
+    -stRotation,
+    enuRotationScratch
+  );
+  const textureMatrix = Matrix3_default.fromQuaternion(
+    rotation,
+    enuRotationMatrixScratch
+  );
+  const positionsLength = positions.length;
+  let enuMinX = Number.POSITIVE_INFINITY;
+  let enuMinY = Number.POSITIVE_INFINITY;
+  let enuMaxX = Number.NEGATIVE_INFINITY;
+  let enuMaxY = Number.NEGATIVE_INFINITY;
+  for (i = 0; i < positionsLength; i++) {
+    posEnu = Matrix4_default.multiplyByPointAsVector(
+      fixedFrameToEnu,
+      positions[i],
+      posEnu
+    );
+    posEnu = Matrix3_default.multiplyByVector(textureMatrix, posEnu, posEnu);
+    enuMinX = Math.min(enuMinX, posEnu.x);
+    enuMinY = Math.min(enuMinY, posEnu.y);
+    enuMaxX = Math.max(enuMaxX, posEnu.x);
+    enuMaxY = Math.max(enuMaxY, posEnu.y);
+  }
+  const toDesiredInComputed = Matrix2_default.fromRotation(
+    stRotation,
+    rotation2DScratch
+  );
+  const points2D = points2DScratch;
+  points2D[0].x = enuMinX;
+  points2D[0].y = enuMinY;
+  points2D[1].x = enuMinX;
+  points2D[1].y = enuMaxY;
+  points2D[2].x = enuMaxX;
+  points2D[2].y = enuMinY;
+  const boundingEnuMin = boundingPointsEnu[0];
+  const boundingPointsWidth = boundingPointsEnu[2].x - boundingEnuMin.x;
+  const boundingPointsHeight = boundingPointsEnu[1].y - boundingEnuMin.y;
+  for (i = 0; i < 3; i++) {
+    const point2D = points2D[i];
+    Matrix2_default.multiplyByVector(toDesiredInComputed, point2D, point2D);
+    point2D.x = (point2D.x - boundingEnuMin.x) / boundingPointsWidth;
+    point2D.y = (point2D.y - boundingEnuMin.y) / boundingPointsHeight;
+  }
+  const minXYCorner = points2D[0];
+  const maxYCorner = points2D[1];
+  const maxXCorner = points2D[2];
+  const result = new Array(6);
+  Cartesian2_default.pack(minXYCorner, result);
+  Cartesian2_default.pack(maxYCorner, result, 2);
+  Cartesian2_default.pack(maxXCorner, result, 4);
+  return result;
+};
+var Geometry_default = Geometry;
+
+// packages/engine/Source/Core/GeometryAttribute.js
+function GeometryAttribute(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  if (!defined_default(options.componentDatatype)) {
+    throw new DeveloperError_default("options.componentDatatype is required.");
+  }
+  if (!defined_default(options.componentsPerAttribute)) {
+    throw new DeveloperError_default("options.componentsPerAttribute is required.");
+  }
+  if (options.componentsPerAttribute < 1 || options.componentsPerAttribute > 4) {
+    throw new DeveloperError_default(
+      "options.componentsPerAttribute must be between 1 and 4."
+    );
+  }
+  if (!defined_default(options.values)) {
+    throw new DeveloperError_default("options.values is required.");
+  }
+  this.componentDatatype = options.componentDatatype;
+  this.componentsPerAttribute = options.componentsPerAttribute;
+  this.normalize = options.normalize ?? false;
+  this.values = options.values;
+}
+var GeometryAttribute_default = GeometryAttribute;
+
+export {
+  GeometryType_default,
+  PrimitiveType_default,
+  Geometry_default,
+  GeometryAttribute_default
+};