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

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

@@ -1,25 +1,640 @@
-/**
- * @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(["./AxisAlignedBoundingBox-d0c22774","./Transforms-d2e5867e","./Matrix2-eefef8eb","./defaultValue-0c475b81","./TerrainEncoding-bc10ab54","./ComponentDatatype-0200bf8c","./OrientedBoundingBox-5193f9a2","./RuntimeError-5baf5c66","./WebMercatorProjection-cd2f30c2","./createTaskProcessorWorker","./_commonjsHelpers-bc29abbc","./combine-7533016d","./AttributeCompression-7b0f288d","./WebGLConstants-5b50ced1","./EllipsoidTangentPlane-c080fd1b","./IntersectionTests-eb4db8e0","./Plane-b0299683"],(function(t,e,n,i,o,r,a,s,c,u,h,d,l,g,m,p,f){"use strict";const I=Uint16Array.BYTES_PER_ELEMENT,E=Int32Array.BYTES_PER_ELEMENT,T=Uint32Array.BYTES_PER_ELEMENT,C=Float32Array.BYTES_PER_ELEMENT,M=Float64Array.BYTES_PER_ELEMENT;function b(t,e,n){n=i.defaultValue(n,r.CesiumMath);const o=t.length;for(let i=0;i<o;++i)if(n.equalsEpsilon(t[i],e,r.CesiumMath.EPSILON12))return i;return-1}const x=new n.Cartographic,N=new n.Cartesian3,S=new n.Cartesian3,w=new n.Cartesian3,B=new n.Matrix4;function P(t,e,o,a,s,c,u,h,d,l,g){const m=h.length;for(let p=0;p<m;++p){const f=h[p],I=f.cartographic,E=f.index,T=t.length,C=I.longitude;let M=I.latitude;M=r.CesiumMath.clamp(M,-r.CesiumMath.PI_OVER_TWO,r.CesiumMath.PI_OVER_TWO);const b=I.height-u.skirtHeight;u.hMin=Math.min(u.hMin,b),n.Cartographic.fromRadians(C,M,b,x),l&&(x.longitude+=d),l?p===m-1?x.latitude+=g:0===p&&(x.latitude-=g):x.latitude+=d;const S=u.ellipsoid.cartographicToCartesian(x);t.push(S),e.push(b),o.push(n.Cartesian2.clone(o[E])),a.length>0&&a.push(a[E]),s.length>0&&s.push(s[E]),n.Matrix4.multiplyByPoint(u.toENU,S,N);const w=u.minimum,B=u.maximum;n.Cartesian3.minimumByComponent(N,w,w),n.Cartesian3.maximumByComponent(N,B,B);const P=u.lastBorderPoint;if(i.defined(P)){const t=P.index;c.push(t,T-1,T,T,E,t)}u.lastBorderPoint=f}}return u((function(u,h){u.ellipsoid=n.Ellipsoid.clone(u.ellipsoid),u.rectangle=n.Rectangle.clone(u.rectangle);const d=function(u,h,d,l,g,m,p,f,A,y,R){let _,W,v,F,O,V;i.defined(l)?(_=l.west,W=l.south,v=l.east,F=l.north,O=l.width,V=l.height):(_=r.CesiumMath.toRadians(g.west),W=r.CesiumMath.toRadians(g.south),v=r.CesiumMath.toRadians(g.east),F=r.CesiumMath.toRadians(g.north),O=r.CesiumMath.toRadians(l.width),V=r.CesiumMath.toRadians(l.height));const Y=[W,F],H=[_,v],U=e.Transforms.eastNorthUpToFixedFrame(h,d),k=n.Matrix4.inverseTransformation(U,B);let L,j;A&&(L=c.WebMercatorProjection.geodeticLatitudeToMercatorAngle(W),j=1/(c.WebMercatorProjection.geodeticLatitudeToMercatorAngle(F)-L));const D=1!==m,G=new DataView(u);let z=Number.POSITIVE_INFINITY,q=Number.NEGATIVE_INFINITY;const J=S;J.x=Number.POSITIVE_INFINITY,J.y=Number.POSITIVE_INFINITY,J.z=Number.POSITIVE_INFINITY;const K=w;K.x=Number.NEGATIVE_INFINITY,K.y=Number.NEGATIVE_INFINITY,K.z=Number.NEGATIVE_INFINITY;let Q,X,Z=0,$=0,tt=0;for(X=0;X<4;++X){let t=Z;Q=G.getUint32(t,!0),t+=T;const e=r.CesiumMath.toRadians(180*G.getFloat64(t,!0));t+=M,-1===b(H,e)&&H.push(e);const n=r.CesiumMath.toRadians(180*G.getFloat64(t,!0));t+=M,-1===b(Y,n)&&Y.push(n),t+=2*M;let i=G.getInt32(t,!0);t+=E,$+=i,i=G.getInt32(t,!0),tt+=3*i,Z+=Q+T}const et=[],nt=[],it=new Array($),ot=new Array($),rt=new Array($),at=A?new Array($):[],st=D?new Array($):[],ct=new Array(tt),ut=[],ht=[],dt=[],lt=[];let gt=0,mt=0;for(Z=0,X=0;X<4;++X){Q=G.getUint32(Z,!0),Z+=T;const t=Z,e=r.CesiumMath.toRadians(180*G.getFloat64(Z,!0));Z+=M;const i=r.CesiumMath.toRadians(180*G.getFloat64(Z,!0));Z+=M;const o=r.CesiumMath.toRadians(180*G.getFloat64(Z,!0)),a=.5*o;Z+=M;const u=r.CesiumMath.toRadians(180*G.getFloat64(Z,!0)),h=.5*u;Z+=M;const l=G.getInt32(Z,!0);Z+=E;const g=G.getInt32(Z,!0);Z+=E,Z+=E;const m=new Array(l);for(let t=0;t<l;++t){const s=e+G.getUint8(Z++)*o;x.longitude=s;const l=i+G.getUint8(Z++)*u;x.latitude=l;let g=G.getFloat32(Z,!0);if(Z+=C,0!==g&&g<R&&(g*=-Math.pow(2,y)),g*=6371010,x.height=g,-1!==b(H,s)||-1!==b(Y,l)){const e=b(et,x,n.Cartographic);if(-1!==e){m[t]=nt[e];continue}et.push(n.Cartographic.clone(x)),nt.push(gt)}m[t]=gt,Math.abs(s-_)<a?ut.push({index:gt,cartographic:n.Cartographic.clone(x)}):Math.abs(s-v)<a?dt.push({index:gt,cartographic:n.Cartographic.clone(x)}):Math.abs(l-W)<h?ht.push({index:gt,cartographic:n.Cartographic.clone(x)}):Math.abs(l-F)<h&&lt.push({index:gt,cartographic:n.Cartographic.clone(x)}),z=Math.min(g,z),q=Math.max(g,q),rt[gt]=g;const p=d.cartographicToCartesian(x);if(it[gt]=p,A&&(at[gt]=(c.WebMercatorProjection.geodeticLatitudeToMercatorAngle(l)-L)*j),D){const t=d.geodeticSurfaceNormal(p);st[gt]=t}n.Matrix4.multiplyByPoint(k,p,N),n.Cartesian3.minimumByComponent(N,J,J),n.Cartesian3.maximumByComponent(N,K,K);let f=(s-_)/(v-_);f=r.CesiumMath.clamp(f,0,1);let I=(l-W)/(F-W);I=r.CesiumMath.clamp(I,0,1),ot[gt]=new n.Cartesian2(f,I),++gt}const p=3*g;for(let t=0;t<p;++t,++mt)ct[mt]=m[G.getUint16(Z,!0)],Z+=I;if(Q!==Z-t)throw new s.RuntimeError("Invalid terrain tile.")}it.length=gt,ot.length=gt,rt.length=gt,A&&(at.length=gt);D&&(st.length=gt);const pt=gt,ft=mt,It={hMin:z,lastBorderPoint:void 0,skirtHeight:f,toENU:k,ellipsoid:d,minimum:J,maximum:K};ut.sort((function(t,e){return e.cartographic.latitude-t.cartographic.latitude})),ht.sort((function(t,e){return t.cartographic.longitude-e.cartographic.longitude})),dt.sort((function(t,e){return t.cartographic.latitude-e.cartographic.latitude})),lt.sort((function(t,e){return e.cartographic.longitude-t.cartographic.longitude}));const Et=1e-5;if(P(it,rt,ot,at,st,ct,It,ut,-Et*O,!0,-Et*V),P(it,rt,ot,at,st,ct,It,ht,-Et*V,!1),P(it,rt,ot,at,st,ct,It,dt,Et*O,!0,Et*V),P(it,rt,ot,at,st,ct,It,lt,Et*V,!1),ut.length>0&&lt.length>0){const t=ut[0].index,e=pt,n=lt[lt.length-1].index,i=it.length-1;ct.push(n,i,e,e,t,n)}$=it.length;const Tt=e.BoundingSphere.fromPoints(it);let Ct;i.defined(l)&&(Ct=a.OrientedBoundingBox.fromRectangle(l,z,q,d));const Mt=new o.EllipsoidalOccluder(d).computeHorizonCullingPointPossiblyUnderEllipsoid(h,it,z),bt=new t.AxisAlignedBoundingBox(J,K,h),xt=new o.TerrainEncoding(h,bt,It.hMin,q,U,!1,A,D,m,p),Nt=new Float32Array($*xt.stride);let St=0;for(let t=0;t<$;++t)St=xt.encode(Nt,St,it[t],ot[t],rt[t],void 0,at[t],st[t]);const wt=ut.map((function(t){return t.index})).reverse(),Bt=ht.map((function(t){return t.index})).reverse(),Pt=dt.map((function(t){return t.index})).reverse(),At=lt.map((function(t){return t.index})).reverse();return Bt.unshift(Pt[Pt.length-1]),Bt.push(wt[0]),At.unshift(wt[wt.length-1]),At.push(Pt[0]),{vertices:Nt,indices:new Uint16Array(ct),maximumHeight:q,minimumHeight:z,encoding:xt,boundingSphere3D:Tt,orientedBoundingBox:Ct,occludeePointInScaledSpace:Mt,vertexCountWithoutSkirts:pt,indexCountWithoutSkirts:ft,westIndicesSouthToNorth:wt,southIndicesEastToWest:Bt,eastIndicesNorthToSouth:Pt,northIndicesWestToEast:At}}(u.buffer,u.relativeToCenter,u.ellipsoid,u.rectangle,u.nativeRectangle,u.exaggeration,u.exaggerationRelativeHeight,u.skirtHeight,u.includeWebMercatorT,u.negativeAltitudeExponentBias,u.negativeElevationThreshold),l=d.vertices;h.push(l.buffer);const g=d.indices;return h.push(g.buffer),{vertices:l.buffer,indices:g.buffer,numberOfAttributes:d.encoding.stride,minimumHeight:d.minimumHeight,maximumHeight:d.maximumHeight,boundingSphere3D:d.boundingSphere3D,orientedBoundingBox:d.orientedBoundingBox,occludeePointInScaledSpace:d.occludeePointInScaledSpace,encoding:d.encoding,vertexCountWithoutSkirts:d.vertexCountWithoutSkirts,indexCountWithoutSkirts:d.indexCountWithoutSkirts,westIndicesSouthToNorth:d.westIndicesSouthToNorth,southIndicesEastToWest:d.southIndicesEastToWest,eastIndicesNorthToSouth:d.eastIndicesNorthToSouth,northIndicesWestToEast:d.northIndicesWestToEast}}))}));
+define(['./AxisAlignedBoundingBox-ff186ccc', './Transforms-40229881', './Matrix2-13178034', './Matrix3-315394f6', './defaultValue-0a909f67', './TerrainEncoding-833187da', './Math-2dbd6b93', './OrientedBoundingBox-04920dc7', './RuntimeError-06c93819', './WebMercatorProjection-13a90d41', './createTaskProcessorWorker', './Check-666ab1a0', './combine-ca22a614', './AttributeCompression-b646d393', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './EllipsoidTangentPlane-214683dc', './IntersectionTests-f6e6bd8a', './Plane-900aa728'], (function (AxisAlignedBoundingBox, Transforms, Matrix2, Matrix3, defaultValue, TerrainEncoding, Math$1, OrientedBoundingBox, RuntimeError, WebMercatorProjection, createTaskProcessorWorker, Check, combine, AttributeCompression, ComponentDatatype, WebGLConstants, EllipsoidTangentPlane, IntersectionTests, Plane) { 'use strict';
+
+  const sizeOfUint16 = Uint16Array.BYTES_PER_ELEMENT;
+  const sizeOfInt32 = Int32Array.BYTES_PER_ELEMENT;
+  const sizeOfUint32 = Uint32Array.BYTES_PER_ELEMENT;
+  const sizeOfFloat = Float32Array.BYTES_PER_ELEMENT;
+  const sizeOfDouble = Float64Array.BYTES_PER_ELEMENT;
+
+  function indexOfEpsilon(arr, elem, elemType) {
+    elemType = defaultValue.defaultValue(elemType, Math$1.CesiumMath);
+    const count = arr.length;
+    for (let i = 0; i < count; ++i) {
+      if (elemType.equalsEpsilon(arr[i], elem, Math$1.CesiumMath.EPSILON12)) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  function createVerticesFromGoogleEarthEnterpriseBuffer(
+    parameters,
+    transferableObjects
+  ) {
+    parameters.ellipsoid = Matrix3.Ellipsoid.clone(parameters.ellipsoid);
+    parameters.rectangle = Matrix2.Rectangle.clone(parameters.rectangle);
+
+    const statistics = processBuffer(
+      parameters.buffer,
+      parameters.relativeToCenter,
+      parameters.ellipsoid,
+      parameters.rectangle,
+      parameters.nativeRectangle,
+      parameters.exaggeration,
+      parameters.exaggerationRelativeHeight,
+      parameters.skirtHeight,
+      parameters.includeWebMercatorT,
+      parameters.negativeAltitudeExponentBias,
+      parameters.negativeElevationThreshold
+    );
+    const vertices = statistics.vertices;
+    transferableObjects.push(vertices.buffer);
+    const indices = statistics.indices;
+    transferableObjects.push(indices.buffer);
+
+    return {
+      vertices: vertices.buffer,
+      indices: indices.buffer,
+      numberOfAttributes: statistics.encoding.stride,
+      minimumHeight: statistics.minimumHeight,
+      maximumHeight: statistics.maximumHeight,
+      boundingSphere3D: statistics.boundingSphere3D,
+      orientedBoundingBox: statistics.orientedBoundingBox,
+      occludeePointInScaledSpace: statistics.occludeePointInScaledSpace,
+      encoding: statistics.encoding,
+      vertexCountWithoutSkirts: statistics.vertexCountWithoutSkirts,
+      indexCountWithoutSkirts: statistics.indexCountWithoutSkirts,
+      westIndicesSouthToNorth: statistics.westIndicesSouthToNorth,
+      southIndicesEastToWest: statistics.southIndicesEastToWest,
+      eastIndicesNorthToSouth: statistics.eastIndicesNorthToSouth,
+      northIndicesWestToEast: statistics.northIndicesWestToEast,
+    };
+  }
+
+  const scratchCartographic = new Matrix3.Cartographic();
+  const scratchCartesian = new Matrix3.Cartesian3();
+  const minimumScratch = new Matrix3.Cartesian3();
+  const maximumScratch = new Matrix3.Cartesian3();
+  const matrix4Scratch = new Matrix2.Matrix4();
+
+  function processBuffer(
+    buffer,
+    relativeToCenter,
+    ellipsoid,
+    rectangle,
+    nativeRectangle,
+    exaggeration,
+    exaggerationRelativeHeight,
+    skirtHeight,
+    includeWebMercatorT,
+    negativeAltitudeExponentBias,
+    negativeElevationThreshold
+  ) {
+    let geographicWest;
+    let geographicSouth;
+    let geographicEast;
+    let geographicNorth;
+    let rectangleWidth, rectangleHeight;
+
+    if (!defaultValue.defined(rectangle)) {
+      geographicWest = Math$1.CesiumMath.toRadians(nativeRectangle.west);
+      geographicSouth = Math$1.CesiumMath.toRadians(nativeRectangle.south);
+      geographicEast = Math$1.CesiumMath.toRadians(nativeRectangle.east);
+      geographicNorth = Math$1.CesiumMath.toRadians(nativeRectangle.north);
+      rectangleWidth = Math$1.CesiumMath.toRadians(rectangle.width);
+      rectangleHeight = Math$1.CesiumMath.toRadians(rectangle.height);
+    } else {
+      geographicWest = rectangle.west;
+      geographicSouth = rectangle.south;
+      geographicEast = rectangle.east;
+      geographicNorth = rectangle.north;
+      rectangleWidth = rectangle.width;
+      rectangleHeight = rectangle.height;
+    }
+
+    // Keep track of quad borders so we can remove duplicates around the borders
+    const quadBorderLatitudes = [geographicSouth, geographicNorth];
+    const quadBorderLongitudes = [geographicWest, geographicEast];
+
+    const fromENU = Transforms.Transforms.eastNorthUpToFixedFrame(
+      relativeToCenter,
+      ellipsoid
+    );
+    const toENU = Matrix2.Matrix4.inverseTransformation(fromENU, matrix4Scratch);
+
+    let southMercatorY;
+    let oneOverMercatorHeight;
+    if (includeWebMercatorT) {
+      southMercatorY = WebMercatorProjection.WebMercatorProjection.geodeticLatitudeToMercatorAngle(
+        geographicSouth
+      );
+      oneOverMercatorHeight =
+        1.0 /
+        (WebMercatorProjection.WebMercatorProjection.geodeticLatitudeToMercatorAngle(geographicNorth) -
+          southMercatorY);
+    }
+
+    const hasExaggeration = exaggeration !== 1.0;
+    const includeGeodeticSurfaceNormals = hasExaggeration;
+
+    const dv = new DataView(buffer);
+
+    let minHeight = Number.POSITIVE_INFINITY;
+    let maxHeight = Number.NEGATIVE_INFINITY;
+
+    const minimum = minimumScratch;
+    minimum.x = Number.POSITIVE_INFINITY;
+    minimum.y = Number.POSITIVE_INFINITY;
+    minimum.z = Number.POSITIVE_INFINITY;
+
+    const maximum = maximumScratch;
+    maximum.x = Number.NEGATIVE_INFINITY;
+    maximum.y = Number.NEGATIVE_INFINITY;
+    maximum.z = Number.NEGATIVE_INFINITY;
+
+    // Compute sizes
+    let offset = 0;
+    let size = 0;
+    let indicesSize = 0;
+    let quadSize;
+    let quad;
+    for (quad = 0; quad < 4; ++quad) {
+      let o = offset;
+      quadSize = dv.getUint32(o, true);
+      o += sizeOfUint32;
+
+      const x = Math$1.CesiumMath.toRadians(dv.getFloat64(o, true) * 180.0);
+      o += sizeOfDouble;
+      if (indexOfEpsilon(quadBorderLongitudes, x) === -1) {
+        quadBorderLongitudes.push(x);
+      }
+
+      const y = Math$1.CesiumMath.toRadians(dv.getFloat64(o, true) * 180.0);
+      o += sizeOfDouble;
+      if (indexOfEpsilon(quadBorderLatitudes, y) === -1) {
+        quadBorderLatitudes.push(y);
+      }
+
+      o += 2 * sizeOfDouble; // stepX + stepY
+
+      let c = dv.getInt32(o, true); // Read point count
+      o += sizeOfInt32;
+      size += c;
+
+      c = dv.getInt32(o, true); // Read index count
+      indicesSize += c * 3;
+
+      offset += quadSize + sizeOfUint32; // Jump to next quad
+    }
+
+    // Quad Border points to remove duplicates
+    const quadBorderPoints = [];
+    const quadBorderIndices = [];
+
+    // Create arrays
+    const positions = new Array(size);
+    const uvs = new Array(size);
+    const heights = new Array(size);
+    const webMercatorTs = includeWebMercatorT ? new Array(size) : [];
+    const geodeticSurfaceNormals = includeGeodeticSurfaceNormals
+      ? new Array(size)
+      : [];
+    const indices = new Array(indicesSize);
+
+    // Points are laid out in rows starting at SW, so storing border points as we
+    //  come across them all points will be adjacent.
+    const westBorder = [];
+    const southBorder = [];
+    const eastBorder = [];
+    const northBorder = [];
+
+    // Each tile is split into 4 parts
+    let pointOffset = 0;
+    let indicesOffset = 0;
+    offset = 0;
+    for (quad = 0; quad < 4; ++quad) {
+      quadSize = dv.getUint32(offset, true);
+      offset += sizeOfUint32;
+      const startQuad = offset;
+
+      const originX = Math$1.CesiumMath.toRadians(dv.getFloat64(offset, true) * 180.0);
+      offset += sizeOfDouble;
+
+      const originY = Math$1.CesiumMath.toRadians(dv.getFloat64(offset, true) * 180.0);
+      offset += sizeOfDouble;
+
+      const stepX = Math$1.CesiumMath.toRadians(dv.getFloat64(offset, true) * 180.0);
+      const halfStepX = stepX * 0.5;
+      offset += sizeOfDouble;
+
+      const stepY = Math$1.CesiumMath.toRadians(dv.getFloat64(offset, true) * 180.0);
+      const halfStepY = stepY * 0.5;
+      offset += sizeOfDouble;
+
+      const numPoints = dv.getInt32(offset, true);
+      offset += sizeOfInt32;
+
+      const numFaces = dv.getInt32(offset, true);
+      offset += sizeOfInt32;
+
+      //const level = dv.getInt32(offset, true);
+      offset += sizeOfInt32;
+
+      // Keep track of quad indices to overall tile indices
+      const indicesMapping = new Array(numPoints);
+      for (let i = 0; i < numPoints; ++i) {
+        const longitude = originX + dv.getUint8(offset++) * stepX;
+        scratchCartographic.longitude = longitude;
+        const latitude = originY + dv.getUint8(offset++) * stepY;
+        scratchCartographic.latitude = latitude;
+
+        let height = dv.getFloat32(offset, true);
+        offset += sizeOfFloat;
+
+        // In order to support old clients, negative altitude values are stored as
+        // height/-2^32. Old clients see the value as really close to 0 but new clients multiply
+        // by -2^32 to get the real negative altitude value.
+        if (height !== 0 && height < negativeElevationThreshold) {
+          height *= -Math.pow(2, negativeAltitudeExponentBias);
+        }
+
+        // Height is stored in units of (1/EarthRadius) or (1/6371010.0)
+        height *= 6371010.0;
+
+        scratchCartographic.height = height;
+
+        // Is it along a quad border - if so check if already exists and use that index
+        if (
+          indexOfEpsilon(quadBorderLongitudes, longitude) !== -1 ||
+          indexOfEpsilon(quadBorderLatitudes, latitude) !== -1
+        ) {
+          const index = indexOfEpsilon(
+            quadBorderPoints,
+            scratchCartographic,
+            Matrix3.Cartographic
+          );
+          if (index === -1) {
+            quadBorderPoints.push(Matrix3.Cartographic.clone(scratchCartographic));
+            quadBorderIndices.push(pointOffset);
+          } else {
+            indicesMapping[i] = quadBorderIndices[index];
+            continue;
+          }
+        }
+        indicesMapping[i] = pointOffset;
+
+        if (Math.abs(longitude - geographicWest) < halfStepX) {
+          westBorder.push({
+            index: pointOffset,
+            cartographic: Matrix3.Cartographic.clone(scratchCartographic),
+          });
+        } else if (Math.abs(longitude - geographicEast) < halfStepX) {
+          eastBorder.push({
+            index: pointOffset,
+            cartographic: Matrix3.Cartographic.clone(scratchCartographic),
+          });
+        } else if (Math.abs(latitude - geographicSouth) < halfStepY) {
+          southBorder.push({
+            index: pointOffset,
+            cartographic: Matrix3.Cartographic.clone(scratchCartographic),
+          });
+        } else if (Math.abs(latitude - geographicNorth) < halfStepY) {
+          northBorder.push({
+            index: pointOffset,
+            cartographic: Matrix3.Cartographic.clone(scratchCartographic),
+          });
+        }
+
+        minHeight = Math.min(height, minHeight);
+        maxHeight = Math.max(height, maxHeight);
+        heights[pointOffset] = height;
+
+        const pos = ellipsoid.cartographicToCartesian(scratchCartographic);
+        positions[pointOffset] = pos;
+
+        if (includeWebMercatorT) {
+          webMercatorTs[pointOffset] =
+            (WebMercatorProjection.WebMercatorProjection.geodeticLatitudeToMercatorAngle(latitude) -
+              southMercatorY) *
+            oneOverMercatorHeight;
+        }
+
+        if (includeGeodeticSurfaceNormals) {
+          const normal = ellipsoid.geodeticSurfaceNormal(pos);
+          geodeticSurfaceNormals[pointOffset] = normal;
+        }
+
+        Matrix2.Matrix4.multiplyByPoint(toENU, pos, scratchCartesian);
+
+        Matrix3.Cartesian3.minimumByComponent(scratchCartesian, minimum, minimum);
+        Matrix3.Cartesian3.maximumByComponent(scratchCartesian, maximum, maximum);
+
+        let u = (longitude - geographicWest) / (geographicEast - geographicWest);
+        u = Math$1.CesiumMath.clamp(u, 0.0, 1.0);
+        let v =
+          (latitude - geographicSouth) / (geographicNorth - geographicSouth);
+        v = Math$1.CesiumMath.clamp(v, 0.0, 1.0);
+
+        uvs[pointOffset] = new Matrix2.Cartesian2(u, v);
+        ++pointOffset;
+      }
+
+      const facesElementCount = numFaces * 3;
+      for (let j = 0; j < facesElementCount; ++j, ++indicesOffset) {
+        indices[indicesOffset] = indicesMapping[dv.getUint16(offset, true)];
+        offset += sizeOfUint16;
+      }
+
+      if (quadSize !== offset - startQuad) {
+        throw new RuntimeError.RuntimeError("Invalid terrain tile.");
+      }
+    }
+
+    positions.length = pointOffset;
+    uvs.length = pointOffset;
+    heights.length = pointOffset;
+    if (includeWebMercatorT) {
+      webMercatorTs.length = pointOffset;
+    }
+    if (includeGeodeticSurfaceNormals) {
+      geodeticSurfaceNormals.length = pointOffset;
+    }
+
+    const vertexCountWithoutSkirts = pointOffset;
+    const indexCountWithoutSkirts = indicesOffset;
+
+    // Add skirt points
+    const skirtOptions = {
+      hMin: minHeight,
+      lastBorderPoint: undefined,
+      skirtHeight: skirtHeight,
+      toENU: toENU,
+      ellipsoid: ellipsoid,
+      minimum: minimum,
+      maximum: maximum,
+    };
+
+    // Sort counter clockwise from NW corner
+    // Corner points are in the east/west arrays
+    westBorder.sort(function (a, b) {
+      return b.cartographic.latitude - a.cartographic.latitude;
+    });
+    southBorder.sort(function (a, b) {
+      return a.cartographic.longitude - b.cartographic.longitude;
+    });
+    eastBorder.sort(function (a, b) {
+      return a.cartographic.latitude - b.cartographic.latitude;
+    });
+    northBorder.sort(function (a, b) {
+      return b.cartographic.longitude - a.cartographic.longitude;
+    });
+
+    const percentage = 0.00001;
+    addSkirt(
+      positions,
+      heights,
+      uvs,
+      webMercatorTs,
+      geodeticSurfaceNormals,
+      indices,
+      skirtOptions,
+      westBorder,
+      -percentage * rectangleWidth,
+      true,
+      -percentage * rectangleHeight
+    );
+    addSkirt(
+      positions,
+      heights,
+      uvs,
+      webMercatorTs,
+      geodeticSurfaceNormals,
+      indices,
+      skirtOptions,
+      southBorder,
+      -percentage * rectangleHeight,
+      false
+    );
+    addSkirt(
+      positions,
+      heights,
+      uvs,
+      webMercatorTs,
+      geodeticSurfaceNormals,
+      indices,
+      skirtOptions,
+      eastBorder,
+      percentage * rectangleWidth,
+      true,
+      percentage * rectangleHeight
+    );
+    addSkirt(
+      positions,
+      heights,
+      uvs,
+      webMercatorTs,
+      geodeticSurfaceNormals,
+      indices,
+      skirtOptions,
+      northBorder,
+      percentage * rectangleHeight,
+      false
+    );
+
+    // Since the corner between the north and west sides is in the west array, generate the last
+    //  two triangles between the last north vertex and the first west vertex
+    if (westBorder.length > 0 && northBorder.length > 0) {
+      const firstBorderIndex = westBorder[0].index;
+      const firstSkirtIndex = vertexCountWithoutSkirts;
+      const lastBorderIndex = northBorder[northBorder.length - 1].index;
+      const lastSkirtIndex = positions.length - 1;
+
+      indices.push(
+        lastBorderIndex,
+        lastSkirtIndex,
+        firstSkirtIndex,
+        firstSkirtIndex,
+        firstBorderIndex,
+        lastBorderIndex
+      );
+    }
+
+    size = positions.length; // Get new size with skirt vertices
+
+    const boundingSphere3D = Transforms.BoundingSphere.fromPoints(positions);
+    let orientedBoundingBox;
+    if (defaultValue.defined(rectangle)) {
+      orientedBoundingBox = OrientedBoundingBox.OrientedBoundingBox.fromRectangle(
+        rectangle,
+        minHeight,
+        maxHeight,
+        ellipsoid
+      );
+    }
+
+    const occluder = new TerrainEncoding.EllipsoidalOccluder(ellipsoid);
+    const occludeePointInScaledSpace = occluder.computeHorizonCullingPointPossiblyUnderEllipsoid(
+      relativeToCenter,
+      positions,
+      minHeight
+    );
+
+    const aaBox = new AxisAlignedBoundingBox.AxisAlignedBoundingBox(minimum, maximum, relativeToCenter);
+    const encoding = new TerrainEncoding.TerrainEncoding(
+      relativeToCenter,
+      aaBox,
+      skirtOptions.hMin,
+      maxHeight,
+      fromENU,
+      false,
+      includeWebMercatorT,
+      includeGeodeticSurfaceNormals,
+      exaggeration,
+      exaggerationRelativeHeight
+    );
+    const vertices = new Float32Array(size * encoding.stride);
+
+    let bufferIndex = 0;
+    for (let k = 0; k < size; ++k) {
+      bufferIndex = encoding.encode(
+        vertices,
+        bufferIndex,
+        positions[k],
+        uvs[k],
+        heights[k],
+        undefined,
+        webMercatorTs[k],
+        geodeticSurfaceNormals[k]
+      );
+    }
+
+    const westIndicesSouthToNorth = westBorder
+      .map(function (vertex) {
+        return vertex.index;
+      })
+      .reverse();
+    const southIndicesEastToWest = southBorder
+      .map(function (vertex) {
+        return vertex.index;
+      })
+      .reverse();
+    const eastIndicesNorthToSouth = eastBorder
+      .map(function (vertex) {
+        return vertex.index;
+      })
+      .reverse();
+    const northIndicesWestToEast = northBorder
+      .map(function (vertex) {
+        return vertex.index;
+      })
+      .reverse();
+
+    southIndicesEastToWest.unshift(
+      eastIndicesNorthToSouth[eastIndicesNorthToSouth.length - 1]
+    );
+    southIndicesEastToWest.push(westIndicesSouthToNorth[0]);
+
+    northIndicesWestToEast.unshift(
+      westIndicesSouthToNorth[westIndicesSouthToNorth.length - 1]
+    );
+    northIndicesWestToEast.push(eastIndicesNorthToSouth[0]);
+
+    return {
+      vertices: vertices,
+      indices: new Uint16Array(indices),
+      maximumHeight: maxHeight,
+      minimumHeight: minHeight,
+      encoding: encoding,
+      boundingSphere3D: boundingSphere3D,
+      orientedBoundingBox: orientedBoundingBox,
+      occludeePointInScaledSpace: occludeePointInScaledSpace,
+      vertexCountWithoutSkirts: vertexCountWithoutSkirts,
+      indexCountWithoutSkirts: indexCountWithoutSkirts,
+      westIndicesSouthToNorth: westIndicesSouthToNorth,
+      southIndicesEastToWest: southIndicesEastToWest,
+      eastIndicesNorthToSouth: eastIndicesNorthToSouth,
+      northIndicesWestToEast: northIndicesWestToEast,
+    };
+  }
+
+  function addSkirt(
+    positions,
+    heights,
+    uvs,
+    webMercatorTs,
+    geodeticSurfaceNormals,
+    indices,
+    skirtOptions,
+    borderPoints,
+    fudgeFactor,
+    eastOrWest,
+    cornerFudge
+  ) {
+    const count = borderPoints.length;
+    for (let j = 0; j < count; ++j) {
+      const borderPoint = borderPoints[j];
+      const borderCartographic = borderPoint.cartographic;
+      const borderIndex = borderPoint.index;
+      const currentIndex = positions.length;
+
+      const longitude = borderCartographic.longitude;
+      let latitude = borderCartographic.latitude;
+      latitude = Math$1.CesiumMath.clamp(
+        latitude,
+        -Math$1.CesiumMath.PI_OVER_TWO,
+        Math$1.CesiumMath.PI_OVER_TWO
+      ); // Don't go over the poles
+      const height = borderCartographic.height - skirtOptions.skirtHeight;
+      skirtOptions.hMin = Math.min(skirtOptions.hMin, height);
+
+      Matrix3.Cartographic.fromRadians(longitude, latitude, height, scratchCartographic);
+
+      // Adjust sides to angle out
+      if (eastOrWest) {
+        scratchCartographic.longitude += fudgeFactor;
+      }
+
+      // Adjust top or bottom to angle out
+      // Since corners are in the east/west arrays angle the first and last points as well
+      if (!eastOrWest) {
+        scratchCartographic.latitude += fudgeFactor;
+      } else if (j === count - 1) {
+        scratchCartographic.latitude += cornerFudge;
+      } else if (j === 0) {
+        scratchCartographic.latitude -= cornerFudge;
+      }
+
+      const pos = skirtOptions.ellipsoid.cartographicToCartesian(
+        scratchCartographic
+      );
+      positions.push(pos);
+      heights.push(height);
+      uvs.push(Matrix2.Cartesian2.clone(uvs[borderIndex])); // Copy UVs from border point
+      if (webMercatorTs.length > 0) {
+        webMercatorTs.push(webMercatorTs[borderIndex]);
+      }
+      if (geodeticSurfaceNormals.length > 0) {
+        geodeticSurfaceNormals.push(geodeticSurfaceNormals[borderIndex]);
+      }
+
+      Matrix2.Matrix4.multiplyByPoint(skirtOptions.toENU, pos, scratchCartesian);
+
+      const minimum = skirtOptions.minimum;
+      const maximum = skirtOptions.maximum;
+      Matrix3.Cartesian3.minimumByComponent(scratchCartesian, minimum, minimum);
+      Matrix3.Cartesian3.maximumByComponent(scratchCartesian, maximum, maximum);
+
+      const lastBorderPoint = skirtOptions.lastBorderPoint;
+      if (defaultValue.defined(lastBorderPoint)) {
+        const lastBorderIndex = lastBorderPoint.index;
+        indices.push(
+          lastBorderIndex,
+          currentIndex - 1,
+          currentIndex,
+          currentIndex,
+          borderIndex,
+          lastBorderIndex
+        );
+      }
+
+      skirtOptions.lastBorderPoint = borderPoint;
+    }
+  }
+  var createVerticesFromGoogleEarthEnterpriseBuffer$1 = createTaskProcessorWorker(
+    createVerticesFromGoogleEarthEnterpriseBuffer
+  );
+
+  return createVerticesFromGoogleEarthEnterpriseBuffer$1;
+
+}));