@vcmap/ui 5.0.0-rc.9 → 5.0.0

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

@@ -1 +1,1262 @@
-define(["./GeometryOffsetAttribute-8c5e10db","./arrayRemoveDuplicates-dc2f4046","./Transforms-c8cb8f43","./Matrix2-47e98d76","./RuntimeError-8952249c","./ComponentDatatype-a15c9a19","./PolylineVolumeGeometryLibrary-67d12fff","./CorridorGeometryLibrary-ddc027d3","./defaultValue-81eec7ed","./GeometryAttribute-89a520b9","./GeometryAttributes-32b29525","./IndexDatatype-f1dcdf35","./PolygonPipeline-a934c4dd","./VertexFormat-a0b706b0","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./WebGLConstants-508b9636","./EllipsoidTangentPlane-a01286f6","./AxisAlignedBoundingBox-a655a4bc","./IntersectionTests-58aa8f80","./Plane-3f01019d","./PolylinePipeline-8095c9bc","./EllipsoidGeodesic-19e75e11","./EllipsoidRhumbLine-6145377b"],(function(t,e,r,a,i,o,n,s,l,d,u,c,m,y,f,p,g,h,b,C,A,_,w,v){"use strict";const T=new a.Cartesian3,G=new a.Cartesian3,E=new a.Cartesian3,V=new a.Cartesian3,x=new a.Cartesian3,F=new a.Cartesian3,L=new a.Cartesian3,P=new a.Cartesian3;function N(t,e){for(let r=0;r<t.length;r++)t[r]=e.scaleToGeodeticSurface(t[r],t[r]);return t}function D(t,e,r,i,o,n){const l=t.normals,d=t.tangents,u=t.bitangents,c=a.Cartesian3.normalize(a.Cartesian3.cross(r,e,L),L);n.normal&&s.CorridorGeometryLibrary.addAttribute(l,e,i,o),n.tangent&&s.CorridorGeometryLibrary.addAttribute(d,c,i,o),n.bitangent&&s.CorridorGeometryLibrary.addAttribute(u,r,i,o)}function M(t,e,r){const i=t.positions,n=t.corners,m=t.endPositions,y=t.lefts,f=t.normals,p=new u.GeometryAttributes;let g,h,b,C=0,A=0,_=0;for(h=0;h<i.length;h+=2)b=i[h].length-3,C+=b,_+=2*b,A+=i[h+1].length-3;for(C+=3,A+=3,h=0;h<n.length;h++){g=n[h];const t=n[h].leftPositions;l.defined(t)?(b=t.length,C+=b,_+=b):(b=n[h].rightPositions.length,A+=b,_+=b)}const w=l.defined(m);let v;w&&(v=m[0].length-3,C+=v,A+=v,v/=3,_+=6*v);const x=C+A,N=new Float64Array(x),M={normals:e.normal?new Float32Array(x):void 0,tangents:e.tangent?new Float32Array(x):void 0,bitangents:e.bitangent?new Float32Array(x):void 0};let O,I,S,R,k,H,z=0,B=x-1,U=T,Y=G;const W=v/2,q=c.IndexDatatype.createTypedArray(x/3,_);let j=0;if(w){H=E,k=V;const t=m[0];for(U=a.Cartesian3.fromArray(f,0,U),Y=a.Cartesian3.fromArray(y,0,Y),h=0;h<W;h++)H=a.Cartesian3.fromArray(t,3*(W-1-h),H),k=a.Cartesian3.fromArray(t,3*(W+h),k),s.CorridorGeometryLibrary.addAttribute(N,k,z),s.CorridorGeometryLibrary.addAttribute(N,H,void 0,B),D(M,U,Y,z,B,e),I=z/3,R=I+1,O=(B-2)/3,S=O-1,q[j++]=O,q[j++]=I,q[j++]=S,q[j++]=S,q[j++]=I,q[j++]=R,z+=3,B-=3}let J,K,Q=0,X=0,Z=i[Q++],$=i[Q++];for(N.set(Z,z),N.set($,B-$.length+1),Y=a.Cartesian3.fromArray(y,X,Y),b=$.length-3,h=0;h<b;h+=3)J=r.geodeticSurfaceNormal(a.Cartesian3.fromArray(Z,h,L),L),K=r.geodeticSurfaceNormal(a.Cartesian3.fromArray($,b-h,P),P),U=a.Cartesian3.normalize(a.Cartesian3.add(J,K,U),U),D(M,U,Y,z,B,e),I=z/3,R=I+1,O=(B-2)/3,S=O-1,q[j++]=O,q[j++]=I,q[j++]=S,q[j++]=S,q[j++]=I,q[j++]=R,z+=3,B-=3;for(J=r.geodeticSurfaceNormal(a.Cartesian3.fromArray(Z,b,L),L),K=r.geodeticSurfaceNormal(a.Cartesian3.fromArray($,b,P),P),U=a.Cartesian3.normalize(a.Cartesian3.add(J,K,U),U),X+=3,h=0;h<n.length;h++){let t;g=n[h];const o=g.leftPositions,d=g.rightPositions;let u,c,m=F,p=E,C=V;if(U=a.Cartesian3.fromArray(f,X,U),l.defined(o)){for(D(M,U,Y,void 0,B,e),B-=3,u=R,c=S,t=0;t<o.length/3;t++)m=a.Cartesian3.fromArray(o,3*t,m),q[j++]=u,q[j++]=c-t-1,q[j++]=c-t,s.CorridorGeometryLibrary.addAttribute(N,m,void 0,B),p=a.Cartesian3.fromArray(N,3*(c-t-1),p),C=a.Cartesian3.fromArray(N,3*u,C),Y=a.Cartesian3.normalize(a.Cartesian3.subtract(p,C,Y),Y),D(M,U,Y,void 0,B,e),B-=3;m=a.Cartesian3.fromArray(N,3*u,m),p=a.Cartesian3.subtract(a.Cartesian3.fromArray(N,3*c,p),m,p),C=a.Cartesian3.subtract(a.Cartesian3.fromArray(N,3*(c-t),C),m,C),Y=a.Cartesian3.normalize(a.Cartesian3.add(p,C,Y),Y),D(M,U,Y,z,void 0,e),z+=3}else{for(D(M,U,Y,z,void 0,e),z+=3,u=S,c=R,t=0;t<d.length/3;t++)m=a.Cartesian3.fromArray(d,3*t,m),q[j++]=u,q[j++]=c+t,q[j++]=c+t+1,s.CorridorGeometryLibrary.addAttribute(N,m,z),p=a.Cartesian3.fromArray(N,3*u,p),C=a.Cartesian3.fromArray(N,3*(c+t),C),Y=a.Cartesian3.normalize(a.Cartesian3.subtract(p,C,Y),Y),D(M,U,Y,z,void 0,e),z+=3;m=a.Cartesian3.fromArray(N,3*u,m),p=a.Cartesian3.subtract(a.Cartesian3.fromArray(N,3*(c+t),p),m,p),C=a.Cartesian3.subtract(a.Cartesian3.fromArray(N,3*c,C),m,C),Y=a.Cartesian3.normalize(a.Cartesian3.negate(a.Cartesian3.add(C,p,Y),Y),Y),D(M,U,Y,void 0,B,e),B-=3}for(Z=i[Q++],$=i[Q++],Z.splice(0,3),$.splice($.length-3,3),N.set(Z,z),N.set($,B-$.length+1),b=$.length-3,X+=3,Y=a.Cartesian3.fromArray(y,X,Y),t=0;t<$.length;t+=3)J=r.geodeticSurfaceNormal(a.Cartesian3.fromArray(Z,t,L),L),K=r.geodeticSurfaceNormal(a.Cartesian3.fromArray($,b-t,P),P),U=a.Cartesian3.normalize(a.Cartesian3.add(J,K,U),U),D(M,U,Y,z,B,e),R=z/3,I=R-1,S=(B-2)/3,O=S+1,q[j++]=O,q[j++]=I,q[j++]=S,q[j++]=S,q[j++]=I,q[j++]=R,z+=3,B-=3;z-=3,B+=3}if(U=a.Cartesian3.fromArray(f,f.length-3,U),D(M,U,Y,z,B,e),w){z+=3,B-=3,H=E,k=V;const t=m[1];for(h=0;h<W;h++)H=a.Cartesian3.fromArray(t,3*(v-h-1),H),k=a.Cartesian3.fromArray(t,3*h,k),s.CorridorGeometryLibrary.addAttribute(N,H,void 0,B),s.CorridorGeometryLibrary.addAttribute(N,k,z),D(M,U,Y,z,B,e),R=z/3,I=R-1,S=(B-2)/3,O=S+1,q[j++]=O,q[j++]=I,q[j++]=S,q[j++]=S,q[j++]=I,q[j++]=R,z+=3,B-=3}if(p.position=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:N}),e.st){const t=new Float32Array(x/3*2);let e,r,a=0;if(w){C/=3,A/=3;const i=Math.PI/(v+1);let n;r=1/(C-v+1),e=1/(A-v+1);const s=v/2;for(h=s+1;h<v+1;h++)n=o.CesiumMath.PI_OVER_TWO+i*h,t[a++]=e*(1+Math.cos(n)),t[a++]=.5*(1+Math.sin(n));for(h=1;h<A-v+1;h++)t[a++]=h*e,t[a++]=0;for(h=v;h>s;h--)n=o.CesiumMath.PI_OVER_TWO-h*i,t[a++]=1-e*(1+Math.cos(n)),t[a++]=.5*(1+Math.sin(n));for(h=s;h>0;h--)n=o.CesiumMath.PI_OVER_TWO-i*h,t[a++]=1-r*(1+Math.cos(n)),t[a++]=.5*(1+Math.sin(n));for(h=C-v;h>0;h--)t[a++]=h*r,t[a++]=1;for(h=1;h<s+1;h++)n=o.CesiumMath.PI_OVER_TWO+i*h,t[a++]=r*(1+Math.cos(n)),t[a++]=.5*(1+Math.sin(n))}else{for(C/=3,A/=3,r=1/(C-1),e=1/(A-1),h=0;h<A;h++)t[a++]=h*e,t[a++]=0;for(h=C;h>0;h--)t[a++]=(h-1)*r,t[a++]=1}p.st=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.FLOAT,componentsPerAttribute:2,values:t})}return e.normal&&(p.normal=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:M.normals})),e.tangent&&(p.tangent=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:M.tangents})),e.bitangent&&(p.bitangent=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:M.bitangents})),{attributes:p,indices:q}}function O(t,e,r){r[e++]=t[0],r[e++]=t[1],r[e++]=t[2];for(let a=3;a<t.length;a+=3){const i=t[a],o=t[a+1],n=t[a+2];r[e++]=i,r[e++]=o,r[e++]=n,r[e++]=i,r[e++]=o,r[e++]=n}return r[e++]=t[0],r[e++]=t[1],r[e++]=t[2],r}function I(e,r){const i=new y.VertexFormat({position:r.position,normal:r.normal||r.bitangent||e.shadowVolume,tangent:r.tangent,bitangent:r.normal||r.bitangent,st:r.st}),n=e.ellipsoid,u=M(s.CorridorGeometryLibrary.computePositions(e),i,n),f=e.height,p=e.extrudedHeight;let g=u.attributes;const h=u.indices;let b=g.position.values,C=b.length;const A=new Float64Array(6*C);let _=new Float64Array(C);_.set(b);let w,v=new Float64Array(4*C);b=m.PolygonPipeline.scaleToGeodeticHeight(b,f,n),v=O(b,0,v),_=m.PolygonPipeline.scaleToGeodeticHeight(_,p,n),v=O(_,2*C,v),A.set(b),A.set(_,C),A.set(v,2*C),g.position.values=A,g=function(t,e){if(!(e.normal||e.tangent||e.bitangent||e.st))return t;const r=t.position.values;let i,o;(e.normal||e.bitangent)&&(i=t.normal.values,o=t.bitangent.values);const n=t.position.values.length/18,l=3*n,d=2*n,u=2*l;let c;if(e.normal||e.bitangent||e.tangent){const n=e.normal?new Float32Array(6*l):void 0,d=e.tangent?new Float32Array(6*l):void 0,m=e.bitangent?new Float32Array(6*l):void 0;let y=T,f=G,p=E,g=V,h=x,b=F,C=u;for(c=0;c<l;c+=3){const t=C+u;y=a.Cartesian3.fromArray(r,c,y),f=a.Cartesian3.fromArray(r,c+l,f),p=a.Cartesian3.fromArray(r,(c+3)%l,p),f=a.Cartesian3.subtract(f,y,f),p=a.Cartesian3.subtract(p,y,p),g=a.Cartesian3.normalize(a.Cartesian3.cross(f,p,g),g),e.normal&&(s.CorridorGeometryLibrary.addAttribute(n,g,t),s.CorridorGeometryLibrary.addAttribute(n,g,t+3),s.CorridorGeometryLibrary.addAttribute(n,g,C),s.CorridorGeometryLibrary.addAttribute(n,g,C+3)),(e.tangent||e.bitangent)&&(b=a.Cartesian3.fromArray(i,c,b),e.bitangent&&(s.CorridorGeometryLibrary.addAttribute(m,b,t),s.CorridorGeometryLibrary.addAttribute(m,b,t+3),s.CorridorGeometryLibrary.addAttribute(m,b,C),s.CorridorGeometryLibrary.addAttribute(m,b,C+3)),e.tangent&&(h=a.Cartesian3.normalize(a.Cartesian3.cross(b,g,h),h),s.CorridorGeometryLibrary.addAttribute(d,h,t),s.CorridorGeometryLibrary.addAttribute(d,h,t+3),s.CorridorGeometryLibrary.addAttribute(d,h,C),s.CorridorGeometryLibrary.addAttribute(d,h,C+3))),C+=6}if(e.normal){for(n.set(i),c=0;c<l;c+=3)n[c+l]=-i[c],n[c+l+1]=-i[c+1],n[c+l+2]=-i[c+2];t.normal.values=n}else t.normal=void 0;if(e.bitangent?(m.set(o),m.set(o,l),t.bitangent.values=m):t.bitangent=void 0,e.tangent){const e=t.tangent.values;d.set(e),d.set(e,l),t.tangent.values=d}}if(e.st){const e=t.st.values,r=new Float32Array(6*d);r.set(e),r.set(e,d);let a=2*d;for(let t=0;t<2;t++){for(r[a++]=e[0],r[a++]=e[1],c=2;c<d;c+=2){const t=e[c],i=e[c+1];r[a++]=t,r[a++]=i,r[a++]=t,r[a++]=i}r[a++]=e[0],r[a++]=e[1]}t.st.values=r}return t}(g,r);const L=C/3;if(e.shadowVolume){const t=g.normal.values;C=t.length;let e=new Float32Array(6*C);for(w=0;w<C;w++)t[w]=-t[w];e.set(t,C),e=O(t,4*C,e),g.extrudeDirection=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:e}),r.normal||(g.normal=void 0)}if(l.defined(e.offsetAttribute)){let r=new Uint8Array(6*L);if(e.offsetAttribute===t.GeometryOffsetAttribute.TOP)r=t.arrayFill(r,1,0,L),r=t.arrayFill(r,1,2*L,4*L);else{const a=e.offsetAttribute===t.GeometryOffsetAttribute.NONE?0:1;r=t.arrayFill(r,a)}g.applyOffset=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:r})}const P=h.length,N=L+L,D=c.IndexDatatype.createTypedArray(A.length/3,2*P+3*N);D.set(h);let I,S,R,k,H=P;for(w=0;w<P;w+=3){const t=h[w],e=h[w+1],r=h[w+2];D[H++]=r+L,D[H++]=e+L,D[H++]=t+L}for(w=0;w<N;w+=2)I=w+N,S=I+N,R=I+1,k=S+1,D[H++]=I,D[H++]=S,D[H++]=R,D[H++]=R,D[H++]=S,D[H++]=k;return{attributes:g,indices:D}}const S=new a.Cartesian3,R=new a.Cartesian3,k=new a.Cartographic;function H(t,e,r,i,o,n){const s=a.Cartesian3.subtract(e,t,S);a.Cartesian3.normalize(s,s);const l=r.geodeticSurfaceNormal(t,R),d=a.Cartesian3.cross(s,l,S);a.Cartesian3.multiplyByScalar(d,i,d);let u=o.latitude,c=o.longitude,m=n.latitude,y=n.longitude;a.Cartesian3.add(t,d,R),r.cartesianToCartographic(R,k);let f=k.latitude,p=k.longitude;u=Math.min(u,f),c=Math.min(c,p),m=Math.max(m,f),y=Math.max(y,p),a.Cartesian3.subtract(t,d,R),r.cartesianToCartographic(R,k),f=k.latitude,p=k.longitude,u=Math.min(u,f),c=Math.min(c,p),m=Math.max(m,f),y=Math.max(y,p),o.latitude=u,o.longitude=c,n.latitude=m,n.longitude=y}const z=new a.Cartesian3,B=new a.Cartesian3,U=new a.Cartographic,Y=new a.Cartographic;function W(t,r,i,o,s){t=N(t,r);const d=e.arrayRemoveDuplicates(t,a.Cartesian3.equalsEpsilon),u=d.length;if(u<2||i<=0)return new a.Rectangle;const c=.5*i;let m,y;if(U.latitude=Number.POSITIVE_INFINITY,U.longitude=Number.POSITIVE_INFINITY,Y.latitude=Number.NEGATIVE_INFINITY,Y.longitude=Number.NEGATIVE_INFINITY,o===n.CornerType.ROUNDED){const t=d[0];a.Cartesian3.subtract(t,d[1],z),a.Cartesian3.normalize(z,z),a.Cartesian3.multiplyByScalar(z,c,z),a.Cartesian3.add(t,z,B),r.cartesianToCartographic(B,k),m=k.latitude,y=k.longitude,U.latitude=Math.min(U.latitude,m),U.longitude=Math.min(U.longitude,y),Y.latitude=Math.max(Y.latitude,m),Y.longitude=Math.max(Y.longitude,y)}for(let t=0;t<u-1;++t)H(d[t],d[t+1],r,c,U,Y);const f=d[u-1];a.Cartesian3.subtract(f,d[u-2],z),a.Cartesian3.normalize(z,z),a.Cartesian3.multiplyByScalar(z,c,z),a.Cartesian3.add(f,z,B),H(f,B,r,c,U,Y),o===n.CornerType.ROUNDED&&(r.cartesianToCartographic(B,k),m=k.latitude,y=k.longitude,U.latitude=Math.min(U.latitude,m),U.longitude=Math.min(U.longitude,y),Y.latitude=Math.max(Y.latitude,m),Y.longitude=Math.max(Y.longitude,y));const p=l.defined(s)?s:new a.Rectangle;return p.north=Y.latitude,p.south=U.latitude,p.east=Y.longitude,p.west=U.longitude,p}function q(t){const e=(t=l.defaultValue(t,l.defaultValue.EMPTY_OBJECT)).positions,r=t.width,i=l.defaultValue(t.height,0),s=l.defaultValue(t.extrudedHeight,i);this._positions=e,this._ellipsoid=a.Ellipsoid.clone(l.defaultValue(t.ellipsoid,a.Ellipsoid.WGS84)),this._vertexFormat=y.VertexFormat.clone(l.defaultValue(t.vertexFormat,y.VertexFormat.DEFAULT)),this._width=r,this._height=Math.max(i,s),this._extrudedHeight=Math.min(i,s),this._cornerType=l.defaultValue(t.cornerType,n.CornerType.ROUNDED),this._granularity=l.defaultValue(t.granularity,o.CesiumMath.RADIANS_PER_DEGREE),this._shadowVolume=l.defaultValue(t.shadowVolume,!1),this._workerName="createCorridorGeometry",this._offsetAttribute=t.offsetAttribute,this._rectangle=void 0,this.packedLength=1+e.length*a.Cartesian3.packedLength+a.Ellipsoid.packedLength+y.VertexFormat.packedLength+7}q.pack=function(t,e,r){r=l.defaultValue(r,0);const i=t._positions,o=i.length;e[r++]=o;for(let t=0;t<o;++t,r+=a.Cartesian3.packedLength)a.Cartesian3.pack(i[t],e,r);return a.Ellipsoid.pack(t._ellipsoid,e,r),r+=a.Ellipsoid.packedLength,y.VertexFormat.pack(t._vertexFormat,e,r),r+=y.VertexFormat.packedLength,e[r++]=t._width,e[r++]=t._height,e[r++]=t._extrudedHeight,e[r++]=t._cornerType,e[r++]=t._granularity,e[r++]=t._shadowVolume?1:0,e[r]=l.defaultValue(t._offsetAttribute,-1),e};const j=a.Ellipsoid.clone(a.Ellipsoid.UNIT_SPHERE),J=new y.VertexFormat,K={positions:void 0,ellipsoid:j,vertexFormat:J,width:void 0,height:void 0,extrudedHeight:void 0,cornerType:void 0,granularity:void 0,shadowVolume:void 0,offsetAttribute:void 0};return q.unpack=function(t,e,r){e=l.defaultValue(e,0);const i=t[e++],o=new Array(i);for(let r=0;r<i;++r,e+=a.Cartesian3.packedLength)o[r]=a.Cartesian3.unpack(t,e);const n=a.Ellipsoid.unpack(t,e,j);e+=a.Ellipsoid.packedLength;const s=y.VertexFormat.unpack(t,e,J);e+=y.VertexFormat.packedLength;const d=t[e++],u=t[e++],c=t[e++],m=t[e++],f=t[e++],p=1===t[e++],g=t[e];return l.defined(r)?(r._positions=o,r._ellipsoid=a.Ellipsoid.clone(n,r._ellipsoid),r._vertexFormat=y.VertexFormat.clone(s,r._vertexFormat),r._width=d,r._height=u,r._extrudedHeight=c,r._cornerType=m,r._granularity=f,r._shadowVolume=p,r._offsetAttribute=-1===g?void 0:g,r):(K.positions=o,K.width=d,K.height=u,K.extrudedHeight=c,K.cornerType=m,K.granularity=f,K.shadowVolume=p,K.offsetAttribute=-1===g?void 0:g,new q(K))},q.computeRectangle=function(t,e){const r=(t=l.defaultValue(t,l.defaultValue.EMPTY_OBJECT)).positions,i=t.width;return W(r,l.defaultValue(t.ellipsoid,a.Ellipsoid.WGS84),i,l.defaultValue(t.cornerType,n.CornerType.ROUNDED),e)},q.createGeometry=function(i){let n=i._positions;const u=i._width,c=i._ellipsoid;n=N(n,c);const y=e.arrayRemoveDuplicates(n,a.Cartesian3.equalsEpsilon);if(y.length<2||u<=0)return;const f=i._height,p=i._extrudedHeight,g=!o.CesiumMath.equalsEpsilon(f,p,0,o.CesiumMath.EPSILON2),h=i._vertexFormat,b={ellipsoid:c,positions:y,width:u,cornerType:i._cornerType,granularity:i._granularity,saveAttributes:!0};let C;if(g)b.height=f,b.extrudedHeight=p,b.shadowVolume=i._shadowVolume,b.offsetAttribute=i._offsetAttribute,C=I(b,h);else{if(C=M(s.CorridorGeometryLibrary.computePositions(b),h,c),C.attributes.position.values=m.PolygonPipeline.scaleToGeodeticHeight(C.attributes.position.values,f,c),l.defined(i._offsetAttribute)){const e=i._offsetAttribute===t.GeometryOffsetAttribute.NONE?0:1,r=C.attributes.position.values.length,a=new Uint8Array(r/3);t.arrayFill(a,e),C.attributes.applyOffset=new d.GeometryAttribute({componentDatatype:o.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:1,values:a})}}const A=C.attributes,_=r.BoundingSphere.fromVertices(A.position.values,void 0,3);return h.position||(C.attributes.position.values=void 0),new d.Geometry({attributes:A,indices:C.indices,primitiveType:d.PrimitiveType.TRIANGLES,boundingSphere:_,offsetAttribute:i._offsetAttribute})},q.createShadowVolume=function(t,e,r){const a=t._granularity,i=t._ellipsoid,o=e(a,i),n=r(a,i);return new q({positions:t._positions,width:t._width,cornerType:t._cornerType,ellipsoid:i,granularity:a,extrudedHeight:o,height:n,vertexFormat:y.VertexFormat.POSITION_ONLY,shadowVolume:!0})},Object.defineProperties(q.prototype,{rectangle:{get:function(){return l.defined(this._rectangle)||(this._rectangle=W(this._positions,this._ellipsoid,this._width,this._cornerType)),this._rectangle}},textureCoordinateRotationPoints:{get:function(){return[0,0,0,1,1,0]}}}),function(t,e){return l.defined(e)&&(t=q.unpack(t,e)),t._ellipsoid=a.Ellipsoid.clone(t._ellipsoid),q.createGeometry(t)}}));
+/**
+ * @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 {
+  CorridorGeometryLibrary_default
+} from "./chunk-C3SXRKRW.js";
+import {
+  CornerType_default
+} from "./chunk-V3NGATMV.js";
+import "./chunk-GLZBE3ML.js";
+import "./chunk-AFFLIKOH.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-MPAZH4BF.js";
+import {
+  VertexFormat_default
+} from "./chunk-QMEMZIJI.js";
+import "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-J3JY6I2C.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./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 {
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Cartographic_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
+} from "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Core/CorridorGeometry.js
+var cartesian1 = new Cartesian3_default();
+var cartesian2 = new Cartesian3_default();
+var cartesian3 = new Cartesian3_default();
+var cartesian4 = new Cartesian3_default();
+var cartesian5 = new Cartesian3_default();
+var cartesian6 = new Cartesian3_default();
+var scratch1 = new Cartesian3_default();
+var scratch2 = new Cartesian3_default();
+function scaleToSurface(positions, ellipsoid) {
+  for (let i = 0; i < positions.length; i++) {
+    positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
+  }
+  return positions;
+}
+function addNormals(attr, normal, left, front, back, vertexFormat) {
+  const normals = attr.normals;
+  const tangents = attr.tangents;
+  const bitangents = attr.bitangents;
+  const forward = Cartesian3_default.normalize(
+    Cartesian3_default.cross(left, normal, scratch1),
+    scratch1
+  );
+  if (vertexFormat.normal) {
+    CorridorGeometryLibrary_default.addAttribute(normals, normal, front, back);
+  }
+  if (vertexFormat.tangent) {
+    CorridorGeometryLibrary_default.addAttribute(tangents, forward, front, back);
+  }
+  if (vertexFormat.bitangent) {
+    CorridorGeometryLibrary_default.addAttribute(bitangents, left, front, back);
+  }
+}
+function combine(computedPositions, vertexFormat, ellipsoid) {
+  const positions = computedPositions.positions;
+  const corners = computedPositions.corners;
+  const endPositions = computedPositions.endPositions;
+  const computedLefts = computedPositions.lefts;
+  const computedNormals = computedPositions.normals;
+  const attributes = new GeometryAttributes_default();
+  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;
+    indicesLength += length * 2;
+    rightCount += positions[i + 1].length - 3;
+  }
+  leftCount += 3;
+  rightCount += 3;
+  for (i = 0; i < corners.length; i++) {
+    corner = corners[i];
+    const leftSide = corners[i].leftPositions;
+    if (defined_default(leftSide)) {
+      length = leftSide.length;
+      leftCount += length;
+      indicesLength += length;
+    } else {
+      length = corners[i].rightPositions.length;
+      rightCount += length;
+      indicesLength += length;
+    }
+  }
+  const addEndPositions = defined_default(endPositions);
+  let endPositionLength;
+  if (addEndPositions) {
+    endPositionLength = endPositions[0].length - 3;
+    leftCount += endPositionLength;
+    rightCount += endPositionLength;
+    endPositionLength /= 3;
+    indicesLength += endPositionLength * 6;
+  }
+  const size = leftCount + rightCount;
+  const finalPositions = new Float64Array(size);
+  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
+  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
+  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
+  const attr = {
+    normals,
+    tangents,
+    bitangents
+  };
+  let front = 0;
+  let back = size - 1;
+  let UL, LL, UR, LR;
+  let normal = cartesian1;
+  let left = cartesian2;
+  let rightPos, leftPos;
+  const halfLength = endPositionLength / 2;
+  const indices = IndexDatatype_default.createTypedArray(size / 3, indicesLength);
+  let index = 0;
+  if (addEndPositions) {
+    leftPos = cartesian3;
+    rightPos = cartesian4;
+    const firstEndPositions = endPositions[0];
+    normal = Cartesian3_default.fromArray(computedNormals, 0, normal);
+    left = Cartesian3_default.fromArray(computedLefts, 0, left);
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength - 1 - i) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength + i) * 3,
+        rightPos
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LL = front / 3;
+      LR = LL + 1;
+      UL = (back - 2) / 3;
+      UR = UL - 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+  }
+  let posIndex = 0;
+  let compIndex = 0;
+  let rightEdge = positions[posIndex++];
+  let leftEdge = positions[posIndex++];
+  finalPositions.set(rightEdge, front);
+  finalPositions.set(leftEdge, back - leftEdge.length + 1);
+  left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
+  let rightNormal;
+  let leftNormal;
+  length = leftEdge.length - 3;
+  for (i = 0; i < length; i += 3) {
+    rightNormal = ellipsoid.geodeticSurfaceNormal(
+      Cartesian3_default.fromArray(rightEdge, i, scratch1),
+      scratch1
+    );
+    leftNormal = ellipsoid.geodeticSurfaceNormal(
+      Cartesian3_default.fromArray(leftEdge, length - i, scratch2),
+      scratch2
+    );
+    normal = Cartesian3_default.normalize(
+      Cartesian3_default.add(rightNormal, leftNormal, normal),
+      normal
+    );
+    addNormals(attr, normal, left, front, back, vertexFormat);
+    LL = front / 3;
+    LR = LL + 1;
+    UL = (back - 2) / 3;
+    UR = UL - 1;
+    indices[index++] = UL;
+    indices[index++] = LL;
+    indices[index++] = UR;
+    indices[index++] = UR;
+    indices[index++] = LL;
+    indices[index++] = LR;
+    front += 3;
+    back -= 3;
+  }
+  rightNormal = ellipsoid.geodeticSurfaceNormal(
+    Cartesian3_default.fromArray(rightEdge, length, scratch1),
+    scratch1
+  );
+  leftNormal = ellipsoid.geodeticSurfaceNormal(
+    Cartesian3_default.fromArray(leftEdge, length, scratch2),
+    scratch2
+  );
+  normal = Cartesian3_default.normalize(
+    Cartesian3_default.add(rightNormal, leftNormal, normal),
+    normal
+  );
+  compIndex += 3;
+  for (i = 0; i < corners.length; i++) {
+    let j;
+    corner = corners[i];
+    const l = corner.leftPositions;
+    const r = corner.rightPositions;
+    let pivot;
+    let start;
+    let outsidePoint = cartesian6;
+    let previousPoint = cartesian3;
+    let nextPoint = cartesian4;
+    normal = Cartesian3_default.fromArray(computedNormals, compIndex, normal);
+    if (defined_default(l)) {
+      addNormals(attr, normal, left, void 0, back, vertexFormat);
+      back -= 3;
+      pivot = LR;
+      start = UR;
+      for (j = 0; j < l.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(l, j * 3, outsidePoint);
+        indices[index++] = pivot;
+        indices[index++] = start - j - 1;
+        indices[index++] = start - j;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          void 0,
+          back
+        );
+        previousPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          (start - j - 1) * 3,
+          previousPoint
+        );
+        nextPoint = Cartesian3_default.fromArray(finalPositions, pivot * 3, nextPoint);
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.subtract(previousPoint, nextPoint, left),
+          left
+        );
+        addNormals(attr, normal, left, void 0, back, vertexFormat);
+        back -= 3;
+      }
+      outsidePoint = Cartesian3_default.fromArray(
+        finalPositions,
+        pivot * 3,
+        outsidePoint
+      );
+      previousPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, start * 3, previousPoint),
+        outsidePoint,
+        previousPoint
+      );
+      nextPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, (start - j) * 3, nextPoint),
+        outsidePoint,
+        nextPoint
+      );
+      left = Cartesian3_default.normalize(
+        Cartesian3_default.add(previousPoint, nextPoint, left),
+        left
+      );
+      addNormals(attr, normal, left, front, void 0, vertexFormat);
+      front += 3;
+    } else {
+      addNormals(attr, normal, left, front, void 0, vertexFormat);
+      front += 3;
+      pivot = UR;
+      start = LR;
+      for (j = 0; j < r.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(r, j * 3, outsidePoint);
+        indices[index++] = pivot;
+        indices[index++] = start + j;
+        indices[index++] = start + j + 1;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          front
+        );
+        previousPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          pivot * 3,
+          previousPoint
+        );
+        nextPoint = Cartesian3_default.fromArray(
+          finalPositions,
+          (start + j) * 3,
+          nextPoint
+        );
+        left = Cartesian3_default.normalize(
+          Cartesian3_default.subtract(previousPoint, nextPoint, left),
+          left
+        );
+        addNormals(attr, normal, left, front, void 0, vertexFormat);
+        front += 3;
+      }
+      outsidePoint = Cartesian3_default.fromArray(
+        finalPositions,
+        pivot * 3,
+        outsidePoint
+      );
+      previousPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, (start + j) * 3, previousPoint),
+        outsidePoint,
+        previousPoint
+      );
+      nextPoint = Cartesian3_default.subtract(
+        Cartesian3_default.fromArray(finalPositions, start * 3, nextPoint),
+        outsidePoint,
+        nextPoint
+      );
+      left = Cartesian3_default.normalize(
+        Cartesian3_default.negate(Cartesian3_default.add(nextPoint, previousPoint, left), left),
+        left
+      );
+      addNormals(attr, normal, left, void 0, back, vertexFormat);
+      back -= 3;
+    }
+    rightEdge = positions[posIndex++];
+    leftEdge = positions[posIndex++];
+    rightEdge.splice(0, 3);
+    leftEdge.splice(leftEdge.length - 3, 3);
+    finalPositions.set(rightEdge, front);
+    finalPositions.set(leftEdge, back - leftEdge.length + 1);
+    length = leftEdge.length - 3;
+    compIndex += 3;
+    left = Cartesian3_default.fromArray(computedLefts, compIndex, left);
+    for (j = 0; j < leftEdge.length; j += 3) {
+      rightNormal = ellipsoid.geodeticSurfaceNormal(
+        Cartesian3_default.fromArray(rightEdge, j, scratch1),
+        scratch1
+      );
+      leftNormal = ellipsoid.geodeticSurfaceNormal(
+        Cartesian3_default.fromArray(leftEdge, length - j, scratch2),
+        scratch2
+      );
+      normal = Cartesian3_default.normalize(
+        Cartesian3_default.add(rightNormal, leftNormal, normal),
+        normal
+      );
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+    front -= 3;
+    back += 3;
+  }
+  normal = Cartesian3_default.fromArray(
+    computedNormals,
+    computedNormals.length - 3,
+    normal
+  );
+  addNormals(attr, normal, left, front, back, vertexFormat);
+  if (addEndPositions) {
+    front += 3;
+    back -= 3;
+    leftPos = cartesian3;
+    rightPos = cartesian4;
+    const lastEndPositions = endPositions[1];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        lastEndPositions,
+        (endPositionLength - i - 1) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(lastEndPositions, i * 3, rightPos);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      addNormals(attr, normal, left, front, back, vertexFormat);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = LL;
+      indices[index++] = UR;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
+    }
+  }
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: finalPositions
+  });
+  if (vertexFormat.st) {
+    const st = new Float32Array(size / 3 * 2);
+    let rightSt;
+    let leftSt;
+    let stIndex = 0;
+    if (addEndPositions) {
+      leftCount /= 3;
+      rightCount /= 3;
+      const theta = Math.PI / (endPositionLength + 1);
+      leftSt = 1 / (leftCount - endPositionLength + 1);
+      rightSt = 1 / (rightCount - endPositionLength + 1);
+      let a;
+      const halfEndPos = endPositionLength / 2;
+      for (i = halfEndPos + 1; i < endPositionLength + 1; i++) {
+        a = Math_default.PI_OVER_TWO + theta * i;
+        st[stIndex++] = rightSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = 1; i < rightCount - endPositionLength + 1; i++) {
+        st[stIndex++] = i * rightSt;
+        st[stIndex++] = 0;
+      }
+      for (i = endPositionLength; i > halfEndPos; i--) {
+        a = Math_default.PI_OVER_TWO - i * theta;
+        st[stIndex++] = 1 - rightSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = halfEndPos; i > 0; i--) {
+        a = Math_default.PI_OVER_TWO - theta * i;
+        st[stIndex++] = 1 - leftSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+      for (i = leftCount - endPositionLength; i > 0; i--) {
+        st[stIndex++] = i * leftSt;
+        st[stIndex++] = 1;
+      }
+      for (i = 1; i < halfEndPos + 1; i++) {
+        a = Math_default.PI_OVER_TWO + theta * i;
+        st[stIndex++] = leftSt * (1 + Math.cos(a));
+        st[stIndex++] = 0.5 * (1 + Math.sin(a));
+      }
+    } else {
+      leftCount /= 3;
+      rightCount /= 3;
+      leftSt = 1 / (leftCount - 1);
+      rightSt = 1 / (rightCount - 1);
+      for (i = 0; i < rightCount; i++) {
+        st[stIndex++] = i * rightSt;
+        st[stIndex++] = 0;
+      }
+      for (i = leftCount; i > 0; i--) {
+        st[stIndex++] = (i - 1) * leftSt;
+        st[stIndex++] = 1;
+      }
+    }
+    attributes.st = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 2,
+      values: st
+    });
+  }
+  if (vertexFormat.normal) {
+    attributes.normal = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.normals
+    });
+  }
+  if (vertexFormat.tangent) {
+    attributes.tangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.tangents
+    });
+  }
+  if (vertexFormat.bitangent) {
+    attributes.bitangent = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: attr.bitangents
+    });
+  }
+  return {
+    attributes,
+    indices
+  };
+}
+function extrudedAttributes(attributes, vertexFormat) {
+  if (!vertexFormat.normal && !vertexFormat.tangent && !vertexFormat.bitangent && !vertexFormat.st) {
+    return attributes;
+  }
+  const positions = attributes.position.values;
+  let topNormals;
+  let topBitangents;
+  if (vertexFormat.normal || vertexFormat.bitangent) {
+    topNormals = attributes.normal.values;
+    topBitangents = attributes.bitangent.values;
+  }
+  const size = attributes.position.values.length / 18;
+  const threeSize = size * 3;
+  const twoSize = size * 2;
+  const sixSize = threeSize * 2;
+  let i;
+  if (vertexFormat.normal || vertexFormat.bitangent || vertexFormat.tangent) {
+    const normals = vertexFormat.normal ? new Float32Array(threeSize * 6) : void 0;
+    const tangents = vertexFormat.tangent ? new Float32Array(threeSize * 6) : void 0;
+    const bitangents = vertexFormat.bitangent ? new Float32Array(threeSize * 6) : void 0;
+    let topPosition = cartesian1;
+    let bottomPosition = cartesian2;
+    let previousPosition = cartesian3;
+    let normal = cartesian4;
+    let tangent = cartesian5;
+    let bitangent = cartesian6;
+    let attrIndex = sixSize;
+    for (i = 0; i < threeSize; i += 3) {
+      const attrIndexOffset = attrIndex + sixSize;
+      topPosition = Cartesian3_default.fromArray(positions, i, topPosition);
+      bottomPosition = Cartesian3_default.fromArray(
+        positions,
+        i + threeSize,
+        bottomPosition
+      );
+      previousPosition = Cartesian3_default.fromArray(
+        positions,
+        (i + 3) % threeSize,
+        previousPosition
+      );
+      bottomPosition = Cartesian3_default.subtract(
+        bottomPosition,
+        topPosition,
+        bottomPosition
+      );
+      previousPosition = Cartesian3_default.subtract(
+        previousPosition,
+        topPosition,
+        previousPosition
+      );
+      normal = Cartesian3_default.normalize(
+        Cartesian3_default.cross(bottomPosition, previousPosition, normal),
+        normal
+      );
+      if (vertexFormat.normal) {
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndexOffset);
+        CorridorGeometryLibrary_default.addAttribute(
+          normals,
+          normal,
+          attrIndexOffset + 3
+        );
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndex);
+        CorridorGeometryLibrary_default.addAttribute(normals, normal, attrIndex + 3);
+      }
+      if (vertexFormat.tangent || vertexFormat.bitangent) {
+        bitangent = Cartesian3_default.fromArray(topNormals, i, bitangent);
+        if (vertexFormat.bitangent) {
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndexOffset
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndexOffset + 3
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndex
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            bitangents,
+            bitangent,
+            attrIndex + 3
+          );
+        }
+        if (vertexFormat.tangent) {
+          tangent = Cartesian3_default.normalize(
+            Cartesian3_default.cross(bitangent, normal, tangent),
+            tangent
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndexOffset
+          );
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndexOffset + 3
+          );
+          CorridorGeometryLibrary_default.addAttribute(tangents, tangent, attrIndex);
+          CorridorGeometryLibrary_default.addAttribute(
+            tangents,
+            tangent,
+            attrIndex + 3
+          );
+        }
+      }
+      attrIndex += 6;
+    }
+    if (vertexFormat.normal) {
+      normals.set(topNormals);
+      for (i = 0; i < threeSize; i += 3) {
+        normals[i + threeSize] = -topNormals[i];
+        normals[i + threeSize + 1] = -topNormals[i + 1];
+        normals[i + threeSize + 2] = -topNormals[i + 2];
+      }
+      attributes.normal.values = normals;
+    } else {
+      attributes.normal = void 0;
+    }
+    if (vertexFormat.bitangent) {
+      bitangents.set(topBitangents);
+      bitangents.set(topBitangents, threeSize);
+      attributes.bitangent.values = bitangents;
+    } else {
+      attributes.bitangent = void 0;
+    }
+    if (vertexFormat.tangent) {
+      const topTangents = attributes.tangent.values;
+      tangents.set(topTangents);
+      tangents.set(topTangents, threeSize);
+      attributes.tangent.values = tangents;
+    }
+  }
+  if (vertexFormat.st) {
+    const topSt = attributes.st.values;
+    const st = new Float32Array(twoSize * 6);
+    st.set(topSt);
+    st.set(topSt, twoSize);
+    let index = twoSize * 2;
+    for (let j = 0; j < 2; j++) {
+      st[index++] = topSt[0];
+      st[index++] = topSt[1];
+      for (i = 2; i < twoSize; i += 2) {
+        const s = topSt[i];
+        const t = topSt[i + 1];
+        st[index++] = s;
+        st[index++] = t;
+        st[index++] = s;
+        st[index++] = t;
+      }
+      st[index++] = topSt[0];
+      st[index++] = topSt[1];
+    }
+    attributes.st.values = st;
+  }
+  return attributes;
+}
+function addWallPositions(positions, index, wallPositions) {
+  wallPositions[index++] = positions[0];
+  wallPositions[index++] = positions[1];
+  wallPositions[index++] = positions[2];
+  for (let i = 3; i < positions.length; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    wallPositions[index++] = x;
+    wallPositions[index++] = y;
+    wallPositions[index++] = z;
+    wallPositions[index++] = x;
+    wallPositions[index++] = y;
+    wallPositions[index++] = z;
+  }
+  wallPositions[index++] = positions[0];
+  wallPositions[index++] = positions[1];
+  wallPositions[index++] = positions[2];
+  return wallPositions;
+}
+function computePositionsExtruded(params, vertexFormat) {
+  const topVertexFormat = new VertexFormat_default({
+    position: vertexFormat.position,
+    normal: vertexFormat.normal || vertexFormat.bitangent || params.shadowVolume,
+    tangent: vertexFormat.tangent,
+    bitangent: vertexFormat.normal || vertexFormat.bitangent,
+    st: vertexFormat.st
+  });
+  const ellipsoid = params.ellipsoid;
+  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+  const attr = combine(computedPositions, topVertexFormat, ellipsoid);
+  const height = params.height;
+  const extrudedHeight = params.extrudedHeight;
+  let attributes = attr.attributes;
+  const indices = attr.indices;
+  let positions = attributes.position.values;
+  let length = positions.length;
+  const newPositions = new Float64Array(length * 6);
+  let extrudedPositions = new Float64Array(length);
+  extrudedPositions.set(positions);
+  let wallPositions = new Float64Array(length * 4);
+  positions = PolygonPipeline_default.scaleToGeodeticHeight(
+    positions,
+    height,
+    ellipsoid
+  );
+  wallPositions = addWallPositions(positions, 0, wallPositions);
+  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
+    extrudedPositions,
+    extrudedHeight,
+    ellipsoid
+  );
+  wallPositions = addWallPositions(
+    extrudedPositions,
+    length * 2,
+    wallPositions
+  );
+  newPositions.set(positions);
+  newPositions.set(extrudedPositions, length);
+  newPositions.set(wallPositions, length * 2);
+  attributes.position.values = newPositions;
+  attributes = extrudedAttributes(attributes, vertexFormat);
+  let i;
+  const size = length / 3;
+  if (params.shadowVolume) {
+    const topNormals = attributes.normal.values;
+    length = topNormals.length;
+    let extrudeNormals = new Float32Array(length * 6);
+    for (i = 0; i < length; i++) {
+      topNormals[i] = -topNormals[i];
+    }
+    extrudeNormals.set(topNormals, length);
+    extrudeNormals = addWallPositions(topNormals, length * 4, extrudeNormals);
+    attributes.extrudeDirection = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.FLOAT,
+      componentsPerAttribute: 3,
+      values: extrudeNormals
+    });
+    if (!vertexFormat.normal) {
+      attributes.normal = void 0;
+    }
+  }
+  if (defined_default(params.offsetAttribute)) {
+    let applyOffset = new Uint8Array(size * 6);
+    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      applyOffset = applyOffset.fill(1, 0, size).fill(1, size * 2, size * 4);
+    } else {
+      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      applyOffset = applyOffset.fill(applyOffsetValue);
+    }
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
+    });
+  }
+  const iLength = indices.length;
+  const twoSize = size + size;
+  const newIndices = IndexDatatype_default.createTypedArray(
+    newPositions.length / 3,
+    iLength * 2 + twoSize * 3
+  );
+  newIndices.set(indices);
+  let index = iLength;
+  for (i = 0; i < iLength; i += 3) {
+    const v0 = indices[i];
+    const v1 = indices[i + 1];
+    const v2 = indices[i + 2];
+    newIndices[index++] = v2 + size;
+    newIndices[index++] = v1 + size;
+    newIndices[index++] = v0 + size;
+  }
+  let UL, LL, UR, LR;
+  for (i = 0; i < twoSize; i += 2) {
+    UL = i + twoSize;
+    LL = UL + twoSize;
+    UR = UL + 1;
+    LR = LL + 1;
+    newIndices[index++] = UL;
+    newIndices[index++] = LL;
+    newIndices[index++] = UR;
+    newIndices[index++] = UR;
+    newIndices[index++] = LL;
+    newIndices[index++] = LR;
+  }
+  return {
+    attributes,
+    indices: newIndices
+  };
+}
+var scratchCartesian1 = new Cartesian3_default();
+var scratchCartesian2 = new Cartesian3_default();
+var scratchCartographic = new Cartographic_default();
+function computeOffsetPoints(position1, position2, ellipsoid, halfWidth, min, max) {
+  const direction = Cartesian3_default.subtract(
+    position2,
+    position1,
+    scratchCartesian1
+  );
+  Cartesian3_default.normalize(direction, direction);
+  const normal = ellipsoid.geodeticSurfaceNormal(position1, scratchCartesian2);
+  const offsetDirection = Cartesian3_default.cross(
+    direction,
+    normal,
+    scratchCartesian1
+  );
+  Cartesian3_default.multiplyByScalar(offsetDirection, halfWidth, offsetDirection);
+  let minLat = min.latitude;
+  let minLon = min.longitude;
+  let maxLat = max.latitude;
+  let maxLon = max.longitude;
+  Cartesian3_default.add(position1, offsetDirection, scratchCartesian2);
+  ellipsoid.cartesianToCartographic(scratchCartesian2, scratchCartographic);
+  let lat = scratchCartographic.latitude;
+  let lon = scratchCartographic.longitude;
+  minLat = Math.min(minLat, lat);
+  minLon = Math.min(minLon, lon);
+  maxLat = Math.max(maxLat, lat);
+  maxLon = Math.max(maxLon, lon);
+  Cartesian3_default.subtract(position1, offsetDirection, scratchCartesian2);
+  ellipsoid.cartesianToCartographic(scratchCartesian2, scratchCartographic);
+  lat = scratchCartographic.latitude;
+  lon = scratchCartographic.longitude;
+  minLat = Math.min(minLat, lat);
+  minLon = Math.min(minLon, lon);
+  maxLat = Math.max(maxLat, lat);
+  maxLon = Math.max(maxLon, lon);
+  min.latitude = minLat;
+  min.longitude = minLon;
+  max.latitude = maxLat;
+  max.longitude = maxLon;
+}
+var scratchCartesianOffset = new Cartesian3_default();
+var scratchCartesianEnds = new Cartesian3_default();
+var scratchCartographicMin = new Cartographic_default();
+var scratchCartographicMax = new Cartographic_default();
+function computeRectangle(positions, ellipsoid, width, cornerType, result) {
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  const length = cleanPositions.length;
+  if (length < 2 || width <= 0) {
+    return new Rectangle_default();
+  }
+  const halfWidth = width * 0.5;
+  scratchCartographicMin.latitude = Number.POSITIVE_INFINITY;
+  scratchCartographicMin.longitude = Number.POSITIVE_INFINITY;
+  scratchCartographicMax.latitude = Number.NEGATIVE_INFINITY;
+  scratchCartographicMax.longitude = Number.NEGATIVE_INFINITY;
+  let lat, lon;
+  if (cornerType === CornerType_default.ROUNDED) {
+    const first = cleanPositions[0];
+    Cartesian3_default.subtract(first, cleanPositions[1], scratchCartesianOffset);
+    Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
+    Cartesian3_default.multiplyByScalar(
+      scratchCartesianOffset,
+      halfWidth,
+      scratchCartesianOffset
+    );
+    Cartesian3_default.add(first, scratchCartesianOffset, scratchCartesianEnds);
+    ellipsoid.cartesianToCartographic(
+      scratchCartesianEnds,
+      scratchCartographic
+    );
+    lat = scratchCartographic.latitude;
+    lon = scratchCartographic.longitude;
+    scratchCartographicMin.latitude = Math.min(
+      scratchCartographicMin.latitude,
+      lat
+    );
+    scratchCartographicMin.longitude = Math.min(
+      scratchCartographicMin.longitude,
+      lon
+    );
+    scratchCartographicMax.latitude = Math.max(
+      scratchCartographicMax.latitude,
+      lat
+    );
+    scratchCartographicMax.longitude = Math.max(
+      scratchCartographicMax.longitude,
+      lon
+    );
+  }
+  for (let i = 0; i < length - 1; ++i) {
+    computeOffsetPoints(
+      cleanPositions[i],
+      cleanPositions[i + 1],
+      ellipsoid,
+      halfWidth,
+      scratchCartographicMin,
+      scratchCartographicMax
+    );
+  }
+  const last = cleanPositions[length - 1];
+  Cartesian3_default.subtract(last, cleanPositions[length - 2], scratchCartesianOffset);
+  Cartesian3_default.normalize(scratchCartesianOffset, scratchCartesianOffset);
+  Cartesian3_default.multiplyByScalar(
+    scratchCartesianOffset,
+    halfWidth,
+    scratchCartesianOffset
+  );
+  Cartesian3_default.add(last, scratchCartesianOffset, scratchCartesianEnds);
+  computeOffsetPoints(
+    last,
+    scratchCartesianEnds,
+    ellipsoid,
+    halfWidth,
+    scratchCartographicMin,
+    scratchCartographicMax
+  );
+  if (cornerType === CornerType_default.ROUNDED) {
+    ellipsoid.cartesianToCartographic(
+      scratchCartesianEnds,
+      scratchCartographic
+    );
+    lat = scratchCartographic.latitude;
+    lon = scratchCartographic.longitude;
+    scratchCartographicMin.latitude = Math.min(
+      scratchCartographicMin.latitude,
+      lat
+    );
+    scratchCartographicMin.longitude = Math.min(
+      scratchCartographicMin.longitude,
+      lon
+    );
+    scratchCartographicMax.latitude = Math.max(
+      scratchCartographicMax.latitude,
+      lat
+    );
+    scratchCartographicMax.longitude = Math.max(
+      scratchCartographicMax.longitude,
+      lon
+    );
+  }
+  const rectangle = defined_default(result) ? result : new Rectangle_default();
+  rectangle.north = scratchCartographicMax.latitude;
+  rectangle.south = scratchCartographicMin.latitude;
+  rectangle.east = scratchCartographicMax.longitude;
+  rectangle.west = scratchCartographicMin.longitude;
+  return rectangle;
+}
+function CorridorGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.defined("options.positions", positions);
+  Check_default.defined("options.width", width);
+  const height = defaultValue_default(options.height, 0);
+  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  this._positions = positions;
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
+  );
+  this._vertexFormat = VertexFormat_default.clone(
+    defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT)
+  );
+  this._width = width;
+  this._height = Math.max(height, extrudedHeight);
+  this._extrudedHeight = Math.min(height, extrudedHeight);
+  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._shadowVolume = defaultValue_default(options.shadowVolume, false);
+  this._workerName = "createCorridorGeometry";
+  this._offsetAttribute = options.offsetAttribute;
+  this._rectangle = void 0;
+  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 7;
+}
+CorridorGeometry.pack = function(value, array, startingIndex) {
+  Check_default.defined("value", value);
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const positions = value._positions;
+  const length = positions.length;
+  array[startingIndex++] = length;
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
+  startingIndex += VertexFormat_default.packedLength;
+  array[startingIndex++] = value._width;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._cornerType;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex++] = value._shadowVolume ? 1 : 0;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchVertexFormat = new VertexFormat_default();
+var scratchOptions = {
+  positions: void 0,
+  ellipsoid: scratchEllipsoid,
+  vertexFormat: scratchVertexFormat,
+  width: void 0,
+  height: void 0,
+  extrudedHeight: void 0,
+  cornerType: void 0,
+  granularity: void 0,
+  shadowVolume: void 0,
+  offsetAttribute: void 0
+};
+CorridorGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.defined("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const length = array[startingIndex++];
+  const positions = new Array(length);
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const vertexFormat = VertexFormat_default.unpack(
+    array,
+    startingIndex,
+    scratchVertexFormat
+  );
+  startingIndex += VertexFormat_default.packedLength;
+  const width = array[startingIndex++];
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const cornerType = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const shadowVolume = array[startingIndex++] === 1;
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.positions = positions;
+    scratchOptions.width = width;
+    scratchOptions.height = height;
+    scratchOptions.extrudedHeight = extrudedHeight;
+    scratchOptions.cornerType = cornerType;
+    scratchOptions.granularity = granularity;
+    scratchOptions.shadowVolume = shadowVolume;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CorridorGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
+  result._width = width;
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._cornerType = cornerType;
+  result._granularity = granularity;
+  result._shadowVolume = shadowVolume;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CorridorGeometry.computeRectangle = function(options, result) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.defined("options.positions", positions);
+  Check_default.defined("options.width", width);
+  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
+  const cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  return computeRectangle(positions, ellipsoid, width, cornerType, result);
+};
+CorridorGeometry.createGeometry = function(corridorGeometry) {
+  let positions = corridorGeometry._positions;
+  const width = corridorGeometry._width;
+  const ellipsoid = corridorGeometry._ellipsoid;
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  if (cleanPositions.length < 2 || width <= 0) {
+    return;
+  }
+  const height = corridorGeometry._height;
+  const extrudedHeight = corridorGeometry._extrudedHeight;
+  const extrude = !Math_default.equalsEpsilon(
+    height,
+    extrudedHeight,
+    0,
+    Math_default.EPSILON2
+  );
+  const vertexFormat = corridorGeometry._vertexFormat;
+  const params = {
+    ellipsoid,
+    positions: cleanPositions,
+    width,
+    cornerType: corridorGeometry._cornerType,
+    granularity: corridorGeometry._granularity,
+    saveAttributes: true
+  };
+  let attr;
+  if (extrude) {
+    params.height = height;
+    params.extrudedHeight = extrudedHeight;
+    params.shadowVolume = corridorGeometry._shadowVolume;
+    params.offsetAttribute = corridorGeometry._offsetAttribute;
+    attr = computePositionsExtruded(params, vertexFormat);
+  } else {
+    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+    attr = combine(computedPositions, vertexFormat, ellipsoid);
+    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+      attr.attributes.position.values,
+      height,
+      ellipsoid
+    );
+    if (defined_default(corridorGeometry._offsetAttribute)) {
+      const applyOffsetValue = corridorGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      const length = attr.attributes.position.values.length;
+      const applyOffset = new Uint8Array(length / 3).fill(applyOffsetValue);
+      attr.attributes.applyOffset = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset
+      });
+    }
+  }
+  const attributes = attr.attributes;
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    attributes.position.values,
+    void 0,
+    3
+  );
+  if (!vertexFormat.position) {
+    attr.attributes.position.values = void 0;
+  }
+  return new Geometry_default({
+    attributes,
+    indices: attr.indices,
+    primitiveType: PrimitiveType_default.TRIANGLES,
+    boundingSphere,
+    offsetAttribute: corridorGeometry._offsetAttribute
+  });
+};
+CorridorGeometry.createShadowVolume = function(corridorGeometry, minHeightFunc, maxHeightFunc) {
+  const granularity = corridorGeometry._granularity;
+  const ellipsoid = corridorGeometry._ellipsoid;
+  const minHeight = minHeightFunc(granularity, ellipsoid);
+  const maxHeight = maxHeightFunc(granularity, ellipsoid);
+  return new CorridorGeometry({
+    positions: corridorGeometry._positions,
+    width: corridorGeometry._width,
+    cornerType: corridorGeometry._cornerType,
+    ellipsoid,
+    granularity,
+    extrudedHeight: minHeight,
+    height: maxHeight,
+    vertexFormat: VertexFormat_default.POSITION_ONLY,
+    shadowVolume: true
+  });
+};
+Object.defineProperties(CorridorGeometry.prototype, {
+  /**
+   * @private
+   */
+  rectangle: {
+    get: function() {
+      if (!defined_default(this._rectangle)) {
+        this._rectangle = computeRectangle(
+          this._positions,
+          this._ellipsoid,
+          this._width,
+          this._cornerType
+        );
+      }
+      return this._rectangle;
+    }
+  },
+  /**
+   * For remapping texture coordinates when rendering CorridorGeometries as GroundPrimitives.
+   *
+   * Corridors don't support stRotation,
+   * so just return the corners of the original system.
+   * @private
+   */
+  textureCoordinateRotationPoints: {
+    get: function() {
+      return [0, 0, 0, 1, 1, 0];
+    }
+  }
+});
+var CorridorGeometry_default = CorridorGeometry;
+
+// packages/engine/Source/Workers/createCorridorGeometry.js
+function createCorridorGeometry(corridorGeometry, offset) {
+  if (defined_default(offset)) {
+    corridorGeometry = CorridorGeometry_default.unpack(corridorGeometry, offset);
+  }
+  corridorGeometry._ellipsoid = Ellipsoid_default.clone(corridorGeometry._ellipsoid);
+  return CorridorGeometry_default.createGeometry(corridorGeometry);
+}
+var createCorridorGeometry_default = createCorridorGeometry;
+export {
+  createCorridorGeometry_default as default
+};