@gmgis/gm-sdk 1.12.5 → 2.0.2

package/dist/resources/Workers/createPolygonOutlineGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.122
+ * Version 1.132
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,511 +23,4 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  PolygonGeometryLibrary_default
-} from "./chunk-PGRPDNHG.js";
-import {
-  ArcType_default
-} from "./chunk-PRGYLLJT.js";
-import {
-  GeometryInstance_default
-} from "./chunk-7KTQP4VB.js";
-import {
-  GeometryPipeline_default
-} from "./chunk-GGZJN2TI.js";
-import "./chunk-NGPPMXRM.js";
-import "./chunk-C6YYBQXW.js";
-import {
-  GeometryOffsetAttribute_default
-} from "./chunk-I2ITFFPX.js";
-import {
-  EllipsoidTangentPlane_default
-} from "./chunk-CKY7HOHV.js";
-import "./chunk-S6MRMMQU.js";
-import {
-  PolygonPipeline_default,
-  WindingOrder_default
-} from "./chunk-SMDOP47J.js";
-import "./chunk-472HQ3EH.js";
-import "./chunk-E6V6SQZW.js";
-import "./chunk-3Q2L65QU.js";
-import "./chunk-2ZGOQXYU.js";
-import {
-  IndexDatatype_default
-} from "./chunk-26GA3JAM.js";
-import {
-  GeometryAttributes_default
-} from "./chunk-DI5NGJUP.js";
-import {
-  GeometryAttribute_default,
-  Geometry_default,
-  PrimitiveType_default
-} from "./chunk-GWCFU2SA.js";
-import {
-  BoundingSphere_default
-} from "./chunk-VJZB3WAV.js";
-import "./chunk-5PTXS2GO.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-K4GQUNB5.js";
-import {
-  Cartesian3_default,
-  Ellipsoid_default
-} from "./chunk-YFXQECWV.js";
-import {
-  Math_default
-} from "./chunk-XY4BATBS.js";
-import "./chunk-MXIZJAPH.js";
-import "./chunk-6CHGCNMW.js";
-import {
-  defaultValue_default
-} from "./chunk-7JO7GPJN.js";
-import {
-  Check_default,
-  DeveloperError_default
-} from "./chunk-AD63PIY6.js";
-import {
-  defined_default
-} from "./chunk-E63IIM5T.js";
-
-// packages/engine/Source/Core/PolygonOutlineGeometry.js
-var createGeometryFromPositionsPositions = [];
-var createGeometryFromPositionsSubdivided = [];
-function createGeometryFromPositions(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
-  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
-  const positions2D = tangentPlane.projectPointsOntoPlane(
-    positions,
-    createGeometryFromPositionsPositions
-  );
-  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
-  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
-    positions2D.reverse();
-    positions = positions.slice().reverse();
-  }
-  let subdividedPositions;
-  let i;
-  let length = positions.length;
-  let index = 0;
-  if (!perPositionHeight) {
-    let numVertices = 0;
-    if (arcType === ArcType_default.GEODESIC) {
-      for (i = 0; i < length; i++) {
-        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance
-        );
-      }
-    } else if (arcType === ArcType_default.RHUMB) {
-      for (i = 0; i < length; i++) {
-        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
-          ellipsoid,
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance
-        );
-      }
-    }
-    subdividedPositions = new Float64Array(numVertices * 3);
-    for (i = 0; i < length; i++) {
-      let tempPositions;
-      if (arcType === ArcType_default.GEODESIC) {
-        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance,
-          createGeometryFromPositionsSubdivided
-        );
-      } else if (arcType === ArcType_default.RHUMB) {
-        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
-          ellipsoid,
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance,
-          createGeometryFromPositionsSubdivided
-        );
-      }
-      const tempPositionsLength = tempPositions.length;
-      for (let j = 0; j < tempPositionsLength; ++j) {
-        subdividedPositions[index++] = tempPositions[j];
-      }
-    }
-  } else {
-    subdividedPositions = new Float64Array(length * 2 * 3);
-    for (i = 0; i < length; i++) {
-      const p0 = positions[i];
-      const p1 = positions[(i + 1) % length];
-      subdividedPositions[index++] = p0.x;
-      subdividedPositions[index++] = p0.y;
-      subdividedPositions[index++] = p0.z;
-      subdividedPositions[index++] = p1.x;
-      subdividedPositions[index++] = p1.y;
-      subdividedPositions[index++] = p1.z;
-    }
-  }
-  length = subdividedPositions.length / 3;
-  const indicesSize = length * 2;
-  const indices = IndexDatatype_default.createTypedArray(length, indicesSize);
-  index = 0;
-  for (i = 0; i < length - 1; i++) {
-    indices[index++] = i;
-    indices[index++] = i + 1;
-  }
-  indices[index++] = length - 1;
-  indices[index++] = 0;
-  return new GeometryInstance_default({
-    geometry: new Geometry_default({
-      attributes: new GeometryAttributes_default({
-        position: new GeometryAttribute_default({
-          componentDatatype: ComponentDatatype_default.DOUBLE,
-          componentsPerAttribute: 3,
-          values: subdividedPositions
-        })
-      }),
-      indices,
-      primitiveType: PrimitiveType_default.LINES
-    })
-  });
-}
-function createGeometryFromPositionsExtruded(ellipsoid, positions, minDistance, perPositionHeight, arcType) {
-  const tangentPlane = EllipsoidTangentPlane_default.fromPoints(positions, ellipsoid);
-  const positions2D = tangentPlane.projectPointsOntoPlane(
-    positions,
-    createGeometryFromPositionsPositions
-  );
-  const originalWindingOrder = PolygonPipeline_default.computeWindingOrder2D(positions2D);
-  if (originalWindingOrder === WindingOrder_default.CLOCKWISE) {
-    positions2D.reverse();
-    positions = positions.slice().reverse();
-  }
-  let subdividedPositions;
-  let i;
-  let length = positions.length;
-  const corners = new Array(length);
-  let index = 0;
-  if (!perPositionHeight) {
-    let numVertices = 0;
-    if (arcType === ArcType_default.GEODESIC) {
-      for (i = 0; i < length; i++) {
-        numVertices += PolygonGeometryLibrary_default.subdivideLineCount(
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance
-        );
-      }
-    } else if (arcType === ArcType_default.RHUMB) {
-      for (i = 0; i < length; i++) {
-        numVertices += PolygonGeometryLibrary_default.subdivideRhumbLineCount(
-          ellipsoid,
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance
-        );
-      }
-    }
-    subdividedPositions = new Float64Array(numVertices * 3 * 2);
-    for (i = 0; i < length; ++i) {
-      corners[i] = index / 3;
-      let tempPositions;
-      if (arcType === ArcType_default.GEODESIC) {
-        tempPositions = PolygonGeometryLibrary_default.subdivideLine(
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance,
-          createGeometryFromPositionsSubdivided
-        );
-      } else if (arcType === ArcType_default.RHUMB) {
-        tempPositions = PolygonGeometryLibrary_default.subdivideRhumbLine(
-          ellipsoid,
-          positions[i],
-          positions[(i + 1) % length],
-          minDistance,
-          createGeometryFromPositionsSubdivided
-        );
-      }
-      const tempPositionsLength = tempPositions.length;
-      for (let j = 0; j < tempPositionsLength; ++j) {
-        subdividedPositions[index++] = tempPositions[j];
-      }
-    }
-  } else {
-    subdividedPositions = new Float64Array(length * 2 * 3 * 2);
-    for (i = 0; i < length; ++i) {
-      corners[i] = index / 3;
-      const p0 = positions[i];
-      const p1 = positions[(i + 1) % length];
-      subdividedPositions[index++] = p0.x;
-      subdividedPositions[index++] = p0.y;
-      subdividedPositions[index++] = p0.z;
-      subdividedPositions[index++] = p1.x;
-      subdividedPositions[index++] = p1.y;
-      subdividedPositions[index++] = p1.z;
-    }
-  }
-  length = subdividedPositions.length / (3 * 2);
-  const cornersLength = corners.length;
-  const indicesSize = (length * 2 + cornersLength) * 2;
-  const indices = IndexDatatype_default.createTypedArray(
-    length + cornersLength,
-    indicesSize
-  );
-  index = 0;
-  for (i = 0; i < length; ++i) {
-    indices[index++] = i;
-    indices[index++] = (i + 1) % length;
-    indices[index++] = i + length;
-    indices[index++] = (i + 1) % length + length;
-  }
-  for (i = 0; i < cornersLength; i++) {
-    const corner = corners[i];
-    indices[index++] = corner;
-    indices[index++] = corner + length;
-  }
-  return new GeometryInstance_default({
-    geometry: new Geometry_default({
-      attributes: new GeometryAttributes_default({
-        position: new GeometryAttribute_default({
-          componentDatatype: ComponentDatatype_default.DOUBLE,
-          componentsPerAttribute: 3,
-          values: subdividedPositions
-        })
-      }),
-      indices,
-      primitiveType: PrimitiveType_default.LINES
-    })
-  });
-}
-function PolygonOutlineGeometry(options) {
-  Check_default.typeOf.object("options", options);
-  Check_default.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
-  if (options.perPositionHeight && defined_default(options.height)) {
-    throw new DeveloperError_default(
-      "Cannot use both options.perPositionHeight and options.height"
-    );
-  }
-  if (defined_default(options.arcType) && options.arcType !== ArcType_default.GEODESIC && options.arcType !== ArcType_default.RHUMB) {
-    throw new DeveloperError_default(
-      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
-    );
-  }
-  const polygonHierarchy = options.polygonHierarchy;
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.default);
-  const granularity = defaultValue_default(
-    options.granularity,
-    Math_default.RADIANS_PER_DEGREE
-  );
-  const perPositionHeight = defaultValue_default(options.perPositionHeight, false);
-  const perPositionHeightExtrude = perPositionHeight && defined_default(options.extrudedHeight);
-  const arcType = defaultValue_default(options.arcType, ArcType_default.GEODESIC);
-  let height = defaultValue_default(options.height, 0);
-  let extrudedHeight = defaultValue_default(options.extrudedHeight, height);
-  if (!perPositionHeightExtrude) {
-    const h = Math.max(height, extrudedHeight);
-    extrudedHeight = Math.min(height, extrudedHeight);
-    height = h;
-  }
-  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
-  this._granularity = granularity;
-  this._height = height;
-  this._extrudedHeight = extrudedHeight;
-  this._arcType = arcType;
-  this._polygonHierarchy = polygonHierarchy;
-  this._perPositionHeight = perPositionHeight;
-  this._perPositionHeightExtrude = perPositionHeightExtrude;
-  this._offsetAttribute = options.offsetAttribute;
-  this._workerName = "createPolygonOutlineGeometry";
-  this.packedLength = PolygonGeometryLibrary_default.computeHierarchyPackedLength(
-    polygonHierarchy,
-    Cartesian3_default
-  ) + Ellipsoid_default.packedLength + 8;
-}
-PolygonOutlineGeometry.pack = function(value, array, startingIndex) {
-  Check_default.typeOf.object("value", value);
-  Check_default.defined("array", array);
-  startingIndex = defaultValue_default(startingIndex, 0);
-  startingIndex = PolygonGeometryLibrary_default.packPolygonHierarchy(
-    value._polygonHierarchy,
-    array,
-    startingIndex,
-    Cartesian3_default
-  );
-  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
-  startingIndex += Ellipsoid_default.packedLength;
-  array[startingIndex++] = value._height;
-  array[startingIndex++] = value._extrudedHeight;
-  array[startingIndex++] = value._granularity;
-  array[startingIndex++] = value._perPositionHeightExtrude ? 1 : 0;
-  array[startingIndex++] = value._perPositionHeight ? 1 : 0;
-  array[startingIndex++] = value._arcType;
-  array[startingIndex++] = defaultValue_default(value._offsetAttribute, -1);
-  array[startingIndex] = value.packedLength;
-  return array;
-};
-var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
-var dummyOptions = {
-  polygonHierarchy: {}
-};
-PolygonOutlineGeometry.unpack = function(array, startingIndex, result) {
-  Check_default.defined("array", array);
-  startingIndex = defaultValue_default(startingIndex, 0);
-  const polygonHierarchy = PolygonGeometryLibrary_default.unpackPolygonHierarchy(
-    array,
-    startingIndex,
-    Cartesian3_default
-  );
-  startingIndex = polygonHierarchy.startingIndex;
-  delete polygonHierarchy.startingIndex;
-  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
-  startingIndex += Ellipsoid_default.packedLength;
-  const height = array[startingIndex++];
-  const extrudedHeight = array[startingIndex++];
-  const granularity = array[startingIndex++];
-  const perPositionHeightExtrude = array[startingIndex++] === 1;
-  const perPositionHeight = array[startingIndex++] === 1;
-  const arcType = array[startingIndex++];
-  const offsetAttribute = array[startingIndex++];
-  const packedLength = array[startingIndex];
-  if (!defined_default(result)) {
-    result = new PolygonOutlineGeometry(dummyOptions);
-  }
-  result._polygonHierarchy = polygonHierarchy;
-  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
-  result._height = height;
-  result._extrudedHeight = extrudedHeight;
-  result._granularity = granularity;
-  result._perPositionHeight = perPositionHeight;
-  result._perPositionHeightExtrude = perPositionHeightExtrude;
-  result._arcType = arcType;
-  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
-  result.packedLength = packedLength;
-  return result;
-};
-PolygonOutlineGeometry.fromPositions = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  Check_default.defined("options.positions", options.positions);
-  const newOptions = {
-    polygonHierarchy: {
-      positions: options.positions
-    },
-    height: options.height,
-    extrudedHeight: options.extrudedHeight,
-    ellipsoid: options.ellipsoid,
-    granularity: options.granularity,
-    perPositionHeight: options.perPositionHeight,
-    arcType: options.arcType,
-    offsetAttribute: options.offsetAttribute
-  };
-  return new PolygonOutlineGeometry(newOptions);
-};
-PolygonOutlineGeometry.createGeometry = function(polygonGeometry) {
-  const ellipsoid = polygonGeometry._ellipsoid;
-  const granularity = polygonGeometry._granularity;
-  const polygonHierarchy = polygonGeometry._polygonHierarchy;
-  const perPositionHeight = polygonGeometry._perPositionHeight;
-  const arcType = polygonGeometry._arcType;
-  const polygons = PolygonGeometryLibrary_default.polygonOutlinesFromHierarchy(
-    polygonHierarchy,
-    !perPositionHeight,
-    ellipsoid
-  );
-  if (polygons.length === 0) {
-    return void 0;
-  }
-  let geometryInstance;
-  const geometries = [];
-  const minDistance = Math_default.chordLength(
-    granularity,
-    ellipsoid.maximumRadius
-  );
-  const height = polygonGeometry._height;
-  const extrudedHeight = polygonGeometry._extrudedHeight;
-  const extrude = polygonGeometry._perPositionHeightExtrude || !Math_default.equalsEpsilon(height, extrudedHeight, 0, Math_default.EPSILON2);
-  let offsetValue;
-  let i;
-  if (extrude) {
-    for (i = 0; i < polygons.length; i++) {
-      geometryInstance = createGeometryFromPositionsExtruded(
-        ellipsoid,
-        polygons[i],
-        minDistance,
-        perPositionHeight,
-        arcType
-      );
-      geometryInstance.geometry = PolygonGeometryLibrary_default.scaleToGeodeticHeightExtruded(
-        geometryInstance.geometry,
-        height,
-        extrudedHeight,
-        ellipsoid,
-        perPositionHeight
-      );
-      if (defined_default(polygonGeometry._offsetAttribute)) {
-        const size = geometryInstance.geometry.attributes.position.values.length / 3;
-        let offsetAttribute = new Uint8Array(size);
-        if (polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.TOP) {
-          offsetAttribute = offsetAttribute.fill(1, 0, size / 2);
-        } else {
-          offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
-          offsetAttribute = offsetAttribute.fill(offsetValue);
-        }
-        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default({
-          componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
-          componentsPerAttribute: 1,
-          values: offsetAttribute
-        });
-      }
-      geometries.push(geometryInstance);
-    }
-  } else {
-    for (i = 0; i < polygons.length; i++) {
-      geometryInstance = createGeometryFromPositions(
-        ellipsoid,
-        polygons[i],
-        minDistance,
-        perPositionHeight,
-        arcType
-      );
-      geometryInstance.geometry.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
-        geometryInstance.geometry.attributes.position.values,
-        height,
-        ellipsoid,
-        !perPositionHeight
-      );
-      if (defined_default(polygonGeometry._offsetAttribute)) {
-        const length = geometryInstance.geometry.attributes.position.values.length;
-        offsetValue = polygonGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
-        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
-        geometryInstance.geometry.attributes.applyOffset = new GeometryAttribute_default({
-          componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
-          componentsPerAttribute: 1,
-          values: applyOffset
-        });
-      }
-      geometries.push(geometryInstance);
-    }
-  }
-  const geometry = GeometryPipeline_default.combineInstances(geometries)[0];
-  const boundingSphere = BoundingSphere_default.fromVertices(
-    geometry.attributes.position.values
-  );
-  return new Geometry_default({
-    attributes: geometry.attributes,
-    indices: geometry.indices,
-    primitiveType: geometry.primitiveType,
-    boundingSphere,
-    offsetAttribute: polygonGeometry._offsetAttribute
-  });
-};
-var PolygonOutlineGeometry_default = PolygonOutlineGeometry;
-
-// packages/engine/Source/Workers/createPolygonOutlineGeometry.js
-function createPolygonOutlineGeometry(polygonGeometry, offset) {
-  if (defined_default(offset)) {
-    polygonGeometry = PolygonOutlineGeometry_default.unpack(polygonGeometry, offset);
-  }
-  polygonGeometry._ellipsoid = Ellipsoid_default.clone(polygonGeometry._ellipsoid);
-  return PolygonOutlineGeometry_default.createGeometry(polygonGeometry);
-}
-var createPolygonOutlineGeometry_default = createPolygonOutlineGeometry;
-export {
-  createPolygonOutlineGeometry_default as default
-};
+import{a}from"./chunk-AJYK4IVJ.js";import{a as P}from"./chunk-J6UP6FLE.js";import{a as F}from"./chunk-D6AA5QVT.js";import{a as V}from"./chunk-VW6VD53G.js";import"./chunk-DEPHB2WM.js";import"./chunk-QOUAJ6TL.js";import{a as C}from"./chunk-GBYLG25F.js";import{a as M}from"./chunk-TCGIRNHN.js";import"./chunk-N4VJKXZS.js";import{a as W,b as D}from"./chunk-77IHZJJ3.js";import"./chunk-3W4GT7KQ.js";import"./chunk-G5AGHVVC.js";import"./chunk-DMEY62ID.js";import"./chunk-HTFSEEMT.js";import{a as G}from"./chunk-OFUUQVMR.js";import{a as B}from"./chunk-A56XVLQR.js";import{b as U,c as S,d as w}from"./chunk-RCV6KWXS.js";import{d as x}from"./chunk-4IW2T6GF.js";import"./chunk-PSPPBZWI.js";import{a as T}from"./chunk-AU7IKHOH.js";import{a as v,d as y,f as j}from"./chunk-64RSHJUE.js";import{a as L}from"./chunk-3SSKC3VN.js";import"./chunk-OSW76XDF.js";import"./chunk-ED5JPB3S.js";import{a as N,b as O}from"./chunk-LEYMRMBK.js";import{e as E}from"./chunk-VTAIKJXX.js";var Y=[],k=[];function K(e,t,r,b,l){let p=M.fromPoints(t,e).projectPointsOntoPlane(t,Y);D.computeWindingOrder2D(p)===W.CLOCKWISE&&(p.reverse(),t=t.slice().reverse());let n,i,o=t.length,c=0;if(b)for(n=new Float64Array(o*2*3),i=0;i<o;i++){let u=t[i],h=t[(i+1)%o];n[c++]=u.x,n[c++]=u.y,n[c++]=u.z,n[c++]=h.x,n[c++]=h.y,n[c++]=h.z}else{let u=0;if(l===P.GEODESIC)for(i=0;i<o;i++)u+=a.subdivideLineCount(t[i],t[(i+1)%o],r);else if(l===P.RHUMB)for(i=0;i<o;i++)u+=a.subdivideRhumbLineCount(e,t[i],t[(i+1)%o],r);for(n=new Float64Array(u*3),i=0;i<o;i++){let h;l===P.GEODESIC?h=a.subdivideLine(t[i],t[(i+1)%o],r,k):l===P.RHUMB&&(h=a.subdivideRhumbLine(e,t[i],t[(i+1)%o],r,k));let g=h.length;for(let d=0;d<g;++d)n[c++]=h[d]}}o=n.length/3;let f=o*2,m=G.createTypedArray(o,f);for(c=0,i=0;i<o-1;i++)m[c++]=i,m[c++]=i+1;return m[c++]=o-1,m[c++]=0,new F({geometry:new S({attributes:new B({position:new w({componentDatatype:T.DOUBLE,componentsPerAttribute:3,values:n})}),indices:m,primitiveType:U.LINES})})}function q(e,t,r,b,l){let p=M.fromPoints(t,e).projectPointsOntoPlane(t,Y);D.computeWindingOrder2D(p)===W.CLOCKWISE&&(p.reverse(),t=t.slice().reverse());let n,i,o=t.length,c=new Array(o),f=0;if(b)for(n=new Float64Array(o*2*3*2),i=0;i<o;++i){c[i]=f/3;let g=t[i],d=t[(i+1)%o];n[f++]=g.x,n[f++]=g.y,n[f++]=g.z,n[f++]=d.x,n[f++]=d.y,n[f++]=d.z}else{let g=0;if(l===P.GEODESIC)for(i=0;i<o;i++)g+=a.subdivideLineCount(t[i],t[(i+1)%o],r);else if(l===P.RHUMB)for(i=0;i<o;i++)g+=a.subdivideRhumbLineCount(e,t[i],t[(i+1)%o],r);for(n=new Float64Array(g*3*2),i=0;i<o;++i){c[i]=f/3;let d;l===P.GEODESIC?d=a.subdivideLine(t[i],t[(i+1)%o],r,k):l===P.RHUMB&&(d=a.subdivideRhumbLine(e,t[i],t[(i+1)%o],r,k));let _=d.length;for(let R=0;R<_;++R)n[f++]=d[R]}}o=n.length/6;let m=c.length,u=(o*2+m)*2,h=G.createTypedArray(o+m,u);for(f=0,i=0;i<o;++i)h[f++]=i,h[f++]=(i+1)%o,h[f++]=i+o,h[f++]=(i+1)%o+o;for(i=0;i<m;i++){let g=c[i];h[f++]=g,h[f++]=g+o}return new F({geometry:new S({attributes:new B({position:new w({componentDatatype:T.DOUBLE,componentsPerAttribute:3,values:n})}),indices:h,primitiveType:U.LINES})})}function A(e){if(O.typeOf.object("options",e),O.typeOf.object("options.polygonHierarchy",e.polygonHierarchy),e.perPositionHeight&&E(e.height))throw new N("Cannot use both options.perPositionHeight and options.height");if(E(e.arcType)&&e.arcType!==P.GEODESIC&&e.arcType!==P.RHUMB)throw new N("Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB.");let t=e.polygonHierarchy,r=e.ellipsoid??y.default,b=e.granularity??L.RADIANS_PER_DEGREE,l=e.perPositionHeight??!1,H=l&&E(e.extrudedHeight),p=e.arcType??P.GEODESIC,s=e.height??0,n=e.extrudedHeight??s;if(!H){let i=Math.max(s,n);n=Math.min(s,n),s=i}this._ellipsoid=y.clone(r),this._granularity=b,this._height=s,this._extrudedHeight=n,this._arcType=p,this._polygonHierarchy=t,this._perPositionHeight=l,this._perPositionHeightExtrude=H,this._offsetAttribute=e.offsetAttribute,this._workerName="createPolygonOutlineGeometry",this.packedLength=a.computeHierarchyPackedLength(t,v)+y.packedLength+8}A.pack=function(e,t,r){return O.typeOf.object("value",e),O.defined("array",t),r=r??0,r=a.packPolygonHierarchy(e._polygonHierarchy,t,r,v),y.pack(e._ellipsoid,t,r),r+=y.packedLength,t[r++]=e._height,t[r++]=e._extrudedHeight,t[r++]=e._granularity,t[r++]=e._perPositionHeightExtrude?1:0,t[r++]=e._perPositionHeight?1:0,t[r++]=e._arcType,t[r++]=e._offsetAttribute??-1,t[r]=e.packedLength,t};var J=y.clone(y.UNIT_SPHERE),Q={polygonHierarchy:{}};A.unpack=function(e,t,r){O.defined("array",e),t=t??0;let b=a.unpackPolygonHierarchy(e,t,v);t=b.startingIndex,delete b.startingIndex;let l=y.unpack(e,t,J);t+=y.packedLength;let H=e[t++],p=e[t++],s=e[t++],n=e[t++]===1,i=e[t++]===1,o=e[t++],c=e[t++],f=e[t];return E(r)||(r=new A(Q)),r._polygonHierarchy=b,r._ellipsoid=y.clone(l,r._ellipsoid),r._height=H,r._extrudedHeight=p,r._granularity=s,r._perPositionHeight=i,r._perPositionHeightExtrude=n,r._arcType=o,r._offsetAttribute=c===-1?void 0:c,r.packedLength=f,r};A.fromPositions=function(e){e=e??j.EMPTY_OBJECT,O.defined("options.positions",e.positions);let t={polygonHierarchy:{positions:e.positions},height:e.height,extrudedHeight:e.extrudedHeight,ellipsoid:e.ellipsoid,granularity:e.granularity,perPositionHeight:e.perPositionHeight,arcType:e.arcType,offsetAttribute:e.offsetAttribute};return new A(t)};A.createGeometry=function(e){let t=e._ellipsoid,r=e._granularity,b=e._polygonHierarchy,l=e._perPositionHeight,H=e._arcType,p=a.polygonOutlinesFromHierarchy(b,!l,t);if(p.length===0)return;let s,n=[],i=L.chordLength(r,t.maximumRadius),o=e._height,c=e._extrudedHeight,f=e._perPositionHeightExtrude||!L.equalsEpsilon(o,c,0,L.EPSILON2),m,u;if(f)for(u=0;u<p.length;u++){if(s=q(t,p[u],i,l,H),s.geometry=a.scaleToGeodeticHeightExtruded(s.geometry,o,c,t,l),E(e._offsetAttribute)){let d=s.geometry.attributes.position.values.length/3,_=new Uint8Array(d);e._offsetAttribute===C.TOP?_=_.fill(1,0,d/2):(m=e._offsetAttribute===C.NONE?0:1,_=_.fill(m)),s.geometry.attributes.applyOffset=new w({componentDatatype:T.UNSIGNED_BYTE,componentsPerAttribute:1,values:_})}n.push(s)}else for(u=0;u<p.length;u++){if(s=K(t,p[u],i,l,H),s.geometry.attributes.position.values=D.scaleToGeodeticHeight(s.geometry.attributes.position.values,o,t,!l),E(e._offsetAttribute)){let d=s.geometry.attributes.position.values.length;m=e._offsetAttribute===C.NONE?0:1;let _=new Uint8Array(d/3).fill(m);s.geometry.attributes.applyOffset=new w({componentDatatype:T.UNSIGNED_BYTE,componentsPerAttribute:1,values:_})}n.push(s)}let h=V.combineInstances(n)[0],g=x.fromVertices(h.attributes.position.values);return new S({attributes:h.attributes,indices:h.indices,primitiveType:h.primitiveType,boundingSphere:g,offsetAttribute:e._offsetAttribute})};var z=A;function X(e,t){return E(t)&&(e=z.unpack(e,t)),e._ellipsoid=y.clone(e._ellipsoid),z.createGeometry(e)}var Oe=X;export{Oe as default};