@vcmap/ui 5.0.0-rc.9 → 5.0.1

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

@@ -1 +1,818 @@
-define(["./AttributeCompression-80665726","./Transforms-c8cb8f43","./Matrix2-47e98d76","./defaultValue-81eec7ed","./TerrainEncoding-f96552d5","./IndexDatatype-f1dcdf35","./RuntimeError-8952249c","./ComponentDatatype-a15c9a19","./OrientedBoundingBox-fcb5b750","./createTaskProcessorWorker","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./WebGLConstants-508b9636","./EllipsoidTangentPlane-a01286f6","./AxisAlignedBoundingBox-a655a4bc","./IntersectionTests-58aa8f80","./Plane-3f01019d"],(function(e,t,n,i,s,r,h,o,u,p,d,l,a,c,f,g,m){"use strict";const x={clipTriangleAtAxisAlignedThreshold:function(e,t,n,s,r,h){let o,u,p;i.defined(h)?h.length=0:h=[],t?(o=n<e,u=s<e,p=r<e):(o=n>e,u=s>e,p=r>e);const d=o+u+p;let l,a,c,f,g,m;return 1===d?o?(l=(e-n)/(s-n),a=(e-n)/(r-n),h.push(1),h.push(2),1!==a&&(h.push(-1),h.push(0),h.push(2),h.push(a)),1!==l&&(h.push(-1),h.push(0),h.push(1),h.push(l))):u?(c=(e-s)/(r-s),f=(e-s)/(n-s),h.push(2),h.push(0),1!==f&&(h.push(-1),h.push(1),h.push(0),h.push(f)),1!==c&&(h.push(-1),h.push(1),h.push(2),h.push(c))):p&&(g=(e-r)/(n-r),m=(e-r)/(s-r),h.push(0),h.push(1),1!==m&&(h.push(-1),h.push(2),h.push(1),h.push(m)),1!==g&&(h.push(-1),h.push(2),h.push(0),h.push(g))):2===d?o||n===e?u||s===e?p||r===e||(a=(e-n)/(r-n),c=(e-s)/(r-s),h.push(2),h.push(-1),h.push(0),h.push(2),h.push(a),h.push(-1),h.push(1),h.push(2),h.push(c)):(m=(e-r)/(s-r),l=(e-n)/(s-n),h.push(1),h.push(-1),h.push(2),h.push(1),h.push(m),h.push(-1),h.push(0),h.push(1),h.push(l)):(f=(e-s)/(n-s),g=(e-r)/(n-r),h.push(0),h.push(-1),h.push(1),h.push(0),h.push(f),h.push(-1),h.push(2),h.push(0),h.push(g)):3!==d&&(h.push(0),h.push(1),h.push(2)),h},computeBarycentricCoordinates:function(e,t,s,r,h,o,u,p,d){const l=s-u,a=u-h,c=o-p,f=r-p,g=1/(c*l+a*f),m=t-p,x=e-u,w=(c*x+a*m)*g,C=(-f*x+l*m)*g,B=1-w-C;return i.defined(d)?(d.x=w,d.y=C,d.z=B,d):new n.Cartesian3(w,C,B)},computeLineSegmentLineSegmentIntersection:function(e,t,s,r,h,o,u,p,d){const l=(p-o)*(s-e)-(u-h)*(r-t);if(0===l)return;const a=((u-h)*(t-o)-(p-o)*(e-h))/l,c=((s-e)*(t-o)-(r-t)*(e-h))/l;return a>=0&&a<=1&&c>=0&&c<=1?(i.defined(d)||(d=new n.Cartesian2),d.x=e+a*(s-e),d.y=t+a*(r-t),d):void 0}},w=32767,C=16383,B=[],y=[],I=[],A=new n.Cartographic;let b=new n.Cartesian3;const v=[],T=[],z=[],V=[],M=[],N=new n.Cartesian3,E=new t.BoundingSphere,H=new u.OrientedBoundingBox,R=new n.Cartesian2,O=new n.Cartesian3;function S(){this.vertexBuffer=void 0,this.index=void 0,this.first=void 0,this.second=void 0,this.ratio=void 0}S.prototype.clone=function(e){return i.defined(e)||(e=new S),e.uBuffer=this.uBuffer,e.vBuffer=this.vBuffer,e.heightBuffer=this.heightBuffer,e.normalBuffer=this.normalBuffer,e.index=this.index,e.first=this.first,e.second=this.second,e.ratio=this.ratio,e},S.prototype.initializeIndexed=function(e,t,n,i,s){this.uBuffer=e,this.vBuffer=t,this.heightBuffer=n,this.normalBuffer=i,this.index=s,this.first=void 0,this.second=void 0,this.ratio=void 0},S.prototype.initializeFromClipResult=function(e,t,n){let i=t+1;return-1!==e[t]?n[e[t]].clone(this):(this.vertexBuffer=void 0,this.index=void 0,this.first=n[e[i]],++i,this.second=n[e[i]],++i,this.ratio=e[i],++i),i},S.prototype.getKey=function(){return this.isIndexed()?this.index:JSON.stringify({first:this.first.getKey(),second:this.second.getKey(),ratio:this.ratio})},S.prototype.isIndexed=function(){return i.defined(this.index)},S.prototype.getH=function(){return i.defined(this.index)?this.heightBuffer[this.index]:o.CesiumMath.lerp(this.first.getH(),this.second.getH(),this.ratio)},S.prototype.getU=function(){return i.defined(this.index)?this.uBuffer[this.index]:o.CesiumMath.lerp(this.first.getU(),this.second.getU(),this.ratio)},S.prototype.getV=function(){return i.defined(this.index)?this.vBuffer[this.index]:o.CesiumMath.lerp(this.first.getV(),this.second.getV(),this.ratio)};let U=new n.Cartesian2,F=-1;const P=[new n.Cartesian3,new n.Cartesian3],D=[new n.Cartesian3,new n.Cartesian3];function W(t,i){++F;let s=P[F],r=D[F];return s=e.AttributeCompression.octDecode(t.first.getNormalX(),t.first.getNormalY(),s),r=e.AttributeCompression.octDecode(t.second.getNormalX(),t.second.getNormalY(),r),b=n.Cartesian3.lerp(s,r,t.ratio,b),n.Cartesian3.normalize(b,b),e.AttributeCompression.octEncode(b,i),--F,i}S.prototype.getNormalX=function(){return i.defined(this.index)?this.normalBuffer[2*this.index]:(U=W(this,U),U.x)},S.prototype.getNormalY=function(){return i.defined(this.index)?this.normalBuffer[2*this.index+1]:(U=W(this,U),U.y)};const X=[];function k(e,t,n,s,r,h,o,u,p){if(0===o.length)return;let d=0,l=0;for(;l<o.length;)l=X[d++].initializeFromClipResult(o,l,u);for(let r=0;r<d;++r){const o=X[r];if(o.isIndexed())o.newIndex=h[o.index],o.uBuffer=e,o.vBuffer=t,o.heightBuffer=n,p&&(o.normalBuffer=s);else{const r=o.getKey();if(i.defined(h[r]))o.newIndex=h[r];else{const i=e.length;e.push(o.getU()),t.push(o.getV()),n.push(o.getH()),p&&(s.push(o.getNormalX()),s.push(o.getNormalY())),o.newIndex=i,h[r]=i}}}3===d?(r.push(X[0].newIndex),r.push(X[1].newIndex),r.push(X[2].newIndex)):4===d&&(r.push(X[0].newIndex),r.push(X[1].newIndex),r.push(X[2].newIndex),r.push(X[0].newIndex),r.push(X[2].newIndex),r.push(X[3].newIndex))}return X.push(new S),X.push(new S),X.push(new S),X.push(new S),p((function(e,i){const h=e.isEastChild,p=e.isNorthChild,d=h?C:0,l=h?w:C,a=p?C:0,c=p?w:C,f=v,g=T,m=z,U=M;f.length=0,g.length=0,m.length=0,U.length=0;const F=V;F.length=0;const P={},D=e.vertices;let W=e.indices;W=W.subarray(0,e.indexCountWithoutSkirts);const X=s.TerrainEncoding.clone(e.encoding),K=X.hasVertexNormals;let L=0;const Y=e.vertexCountWithoutSkirts,_=e.minimumHeight,j=e.maximumHeight,G=new Array(Y),J=new Array(Y),Z=new Array(Y),q=K?new Array(2*Y):void 0;let Q,$,ee,te,ne;for($=0,ee=0;$<Y;++$,ee+=2){const e=X.decodeTextureCoordinates(D,$,R);if(Q=X.decodeHeight(D,$),te=o.CesiumMath.clamp(e.x*w|0,0,w),ne=o.CesiumMath.clamp(e.y*w|0,0,w),Z[$]=o.CesiumMath.clamp((Q-_)/(j-_)*w|0,0,w),te<20&&(te=0),ne<20&&(ne=0),w-te<20&&(te=w),w-ne<20&&(ne=w),G[$]=te,J[$]=ne,K){const e=X.getOctEncodedNormal(D,$,O);q[ee]=e.x,q[ee+1]=e.y}(h&&te>=C||!h&&te<=C)&&(p&&ne>=C||!p&&ne<=C)&&(P[$]=L,f.push(te),g.push(ne),m.push(Z[$]),K&&(U.push(q[ee]),U.push(q[ee+1])),++L)}const ie=[];ie.push(new S),ie.push(new S),ie.push(new S);const se=[];let re,he;for(se.push(new S),se.push(new S),se.push(new S),$=0;$<W.length;$+=3){const e=W[$],t=W[$+1],n=W[$+2],i=G[e],s=G[t],r=G[n];ie[0].initializeIndexed(G,J,Z,q,e),ie[1].initializeIndexed(G,J,Z,q,t),ie[2].initializeIndexed(G,J,Z,q,n);const o=x.clipTriangleAtAxisAlignedThreshold(C,h,i,s,r,B);re=0,re>=o.length||(re=se[0].initializeFromClipResult(o,re,ie),re>=o.length||(re=se[1].initializeFromClipResult(o,re,ie),re>=o.length||(re=se[2].initializeFromClipResult(o,re,ie),he=x.clipTriangleAtAxisAlignedThreshold(C,p,se[0].getV(),se[1].getV(),se[2].getV(),y),k(f,g,m,U,F,P,he,se,K),re<o.length&&(se[2].clone(se[1]),se[2].initializeFromClipResult(o,re,ie),he=x.clipTriangleAtAxisAlignedThreshold(C,p,se[0].getV(),se[1].getV(),se[2].getV(),y),k(f,g,m,U,F,P,he,se,K)))))}const oe=h?-32767:0,ue=p?-32767:0,pe=[],de=[],le=[],ae=[];let ce=Number.MAX_VALUE,fe=-ce;const ge=I;ge.length=0;const me=n.Ellipsoid.clone(e.ellipsoid),xe=n.Rectangle.clone(e.childRectangle),we=xe.north,Ce=xe.south;let Be=xe.east;const ye=xe.west;for(Be<ye&&(Be+=o.CesiumMath.TWO_PI),$=0;$<f.length;++$)te=Math.round(f[$]),te<=d?(pe.push($),te=0):te>=l?(le.push($),te=w):te=2*te+oe,f[$]=te,ne=Math.round(g[$]),ne<=a?(de.push($),ne=0):ne>=c?(ae.push($),ne=w):ne=2*ne+ue,g[$]=ne,Q=o.CesiumMath.lerp(_,j,m[$]/w),Q<ce&&(ce=Q),Q>fe&&(fe=Q),m[$]=Q,A.longitude=o.CesiumMath.lerp(ye,Be,te/w),A.latitude=o.CesiumMath.lerp(Ce,we,ne/w),A.height=Q,me.cartographicToCartesian(A,b),ge.push(b.x),ge.push(b.y),ge.push(b.z);const Ie=t.BoundingSphere.fromVertices(ge,n.Cartesian3.ZERO,3,E),Ae=u.OrientedBoundingBox.fromRectangle(xe,ce,fe,me,H),be=new s.EllipsoidalOccluder(me).computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid(Ie.center,ge,3,Ie.center,ce,N),ve=fe-ce,Te=new Uint16Array(f.length+g.length+m.length);for($=0;$<f.length;++$)Te[$]=f[$];let ze=f.length;for($=0;$<g.length;++$)Te[ze+$]=g[$];for(ze+=g.length,$=0;$<m.length;++$)Te[ze+$]=w*(m[$]-ce)/ve;const Ve=r.IndexDatatype.createTypedArray(f.length,F);let Me;if(K){const e=new Uint8Array(U);i.push(Te.buffer,Ve.buffer,e.buffer),Me=e.buffer}else i.push(Te.buffer,Ve.buffer);return{vertices:Te.buffer,encodedNormals:Me,indices:Ve.buffer,minimumHeight:ce,maximumHeight:fe,westIndices:pe,southIndices:de,eastIndices:le,northIndices:ae,boundingSphere:Ie,orientedBoundingBox:Ae,horizonOcclusionPoint:be}}))}));
+/**
+ * @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 {
+  EllipsoidalOccluder_default,
+  TerrainEncoding_default
+} from "./chunk-TFC6TZ3S.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  OrientedBoundingBox_default
+} from "./chunk-Z24VKNDO.js";
+import {
+  AttributeCompression_default
+} from "./chunk-O5AMBQ36.js";
+import "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import {
+  BoundingSphere_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import {
+  Cartesian2_default,
+  Rectangle_default
+} from "./chunk-DUHWWBQQ.js";
+import "./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 "./chunk-WXTV4ATB.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Core/Intersections2D.js
+var Intersections2D = {};
+Intersections2D.clipTriangleAtAxisAlignedThreshold = function(threshold, keepAbove, u0, u1, u2, result) {
+  if (!defined_default(threshold)) {
+    throw new DeveloperError_default("threshold is required.");
+  }
+  if (!defined_default(keepAbove)) {
+    throw new DeveloperError_default("keepAbove is required.");
+  }
+  if (!defined_default(u0)) {
+    throw new DeveloperError_default("u0 is required.");
+  }
+  if (!defined_default(u1)) {
+    throw new DeveloperError_default("u1 is required.");
+  }
+  if (!defined_default(u2)) {
+    throw new DeveloperError_default("u2 is required.");
+  }
+  if (!defined_default(result)) {
+    result = [];
+  } else {
+    result.length = 0;
+  }
+  let u0Behind;
+  let u1Behind;
+  let u2Behind;
+  if (keepAbove) {
+    u0Behind = u0 < threshold;
+    u1Behind = u1 < threshold;
+    u2Behind = u2 < threshold;
+  } else {
+    u0Behind = u0 > threshold;
+    u1Behind = u1 > threshold;
+    u2Behind = u2 > threshold;
+  }
+  const numBehind = u0Behind + u1Behind + u2Behind;
+  let u01Ratio;
+  let u02Ratio;
+  let u12Ratio;
+  let u10Ratio;
+  let u20Ratio;
+  let u21Ratio;
+  if (numBehind === 1) {
+    if (u0Behind) {
+      u01Ratio = (threshold - u0) / (u1 - u0);
+      u02Ratio = (threshold - u0) / (u2 - u0);
+      result.push(1);
+      result.push(2);
+      if (u02Ratio !== 1) {
+        result.push(-1);
+        result.push(0);
+        result.push(2);
+        result.push(u02Ratio);
+      }
+      if (u01Ratio !== 1) {
+        result.push(-1);
+        result.push(0);
+        result.push(1);
+        result.push(u01Ratio);
+      }
+    } else if (u1Behind) {
+      u12Ratio = (threshold - u1) / (u2 - u1);
+      u10Ratio = (threshold - u1) / (u0 - u1);
+      result.push(2);
+      result.push(0);
+      if (u10Ratio !== 1) {
+        result.push(-1);
+        result.push(1);
+        result.push(0);
+        result.push(u10Ratio);
+      }
+      if (u12Ratio !== 1) {
+        result.push(-1);
+        result.push(1);
+        result.push(2);
+        result.push(u12Ratio);
+      }
+    } else if (u2Behind) {
+      u20Ratio = (threshold - u2) / (u0 - u2);
+      u21Ratio = (threshold - u2) / (u1 - u2);
+      result.push(0);
+      result.push(1);
+      if (u21Ratio !== 1) {
+        result.push(-1);
+        result.push(2);
+        result.push(1);
+        result.push(u21Ratio);
+      }
+      if (u20Ratio !== 1) {
+        result.push(-1);
+        result.push(2);
+        result.push(0);
+        result.push(u20Ratio);
+      }
+    }
+  } else if (numBehind === 2) {
+    if (!u0Behind && u0 !== threshold) {
+      u10Ratio = (threshold - u1) / (u0 - u1);
+      u20Ratio = (threshold - u2) / (u0 - u2);
+      result.push(0);
+      result.push(-1);
+      result.push(1);
+      result.push(0);
+      result.push(u10Ratio);
+      result.push(-1);
+      result.push(2);
+      result.push(0);
+      result.push(u20Ratio);
+    } else if (!u1Behind && u1 !== threshold) {
+      u21Ratio = (threshold - u2) / (u1 - u2);
+      u01Ratio = (threshold - u0) / (u1 - u0);
+      result.push(1);
+      result.push(-1);
+      result.push(2);
+      result.push(1);
+      result.push(u21Ratio);
+      result.push(-1);
+      result.push(0);
+      result.push(1);
+      result.push(u01Ratio);
+    } else if (!u2Behind && u2 !== threshold) {
+      u02Ratio = (threshold - u0) / (u2 - u0);
+      u12Ratio = (threshold - u1) / (u2 - u1);
+      result.push(2);
+      result.push(-1);
+      result.push(0);
+      result.push(2);
+      result.push(u02Ratio);
+      result.push(-1);
+      result.push(1);
+      result.push(2);
+      result.push(u12Ratio);
+    }
+  } else if (numBehind !== 3) {
+    result.push(0);
+    result.push(1);
+    result.push(2);
+  }
+  return result;
+};
+Intersections2D.computeBarycentricCoordinates = function(x, y, x1, y1, x2, y2, x3, y3, result) {
+  if (!defined_default(x)) {
+    throw new DeveloperError_default("x is required.");
+  }
+  if (!defined_default(y)) {
+    throw new DeveloperError_default("y is required.");
+  }
+  if (!defined_default(x1)) {
+    throw new DeveloperError_default("x1 is required.");
+  }
+  if (!defined_default(y1)) {
+    throw new DeveloperError_default("y1 is required.");
+  }
+  if (!defined_default(x2)) {
+    throw new DeveloperError_default("x2 is required.");
+  }
+  if (!defined_default(y2)) {
+    throw new DeveloperError_default("y2 is required.");
+  }
+  if (!defined_default(x3)) {
+    throw new DeveloperError_default("x3 is required.");
+  }
+  if (!defined_default(y3)) {
+    throw new DeveloperError_default("y3 is required.");
+  }
+  const x1mx3 = x1 - x3;
+  const x3mx2 = x3 - x2;
+  const y2my3 = y2 - y3;
+  const y1my3 = y1 - y3;
+  const inverseDeterminant = 1 / (y2my3 * x1mx3 + x3mx2 * y1my3);
+  const ymy3 = y - y3;
+  const xmx3 = x - x3;
+  const l1 = (y2my3 * xmx3 + x3mx2 * ymy3) * inverseDeterminant;
+  const l2 = (-y1my3 * xmx3 + x1mx3 * ymy3) * inverseDeterminant;
+  const l3 = 1 - l1 - l2;
+  if (defined_default(result)) {
+    result.x = l1;
+    result.y = l2;
+    result.z = l3;
+    return result;
+  }
+  return new Cartesian3_default(l1, l2, l3);
+};
+Intersections2D.computeLineSegmentLineSegmentIntersection = function(x00, y00, x01, y01, x10, y10, x11, y11, result) {
+  Check_default.typeOf.number("x00", x00);
+  Check_default.typeOf.number("y00", y00);
+  Check_default.typeOf.number("x01", x01);
+  Check_default.typeOf.number("y01", y01);
+  Check_default.typeOf.number("x10", x10);
+  Check_default.typeOf.number("y10", y10);
+  Check_default.typeOf.number("x11", x11);
+  Check_default.typeOf.number("y11", y11);
+  const numerator1A = (x11 - x10) * (y00 - y10) - (y11 - y10) * (x00 - x10);
+  const numerator1B = (x01 - x00) * (y00 - y10) - (y01 - y00) * (x00 - x10);
+  const denominator1 = (y11 - y10) * (x01 - x00) - (x11 - x10) * (y01 - y00);
+  if (denominator1 === 0) {
+    return;
+  }
+  const ua1 = numerator1A / denominator1;
+  const ub1 = numerator1B / denominator1;
+  if (ua1 >= 0 && ua1 <= 1 && ub1 >= 0 && ub1 <= 1) {
+    if (!defined_default(result)) {
+      result = new Cartesian2_default();
+    }
+    result.x = x00 + ua1 * (x01 - x00);
+    result.y = y00 + ua1 * (y01 - y00);
+    return result;
+  }
+};
+var Intersections2D_default = Intersections2D;
+
+// packages/engine/Source/Workers/upsampleQuantizedTerrainMesh.js
+var maxShort = 32767;
+var halfMaxShort = maxShort / 2 | 0;
+var clipScratch = [];
+var clipScratch2 = [];
+var verticesScratch = [];
+var cartographicScratch = new Cartographic_default();
+var cartesian3Scratch = new Cartesian3_default();
+var uScratch = [];
+var vScratch = [];
+var heightScratch = [];
+var indicesScratch = [];
+var normalsScratch = [];
+var horizonOcclusionPointScratch = new Cartesian3_default();
+var boundingSphereScratch = new BoundingSphere_default();
+var orientedBoundingBoxScratch = new OrientedBoundingBox_default();
+var decodeTexCoordsScratch = new Cartesian2_default();
+var octEncodedNormalScratch = new Cartesian3_default();
+function upsampleQuantizedTerrainMesh(parameters, transferableObjects) {
+  const isEastChild = parameters.isEastChild;
+  const isNorthChild = parameters.isNorthChild;
+  const minU = isEastChild ? halfMaxShort : 0;
+  const maxU = isEastChild ? maxShort : halfMaxShort;
+  const minV = isNorthChild ? halfMaxShort : 0;
+  const maxV = isNorthChild ? maxShort : halfMaxShort;
+  const uBuffer = uScratch;
+  const vBuffer = vScratch;
+  const heightBuffer = heightScratch;
+  const normalBuffer = normalsScratch;
+  uBuffer.length = 0;
+  vBuffer.length = 0;
+  heightBuffer.length = 0;
+  normalBuffer.length = 0;
+  const indices = indicesScratch;
+  indices.length = 0;
+  const vertexMap = {};
+  const parentVertices = parameters.vertices;
+  let parentIndices = parameters.indices;
+  parentIndices = parentIndices.subarray(0, parameters.indexCountWithoutSkirts);
+  const encoding = TerrainEncoding_default.clone(parameters.encoding);
+  const hasVertexNormals = encoding.hasVertexNormals;
+  let vertexCount = 0;
+  const quantizedVertexCount = parameters.vertexCountWithoutSkirts;
+  const parentMinimumHeight = parameters.minimumHeight;
+  const parentMaximumHeight = parameters.maximumHeight;
+  const parentUBuffer = new Array(quantizedVertexCount);
+  const parentVBuffer = new Array(quantizedVertexCount);
+  const parentHeightBuffer = new Array(quantizedVertexCount);
+  const parentNormalBuffer = hasVertexNormals ? new Array(quantizedVertexCount * 2) : void 0;
+  const threshold = 20;
+  let height;
+  let i, n;
+  let u, v;
+  for (i = 0, n = 0; i < quantizedVertexCount; ++i, n += 2) {
+    const texCoords = encoding.decodeTextureCoordinates(
+      parentVertices,
+      i,
+      decodeTexCoordsScratch
+    );
+    height = encoding.decodeHeight(parentVertices, i);
+    u = Math_default.clamp(texCoords.x * maxShort | 0, 0, maxShort);
+    v = Math_default.clamp(texCoords.y * maxShort | 0, 0, maxShort);
+    parentHeightBuffer[i] = Math_default.clamp(
+      (height - parentMinimumHeight) / (parentMaximumHeight - parentMinimumHeight) * maxShort | 0,
+      0,
+      maxShort
+    );
+    if (u < threshold) {
+      u = 0;
+    }
+    if (v < threshold) {
+      v = 0;
+    }
+    if (maxShort - u < threshold) {
+      u = maxShort;
+    }
+    if (maxShort - v < threshold) {
+      v = maxShort;
+    }
+    parentUBuffer[i] = u;
+    parentVBuffer[i] = v;
+    if (hasVertexNormals) {
+      const encodedNormal = encoding.getOctEncodedNormal(
+        parentVertices,
+        i,
+        octEncodedNormalScratch
+      );
+      parentNormalBuffer[n] = encodedNormal.x;
+      parentNormalBuffer[n + 1] = encodedNormal.y;
+    }
+    if ((isEastChild && u >= halfMaxShort || !isEastChild && u <= halfMaxShort) && (isNorthChild && v >= halfMaxShort || !isNorthChild && v <= halfMaxShort)) {
+      vertexMap[i] = vertexCount;
+      uBuffer.push(u);
+      vBuffer.push(v);
+      heightBuffer.push(parentHeightBuffer[i]);
+      if (hasVertexNormals) {
+        normalBuffer.push(parentNormalBuffer[n]);
+        normalBuffer.push(parentNormalBuffer[n + 1]);
+      }
+      ++vertexCount;
+    }
+  }
+  const triangleVertices = [];
+  triangleVertices.push(new Vertex());
+  triangleVertices.push(new Vertex());
+  triangleVertices.push(new Vertex());
+  const clippedTriangleVertices = [];
+  clippedTriangleVertices.push(new Vertex());
+  clippedTriangleVertices.push(new Vertex());
+  clippedTriangleVertices.push(new Vertex());
+  let clippedIndex;
+  let clipped2;
+  for (i = 0; i < parentIndices.length; i += 3) {
+    const i0 = parentIndices[i];
+    const i1 = parentIndices[i + 1];
+    const i2 = parentIndices[i + 2];
+    const u0 = parentUBuffer[i0];
+    const u1 = parentUBuffer[i1];
+    const u2 = parentUBuffer[i2];
+    triangleVertices[0].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i0
+    );
+    triangleVertices[1].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i1
+    );
+    triangleVertices[2].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i2
+    );
+    const clipped = Intersections2D_default.clipTriangleAtAxisAlignedThreshold(
+      halfMaxShort,
+      isEastChild,
+      u0,
+      u1,
+      u2,
+      clipScratch
+    );
+    clippedIndex = 0;
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[0].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices
+    );
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[1].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices
+    );
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[2].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices
+    );
+    clipped2 = Intersections2D_default.clipTriangleAtAxisAlignedThreshold(
+      halfMaxShort,
+      isNorthChild,
+      clippedTriangleVertices[0].getV(),
+      clippedTriangleVertices[1].getV(),
+      clippedTriangleVertices[2].getV(),
+      clipScratch2
+    );
+    addClippedPolygon(
+      uBuffer,
+      vBuffer,
+      heightBuffer,
+      normalBuffer,
+      indices,
+      vertexMap,
+      clipped2,
+      clippedTriangleVertices,
+      hasVertexNormals
+    );
+    if (clippedIndex < clipped.length) {
+      clippedTriangleVertices[2].clone(clippedTriangleVertices[1]);
+      clippedTriangleVertices[2].initializeFromClipResult(
+        clipped,
+        clippedIndex,
+        triangleVertices
+      );
+      clipped2 = Intersections2D_default.clipTriangleAtAxisAlignedThreshold(
+        halfMaxShort,
+        isNorthChild,
+        clippedTriangleVertices[0].getV(),
+        clippedTriangleVertices[1].getV(),
+        clippedTriangleVertices[2].getV(),
+        clipScratch2
+      );
+      addClippedPolygon(
+        uBuffer,
+        vBuffer,
+        heightBuffer,
+        normalBuffer,
+        indices,
+        vertexMap,
+        clipped2,
+        clippedTriangleVertices,
+        hasVertexNormals
+      );
+    }
+  }
+  const uOffset = isEastChild ? -maxShort : 0;
+  const vOffset = isNorthChild ? -maxShort : 0;
+  const westIndices = [];
+  const southIndices = [];
+  const eastIndices = [];
+  const northIndices = [];
+  let minimumHeight = Number.MAX_VALUE;
+  let maximumHeight = -minimumHeight;
+  const cartesianVertices = verticesScratch;
+  cartesianVertices.length = 0;
+  const ellipsoid = Ellipsoid_default.clone(parameters.ellipsoid);
+  const rectangle = Rectangle_default.clone(parameters.childRectangle);
+  const north = rectangle.north;
+  const south = rectangle.south;
+  let east = rectangle.east;
+  const west = rectangle.west;
+  if (east < west) {
+    east += Math_default.TWO_PI;
+  }
+  for (i = 0; i < uBuffer.length; ++i) {
+    u = Math.round(uBuffer[i]);
+    if (u <= minU) {
+      westIndices.push(i);
+      u = 0;
+    } else if (u >= maxU) {
+      eastIndices.push(i);
+      u = maxShort;
+    } else {
+      u = u * 2 + uOffset;
+    }
+    uBuffer[i] = u;
+    v = Math.round(vBuffer[i]);
+    if (v <= minV) {
+      southIndices.push(i);
+      v = 0;
+    } else if (v >= maxV) {
+      northIndices.push(i);
+      v = maxShort;
+    } else {
+      v = v * 2 + vOffset;
+    }
+    vBuffer[i] = v;
+    height = Math_default.lerp(
+      parentMinimumHeight,
+      parentMaximumHeight,
+      heightBuffer[i] / maxShort
+    );
+    if (height < minimumHeight) {
+      minimumHeight = height;
+    }
+    if (height > maximumHeight) {
+      maximumHeight = height;
+    }
+    heightBuffer[i] = height;
+    cartographicScratch.longitude = Math_default.lerp(west, east, u / maxShort);
+    cartographicScratch.latitude = Math_default.lerp(south, north, v / maxShort);
+    cartographicScratch.height = height;
+    ellipsoid.cartographicToCartesian(cartographicScratch, cartesian3Scratch);
+    cartesianVertices.push(cartesian3Scratch.x);
+    cartesianVertices.push(cartesian3Scratch.y);
+    cartesianVertices.push(cartesian3Scratch.z);
+  }
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    cartesianVertices,
+    Cartesian3_default.ZERO,
+    3,
+    boundingSphereScratch
+  );
+  const orientedBoundingBox = OrientedBoundingBox_default.fromRectangle(
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    ellipsoid,
+    orientedBoundingBoxScratch
+  );
+  const occluder = new EllipsoidalOccluder_default(ellipsoid);
+  const horizonOcclusionPoint = occluder.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid(
+    boundingSphere.center,
+    cartesianVertices,
+    3,
+    boundingSphere.center,
+    minimumHeight,
+    horizonOcclusionPointScratch
+  );
+  const heightRange = maximumHeight - minimumHeight;
+  const vertices = new Uint16Array(
+    uBuffer.length + vBuffer.length + heightBuffer.length
+  );
+  for (i = 0; i < uBuffer.length; ++i) {
+    vertices[i] = uBuffer[i];
+  }
+  let start = uBuffer.length;
+  for (i = 0; i < vBuffer.length; ++i) {
+    vertices[start + i] = vBuffer[i];
+  }
+  start += vBuffer.length;
+  for (i = 0; i < heightBuffer.length; ++i) {
+    vertices[start + i] = maxShort * (heightBuffer[i] - minimumHeight) / heightRange;
+  }
+  const indicesTypedArray = IndexDatatype_default.createTypedArray(
+    uBuffer.length,
+    indices
+  );
+  let encodedNormals;
+  if (hasVertexNormals) {
+    const normalArray = new Uint8Array(normalBuffer);
+    transferableObjects.push(
+      vertices.buffer,
+      indicesTypedArray.buffer,
+      normalArray.buffer
+    );
+    encodedNormals = normalArray.buffer;
+  } else {
+    transferableObjects.push(vertices.buffer, indicesTypedArray.buffer);
+  }
+  return {
+    vertices: vertices.buffer,
+    encodedNormals,
+    indices: indicesTypedArray.buffer,
+    minimumHeight,
+    maximumHeight,
+    westIndices,
+    southIndices,
+    eastIndices,
+    northIndices,
+    boundingSphere,
+    orientedBoundingBox,
+    horizonOcclusionPoint
+  };
+}
+function Vertex() {
+  this.vertexBuffer = void 0;
+  this.index = void 0;
+  this.first = void 0;
+  this.second = void 0;
+  this.ratio = void 0;
+}
+Vertex.prototype.clone = function(result) {
+  if (!defined_default(result)) {
+    result = new Vertex();
+  }
+  result.uBuffer = this.uBuffer;
+  result.vBuffer = this.vBuffer;
+  result.heightBuffer = this.heightBuffer;
+  result.normalBuffer = this.normalBuffer;
+  result.index = this.index;
+  result.first = this.first;
+  result.second = this.second;
+  result.ratio = this.ratio;
+  return result;
+};
+Vertex.prototype.initializeIndexed = function(uBuffer, vBuffer, heightBuffer, normalBuffer, index) {
+  this.uBuffer = uBuffer;
+  this.vBuffer = vBuffer;
+  this.heightBuffer = heightBuffer;
+  this.normalBuffer = normalBuffer;
+  this.index = index;
+  this.first = void 0;
+  this.second = void 0;
+  this.ratio = void 0;
+};
+Vertex.prototype.initializeFromClipResult = function(clipResult, index, vertices) {
+  let nextIndex = index + 1;
+  if (clipResult[index] !== -1) {
+    vertices[clipResult[index]].clone(this);
+  } else {
+    this.vertexBuffer = void 0;
+    this.index = void 0;
+    this.first = vertices[clipResult[nextIndex]];
+    ++nextIndex;
+    this.second = vertices[clipResult[nextIndex]];
+    ++nextIndex;
+    this.ratio = clipResult[nextIndex];
+    ++nextIndex;
+  }
+  return nextIndex;
+};
+Vertex.prototype.getKey = function() {
+  if (this.isIndexed()) {
+    return this.index;
+  }
+  return JSON.stringify({
+    first: this.first.getKey(),
+    second: this.second.getKey(),
+    ratio: this.ratio
+  });
+};
+Vertex.prototype.isIndexed = function() {
+  return defined_default(this.index);
+};
+Vertex.prototype.getH = function() {
+  if (defined_default(this.index)) {
+    return this.heightBuffer[this.index];
+  }
+  return Math_default.lerp(this.first.getH(), this.second.getH(), this.ratio);
+};
+Vertex.prototype.getU = function() {
+  if (defined_default(this.index)) {
+    return this.uBuffer[this.index];
+  }
+  return Math_default.lerp(this.first.getU(), this.second.getU(), this.ratio);
+};
+Vertex.prototype.getV = function() {
+  if (defined_default(this.index)) {
+    return this.vBuffer[this.index];
+  }
+  return Math_default.lerp(this.first.getV(), this.second.getV(), this.ratio);
+};
+var encodedScratch = new Cartesian2_default();
+var depth = -1;
+var cartesianScratch1 = [new Cartesian3_default(), new Cartesian3_default()];
+var cartesianScratch2 = [new Cartesian3_default(), new Cartesian3_default()];
+function lerpOctEncodedNormal(vertex, result) {
+  ++depth;
+  let first = cartesianScratch1[depth];
+  let second = cartesianScratch2[depth];
+  first = AttributeCompression_default.octDecode(
+    vertex.first.getNormalX(),
+    vertex.first.getNormalY(),
+    first
+  );
+  second = AttributeCompression_default.octDecode(
+    vertex.second.getNormalX(),
+    vertex.second.getNormalY(),
+    second
+  );
+  cartesian3Scratch = Cartesian3_default.lerp(
+    first,
+    second,
+    vertex.ratio,
+    cartesian3Scratch
+  );
+  Cartesian3_default.normalize(cartesian3Scratch, cartesian3Scratch);
+  AttributeCompression_default.octEncode(cartesian3Scratch, result);
+  --depth;
+  return result;
+}
+Vertex.prototype.getNormalX = function() {
+  if (defined_default(this.index)) {
+    return this.normalBuffer[this.index * 2];
+  }
+  encodedScratch = lerpOctEncodedNormal(this, encodedScratch);
+  return encodedScratch.x;
+};
+Vertex.prototype.getNormalY = function() {
+  if (defined_default(this.index)) {
+    return this.normalBuffer[this.index * 2 + 1];
+  }
+  encodedScratch = lerpOctEncodedNormal(this, encodedScratch);
+  return encodedScratch.y;
+};
+var polygonVertices = [];
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+function addClippedPolygon(uBuffer, vBuffer, heightBuffer, normalBuffer, indices, vertexMap, clipped, triangleVertices, hasVertexNormals) {
+  if (clipped.length === 0) {
+    return;
+  }
+  let numVertices = 0;
+  let clippedIndex = 0;
+  while (clippedIndex < clipped.length) {
+    clippedIndex = polygonVertices[numVertices++].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices
+    );
+  }
+  for (let i = 0; i < numVertices; ++i) {
+    const polygonVertex = polygonVertices[i];
+    if (!polygonVertex.isIndexed()) {
+      const key = polygonVertex.getKey();
+      if (defined_default(vertexMap[key])) {
+        polygonVertex.newIndex = vertexMap[key];
+      } else {
+        const newIndex = uBuffer.length;
+        uBuffer.push(polygonVertex.getU());
+        vBuffer.push(polygonVertex.getV());
+        heightBuffer.push(polygonVertex.getH());
+        if (hasVertexNormals) {
+          normalBuffer.push(polygonVertex.getNormalX());
+          normalBuffer.push(polygonVertex.getNormalY());
+        }
+        polygonVertex.newIndex = newIndex;
+        vertexMap[key] = newIndex;
+      }
+    } else {
+      polygonVertex.newIndex = vertexMap[polygonVertex.index];
+      polygonVertex.uBuffer = uBuffer;
+      polygonVertex.vBuffer = vBuffer;
+      polygonVertex.heightBuffer = heightBuffer;
+      if (hasVertexNormals) {
+        polygonVertex.normalBuffer = normalBuffer;
+      }
+    }
+  }
+  if (numVertices === 3) {
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[1].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+  } else if (numVertices === 4) {
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[1].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+    indices.push(polygonVertices[3].newIndex);
+  }
+}
+var upsampleQuantizedTerrainMesh_default = createTaskProcessorWorker_default(upsampleQuantizedTerrainMesh);
+export {
+  upsampleQuantizedTerrainMesh_default as default
+};