@gmgis/gm-sdk 1.12.5 → 2.0.2

package/dist/resources/Workers/chunk-27HUZ7SA.js

@@ -1,305 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.122
- *
- * 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 {
-  Quaternion_default
-} from "./chunk-5PTXS2GO.js";
-import {
-  Cartesian3_default,
-  Matrix3_default
-} from "./chunk-YFXQECWV.js";
-import {
-  Math_default
-} from "./chunk-XY4BATBS.js";
-
-// packages/engine/Source/Core/EllipseGeometryLibrary.js
-var EllipseGeometryLibrary = {};
-var rotAxis = new Cartesian3_default();
-var tempVec = new Cartesian3_default();
-var unitQuat = new Quaternion_default();
-var rotMtx = new Matrix3_default();
-function pointOnEllipsoid(theta, rotation, northVec, eastVec, aSqr, ab, bSqr, mag, unitPos, result) {
-  const azimuth = theta + rotation;
-  Cartesian3_default.multiplyByScalar(eastVec, Math.cos(azimuth), rotAxis);
-  Cartesian3_default.multiplyByScalar(northVec, Math.sin(azimuth), tempVec);
-  Cartesian3_default.add(rotAxis, tempVec, rotAxis);
-  let cosThetaSquared = Math.cos(theta);
-  cosThetaSquared = cosThetaSquared * cosThetaSquared;
-  let sinThetaSquared = Math.sin(theta);
-  sinThetaSquared = sinThetaSquared * sinThetaSquared;
-  const radius = ab / Math.sqrt(bSqr * cosThetaSquared + aSqr * sinThetaSquared);
-  const angle = radius / mag;
-  Quaternion_default.fromAxisAngle(rotAxis, angle, unitQuat);
-  Matrix3_default.fromQuaternion(unitQuat, rotMtx);
-  Matrix3_default.multiplyByVector(rotMtx, unitPos, result);
-  Cartesian3_default.normalize(result, result);
-  Cartesian3_default.multiplyByScalar(result, mag, result);
-  return result;
-}
-var scratchCartesian1 = new Cartesian3_default();
-var scratchCartesian2 = new Cartesian3_default();
-var scratchCartesian3 = new Cartesian3_default();
-var scratchNormal = new Cartesian3_default();
-EllipseGeometryLibrary.raisePositionsToHeight = function(positions, options, extrude) {
-  const ellipsoid = options.ellipsoid;
-  const height = options.height;
-  const extrudedHeight = options.extrudedHeight;
-  const size = extrude ? positions.length / 3 * 2 : positions.length / 3;
-  const finalPositions = new Float64Array(size * 3);
-  const length = positions.length;
-  const bottomOffset = extrude ? length : 0;
-  for (let i = 0; i < length; i += 3) {
-    const i1 = i + 1;
-    const i2 = i + 2;
-    const position = Cartesian3_default.fromArray(positions, i, scratchCartesian1);
-    ellipsoid.scaleToGeodeticSurface(position, position);
-    const extrudedPosition = Cartesian3_default.clone(position, scratchCartesian2);
-    const normal = ellipsoid.geodeticSurfaceNormal(position, scratchNormal);
-    const scaledNormal = Cartesian3_default.multiplyByScalar(
-      normal,
-      height,
-      scratchCartesian3
-    );
-    Cartesian3_default.add(position, scaledNormal, position);
-    if (extrude) {
-      Cartesian3_default.multiplyByScalar(normal, extrudedHeight, scaledNormal);
-      Cartesian3_default.add(extrudedPosition, scaledNormal, extrudedPosition);
-      finalPositions[i + bottomOffset] = extrudedPosition.x;
-      finalPositions[i1 + bottomOffset] = extrudedPosition.y;
-      finalPositions[i2 + bottomOffset] = extrudedPosition.z;
-    }
-    finalPositions[i] = position.x;
-    finalPositions[i1] = position.y;
-    finalPositions[i2] = position.z;
-  }
-  return finalPositions;
-};
-var unitPosScratch = new Cartesian3_default();
-var eastVecScratch = new Cartesian3_default();
-var northVecScratch = new Cartesian3_default();
-EllipseGeometryLibrary.computeEllipsePositions = function(options, addFillPositions, addEdgePositions) {
-  const semiMinorAxis = options.semiMinorAxis;
-  const semiMajorAxis = options.semiMajorAxis;
-  const rotation = options.rotation;
-  const center = options.center;
-  const granularity = options.granularity * 8;
-  const aSqr = semiMinorAxis * semiMinorAxis;
-  const bSqr = semiMajorAxis * semiMajorAxis;
-  const ab = semiMajorAxis * semiMinorAxis;
-  const mag = Cartesian3_default.magnitude(center);
-  const unitPos = Cartesian3_default.normalize(center, unitPosScratch);
-  let eastVec = Cartesian3_default.cross(Cartesian3_default.UNIT_Z, center, eastVecScratch);
-  eastVec = Cartesian3_default.normalize(eastVec, eastVec);
-  const northVec = Cartesian3_default.cross(unitPos, eastVec, northVecScratch);
-  let numPts = 1 + Math.ceil(Math_default.PI_OVER_TWO / granularity);
-  const deltaTheta = Math_default.PI_OVER_TWO / (numPts - 1);
-  let theta = Math_default.PI_OVER_TWO - numPts * deltaTheta;
-  if (theta < 0) {
-    numPts -= Math.ceil(Math.abs(theta) / deltaTheta);
-  }
-  const size = 2 * (numPts * (numPts + 2));
-  const positions = addFillPositions ? new Array(size * 3) : void 0;
-  let positionIndex = 0;
-  let position = scratchCartesian1;
-  let reflectedPosition = scratchCartesian2;
-  const outerPositionsLength = numPts * 4 * 3;
-  let outerRightIndex = outerPositionsLength - 1;
-  let outerLeftIndex = 0;
-  const outerPositions = addEdgePositions ? new Array(outerPositionsLength) : void 0;
-  let i;
-  let j;
-  let numInterior;
-  let t;
-  let interiorPosition;
-  theta = Math_default.PI_OVER_TWO;
-  position = pointOnEllipsoid(
-    theta,
-    rotation,
-    northVec,
-    eastVec,
-    aSqr,
-    ab,
-    bSqr,
-    mag,
-    unitPos,
-    position
-  );
-  if (addFillPositions) {
-    positions[positionIndex++] = position.x;
-    positions[positionIndex++] = position.y;
-    positions[positionIndex++] = position.z;
-  }
-  if (addEdgePositions) {
-    outerPositions[outerRightIndex--] = position.z;
-    outerPositions[outerRightIndex--] = position.y;
-    outerPositions[outerRightIndex--] = position.x;
-  }
-  theta = Math_default.PI_OVER_TWO - deltaTheta;
-  for (i = 1; i < numPts + 1; ++i) {
-    position = pointOnEllipsoid(
-      theta,
-      rotation,
-      northVec,
-      eastVec,
-      aSqr,
-      ab,
-      bSqr,
-      mag,
-      unitPos,
-      position
-    );
-    reflectedPosition = pointOnEllipsoid(
-      Math.PI - theta,
-      rotation,
-      northVec,
-      eastVec,
-      aSqr,
-      ab,
-      bSqr,
-      mag,
-      unitPos,
-      reflectedPosition
-    );
-    if (addFillPositions) {
-      positions[positionIndex++] = position.x;
-      positions[positionIndex++] = position.y;
-      positions[positionIndex++] = position.z;
-      numInterior = 2 * i + 2;
-      for (j = 1; j < numInterior - 1; ++j) {
-        t = j / (numInterior - 1);
-        interiorPosition = Cartesian3_default.lerp(
-          position,
-          reflectedPosition,
-          t,
-          scratchCartesian3
-        );
-        positions[positionIndex++] = interiorPosition.x;
-        positions[positionIndex++] = interiorPosition.y;
-        positions[positionIndex++] = interiorPosition.z;
-      }
-      positions[positionIndex++] = reflectedPosition.x;
-      positions[positionIndex++] = reflectedPosition.y;
-      positions[positionIndex++] = reflectedPosition.z;
-    }
-    if (addEdgePositions) {
-      outerPositions[outerRightIndex--] = position.z;
-      outerPositions[outerRightIndex--] = position.y;
-      outerPositions[outerRightIndex--] = position.x;
-      outerPositions[outerLeftIndex++] = reflectedPosition.x;
-      outerPositions[outerLeftIndex++] = reflectedPosition.y;
-      outerPositions[outerLeftIndex++] = reflectedPosition.z;
-    }
-    theta = Math_default.PI_OVER_TWO - (i + 1) * deltaTheta;
-  }
-  for (i = numPts; i > 1; --i) {
-    theta = Math_default.PI_OVER_TWO - (i - 1) * deltaTheta;
-    position = pointOnEllipsoid(
-      -theta,
-      rotation,
-      northVec,
-      eastVec,
-      aSqr,
-      ab,
-      bSqr,
-      mag,
-      unitPos,
-      position
-    );
-    reflectedPosition = pointOnEllipsoid(
-      theta + Math.PI,
-      rotation,
-      northVec,
-      eastVec,
-      aSqr,
-      ab,
-      bSqr,
-      mag,
-      unitPos,
-      reflectedPosition
-    );
-    if (addFillPositions) {
-      positions[positionIndex++] = position.x;
-      positions[positionIndex++] = position.y;
-      positions[positionIndex++] = position.z;
-      numInterior = 2 * (i - 1) + 2;
-      for (j = 1; j < numInterior - 1; ++j) {
-        t = j / (numInterior - 1);
-        interiorPosition = Cartesian3_default.lerp(
-          position,
-          reflectedPosition,
-          t,
-          scratchCartesian3
-        );
-        positions[positionIndex++] = interiorPosition.x;
-        positions[positionIndex++] = interiorPosition.y;
-        positions[positionIndex++] = interiorPosition.z;
-      }
-      positions[positionIndex++] = reflectedPosition.x;
-      positions[positionIndex++] = reflectedPosition.y;
-      positions[positionIndex++] = reflectedPosition.z;
-    }
-    if (addEdgePositions) {
-      outerPositions[outerRightIndex--] = position.z;
-      outerPositions[outerRightIndex--] = position.y;
-      outerPositions[outerRightIndex--] = position.x;
-      outerPositions[outerLeftIndex++] = reflectedPosition.x;
-      outerPositions[outerLeftIndex++] = reflectedPosition.y;
-      outerPositions[outerLeftIndex++] = reflectedPosition.z;
-    }
-  }
-  theta = Math_default.PI_OVER_TWO;
-  position = pointOnEllipsoid(
-    -theta,
-    rotation,
-    northVec,
-    eastVec,
-    aSqr,
-    ab,
-    bSqr,
-    mag,
-    unitPos,
-    position
-  );
-  const r = {};
-  if (addFillPositions) {
-    positions[positionIndex++] = position.x;
-    positions[positionIndex++] = position.y;
-    positions[positionIndex++] = position.z;
-    r.positions = positions;
-    r.numPts = numPts;
-  }
-  if (addEdgePositions) {
-    outerPositions[outerRightIndex--] = position.z;
-    outerPositions[outerRightIndex--] = position.y;
-    outerPositions[outerRightIndex--] = position.x;
-    r.outerPositions = outerPositions;
-  }
-  return r;
-};
-var EllipseGeometryLibrary_default = EllipseGeometryLibrary;
-
-export {
-  EllipseGeometryLibrary_default
-};

package/dist/resources/Workers/chunk-2ZGOQXYU.js

@@ -1,171 +0,0 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.122
- *
- * 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-5PTXS2GO.js";
-import {
-  Cartesian3_default
-} from "./chunk-YFXQECWV.js";
-import {
-  Math_default
-} from "./chunk-XY4BATBS.js";
-import {
-  Check_default,
-  DeveloperError_default
-} from "./chunk-AD63PIY6.js";
-import {
-  defined_default
-} from "./chunk-E63IIM5T.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
-};