@vcmap/ui 5.0.0-rc.17 → 5.0.0-rc.20

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

@@ -1,25 +1,603 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./arrayRemoveDuplicates-f13aceb1","./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./PolylineVolumeGeometryLibrary-2d903430","./CorridorGeometryLibrary-850a6c35","./defaultValue-0c475b81","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./IndexDatatype-e713bfd2","./PolygonPipeline-eb527514","./_commonjsHelpers-bc29abbc","./combine-7533016d","./RuntimeError-5baf5c66","./WebGLConstants-5b50ced1","./EllipsoidTangentPlane-c080fd1b","./AxisAlignedBoundingBox-d0c22774","./IntersectionTests-eb4db8e0","./Plane-b0299683","./PolylinePipeline-0f23dd84","./EllipsoidGeodesic-8bfefbff","./EllipsoidRhumbLine-03528f73"],(function(e,t,i,r,o,n,s,a,l,d,u,p,f,c,h,y,b,g,m,A,_,E,C){"use strict";const G=new i.Cartesian3,T=new i.Cartesian3,P=new i.Cartesian3;function v(e,t){const d=[],p=e.positions,f=e.corners,c=e.endPositions,h=new l.GeometryAttributes;let y,b,g,m=0,A=0,_=0;for(b=0;b<p.length;b+=2)g=p[b].length-3,m+=g,_+=g/3*4,A+=p[b+1].length-3;for(m+=3,A+=3,b=0;b<f.length;b++){y=f[b];const e=f[b].leftPositions;s.defined(e)?(g=e.length,m+=g,_+=g/3*2):(g=f[b].rightPositions.length,A+=g,_+=g/3*2)}const E=s.defined(c);let C;E&&(C=c[0].length-3,m+=C,A+=C,C/=3,_+=4*C);const v=m+A,w=new Float64Array(v);let L,D,x,k,V,H,N=0,O=v-1;const I=C/2,S=u.IndexDatatype.createTypedArray(v/3,_+4);let B=0;if(S[B++]=N/3,S[B++]=(O-2)/3,E){d.push(N/3),H=G,V=T;const e=c[0];for(b=0;b<I;b++)H=i.Cartesian3.fromArray(e,3*(I-1-b),H),V=i.Cartesian3.fromArray(e,3*(I+b),V),n.CorridorGeometryLibrary.addAttribute(w,V,N),n.CorridorGeometryLibrary.addAttribute(w,H,void 0,O),D=N/3,k=D+1,L=(O-2)/3,x=L-1,S[B++]=L,S[B++]=x,S[B++]=D,S[B++]=k,N+=3,O-=3}let M=0,R=p[M++],U=p[M++];for(w.set(R,N),w.set(U,O-U.length+1),g=U.length-3,d.push(N/3,(O-2)/3),b=0;b<g;b+=3)D=N/3,k=D+1,L=(O-2)/3,x=L-1,S[B++]=L,S[B++]=x,S[B++]=D,S[B++]=k,N+=3,O-=3;for(b=0;b<f.length;b++){let e;y=f[b];const r=y.leftPositions,a=y.rightPositions;let l,u=P;if(s.defined(r)){for(O-=3,l=x,d.push(k),e=0;e<r.length/3;e++)u=i.Cartesian3.fromArray(r,3*e,u),S[B++]=l-e-1,S[B++]=l-e,n.CorridorGeometryLibrary.addAttribute(w,u,void 0,O),O-=3;d.push(l-Math.floor(r.length/6)),t===o.CornerType.BEVELED&&d.push((O-2)/3+1),N+=3}else{for(N+=3,l=k,d.push(x),e=0;e<a.length/3;e++)u=i.Cartesian3.fromArray(a,3*e,u),S[B++]=l+e,S[B++]=l+e+1,n.CorridorGeometryLibrary.addAttribute(w,u,N),N+=3;d.push(l+Math.floor(a.length/6)),t===o.CornerType.BEVELED&&d.push(N/3-1),O-=3}for(R=p[M++],U=p[M++],R.splice(0,3),U.splice(U.length-3,3),w.set(R,N),w.set(U,O-U.length+1),g=U.length-3,e=0;e<U.length;e+=3)k=N/3,D=k-1,x=(O-2)/3,L=x+1,S[B++]=L,S[B++]=x,S[B++]=D,S[B++]=k,N+=3,O-=3;N-=3,O+=3,d.push(N/3,(O-2)/3)}if(E){N+=3,O-=3,H=G,V=T;const e=c[1];for(b=0;b<I;b++)H=i.Cartesian3.fromArray(e,3*(C-b-1),H),V=i.Cartesian3.fromArray(e,3*b,V),n.CorridorGeometryLibrary.addAttribute(w,H,void 0,O),n.CorridorGeometryLibrary.addAttribute(w,V,N),k=N/3,D=k-1,x=(O-2)/3,L=x+1,S[B++]=L,S[B++]=x,S[B++]=D,S[B++]=k,N+=3,O-=3;d.push(N/3)}else d.push(N/3,(O-2)/3);return S[B++]=N/3,S[B++]=(O-2)/3,h.position=new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:w}),{attributes:h,indices:S,wallIndices:d}}function w(e){const t=(e=s.defaultValue(e,s.defaultValue.EMPTY_OBJECT)).positions,n=e.width,a=s.defaultValue(e.height,0),l=s.defaultValue(e.extrudedHeight,a);this._positions=t,this._ellipsoid=i.Ellipsoid.clone(s.defaultValue(e.ellipsoid,i.Ellipsoid.WGS84)),this._width=n,this._height=Math.max(a,l),this._extrudedHeight=Math.min(a,l),this._cornerType=s.defaultValue(e.cornerType,o.CornerType.ROUNDED),this._granularity=s.defaultValue(e.granularity,r.CesiumMath.RADIANS_PER_DEGREE),this._offsetAttribute=e.offsetAttribute,this._workerName="createCorridorOutlineGeometry",this.packedLength=1+t.length*i.Cartesian3.packedLength+i.Ellipsoid.packedLength+6}w.pack=function(e,t,r){r=s.defaultValue(r,0);const o=e._positions,n=o.length;t[r++]=n;for(let e=0;e<n;++e,r+=i.Cartesian3.packedLength)i.Cartesian3.pack(o[e],t,r);return i.Ellipsoid.pack(e._ellipsoid,t,r),r+=i.Ellipsoid.packedLength,t[r++]=e._width,t[r++]=e._height,t[r++]=e._extrudedHeight,t[r++]=e._cornerType,t[r++]=e._granularity,t[r]=s.defaultValue(e._offsetAttribute,-1),t};const L=i.Ellipsoid.clone(i.Ellipsoid.UNIT_SPHERE),D={positions:void 0,ellipsoid:L,width:void 0,height:void 0,extrudedHeight:void 0,cornerType:void 0,granularity:void 0,offsetAttribute:void 0};return w.unpack=function(e,t,r){t=s.defaultValue(t,0);const o=e[t++],n=new Array(o);for(let r=0;r<o;++r,t+=i.Cartesian3.packedLength)n[r]=i.Cartesian3.unpack(e,t);const a=i.Ellipsoid.unpack(e,t,L);t+=i.Ellipsoid.packedLength;const l=e[t++],d=e[t++],u=e[t++],p=e[t++],f=e[t++],c=e[t];return s.defined(r)?(r._positions=n,r._ellipsoid=i.Ellipsoid.clone(a,r._ellipsoid),r._width=l,r._height=d,r._extrudedHeight=u,r._cornerType=p,r._granularity=f,r._offsetAttribute=-1===c?void 0:c,r):(D.positions=n,D.width=l,D.height=d,D.extrudedHeight=u,D.cornerType=p,D.granularity=f,D.offsetAttribute=-1===c?void 0:c,new w(D))},w.createGeometry=function(o){let l=o._positions;const f=o._width,c=o._ellipsoid;l=function(e,t){for(let i=0;i<e.length;i++)e[i]=t.scaleToGeodeticSurface(e[i],e[i]);return e}(l,c);const h=e.arrayRemoveDuplicates(l,i.Cartesian3.equalsEpsilon);if(h.length<2||f<=0)return;const y=o._height,b=o._extrudedHeight,g=!r.CesiumMath.equalsEpsilon(y,b,0,r.CesiumMath.EPSILON2),m={ellipsoid:c,positions:h,width:f,cornerType:o._cornerType,granularity:o._granularity,saveAttributes:!1};let A;if(g)m.height=y,m.extrudedHeight=b,m.offsetAttribute=o._offsetAttribute,A=function(e){const t=e.ellipsoid,i=v(n.CorridorGeometryLibrary.computePositions(e),e.cornerType),o=i.wallIndices,l=e.height,f=e.extrudedHeight,c=i.attributes,h=i.indices;let y=c.position.values,b=y.length,g=new Float64Array(b);g.set(y);const m=new Float64Array(2*b);if(y=p.PolygonPipeline.scaleToGeodeticHeight(y,l,t),g=p.PolygonPipeline.scaleToGeodeticHeight(g,f,t),m.set(y),m.set(g,b),c.position.values=m,b/=3,s.defined(e.offsetAttribute)){let t=new Uint8Array(2*b);if(e.offsetAttribute===d.GeometryOffsetAttribute.TOP)t=t.fill(1,0,b);else{const i=e.offsetAttribute===d.GeometryOffsetAttribute.NONE?0:1;t=t.fill(i)}c.applyOffset=new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:t})}let A;const _=h.length,E=u.IndexDatatype.createTypedArray(m.length/3,2*(_+o.length));E.set(h);let C,G,T=_;for(A=0;A<_;A+=2){const e=h[A],t=h[A+1];E[T++]=e+b,E[T++]=t+b}for(A=0;A<o.length;A++)C=o[A],G=C+b,E[T++]=C,E[T++]=G;return{attributes:c,indices:E}}(m);else{if(A=v(n.CorridorGeometryLibrary.computePositions(m),m.cornerType),A.attributes.position.values=p.PolygonPipeline.scaleToGeodeticHeight(A.attributes.position.values,y,c),s.defined(o._offsetAttribute)){const e=A.attributes.position.values.length,t=o._offsetAttribute===d.GeometryOffsetAttribute.NONE?0:1,i=new Uint8Array(e/3).fill(t);A.attributes.applyOffset=new a.GeometryAttribute({componentDatatype:r.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:i})}}const _=A.attributes,E=t.BoundingSphere.fromVertices(_.position.values,void 0,3);return new a.Geometry({attributes:_,indices:A.indices,primitiveType:a.PrimitiveType.LINES,boundingSphere:E,offsetAttribute:o._offsetAttribute})},function(e,t){return s.defined(t)&&(e=w.unpack(e,t)),e._ellipsoid=i.Ellipsoid.clone(e._ellipsoid),w.createGeometry(e)}}));
+define(['./arrayRemoveDuplicates-c2038105', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './ComponentDatatype-f7b11d02', './PolylineVolumeGeometryLibrary-a510d657', './CorridorGeometryLibrary-0170e093', './defaultValue-0a909f67', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './PolygonPipeline-844aab0a', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './EllipsoidTangentPlane-214683dc', './AxisAlignedBoundingBox-ff186ccc', './IntersectionTests-f6e6bd8a', './Plane-900aa728', './PolylinePipeline-32f36d2a', './EllipsoidGeodesic-98c62a56', './EllipsoidRhumbLine-19756602'], (function (arrayRemoveDuplicates, Transforms, Matrix3, Check, ComponentDatatype, PolylineVolumeGeometryLibrary, CorridorGeometryLibrary, defaultValue, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype, Math$1, PolygonPipeline, Matrix2, RuntimeError, combine$1, WebGLConstants, EllipsoidTangentPlane, AxisAlignedBoundingBox, IntersectionTests, Plane, PolylinePipeline, EllipsoidGeodesic, EllipsoidRhumbLine) { 'use strict';
+
+  const cartesian1 = new Matrix3.Cartesian3();
+  const cartesian2 = new Matrix3.Cartesian3();
+  const cartesian3 = new Matrix3.Cartesian3();
+
+  function scaleToSurface(positions, ellipsoid) {
+    for (let i = 0; i < positions.length; i++) {
+      positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
+    }
+    return positions;
+  }
+
+  function combine(computedPositions, cornerType) {
+    const wallIndices = [];
+    const positions = computedPositions.positions;
+    const corners = computedPositions.corners;
+    const endPositions = computedPositions.endPositions;
+    const attributes = new GeometryAttributes.GeometryAttributes();
+    let corner;
+    let leftCount = 0;
+    let rightCount = 0;
+    let i;
+    let indicesLength = 0;
+    let length;
+    for (i = 0; i < positions.length; i += 2) {
+      length = positions[i].length - 3;
+      leftCount += length; //subtracting 3 to account for duplicate points at corners
+      indicesLength += (length / 3) * 4;
+      rightCount += positions[i + 1].length - 3;
+    }
+    leftCount += 3; //add back count for end positions
+    rightCount += 3;
+    for (i = 0; i < corners.length; i++) {
+      corner = corners[i];
+      const leftSide = corners[i].leftPositions;
+      if (defaultValue.defined(leftSide)) {
+        length = leftSide.length;
+        leftCount += length;
+        indicesLength += (length / 3) * 2;
+      } else {
+        length = corners[i].rightPositions.length;
+        rightCount += length;
+        indicesLength += (length / 3) * 2;
+      }
+    }
+
+    const addEndPositions = defaultValue.defined(endPositions);
+    let endPositionLength;
+    if (addEndPositions) {
+      endPositionLength = endPositions[0].length - 3;
+      leftCount += endPositionLength;
+      rightCount += endPositionLength;
+      endPositionLength /= 3;
+      indicesLength += endPositionLength * 4;
+    }
+    const size = leftCount + rightCount;
+    const finalPositions = new Float64Array(size);
+    let front = 0;
+    let back = size - 1;
+    let UL, LL, UR, LR;
+    let rightPos, leftPos;
+    const halfLength = endPositionLength / 2;
+
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(size / 3, indicesLength + 4);
+    let index = 0;
+
+    indices[index++] = front / 3;
+    indices[index++] = (back - 2) / 3;
+    if (addEndPositions) {
+      // add rounded end
+      wallIndices.push(front / 3);
+      leftPos = cartesian1;
+      rightPos = cartesian2;
+      const firstEndPositions = endPositions[0];
+      for (i = 0; i < halfLength; i++) {
+        leftPos = Matrix3.Cartesian3.fromArray(
+          firstEndPositions,
+          (halfLength - 1 - i) * 3,
+          leftPos
+        );
+        rightPos = Matrix3.Cartesian3.fromArray(
+          firstEndPositions,
+          (halfLength + i) * 3,
+          rightPos
+        );
+        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
+        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
+          finalPositions,
+          leftPos,
+          undefined,
+          back
+        );
+
+        LL = front / 3;
+        LR = LL + 1;
+        UL = (back - 2) / 3;
+        UR = UL - 1;
+        indices[index++] = UL;
+        indices[index++] = UR;
+        indices[index++] = LL;
+        indices[index++] = LR;
+
+        front += 3;
+        back -= 3;
+      }
+    }
+
+    let posIndex = 0;
+    let rightEdge = positions[posIndex++]; //add first two edges
+    let leftEdge = positions[posIndex++];
+    finalPositions.set(rightEdge, front);
+    finalPositions.set(leftEdge, back - leftEdge.length + 1);
+
+    length = leftEdge.length - 3;
+    wallIndices.push(front / 3, (back - 2) / 3);
+    for (i = 0; i < length; i += 3) {
+      LL = front / 3;
+      LR = LL + 1;
+      UL = (back - 2) / 3;
+      UR = UL - 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+
+      front += 3;
+      back -= 3;
+    }
+
+    for (i = 0; i < corners.length; i++) {
+      let j;
+      corner = corners[i];
+      const l = corner.leftPositions;
+      const r = corner.rightPositions;
+      let start;
+      let outsidePoint = cartesian3;
+      if (defaultValue.defined(l)) {
+        back -= 3;
+        start = UR;
+        wallIndices.push(LR);
+        for (j = 0; j < l.length / 3; j++) {
+          outsidePoint = Matrix3.Cartesian3.fromArray(l, j * 3, outsidePoint);
+          indices[index++] = start - j - 1;
+          indices[index++] = start - j;
+          CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
+            finalPositions,
+            outsidePoint,
+            undefined,
+            back
+          );
+          back -= 3;
+        }
+        wallIndices.push(start - Math.floor(l.length / 6));
+        if (cornerType === PolylineVolumeGeometryLibrary.CornerType.BEVELED) {
+          wallIndices.push((back - 2) / 3 + 1);
+        }
+        front += 3;
+      } else {
+        front += 3;
+        start = LR;
+        wallIndices.push(UR);
+        for (j = 0; j < r.length / 3; j++) {
+          outsidePoint = Matrix3.Cartesian3.fromArray(r, j * 3, outsidePoint);
+          indices[index++] = start + j;
+          indices[index++] = start + j + 1;
+          CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
+            finalPositions,
+            outsidePoint,
+            front
+          );
+          front += 3;
+        }
+        wallIndices.push(start + Math.floor(r.length / 6));
+        if (cornerType === PolylineVolumeGeometryLibrary.CornerType.BEVELED) {
+          wallIndices.push(front / 3 - 1);
+        }
+        back -= 3;
+      }
+      rightEdge = positions[posIndex++];
+      leftEdge = positions[posIndex++];
+      rightEdge.splice(0, 3); //remove duplicate points added by corner
+      leftEdge.splice(leftEdge.length - 3, 3);
+      finalPositions.set(rightEdge, front);
+      finalPositions.set(leftEdge, back - leftEdge.length + 1);
+      length = leftEdge.length - 3;
+
+      for (j = 0; j < leftEdge.length; j += 3) {
+        LR = front / 3;
+        LL = LR - 1;
+        UR = (back - 2) / 3;
+        UL = UR + 1;
+        indices[index++] = UL;
+        indices[index++] = UR;
+        indices[index++] = LL;
+        indices[index++] = LR;
+        front += 3;
+        back -= 3;
+      }
+      front -= 3;
+      back += 3;
+      wallIndices.push(front / 3, (back - 2) / 3);
+    }
+
+    if (addEndPositions) {
+      // add rounded end
+      front += 3;
+      back -= 3;
+      leftPos = cartesian1;
+      rightPos = cartesian2;
+      const lastEndPositions = endPositions[1];
+      for (i = 0; i < halfLength; i++) {
+        leftPos = Matrix3.Cartesian3.fromArray(
+          lastEndPositions,
+          (endPositionLength - i - 1) * 3,
+          leftPos
+        );
+        rightPos = Matrix3.Cartesian3.fromArray(lastEndPositions, i * 3, rightPos);
+        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
+          finalPositions,
+          leftPos,
+          undefined,
+          back
+        );
+        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
+
+        LR = front / 3;
+        LL = LR - 1;
+        UR = (back - 2) / 3;
+        UL = UR + 1;
+        indices[index++] = UL;
+        indices[index++] = UR;
+        indices[index++] = LL;
+        indices[index++] = LR;
+
+        front += 3;
+        back -= 3;
+      }
+
+      wallIndices.push(front / 3);
+    } else {
+      wallIndices.push(front / 3, (back - 2) / 3);
+    }
+    indices[index++] = front / 3;
+    indices[index++] = (back - 2) / 3;
+
+    attributes.position = new GeometryAttribute.GeometryAttribute({
+      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+      componentsPerAttribute: 3,
+      values: finalPositions,
+    });
+
+    return {
+      attributes: attributes,
+      indices: indices,
+      wallIndices: wallIndices,
+    };
+  }
+
+  function computePositionsExtruded(params) {
+    const ellipsoid = params.ellipsoid;
+    const computedPositions = CorridorGeometryLibrary.CorridorGeometryLibrary.computePositions(params);
+    const attr = combine(computedPositions, params.cornerType);
+    const wallIndices = attr.wallIndices;
+    const height = params.height;
+    const extrudedHeight = params.extrudedHeight;
+    const attributes = attr.attributes;
+    const indices = attr.indices;
+    let positions = attributes.position.values;
+    let length = positions.length;
+    let extrudedPositions = new Float64Array(length);
+    extrudedPositions.set(positions);
+    const newPositions = new Float64Array(length * 2);
+
+    positions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+      positions,
+      height,
+      ellipsoid
+    );
+    extrudedPositions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+      extrudedPositions,
+      extrudedHeight,
+      ellipsoid
+    );
+    newPositions.set(positions);
+    newPositions.set(extrudedPositions, length);
+    attributes.position.values = newPositions;
+
+    length /= 3;
+    if (defaultValue.defined(params.offsetAttribute)) {
+      let applyOffset = new Uint8Array(length * 2);
+      if (params.offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.TOP) {
+        applyOffset = applyOffset.fill(1, 0, length);
+      } else {
+        const applyOffsetValue =
+          params.offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE ? 0 : 1;
+        applyOffset = applyOffset.fill(applyOffsetValue);
+      }
+
+      attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset,
+      });
+    }
+
+    let i;
+    const iLength = indices.length;
+    const newIndices = IndexDatatype.IndexDatatype.createTypedArray(
+      newPositions.length / 3,
+      (iLength + wallIndices.length) * 2
+    );
+    newIndices.set(indices);
+    let index = iLength;
+    for (i = 0; i < iLength; i += 2) {
+      // bottom indices
+      const v0 = indices[i];
+      const v1 = indices[i + 1];
+      newIndices[index++] = v0 + length;
+      newIndices[index++] = v1 + length;
+    }
+
+    let UL, LL;
+    for (i = 0; i < wallIndices.length; i++) {
+      //wall indices
+      UL = wallIndices[i];
+      LL = UL + length;
+      newIndices[index++] = UL;
+      newIndices[index++] = LL;
+    }
+
+    return {
+      attributes: attributes,
+      indices: newIndices,
+    };
+  }
+
+  /**
+   * A description of a corridor outline.
+   *
+   * @alias CorridorOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of positions that define the center of the corridor outline.
+   * @param {Number} options.width The distance between the edges of the corridor outline.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
+   * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+   * @param {Number} [options.height=0] The distance in meters between the positions and the ellipsoid surface.
+   * @param {Number} [options.extrudedHeight] The distance in meters between the extruded face and the ellipsoid surface.
+   * @param {CornerType} [options.cornerType=CornerType.ROUNDED] Determines the style of the corners.
+   *
+   * @see CorridorOutlineGeometry.createGeometry
+   *
+   * @example
+   * const corridor = new Cesium.CorridorOutlineGeometry({
+   *   positions : Cesium.Cartesian3.fromDegreesArray([-72.0, 40.0, -70.0, 35.0]),
+   *   width : 100000
+   * });
+   */
+  function CorridorOutlineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const positions = options.positions;
+    const width = options.width;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("options.positions", positions);
+    Check.Check.typeOf.number("options.width", width);
+    //>>includeEnd('debug');
+
+    const height = defaultValue.defaultValue(options.height, 0.0);
+    const extrudedHeight = defaultValue.defaultValue(options.extrudedHeight, height);
+
+    this._positions = positions;
+    this._ellipsoid = Matrix3.Ellipsoid.clone(
+      defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84)
+    );
+    this._width = width;
+    this._height = Math.max(height, extrudedHeight);
+    this._extrudedHeight = Math.min(height, extrudedHeight);
+    this._cornerType = defaultValue.defaultValue(options.cornerType, PolylineVolumeGeometryLibrary.CornerType.ROUNDED);
+    this._granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math$1.CesiumMath.RADIANS_PER_DEGREE
+    );
+    this._offsetAttribute = options.offsetAttribute;
+    this._workerName = "createCorridorOutlineGeometry";
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength =
+      1 + positions.length * Matrix3.Cartesian3.packedLength + Matrix3.Ellipsoid.packedLength + 6;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {CorridorOutlineGeometry} value The value to pack.
+   * @param {Number[]} array The array to pack into.
+   * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {Number[]} The array that was packed into
+   */
+  CorridorOutlineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    Check.Check.typeOf.object("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const positions = value._positions;
+    const length = positions.length;
+    array[startingIndex++] = length;
+
+    for (let i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      Matrix3.Cartesian3.pack(positions[i], array, startingIndex);
+    }
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex++] = value._width;
+    array[startingIndex++] = value._height;
+    array[startingIndex++] = value._extrudedHeight;
+    array[startingIndex++] = value._cornerType;
+    array[startingIndex++] = value._granularity;
+    array[startingIndex] = defaultValue.defaultValue(value._offsetAttribute, -1);
+
+    return array;
+  };
+
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const scratchOptions = {
+    positions: undefined,
+    ellipsoid: scratchEllipsoid,
+    width: undefined,
+    height: undefined,
+    extrudedHeight: undefined,
+    cornerType: undefined,
+    granularity: undefined,
+    offsetAttribute: undefined,
+  };
+
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {Number[]} array The packed array.
+   * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {CorridorOutlineGeometry} [result] The object into which to store the result.
+   * @returns {CorridorOutlineGeometry} The modified result parameter or a new CorridorOutlineGeometry instance if one was not provided.
+   */
+  CorridorOutlineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const length = array[startingIndex++];
+    const positions = new Array(length);
+
+    for (let i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      positions[i] = Matrix3.Cartesian3.unpack(array, startingIndex);
+    }
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const width = array[startingIndex++];
+    const height = array[startingIndex++];
+    const extrudedHeight = array[startingIndex++];
+    const cornerType = array[startingIndex++];
+    const granularity = array[startingIndex++];
+    const offsetAttribute = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.positions = positions;
+      scratchOptions.width = width;
+      scratchOptions.height = height;
+      scratchOptions.extrudedHeight = extrudedHeight;
+      scratchOptions.cornerType = cornerType;
+      scratchOptions.granularity = granularity;
+      scratchOptions.offsetAttribute =
+        offsetAttribute === -1 ? undefined : offsetAttribute;
+      return new CorridorOutlineGeometry(scratchOptions);
+    }
+
+    result._positions = positions;
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._width = width;
+    result._height = height;
+    result._extrudedHeight = extrudedHeight;
+    result._cornerType = cornerType;
+    result._granularity = granularity;
+    result._offsetAttribute =
+      offsetAttribute === -1 ? undefined : offsetAttribute;
+
+    return result;
+  };
+
+  /**
+   * Computes the geometric representation of a corridor, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {CorridorOutlineGeometry} corridorOutlineGeometry A description of the corridor.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
+    let positions = corridorOutlineGeometry._positions;
+    const width = corridorOutlineGeometry._width;
+    const ellipsoid = corridorOutlineGeometry._ellipsoid;
+
+    positions = scaleToSurface(positions, ellipsoid);
+    const cleanPositions = arrayRemoveDuplicates.arrayRemoveDuplicates(
+      positions,
+      Matrix3.Cartesian3.equalsEpsilon
+    );
+
+    if (cleanPositions.length < 2 || width <= 0) {
+      return;
+    }
+
+    const height = corridorOutlineGeometry._height;
+    const extrudedHeight = corridorOutlineGeometry._extrudedHeight;
+    const extrude = !Math$1.CesiumMath.equalsEpsilon(
+      height,
+      extrudedHeight,
+      0,
+      Math$1.CesiumMath.EPSILON2
+    );
+
+    const params = {
+      ellipsoid: ellipsoid,
+      positions: cleanPositions,
+      width: width,
+      cornerType: corridorOutlineGeometry._cornerType,
+      granularity: corridorOutlineGeometry._granularity,
+      saveAttributes: false,
+    };
+    let attr;
+    if (extrude) {
+      params.height = height;
+      params.extrudedHeight = extrudedHeight;
+      params.offsetAttribute = corridorOutlineGeometry._offsetAttribute;
+      attr = computePositionsExtruded(params);
+    } else {
+      const computedPositions = CorridorGeometryLibrary.CorridorGeometryLibrary.computePositions(params);
+      attr = combine(computedPositions, params.cornerType);
+      attr.attributes.position.values = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
+        attr.attributes.position.values,
+        height,
+        ellipsoid
+      );
+
+      if (defaultValue.defined(corridorOutlineGeometry._offsetAttribute)) {
+        const length = attr.attributes.position.values.length;
+        const offsetValue =
+          corridorOutlineGeometry._offsetAttribute ===
+          GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
+            ? 0
+            : 1;
+        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+        attr.attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
+          componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+          componentsPerAttribute: 1,
+          values: applyOffset,
+        });
+      }
+    }
+    const attributes = attr.attributes;
+    const boundingSphere = Transforms.BoundingSphere.fromVertices(
+      attributes.position.values,
+      undefined,
+      3
+    );
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: attr.indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: boundingSphere,
+      offsetAttribute: corridorOutlineGeometry._offsetAttribute,
+    });
+  };
+
+  function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      corridorOutlineGeometry = CorridorOutlineGeometry.unpack(
+        corridorOutlineGeometry,
+        offset
+      );
+    }
+    corridorOutlineGeometry._ellipsoid = Matrix3.Ellipsoid.clone(
+      corridorOutlineGeometry._ellipsoid
+    );
+    return CorridorOutlineGeometry.createGeometry(corridorOutlineGeometry);
+  }
+
+  return createCorridorOutlineGeometry;
+
+}));

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

@@ -1,25 +1,12 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./CylinderGeometry-57a1051a","./defaultValue-0c475b81","./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./CylinderGeometryLibrary-62ce5a1f","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./IndexDatatype-e713bfd2","./VertexFormat-5ec0d9ff"],(function(e,t,r,n,a,o,f,c,i,b,d,m,y,u,s){"use strict";return function(r,n){return t.defined(n)&&(r=e.CylinderGeometry.unpack(r,n)),e.CylinderGeometry.createGeometry(r)}}));
+define(['./CylinderGeometry-7c5da648', './defaultValue-0a909f67', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './CylinderGeometryLibrary-372c07d8', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './IndexDatatype-a55ceaa1', './VertexFormat-6b480673'], (function (CylinderGeometry, defaultValue, Transforms, Matrix3, Check, Math, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, CylinderGeometryLibrary, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype, VertexFormat) { 'use strict';
+
+  function createCylinderGeometry(cylinderGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      cylinderGeometry = CylinderGeometry.CylinderGeometry.unpack(cylinderGeometry, offset);
+    }
+    return CylinderGeometry.CylinderGeometry.createGeometry(cylinderGeometry);
+  }
+
+  return createCylinderGeometry;
+
+}));