@vcmap/ui 5.0.0-rc.9 → 5.0.0

package/dist/assets/cesium/Workers/createPolygonOutlineGeometry.js

@@ -1 +1,542 @@
-define(["./defaultValue-81eec7ed","./Matrix2-47e98d76","./ArcType-fc72c06c","./GeometryOffsetAttribute-8c5e10db","./Transforms-c8cb8f43","./RuntimeError-8952249c","./ComponentDatatype-a15c9a19","./EllipsoidTangentPlane-a01286f6","./GeometryAttribute-89a520b9","./GeometryAttributes-32b29525","./GeometryInstance-4fbf16ba","./GeometryPipeline-309fad76","./IndexDatatype-f1dcdf35","./PolygonGeometryLibrary-0b29eb16","./PolygonPipeline-a934c4dd","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./WebGLConstants-508b9636","./AxisAlignedBoundingBox-a655a4bc","./IntersectionTests-58aa8f80","./Plane-3f01019d","./AttributeCompression-80665726","./EncodedCartesian3-d9f5c4a4","./arrayRemoveDuplicates-dc2f4046","./EllipsoidRhumbLine-6145377b"],(function(e,t,i,o,r,n,a,l,s,y,u,p,d,c,f,g,m,h,b,P,E,A,_,G,L){"use strict";const H=[],T=[];function v(e,t,o,r,n){const p=l.EllipsoidTangentPlane.fromPoints(t,e).projectPointsOntoPlane(t,H);let g,m;f.PolygonPipeline.computeWindingOrder2D(p)===f.WindingOrder.CLOCKWISE&&(p.reverse(),t=t.slice().reverse());let h=t.length,b=0;if(r)for(g=new Float64Array(2*h*3),m=0;m<h;m++){const e=t[m],i=t[(m+1)%h];g[b++]=e.x,g[b++]=e.y,g[b++]=e.z,g[b++]=i.x,g[b++]=i.y,g[b++]=i.z}else{let r=0;if(n===i.ArcType.GEODESIC)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideLineCount(t[m],t[(m+1)%h],o);else if(n===i.ArcType.RHUMB)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideRhumbLineCount(e,t[m],t[(m+1)%h],o);for(g=new Float64Array(3*r),m=0;m<h;m++){let r;n===i.ArcType.GEODESIC?r=c.PolygonGeometryLibrary.subdivideLine(t[m],t[(m+1)%h],o,T):n===i.ArcType.RHUMB&&(r=c.PolygonGeometryLibrary.subdivideRhumbLine(e,t[m],t[(m+1)%h],o,T));const a=r.length;for(let e=0;e<a;++e)g[b++]=r[e]}}h=g.length/3;const P=2*h,E=d.IndexDatatype.createTypedArray(h,P);for(b=0,m=0;m<h-1;m++)E[b++]=m,E[b++]=m+1;return E[b++]=h-1,E[b++]=0,new u.GeometryInstance({geometry:new s.Geometry({attributes:new y.GeometryAttributes({position:new s.GeometryAttribute({componentDatatype:a.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:g})}),indices:E,primitiveType:s.PrimitiveType.LINES})})}function O(e,t,o,r,n){const p=l.EllipsoidTangentPlane.fromPoints(t,e).projectPointsOntoPlane(t,H);let g,m;f.PolygonPipeline.computeWindingOrder2D(p)===f.WindingOrder.CLOCKWISE&&(p.reverse(),t=t.slice().reverse());let h=t.length;const b=new Array(h);let P=0;if(r)for(g=new Float64Array(2*h*3*2),m=0;m<h;++m){b[m]=P/3;const e=t[m],i=t[(m+1)%h];g[P++]=e.x,g[P++]=e.y,g[P++]=e.z,g[P++]=i.x,g[P++]=i.y,g[P++]=i.z}else{let r=0;if(n===i.ArcType.GEODESIC)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideLineCount(t[m],t[(m+1)%h],o);else if(n===i.ArcType.RHUMB)for(m=0;m<h;m++)r+=c.PolygonGeometryLibrary.subdivideRhumbLineCount(e,t[m],t[(m+1)%h],o);for(g=new Float64Array(3*r*2),m=0;m<h;++m){let r;b[m]=P/3,n===i.ArcType.GEODESIC?r=c.PolygonGeometryLibrary.subdivideLine(t[m],t[(m+1)%h],o,T):n===i.ArcType.RHUMB&&(r=c.PolygonGeometryLibrary.subdivideRhumbLine(e,t[m],t[(m+1)%h],o,T));const a=r.length;for(let e=0;e<a;++e)g[P++]=r[e]}}h=g.length/6;const E=b.length,A=2*(2*h+E),_=d.IndexDatatype.createTypedArray(h+E,A);for(P=0,m=0;m<h;++m)_[P++]=m,_[P++]=(m+1)%h,_[P++]=m+h,_[P++]=(m+1)%h+h;for(m=0;m<E;m++){const e=b[m];_[P++]=e,_[P++]=e+h}return new u.GeometryInstance({geometry:new s.Geometry({attributes:new y.GeometryAttributes({position:new s.GeometryAttribute({componentDatatype:a.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:g})}),indices:_,primitiveType:s.PrimitiveType.LINES})})}function x(o){const r=o.polygonHierarchy,n=e.defaultValue(o.ellipsoid,t.Ellipsoid.WGS84),l=e.defaultValue(o.granularity,a.CesiumMath.RADIANS_PER_DEGREE),s=e.defaultValue(o.perPositionHeight,!1),y=s&&e.defined(o.extrudedHeight),u=e.defaultValue(o.arcType,i.ArcType.GEODESIC);let p=e.defaultValue(o.height,0),d=e.defaultValue(o.extrudedHeight,p);if(!y){const e=Math.max(p,d);d=Math.min(p,d),p=e}this._ellipsoid=t.Ellipsoid.clone(n),this._granularity=l,this._height=p,this._extrudedHeight=d,this._arcType=u,this._polygonHierarchy=r,this._perPositionHeight=s,this._perPositionHeightExtrude=y,this._offsetAttribute=o.offsetAttribute,this._workerName="createPolygonOutlineGeometry",this.packedLength=c.PolygonGeometryLibrary.computeHierarchyPackedLength(r)+t.Ellipsoid.packedLength+8}x.pack=function(i,o,r){return r=e.defaultValue(r,0),r=c.PolygonGeometryLibrary.packPolygonHierarchy(i._polygonHierarchy,o,r),t.Ellipsoid.pack(i._ellipsoid,o,r),r+=t.Ellipsoid.packedLength,o[r++]=i._height,o[r++]=i._extrudedHeight,o[r++]=i._granularity,o[r++]=i._perPositionHeightExtrude?1:0,o[r++]=i._perPositionHeight?1:0,o[r++]=i._arcType,o[r++]=e.defaultValue(i._offsetAttribute,-1),o[r]=i.packedLength,o};const C=t.Ellipsoid.clone(t.Ellipsoid.UNIT_SPHERE),D={polygonHierarchy:{}};return x.unpack=function(i,o,r){o=e.defaultValue(o,0);const n=c.PolygonGeometryLibrary.unpackPolygonHierarchy(i,o);o=n.startingIndex,delete n.startingIndex;const a=t.Ellipsoid.unpack(i,o,C);o+=t.Ellipsoid.packedLength;const l=i[o++],s=i[o++],y=i[o++],u=1===i[o++],p=1===i[o++],d=i[o++],f=i[o++],g=i[o];return e.defined(r)||(r=new x(D)),r._polygonHierarchy=n,r._ellipsoid=t.Ellipsoid.clone(a,r._ellipsoid),r._height=l,r._extrudedHeight=s,r._granularity=y,r._perPositionHeight=p,r._perPositionHeightExtrude=u,r._arcType=d,r._offsetAttribute=-1===f?void 0:f,r.packedLength=g,r},x.fromPositions=function(t){return new x({polygonHierarchy:{positions:(t=e.defaultValue(t,e.defaultValue.EMPTY_OBJECT)).positions},height:t.height,extrudedHeight:t.extrudedHeight,ellipsoid:t.ellipsoid,granularity:t.granularity,perPositionHeight:t.perPositionHeight,arcType:t.arcType,offsetAttribute:t.offsetAttribute})},x.createGeometry=function(t){const i=t._ellipsoid,n=t._granularity,l=t._polygonHierarchy,y=t._perPositionHeight,u=t._arcType,d=c.PolygonGeometryLibrary.polygonOutlinesFromHierarchy(l,!y,i);if(0===d.length)return;let g;const m=[],h=a.CesiumMath.chordLength(n,i.maximumRadius),b=t._height,P=t._extrudedHeight;let E,A;if(t._perPositionHeightExtrude||!a.CesiumMath.equalsEpsilon(b,P,0,a.CesiumMath.EPSILON2))for(A=0;A<d.length;A++){if(g=O(i,d[A],h,y,u),g.geometry=c.PolygonGeometryLibrary.scaleToGeodeticHeightExtruded(g.geometry,b,P,i,y),e.defined(t._offsetAttribute)){const e=g.geometry.attributes.position.values.length/3;let i=new Uint8Array(e);t._offsetAttribute===o.GeometryOffsetAttribute.TOP?i=o.arrayFill(i,1,0,e/2):(E=t._offsetAttribute===o.GeometryOffsetAttribute.NONE?0:1,i=o.arrayFill(i,E)),g.geometry.attributes.applyOffset=new s.GeometryAttribute({componentDatatype:a.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}m.push(g)}else for(A=0;A<d.length;A++){if(g=v(i,d[A],h,y,u),g.geometry.attributes.position.values=f.PolygonPipeline.scaleToGeodeticHeight(g.geometry.attributes.position.values,b,i,!y),e.defined(t._offsetAttribute)){const e=g.geometry.attributes.position.values.length,i=new Uint8Array(e/3);E=t._offsetAttribute===o.GeometryOffsetAttribute.NONE?0:1,o.arrayFill(i,E),g.geometry.attributes.applyOffset=new s.GeometryAttribute({componentDatatype:a.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}m.push(g)}const _=p.GeometryPipeline.combineInstances(m)[0],G=r.BoundingSphere.fromVertices(_.attributes.position.values);return new s.Geometry({attributes:_.attributes,indices:_.indices,primitiveType:_.primitiveType,boundingSphere:G,offsetAttribute:t._offsetAttribute})},function(i,o){return e.defined(o)&&(i=x.unpack(i,o)),i._ellipsoid=t.Ellipsoid.clone(i._ellipsoid),x.createGeometry(i)}}));
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109.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 {
+  PolygonGeometryLibrary_default
+} from "./chunk-KTJSNCK4.js";
+import {
+  ArcType_default
+} from "./chunk-CCFQRR6D.js";
+import {
+  GeometryInstance_default
+} from "./chunk-227AJNOA.js";
+import {
+  GeometryPipeline_default
+} from "./chunk-XTY7B2N6.js";
+import "./chunk-O5AMBQ36.js";
+import "./chunk-QT3MPEMI.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-MPAZH4BF.js";
+import {
+  EllipsoidTangentPlane_default
+} from "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import {
+  PolygonPipeline_default,
+  WindingOrder_default
+} from "./chunk-J3JY6I2C.js";
+import "./chunk-3W63OHNJ.js";
+import "./chunk-K36FEYS7.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-EW2GWJYB.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-X4SU25DT.js";
+import {
+  BoundingSphere_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import "./chunk-DUHWWBQQ.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import {
+  defaultValue_default
+} from "./chunk-WXTV4ATB.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.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.WGS84);
+  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
+};