@rtzh/engine 0.0.5 → 0.0.7

package/Build/Workers/chunk-HM4MH5IG.js

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.6
+ *
+ * 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 {
+  Frozen_default
+} from "./chunk-GZMTBQM2.js";
+import {
+  DeveloperError_default
+} from "./chunk-SZELHE7Q.js";
+import {
+  defined_default
+} from "./chunk-OBM2JYMG.js";
+
+// packages/engine/Source/Core/VertexFormat.js
+function VertexFormat(options) {
+  options = options ?? Frozen_default.EMPTY_OBJECT;
+  this.position = options.position ?? false;
+  this.normal = options.normal ?? false;
+  this.st = options.st ?? false;
+  this.bitangent = options.bitangent ?? false;
+  this.tangent = options.tangent ?? false;
+  this.color = options.color ?? false;
+}
+VertexFormat.POSITION_ONLY = Object.freeze(
+  new VertexFormat({
+    position: true
+  })
+);
+VertexFormat.POSITION_AND_NORMAL = Object.freeze(
+  new VertexFormat({
+    position: true,
+    normal: true
+  })
+);
+VertexFormat.POSITION_NORMAL_AND_ST = Object.freeze(
+  new VertexFormat({
+    position: true,
+    normal: true,
+    st: true
+  })
+);
+VertexFormat.POSITION_AND_ST = Object.freeze(
+  new VertexFormat({
+    position: true,
+    st: true
+  })
+);
+VertexFormat.POSITION_AND_COLOR = Object.freeze(
+  new VertexFormat({
+    position: true,
+    color: true
+  })
+);
+VertexFormat.ALL = Object.freeze(
+  new VertexFormat({
+    position: true,
+    normal: true,
+    st: true,
+    tangent: true,
+    bitangent: true
+  })
+);
+VertexFormat.DEFAULT = VertexFormat.POSITION_NORMAL_AND_ST;
+VertexFormat.packedLength = 6;
+VertexFormat.pack = function(value, array, startingIndex) {
+  if (!defined_default(value)) {
+    throw new DeveloperError_default("value is required");
+  }
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  array[startingIndex++] = value.position ? 1 : 0;
+  array[startingIndex++] = value.normal ? 1 : 0;
+  array[startingIndex++] = value.st ? 1 : 0;
+  array[startingIndex++] = value.tangent ? 1 : 0;
+  array[startingIndex++] = value.bitangent ? 1 : 0;
+  array[startingIndex] = value.color ? 1 : 0;
+  return array;
+};
+VertexFormat.unpack = function(array, startingIndex, result) {
+  if (!defined_default(array)) {
+    throw new DeveloperError_default("array is required");
+  }
+  startingIndex = startingIndex ?? 0;
+  if (!defined_default(result)) {
+    result = new VertexFormat();
+  }
+  result.position = array[startingIndex++] === 1;
+  result.normal = array[startingIndex++] === 1;
+  result.st = array[startingIndex++] === 1;
+  result.tangent = array[startingIndex++] === 1;
+  result.bitangent = array[startingIndex++] === 1;
+  result.color = array[startingIndex] === 1;
+  return result;
+};
+VertexFormat.clone = function(vertexFormat, result) {
+  if (!defined_default(vertexFormat)) {
+    return void 0;
+  }
+  if (!defined_default(result)) {
+    result = new VertexFormat();
+  }
+  result.position = vertexFormat.position;
+  result.normal = vertexFormat.normal;
+  result.st = vertexFormat.st;
+  result.tangent = vertexFormat.tangent;
+  result.bitangent = vertexFormat.bitangent;
+  result.color = vertexFormat.color;
+  return result;
+};
+var VertexFormat_default = VertexFormat;
+
+export {
+  VertexFormat_default
+};

package/Build/Workers/chunk-I5JHYEIE.js

