deeptwins-engine-3d 0.1.76 → 0.2.1

package/dist/assets/Build/Map3d/Workers/chunk-YIKGVMJ5.js

@@ -0,0 +1,287 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.42
+ *
+ * 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 {
+  AxisAlignedBoundingBox_default
+} from "./chunk-CZ44I32U.js";
+import {
+  IntersectionTests_default,
+  Ray_default
+} from "./chunk-R5PZXG56.js";
+import {
+  Plane_default
+} from "./chunk-7B5XGQRN.js";
+import {
+  Cartesian4_default,
+  Matrix4_default,
+  Transforms_default
+} from "./chunk-R4W6IRJZ.js";
+import {
+  Cartesian2_default,
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-ZW52HXFN.js";
+import {
+  defaultValue_default
+} from "./chunk-ATLWOZFF.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-PN3GIZ5Q.js";
+import {
+  defined_default
+} from "./chunk-JKLMRPKK.js";
+
+// packages/engine/Source/Core/EllipsoidTangentPlane.js
+var scratchCart4 = new Cartesian4_default();
+function EllipsoidTangentPlane(origin, ellipsoid) {
+  Check_default.defined("origin", origin);
+  ellipsoid = defaultValue_default(ellipsoid, Ellipsoid_default.default);
+  origin = ellipsoid.scaleToGeodeticSurface(origin);
+  if (!defined_default(origin)) {
+    throw new DeveloperError_default(
+      "origin must not be at the center of the ellipsoid."
+    );
+  }
+  const eastNorthUp = Transforms_default.eastNorthUpToFixedFrame(origin, ellipsoid);
+  this._ellipsoid = ellipsoid;
+  this._origin = origin;
+  this._xAxis = Cartesian3_default.fromCartesian4(
+    Matrix4_default.getColumn(eastNorthUp, 0, scratchCart4)
+  );
+  this._yAxis = Cartesian3_default.fromCartesian4(
+    Matrix4_default.getColumn(eastNorthUp, 1, scratchCart4)
+  );
+  const normal = Cartesian3_default.fromCartesian4(
+    Matrix4_default.getColumn(eastNorthUp, 2, scratchCart4)
+  );
+  this._plane = Plane_default.fromPointNormal(origin, normal);
+}
+Object.defineProperties(EllipsoidTangentPlane.prototype, {
+  /**
+   * Gets the ellipsoid.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @type {Ellipsoid}
+   */
+  ellipsoid: {
+    get: function() {
+      return this._ellipsoid;
+    }
+  },
+  /**
+   * Gets the origin.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @type {Cartesian3}
+   */
+  origin: {
+    get: function() {
+      return this._origin;
+    }
+  },
+  /**
+   * Gets the plane which is tangent to the ellipsoid.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @readonly
+   * @type {Plane}
+   */
+  plane: {
+    get: function() {
+      return this._plane;
+    }
+  },
+  /**
+   * Gets the local X-axis (east) of the tangent plane.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @readonly
+   * @type {Cartesian3}
+   */
+  xAxis: {
+    get: function() {
+      return this._xAxis;
+    }
+  },
+  /**
+   * Gets the local Y-axis (north) of the tangent plane.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @readonly
+   * @type {Cartesian3}
+   */
+  yAxis: {
+    get: function() {
+      return this._yAxis;
+    }
+  },
+  /**
+   * Gets the local Z-axis (up) of the tangent plane.
+   * @memberof EllipsoidTangentPlane.prototype
+   * @readonly
+   * @type {Cartesian3}
+   */
+  zAxis: {
+    get: function() {
+      return this._plane.normal;
+    }
+  }
+});
+var tmp = new AxisAlignedBoundingBox_default();
+EllipsoidTangentPlane.fromPoints = function(cartesians, ellipsoid) {
+  Check_default.defined("cartesians", cartesians);
+  const box = AxisAlignedBoundingBox_default.fromPoints(cartesians, tmp);
+  return new EllipsoidTangentPlane(box.center, ellipsoid);
+};
+var scratchProjectPointOntoPlaneRay = new Ray_default();
+var scratchProjectPointOntoPlaneCartesian3 = new Cartesian3_default();
+EllipsoidTangentPlane.prototype.projectPointOntoPlane = function(cartesian, result) {
+  Check_default.defined("cartesian", cartesian);
+  const ray = scratchProjectPointOntoPlaneRay;
+  ray.origin = cartesian;
+  Cartesian3_default.normalize(cartesian, ray.direction);
+  let intersectionPoint = IntersectionTests_default.rayPlane(
+    ray,
+    this._plane,
+    scratchProjectPointOntoPlaneCartesian3
+  );
+  if (!defined_default(intersectionPoint)) {
+    Cartesian3_default.negate(ray.direction, ray.direction);
+    intersectionPoint = IntersectionTests_default.rayPlane(
+      ray,
+      this._plane,
+      scratchProjectPointOntoPlaneCartesian3
+    );
+  }
+  if (defined_default(intersectionPoint)) {
+    const v = Cartesian3_default.subtract(
+      intersectionPoint,
+      this._origin,
+      intersectionPoint
+    );
+    const x = Cartesian3_default.dot(this._xAxis, v);
+    const y = Cartesian3_default.dot(this._yAxis, v);
+    if (!defined_default(result)) {
+      return new Cartesian2_default(x, y);
+    }
+    result.x = x;
+    result.y = y;
+    return result;
+  }
+  return void 0;
+};
+EllipsoidTangentPlane.prototype.projectPointsOntoPlane = function(cartesians, result) {
+  Check_default.defined("cartesians", cartesians);
+  if (!defined_default(result)) {
+    result = [];
+  }
+  let count = 0;
+  const length = cartesians.length;
+  for (let i = 0; i < length; i++) {
+    const p = this.projectPointOntoPlane(cartesians[i], result[count]);
+    if (defined_default(p)) {
+      result[count] = p;
+      count++;
+    }
+  }
+  result.length = count;
+  return result;
+};
+EllipsoidTangentPlane.prototype.projectPointToNearestOnPlane = function(cartesian, result) {
+  Check_default.defined("cartesian", cartesian);
+  if (!defined_default(result)) {
+    result = new Cartesian2_default();
+  }
+  const ray = scratchProjectPointOntoPlaneRay;
+  ray.origin = cartesian;
+  Cartesian3_default.clone(this._plane.normal, ray.direction);
+  let intersectionPoint = IntersectionTests_default.rayPlane(
+    ray,
+    this._plane,
+    scratchProjectPointOntoPlaneCartesian3
+  );
+  if (!defined_default(intersectionPoint)) {
+    Cartesian3_default.negate(ray.direction, ray.direction);
+    intersectionPoint = IntersectionTests_default.rayPlane(
+      ray,
+      this._plane,
+      scratchProjectPointOntoPlaneCartesian3
+    );
+  }
+  const v = Cartesian3_default.subtract(
+    intersectionPoint,
+    this._origin,
+    intersectionPoint
+  );
+  const x = Cartesian3_default.dot(this._xAxis, v);
+  const y = Cartesian3_default.dot(this._yAxis, v);
+  result.x = x;
+  result.y = y;
+  return result;
+};
+EllipsoidTangentPlane.prototype.projectPointsToNearestOnPlane = function(cartesians, result) {
+  Check_default.defined("cartesians", cartesians);
+  if (!defined_default(result)) {
+    result = [];
+  }
+  const length = cartesians.length;
+  result.length = length;
+  for (let i = 0; i < length; i++) {
+    result[i] = this.projectPointToNearestOnPlane(cartesians[i], result[i]);
+  }
+  return result;
+};
+var projectPointsOntoEllipsoidScratch = new Cartesian3_default();
+EllipsoidTangentPlane.prototype.projectPointOntoEllipsoid = function(cartesian, result) {
+  Check_default.defined("cartesian", cartesian);
+  if (!defined_default(result)) {
+    result = new Cartesian3_default();
+  }
+  const ellipsoid = this._ellipsoid;
+  const origin = this._origin;
+  const xAxis = this._xAxis;
+  const yAxis = this._yAxis;
+  const tmp2 = projectPointsOntoEllipsoidScratch;
+  Cartesian3_default.multiplyByScalar(xAxis, cartesian.x, tmp2);
+  result = Cartesian3_default.add(origin, tmp2, result);
+  Cartesian3_default.multiplyByScalar(yAxis, cartesian.y, tmp2);
+  Cartesian3_default.add(result, tmp2, result);
+  ellipsoid.scaleToGeocentricSurface(result, result);
+  return result;
+};
+EllipsoidTangentPlane.prototype.projectPointsOntoEllipsoid = function(cartesians, result) {
+  Check_default.defined("cartesians", cartesians);
+  const length = cartesians.length;
+  if (!defined_default(result)) {
+    result = new Array(length);
+  } else {
+    result.length = length;
+  }
+  for (let i = 0; i < length; ++i) {
+    result[i] = this.projectPointOntoEllipsoid(cartesians[i], result[i]);
+  }
+  return result;
+};
+var EllipsoidTangentPlane_default = EllipsoidTangentPlane;
+
+export {
+  EllipsoidTangentPlane_default
+};

package/dist/assets/Build/Map3d/Workers/chunk-YTNCIBPQ.js

@@ -0,0 +1,262 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.42
+ *
+ * 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-RZQLZIUI.js";
+import {
+  defaultValue_default
+} from "./chunk-ATLWOZFF.js";
+import {
+  DeveloperError_default
+} from "./chunk-PN3GIZ5Q.js";
+import {
+  defined_default
+} from "./chunk-JKLMRPKK.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;
+    //>>includeStart('debug', pragmas.debug);
+    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);
+    //>>includeStart('debug', pragmas.debug);
+    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);
+    //>>includeStart('debug', pragmas.debug);
+    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;
+    //>>includeStart('debug', pragmas.debug);
+    default:
+      throw new DeveloperError_default("name is not a valid value.");
+  }
+};
+var ComponentDatatype_default = Object.freeze(ComponentDatatype);
+
+export {
+  ComponentDatatype_default
+};

package/dist/assets/Build/Map3d/Workers/chunk-ZMDUYETO.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 0.0.42
+ *
+ * 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/ArcType.js
+var ArcType = {
+  /**
+   * Straight line that does not conform to the surface of the ellipsoid.
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * Follow geodesic path.
+   *
+   * @type {number}
+   * @constant
+   */
+  GEODESIC: 1,
+  /**
+   * Follow rhumb or loxodrome path.
+   *
+   * @type {number}
+   * @constant
+   */
+  RHUMB: 2
+};
+var ArcType_default = Object.freeze(ArcType);
+
+export {
+  ArcType_default
+};