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

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

@@ -1,25 +1,254 @@
-/**
- * @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(["./Matrix2-eefef8eb","./combine-7533016d","./AttributeCompression-7b0f288d","./ComponentDatatype-0200bf8c","./IndexDatatype-e713bfd2","./createTaskProcessorWorker","./defaultValue-0c475b81","./RuntimeError-5baf5c66","./WebGLConstants-5b50ced1"],(function(e,t,a,n,r,s,i,o,c){"use strict";const u=32767,f=new e.Cartographic,p=new e.Cartesian3;const d=new e.Rectangle,l=new e.Ellipsoid,b=new e.Cartesian3,C={min:void 0,max:void 0};const w=new e.Cartesian3,y=new e.Cartesian3,h=new e.Cartesian3,k=new e.Cartesian3,m=new e.Cartesian3;return s((function(s,i){const o=new Uint16Array(s.positions),c=new Uint16Array(s.widths),A=new Uint32Array(s.counts),g=new Uint16Array(s.batchIds);!function(t){t=new Float64Array(t);let a=0;C.min=t[a++],C.max=t[a++],e.Rectangle.unpack(t,a,d),a+=e.Rectangle.packedLength,e.Ellipsoid.unpack(t,a,l),a+=e.Ellipsoid.packedLength,e.Cartesian3.unpack(t,a,b)}(s.packedBuffer);const x=l,D=b,E=function(t,r,s,i,o){const c=t.length/3,d=t.subarray(0,c),l=t.subarray(c,2*c),b=t.subarray(2*c,3*c);a.AttributeCompression.zigZagDeltaDecode(d,l,b);const C=new Float64Array(t.length);for(let t=0;t<c;++t){const a=d[t],c=l[t],w=b[t],y=n.CesiumMath.lerp(r.west,r.east,a/u),h=n.CesiumMath.lerp(r.south,r.north,c/u),k=n.CesiumMath.lerp(s,i,w/u),m=e.Cartographic.fromRadians(y,h,k,f),A=o.cartographicToCartesian(m,p);e.Cartesian3.pack(A,C,3*t)}return C}(o,d,C.min,C.max,x),I=E.length/3,P=4*I-4,U=new Float32Array(3*P),R=new Float32Array(3*P),T=new Float32Array(3*P),F=new Float32Array(2*P),N=new Uint16Array(P);let M,L=0,S=0,_=0,v=0,G=A.length;for(M=0;M<G;++M){const t=A[M],a=c[M],n=g[M];for(let r=0;r<t;++r){let s;if(0===r){const t=e.Cartesian3.unpack(E,3*v,w),a=e.Cartesian3.unpack(E,3*(v+1),y);s=e.Cartesian3.subtract(t,a,h),e.Cartesian3.add(t,s,s)}else s=e.Cartesian3.unpack(E,3*(v+r-1),h);const i=e.Cartesian3.unpack(E,3*(v+r),k);let o;if(r===t-1){const a=e.Cartesian3.unpack(E,3*(v+t-1),w),n=e.Cartesian3.unpack(E,3*(v+t-2),y);o=e.Cartesian3.subtract(a,n,m),e.Cartesian3.add(a,o,o)}else o=e.Cartesian3.unpack(E,3*(v+r+1),m);e.Cartesian3.subtract(s,D,s),e.Cartesian3.subtract(i,D,i),e.Cartesian3.subtract(o,D,o);const c=r===t-1?2:4;for(let t=0===r?2:0;t<c;++t){e.Cartesian3.pack(i,U,L),e.Cartesian3.pack(s,R,L),e.Cartesian3.pack(o,T,L),L+=3;const r=t-2<0?-1:1;F[S++]=t%2*2-1,F[S++]=r*a,N[_++]=n}}v+=t}const W=r.IndexDatatype.createTypedArray(P,6*I-6);let B=0,O=0;for(G=I-1,M=0;M<G;++M)W[O++]=B,W[O++]=B+2,W[O++]=B+1,W[O++]=B+1,W[O++]=B+2,W[O++]=B+3,B+=4;i.push(U.buffer,R.buffer,T.buffer),i.push(F.buffer,N.buffer,W.buffer);let z={indexDatatype:2===W.BYTES_PER_ELEMENT?r.IndexDatatype.UNSIGNED_SHORT:r.IndexDatatype.UNSIGNED_INT,currentPositions:U.buffer,previousPositions:R.buffer,nextPositions:T.buffer,expandAndWidth:F.buffer,batchIds:N.buffer,indices:W.buffer};if(s.keepDecodedPositions){const e=function(e){const t=e.length,a=new Uint32Array(t+1);let n=0;for(let r=0;r<t;++r)a[r]=n,n+=e[r];return a[t]=n,a}(A);i.push(E.buffer,e.buffer),z=t.combine(z,{decodedPositions:E.buffer,decodedPositionOffsets:e.buffer})}return z}))}));
+define(['./Matrix3-315394f6', './combine-ca22a614', './AttributeCompression-b646d393', './Math-2dbd6b93', './IndexDatatype-a55ceaa1', './Matrix2-13178034', './createTaskProcessorWorker', './Check-666ab1a0', './defaultValue-0a909f67', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './RuntimeError-06c93819'], (function (Matrix3, combine, AttributeCompression, Math, IndexDatatype, Matrix2, createTaskProcessorWorker, Check, defaultValue, ComponentDatatype, WebGLConstants, RuntimeError) { 'use strict';
+
+  const maxShort = 32767;
+
+  const scratchBVCartographic = new Matrix3.Cartographic();
+  const scratchEncodedPosition = new Matrix3.Cartesian3();
+
+  function decodeVectorPolylinePositions(
+    positions,
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    ellipsoid
+  ) {
+    const positionsLength = positions.length / 3;
+    const uBuffer = positions.subarray(0, positionsLength);
+    const vBuffer = positions.subarray(positionsLength, 2 * positionsLength);
+    const heightBuffer = positions.subarray(
+      2 * positionsLength,
+      3 * positionsLength
+    );
+    AttributeCompression.AttributeCompression.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
+
+    const decoded = new Float64Array(positions.length);
+    for (let i = 0; i < positionsLength; ++i) {
+      const u = uBuffer[i];
+      const v = vBuffer[i];
+      const h = heightBuffer[i];
+
+      const lon = Math.CesiumMath.lerp(rectangle.west, rectangle.east, u / maxShort);
+      const lat = Math.CesiumMath.lerp(rectangle.south, rectangle.north, v / maxShort);
+      const alt = Math.CesiumMath.lerp(minimumHeight, maximumHeight, h / maxShort);
+
+      const cartographic = Matrix3.Cartographic.fromRadians(
+        lon,
+        lat,
+        alt,
+        scratchBVCartographic
+      );
+      const decodedPosition = ellipsoid.cartographicToCartesian(
+        cartographic,
+        scratchEncodedPosition
+      );
+      Matrix3.Cartesian3.pack(decodedPosition, decoded, i * 3);
+    }
+    return decoded;
+  }
+
+  const scratchRectangle = new Matrix2.Rectangle();
+  const scratchEllipsoid = new Matrix3.Ellipsoid();
+  const scratchCenter = new Matrix3.Cartesian3();
+  const scratchMinMaxHeights = {
+    min: undefined,
+    max: undefined,
+  };
+
+  function unpackBuffer(packedBuffer) {
+    packedBuffer = new Float64Array(packedBuffer);
+
+    let offset = 0;
+    scratchMinMaxHeights.min = packedBuffer[offset++];
+    scratchMinMaxHeights.max = packedBuffer[offset++];
+
+    Matrix2.Rectangle.unpack(packedBuffer, offset, scratchRectangle);
+    offset += Matrix2.Rectangle.packedLength;
+
+    Matrix3.Ellipsoid.unpack(packedBuffer, offset, scratchEllipsoid);
+    offset += Matrix3.Ellipsoid.packedLength;
+
+    Matrix3.Cartesian3.unpack(packedBuffer, offset, scratchCenter);
+  }
+
+  function getPositionOffsets(counts) {
+    const countsLength = counts.length;
+    const positionOffsets = new Uint32Array(countsLength + 1);
+    let offset = 0;
+    for (let i = 0; i < countsLength; ++i) {
+      positionOffsets[i] = offset;
+      offset += counts[i];
+    }
+    positionOffsets[countsLength] = offset;
+    return positionOffsets;
+  }
+
+  const scratchP0 = new Matrix3.Cartesian3();
+  const scratchP1 = new Matrix3.Cartesian3();
+  const scratchPrev = new Matrix3.Cartesian3();
+  const scratchCur = new Matrix3.Cartesian3();
+  const scratchNext = new Matrix3.Cartesian3();
+
+  function createVectorTilePolylines(parameters, transferableObjects) {
+    const encodedPositions = new Uint16Array(parameters.positions);
+    const widths = new Uint16Array(parameters.widths);
+    const counts = new Uint32Array(parameters.counts);
+    const batchIds = new Uint16Array(parameters.batchIds);
+
+    unpackBuffer(parameters.packedBuffer);
+    const rectangle = scratchRectangle;
+    const ellipsoid = scratchEllipsoid;
+    const center = scratchCenter;
+    const minimumHeight = scratchMinMaxHeights.min;
+    const maximumHeight = scratchMinMaxHeights.max;
+
+    const positions = decodeVectorPolylinePositions(
+      encodedPositions,
+      rectangle,
+      minimumHeight,
+      maximumHeight,
+      ellipsoid
+    );
+
+    const positionsLength = positions.length / 3;
+    const size = positionsLength * 4 - 4;
+
+    const curPositions = new Float32Array(size * 3);
+    const prevPositions = new Float32Array(size * 3);
+    const nextPositions = new Float32Array(size * 3);
+    const expandAndWidth = new Float32Array(size * 2);
+    const vertexBatchIds = new Uint16Array(size);
+
+    let positionIndex = 0;
+    let expandAndWidthIndex = 0;
+    let batchIdIndex = 0;
+
+    let i;
+    let offset = 0;
+    let length = counts.length;
+
+    for (i = 0; i < length; ++i) {
+      const count = counts[i];
+      const width = widths[i];
+      const batchId = batchIds[i];
+
+      for (let j = 0; j < count; ++j) {
+        let previous;
+        if (j === 0) {
+          const p0 = Matrix3.Cartesian3.unpack(positions, offset * 3, scratchP0);
+          const p1 = Matrix3.Cartesian3.unpack(positions, (offset + 1) * 3, scratchP1);
+
+          previous = Matrix3.Cartesian3.subtract(p0, p1, scratchPrev);
+          Matrix3.Cartesian3.add(p0, previous, previous);
+        } else {
+          previous = Matrix3.Cartesian3.unpack(
+            positions,
+            (offset + j - 1) * 3,
+            scratchPrev
+          );
+        }
+
+        const current = Matrix3.Cartesian3.unpack(
+          positions,
+          (offset + j) * 3,
+          scratchCur
+        );
+
+        let next;
+        if (j === count - 1) {
+          const p2 = Matrix3.Cartesian3.unpack(
+            positions,
+            (offset + count - 1) * 3,
+            scratchP0
+          );
+          const p3 = Matrix3.Cartesian3.unpack(
+            positions,
+            (offset + count - 2) * 3,
+            scratchP1
+          );
+
+          next = Matrix3.Cartesian3.subtract(p2, p3, scratchNext);
+          Matrix3.Cartesian3.add(p2, next, next);
+        } else {
+          next = Matrix3.Cartesian3.unpack(positions, (offset + j + 1) * 3, scratchNext);
+        }
+
+        Matrix3.Cartesian3.subtract(previous, center, previous);
+        Matrix3.Cartesian3.subtract(current, center, current);
+        Matrix3.Cartesian3.subtract(next, center, next);
+
+        const startK = j === 0 ? 2 : 0;
+        const endK = j === count - 1 ? 2 : 4;
+
+        for (let k = startK; k < endK; ++k) {
+          Matrix3.Cartesian3.pack(current, curPositions, positionIndex);
+          Matrix3.Cartesian3.pack(previous, prevPositions, positionIndex);
+          Matrix3.Cartesian3.pack(next, nextPositions, positionIndex);
+          positionIndex += 3;
+
+          const direction = k - 2 < 0 ? -1.0 : 1.0;
+          expandAndWidth[expandAndWidthIndex++] = 2 * (k % 2) - 1;
+          expandAndWidth[expandAndWidthIndex++] = direction * width;
+
+          vertexBatchIds[batchIdIndex++] = batchId;
+        }
+      }
+
+      offset += count;
+    }
+
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(size, positionsLength * 6 - 6);
+    let index = 0;
+    let indicesIndex = 0;
+    length = positionsLength - 1;
+    for (i = 0; i < length; ++i) {
+      indices[indicesIndex++] = index;
+      indices[indicesIndex++] = index + 2;
+      indices[indicesIndex++] = index + 1;
+
+      indices[indicesIndex++] = index + 1;
+      indices[indicesIndex++] = index + 2;
+      indices[indicesIndex++] = index + 3;
+
+      index += 4;
+    }
+
+    transferableObjects.push(
+      curPositions.buffer,
+      prevPositions.buffer,
+      nextPositions.buffer
+    );
+    transferableObjects.push(
+      expandAndWidth.buffer,
+      vertexBatchIds.buffer,
+      indices.buffer
+    );
+
+    let results = {
+      indexDatatype:
+        indices.BYTES_PER_ELEMENT === 2
+          ? IndexDatatype.IndexDatatype.UNSIGNED_SHORT
+          : IndexDatatype.IndexDatatype.UNSIGNED_INT,
+      currentPositions: curPositions.buffer,
+      previousPositions: prevPositions.buffer,
+      nextPositions: nextPositions.buffer,
+      expandAndWidth: expandAndWidth.buffer,
+      batchIds: vertexBatchIds.buffer,
+      indices: indices.buffer,
+    };
+
+    if (parameters.keepDecodedPositions) {
+      const positionOffsets = getPositionOffsets(counts);
+      transferableObjects.push(positions.buffer, positionOffsets.buffer);
+      results = combine.combine(results, {
+        decodedPositions: positions.buffer,
+        decodedPositionOffsets: positionOffsets.buffer,
+      });
+    }
+
+    return results;
+  }
+  var createVectorTilePolylines$1 = createTaskProcessorWorker(createVectorTilePolylines);
+
+  return createVectorTilePolylines$1;
+
+}));