@@ -0,0 +1,241 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.8
+ *
+ * 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-H33FCT5U.js";
+import {
+  Matrix2_default,
+  Rectangle_default
+} from "./chunk-EPVJ5OOH.js";
+import {
+  Cartographic_default,
+  Ellipsoid_default
+} from "./chunk-KMZXZUA7.js";
+import {
+  Cartesian3_default
+} from "./chunk-HEKLTOOR.js";
+import {
+  Math_default
+} from "./chunk-YR3LX3PR.js";
+import {
+  DeveloperError_default
+} from "./chunk-2ZXYLPPT.js";
+import {
+  defined_default
+} from "./chunk-PU44PXY2.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-IB2XQV6U.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.6
+ *
+ * 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-OBM2JYMG.js";
+
+// packages/engine/Source/Core/formatError.js
+function formatError(object) {
+  let result;
+  const name = object.name;
+  const message = object.message;
+  if (defined_default(name) && defined_default(message)) {
+    result = `${name}: ${message}`;
+  } else {
+    result = object.toString();
+  }
+  const stack = object.stack;
+  if (defined_default(stack)) {
+    result += `
+${stack}`;
+  }
+  return result;
+}
+var formatError_default = formatError;
+
+// packages/engine/Source/Workers/createTaskProcessorWorker.js
+function createTaskProcessorWorker(workerFunction) {
+  async function onMessageHandler({ data }) {
+    const transferableObjects = [];
+    const responseMessage = {
+      id: data.id,
+      result: void 0,
+      error: void 0
+    };
+    self.CESIUM_BASE_URL = data.baseUrl;
+    try {
+      const result = await workerFunction(data.parameters, transferableObjects);
+      responseMessage.result = result;
+    } catch (error) {
+      if (error instanceof Error) {
+        responseMessage.error = {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        };
+      } else {
+        responseMessage.error = error;
+      }
+    }
+    if (!data.canTransferArrayBuffer) {
+      transferableObjects.length = 0;
+    }
+    try {
+      postMessage(responseMessage, transferableObjects);
+    } catch (error) {
+      responseMessage.result = void 0;
+      responseMessage.error = `postMessage failed with error: ${formatError_default(
+        error
+      )}
+  with responseMessage: ${JSON.stringify(responseMessage)}`;
+      postMessage(responseMessage);
+    }
+  }
+  function onMessageErrorHandler(event) {
+    postMessage({
+      id: event.data?.id,
+      error: `postMessage failed with error: ${JSON.stringify(event)}`
+    });
+  }
+  self.onmessage = onMessageHandler;
+  self.onmessageerror = onMessageErrorHandler;
+  return self;
+}
+var createTaskProcessorWorker_default = createTaskProcessorWorker;
+
+export {
+  createTaskProcessorWorker_default
+};

package/Build/Workers/chunk-IC2JHDCI.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.8
+ *
+ * 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,
+  Ellipsoid_default
+} from "./chunk-KMZXZUA7.js";
+import {
+  Cartesian3_default
+} from "./chunk-HEKLTOOR.js";
+import {
+  Math_default
+} from "./chunk-YR3LX3PR.js";
+import {
+  DeveloperError_default
+} from "./chunk-2ZXYLPPT.js";
+import {
+  defined_default
+} from "./chunk-PU44PXY2.js";
+
+// packages/engine/Source/Core/WebMercatorProjection.js
+function WebMercatorProjection(ellipsoid) {
+  this._ellipsoid = ellipsoid ?? Ellipsoid_default.WGS84;
+  this._semimajorAxis = this._ellipsoid.maximumRadius;
+  this._oneOverSemimajorAxis = 1 / this._semimajorAxis;
+}
+Object.defineProperties(WebMercatorProjection.prototype, {
+  /**
+   * Gets the {@link Ellipsoid}.
+   *
+   * @memberof WebMercatorProjection.prototype
+   *
+   * @type {Ellipsoid}
+   * @readonly
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  }
+});
+WebMercatorProjection.mercatorAngleToGeodeticLatitude = function(mercatorAngle) {
+  return Math_default.PI_OVER_TWO - 2 * Math.atan(Math.exp(-mercatorAngle));
+};
+WebMercatorProjection.geodeticLatitudeToMercatorAngle = function(latitude) {
+  if (latitude > WebMercatorProjection.MaximumLatitude) {
+    latitude = WebMercatorProjection.MaximumLatitude;
+  } else if (latitude < -WebMercatorProjection.MaximumLatitude) {
+    latitude = -WebMercatorProjection.MaximumLatitude;
+  }
+  const sinLatitude = Math.sin(latitude);
+  return 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
+};
+WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI);
+WebMercatorProjection.prototype.project = function(cartographic, result) {
+  const semimajorAxis = this._semimajorAxis;
+  const x = cartographic.longitude * semimajorAxis;
+  const y = WebMercatorProjection.geodeticLatitudeToMercatorAngle(
+    cartographic.latitude
+  ) * semimajorAxis;
+  const z = cartographic.height;
+  if (!defined_default(result)) {
+    return new Cartesian3_default(x, y, z);
+  }
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return result;
+};
+WebMercatorProjection.prototype.unproject = function(cartesian, result) {
+  if (!defined_default(cartesian)) {
+    throw new DeveloperError_default("cartesian is required");
+  }
+  const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+  const longitude = cartesian.x * oneOverEarthSemimajorAxis;
+  const latitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(
+    cartesian.y * oneOverEarthSemimajorAxis
+  );
+  const height = cartesian.z;
+  if (!defined_default(result)) {
+    return new Cartographic_default(longitude, latitude, height);
+  }
+  result.longitude = longitude;
+  result.latitude = latitude;
+  result.height = height;
+  return result;
+};
+var WebMercatorProjection_default = WebMercatorProjection;
+
+export {
+  WebMercatorProjection_default
+};