@gmgis/gm-sdk 1.12.5 → 2.0.2

package/dist/resources/Workers/createVectorTileClampedPolylines.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.122
+ * Version 1.132
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,468 +23,4 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  createTaskProcessorWorker_default
-} from "./chunk-5ODQSF26.js";
-import {
-  AttributeCompression_default
-} from "./chunk-NGPPMXRM.js";
-import {
-  IndexDatatype_default
-} from "./chunk-26GA3JAM.js";
-import {
-  Rectangle_default,
-  combine_default
-} from "./chunk-5PTXS2GO.js";
-import "./chunk-K4GQUNB5.js";
-import {
-  Cartesian3_default,
-  Cartographic_default,
-  Ellipsoid_default
-} from "./chunk-YFXQECWV.js";
-import {
-  Math_default
-} from "./chunk-XY4BATBS.js";
-import "./chunk-MXIZJAPH.js";
-import "./chunk-6CHGCNMW.js";
-import "./chunk-7JO7GPJN.js";
-import "./chunk-AD63PIY6.js";
-import "./chunk-E63IIM5T.js";
-
-// packages/engine/Source/Workers/createVectorTileClampedPolylines.js
-var MAX_SHORT = 32767;
-var MITER_BREAK = Math.cos(Math_default.toRadians(150));
-var scratchBVCartographic = new Cartographic_default();
-var scratchEncodedPosition = new Cartesian3_default();
-function decodePositions(uBuffer, vBuffer, heightBuffer, rectangle, minimumHeight, maximumHeight, ellipsoid) {
-  const positionsLength = uBuffer.length;
-  const decodedPositions = new Float64Array(positionsLength * 3);
-  for (let i = 0; i < positionsLength; ++i) {
-    const u = uBuffer[i];
-    const v = vBuffer[i];
-    const h = heightBuffer[i];
-    const lon = Math_default.lerp(rectangle.west, rectangle.east, u / MAX_SHORT);
-    const lat = Math_default.lerp(
-      rectangle.south,
-      rectangle.north,
-      v / MAX_SHORT
-    );
-    const alt = Math_default.lerp(minimumHeight, maximumHeight, h / MAX_SHORT);
-    const cartographic = Cartographic_default.fromRadians(
-      lon,
-      lat,
-      alt,
-      scratchBVCartographic
-    );
-    const decodedPosition = ellipsoid.cartographicToCartesian(
-      cartographic,
-      scratchEncodedPosition
-    );
-    Cartesian3_default.pack(decodedPosition, decodedPositions, i * 3);
-  }
-  return decodedPositions;
-}
-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;
-}
-var previousCompressedCartographicScratch = new Cartographic_default();
-var currentCompressedCartographicScratch = new Cartographic_default();
-function removeDuplicates(uBuffer, vBuffer, heightBuffer, counts) {
-  const countsLength = counts.length;
-  const positionsLength = uBuffer.length;
-  const markRemoval = new Uint8Array(positionsLength);
-  const previous = previousCompressedCartographicScratch;
-  const current = currentCompressedCartographicScratch;
-  let offset = 0;
-  for (let i = 0; i < countsLength; i++) {
-    const count = counts[i];
-    let updatedCount = count;
-    for (let j = 1; j < count; j++) {
-      const index = offset + j;
-      const previousIndex = index - 1;
-      current.longitude = uBuffer[index];
-      current.latitude = vBuffer[index];
-      previous.longitude = uBuffer[previousIndex];
-      previous.latitude = vBuffer[previousIndex];
-      if (Cartographic_default.equals(current, previous)) {
-        updatedCount--;
-        markRemoval[previousIndex] = 1;
-      }
-    }
-    counts[i] = updatedCount;
-    offset += count;
-  }
-  let nextAvailableIndex = 0;
-  for (let k = 0; k < positionsLength; k++) {
-    if (markRemoval[k] !== 1) {
-      uBuffer[nextAvailableIndex] = uBuffer[k];
-      vBuffer[nextAvailableIndex] = vBuffer[k];
-      heightBuffer[nextAvailableIndex] = heightBuffer[k];
-      nextAvailableIndex++;
-    }
-  }
-}
-function VertexAttributesAndIndices(volumesCount) {
-  const vertexCount = volumesCount * 8;
-  const vec3Floats = vertexCount * 3;
-  const vec4Floats = vertexCount * 4;
-  this.startEllipsoidNormals = new Float32Array(vec3Floats);
-  this.endEllipsoidNormals = new Float32Array(vec3Floats);
-  this.startPositionAndHeights = new Float32Array(vec4Floats);
-  this.startFaceNormalAndVertexCornerIds = new Float32Array(vec4Floats);
-  this.endPositionAndHeights = new Float32Array(vec4Floats);
-  this.endFaceNormalAndHalfWidths = new Float32Array(vec4Floats);
-  this.vertexBatchIds = new Uint16Array(vertexCount);
-  this.indices = IndexDatatype_default.createTypedArray(vertexCount, 36 * volumesCount);
-  this.vec3Offset = 0;
-  this.vec4Offset = 0;
-  this.batchIdOffset = 0;
-  this.indexOffset = 0;
-  this.volumeStartIndex = 0;
-}
-var towardCurrScratch = new Cartesian3_default();
-var towardNextScratch = new Cartesian3_default();
-function computeMiteredNormal(previousPosition, position, nextPosition, ellipsoidSurfaceNormal, result) {
-  const towardNext = Cartesian3_default.subtract(
-    nextPosition,
-    position,
-    towardNextScratch
-  );
-  let towardCurr = Cartesian3_default.subtract(
-    position,
-    previousPosition,
-    towardCurrScratch
-  );
-  Cartesian3_default.normalize(towardNext, towardNext);
-  Cartesian3_default.normalize(towardCurr, towardCurr);
-  if (Cartesian3_default.dot(towardNext, towardCurr) < MITER_BREAK) {
-    towardCurr = Cartesian3_default.multiplyByScalar(
-      towardCurr,
-      -1,
-      towardCurrScratch
-    );
-  }
-  Cartesian3_default.add(towardNext, towardCurr, result);
-  if (Cartesian3_default.equals(result, Cartesian3_default.ZERO)) {
-    result = Cartesian3_default.subtract(previousPosition, position);
-  }
-  Cartesian3_default.cross(result, ellipsoidSurfaceNormal, result);
-  Cartesian3_default.cross(ellipsoidSurfaceNormal, result, result);
-  Cartesian3_default.normalize(result, result);
-  return result;
-}
-var REFERENCE_INDICES = [
-  0,
-  2,
-  6,
-  0,
-  6,
-  4,
-  // right
-  0,
-  1,
-  3,
-  0,
-  3,
-  2,
-  // start face
-  0,
-  4,
-  5,
-  0,
-  5,
-  1,
-  // bottom
-  5,
-  3,
-  1,
-  5,
-  7,
-  3,
-  // left
-  7,
-  5,
-  4,
-  7,
-  4,
-  6,
-  // end face
-  7,
-  6,
-  2,
-  7,
-  2,
-  3
-  // top
-];
-var REFERENCE_INDICES_LENGTH = REFERENCE_INDICES.length;
-var positionScratch = new Cartesian3_default();
-var scratchStartEllipsoidNormal = new Cartesian3_default();
-var scratchStartFaceNormal = new Cartesian3_default();
-var scratchEndEllipsoidNormal = new Cartesian3_default();
-var scratchEndFaceNormal = new Cartesian3_default();
-VertexAttributesAndIndices.prototype.addVolume = function(preStartRTC, startRTC, endRTC, postEndRTC, startHeight, endHeight, halfWidth, batchId, center, ellipsoid) {
-  let position = Cartesian3_default.add(startRTC, center, positionScratch);
-  const startEllipsoidNormal = ellipsoid.geodeticSurfaceNormal(
-    position,
-    scratchStartEllipsoidNormal
-  );
-  position = Cartesian3_default.add(endRTC, center, positionScratch);
-  const endEllipsoidNormal = ellipsoid.geodeticSurfaceNormal(
-    position,
-    scratchEndEllipsoidNormal
-  );
-  const startFaceNormal = computeMiteredNormal(
-    preStartRTC,
-    startRTC,
-    endRTC,
-    startEllipsoidNormal,
-    scratchStartFaceNormal
-  );
-  const endFaceNormal = computeMiteredNormal(
-    postEndRTC,
-    endRTC,
-    startRTC,
-    endEllipsoidNormal,
-    scratchEndFaceNormal
-  );
-  const startEllipsoidNormals = this.startEllipsoidNormals;
-  const endEllipsoidNormals = this.endEllipsoidNormals;
-  const startPositionAndHeights = this.startPositionAndHeights;
-  const startFaceNormalAndVertexCornerIds = this.startFaceNormalAndVertexCornerIds;
-  const endPositionAndHeights = this.endPositionAndHeights;
-  const endFaceNormalAndHalfWidths = this.endFaceNormalAndHalfWidths;
-  const vertexBatchIds = this.vertexBatchIds;
-  let batchIdOffset = this.batchIdOffset;
-  let vec3Offset = this.vec3Offset;
-  let vec4Offset = this.vec4Offset;
-  let i;
-  for (i = 0; i < 8; i++) {
-    Cartesian3_default.pack(startEllipsoidNormal, startEllipsoidNormals, vec3Offset);
-    Cartesian3_default.pack(endEllipsoidNormal, endEllipsoidNormals, vec3Offset);
-    Cartesian3_default.pack(startRTC, startPositionAndHeights, vec4Offset);
-    startPositionAndHeights[vec4Offset + 3] = startHeight;
-    Cartesian3_default.pack(endRTC, endPositionAndHeights, vec4Offset);
-    endPositionAndHeights[vec4Offset + 3] = endHeight;
-    Cartesian3_default.pack(
-      startFaceNormal,
-      startFaceNormalAndVertexCornerIds,
-      vec4Offset
-    );
-    startFaceNormalAndVertexCornerIds[vec4Offset + 3] = i;
-    Cartesian3_default.pack(endFaceNormal, endFaceNormalAndHalfWidths, vec4Offset);
-    endFaceNormalAndHalfWidths[vec4Offset + 3] = halfWidth;
-    vertexBatchIds[batchIdOffset++] = batchId;
-    vec3Offset += 3;
-    vec4Offset += 4;
-  }
-  this.batchIdOffset = batchIdOffset;
-  this.vec3Offset = vec3Offset;
-  this.vec4Offset = vec4Offset;
-  const indices = this.indices;
-  const volumeStartIndex = this.volumeStartIndex;
-  const indexOffset = this.indexOffset;
-  for (i = 0; i < REFERENCE_INDICES_LENGTH; i++) {
-    indices[indexOffset + i] = REFERENCE_INDICES[i] + volumeStartIndex;
-  }
-  this.volumeStartIndex += 8;
-  this.indexOffset += REFERENCE_INDICES_LENGTH;
-};
-var scratchRectangle = new Rectangle_default();
-var scratchEllipsoid = new Ellipsoid_default();
-var scratchCenter = new Cartesian3_default();
-var scratchPrev = new Cartesian3_default();
-var scratchP0 = new Cartesian3_default();
-var scratchP1 = new Cartesian3_default();
-var scratchNext = new Cartesian3_default();
-function createVectorTileClampedPolylines(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);
-  const rectangle = scratchRectangle;
-  const ellipsoid = scratchEllipsoid;
-  const center = scratchCenter;
-  const packedBuffer = new Float64Array(parameters.packedBuffer);
-  let offset = 0;
-  const minimumHeight = packedBuffer[offset++];
-  const maximumHeight = packedBuffer[offset++];
-  Rectangle_default.unpack(packedBuffer, offset, rectangle);
-  offset += Rectangle_default.packedLength;
-  Ellipsoid_default.unpack(packedBuffer, offset, ellipsoid);
-  offset += Ellipsoid_default.packedLength;
-  Cartesian3_default.unpack(packedBuffer, offset, center);
-  let i;
-  let positionsLength = encodedPositions.length / 3;
-  const uBuffer = encodedPositions.subarray(0, positionsLength);
-  const vBuffer = encodedPositions.subarray(
-    positionsLength,
-    2 * positionsLength
-  );
-  const heightBuffer = encodedPositions.subarray(
-    2 * positionsLength,
-    3 * positionsLength
-  );
-  AttributeCompression_default.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
-  removeDuplicates(uBuffer, vBuffer, heightBuffer, counts);
-  const countsLength = counts.length;
-  let volumesCount = 0;
-  for (i = 0; i < countsLength; i++) {
-    const polylinePositionCount = counts[i];
-    volumesCount += polylinePositionCount - 1;
-  }
-  const attribsAndIndices = new VertexAttributesAndIndices(volumesCount);
-  const positions = decodePositions(
-    uBuffer,
-    vBuffer,
-    heightBuffer,
-    rectangle,
-    minimumHeight,
-    maximumHeight,
-    ellipsoid,
-    center
-  );
-  positionsLength = uBuffer.length;
-  const positionsRTC = new Float32Array(positionsLength * 3);
-  for (i = 0; i < positionsLength; ++i) {
-    positionsRTC[i * 3] = positions[i * 3] - center.x;
-    positionsRTC[i * 3 + 1] = positions[i * 3 + 1] - center.y;
-    positionsRTC[i * 3 + 2] = positions[i * 3 + 2] - center.z;
-  }
-  let currentPositionIndex = 0;
-  let currentHeightIndex = 0;
-  for (i = 0; i < countsLength; i++) {
-    const polylineVolumeCount = counts[i] - 1;
-    const halfWidth = widths[i] * 0.5;
-    const batchId = batchIds[i];
-    const volumeFirstPositionIndex = currentPositionIndex;
-    for (let j = 0; j < polylineVolumeCount; j++) {
-      const volumeStart = Cartesian3_default.unpack(
-        positionsRTC,
-        currentPositionIndex,
-        scratchP0
-      );
-      const volumeEnd = Cartesian3_default.unpack(
-        positionsRTC,
-        currentPositionIndex + 3,
-        scratchP1
-      );
-      let startHeight = heightBuffer[currentHeightIndex];
-      let endHeight = heightBuffer[currentHeightIndex + 1];
-      startHeight = Math_default.lerp(
-        minimumHeight,
-        maximumHeight,
-        startHeight / MAX_SHORT
-      );
-      endHeight = Math_default.lerp(
-        minimumHeight,
-        maximumHeight,
-        endHeight / MAX_SHORT
-      );
-      currentHeightIndex++;
-      let preStart = scratchPrev;
-      let postEnd = scratchNext;
-      if (j === 0) {
-        const finalPositionIndex = volumeFirstPositionIndex + polylineVolumeCount * 3;
-        const finalPosition = Cartesian3_default.unpack(
-          positionsRTC,
-          finalPositionIndex,
-          scratchPrev
-        );
-        if (Cartesian3_default.equals(finalPosition, volumeStart)) {
-          Cartesian3_default.unpack(positionsRTC, finalPositionIndex - 3, preStart);
-        } else {
-          const offsetPastStart = Cartesian3_default.subtract(
-            volumeStart,
-            volumeEnd,
-            scratchPrev
-          );
-          preStart = Cartesian3_default.add(offsetPastStart, volumeStart, scratchPrev);
-        }
-      } else {
-        Cartesian3_default.unpack(positionsRTC, currentPositionIndex - 3, preStart);
-      }
-      if (j === polylineVolumeCount - 1) {
-        const firstPosition = Cartesian3_default.unpack(
-          positionsRTC,
-          volumeFirstPositionIndex,
-          scratchNext
-        );
-        if (Cartesian3_default.equals(firstPosition, volumeEnd)) {
-          Cartesian3_default.unpack(
-            positionsRTC,
-            volumeFirstPositionIndex + 3,
-            postEnd
-          );
-        } else {
-          const offsetPastEnd = Cartesian3_default.subtract(
-            volumeEnd,
-            volumeStart,
-            scratchNext
-          );
-          postEnd = Cartesian3_default.add(offsetPastEnd, volumeEnd, scratchNext);
-        }
-      } else {
-        Cartesian3_default.unpack(positionsRTC, currentPositionIndex + 6, postEnd);
-      }
-      attribsAndIndices.addVolume(
-        preStart,
-        volumeStart,
-        volumeEnd,
-        postEnd,
-        startHeight,
-        endHeight,
-        halfWidth,
-        batchId,
-        center,
-        ellipsoid
-      );
-      currentPositionIndex += 3;
-    }
-    currentPositionIndex += 3;
-    currentHeightIndex++;
-  }
-  const indices = attribsAndIndices.indices;
-  transferableObjects.push(attribsAndIndices.startEllipsoidNormals.buffer);
-  transferableObjects.push(attribsAndIndices.endEllipsoidNormals.buffer);
-  transferableObjects.push(attribsAndIndices.startPositionAndHeights.buffer);
-  transferableObjects.push(
-    attribsAndIndices.startFaceNormalAndVertexCornerIds.buffer
-  );
-  transferableObjects.push(attribsAndIndices.endPositionAndHeights.buffer);
-  transferableObjects.push(attribsAndIndices.endFaceNormalAndHalfWidths.buffer);
-  transferableObjects.push(attribsAndIndices.vertexBatchIds.buffer);
-  transferableObjects.push(indices.buffer);
-  let results = {
-    indexDatatype: indices.BYTES_PER_ELEMENT === 2 ? IndexDatatype_default.UNSIGNED_SHORT : IndexDatatype_default.UNSIGNED_INT,
-    startEllipsoidNormals: attribsAndIndices.startEllipsoidNormals.buffer,
-    endEllipsoidNormals: attribsAndIndices.endEllipsoidNormals.buffer,
-    startPositionAndHeights: attribsAndIndices.startPositionAndHeights.buffer,
-    startFaceNormalAndVertexCornerIds: attribsAndIndices.startFaceNormalAndVertexCornerIds.buffer,
-    endPositionAndHeights: attribsAndIndices.endPositionAndHeights.buffer,
-    endFaceNormalAndHalfWidths: attribsAndIndices.endFaceNormalAndHalfWidths.buffer,
-    vertexBatchIds: attribsAndIndices.vertexBatchIds.buffer,
-    indices: indices.buffer
-  };
-  if (parameters.keepDecodedPositions) {
-    const positionOffsets = getPositionOffsets(counts);
-    transferableObjects.push(positions.buffer, positionOffsets.buffer);
-    results = combine_default(results, {
-      decodedPositions: positions.buffer,
-      decodedPositionOffsets: positionOffsets.buffer
-    });
-  }
-  return results;
-}
-var createVectorTileClampedPolylines_default = createTaskProcessorWorker_default(createVectorTileClampedPolylines);
-export {
-  createVectorTileClampedPolylines_default as default
-};
+import{a as J}from"./chunk-WZDE3RYP.js";import{a as Y}from"./chunk-DEPHB2WM.js";import{a as B}from"./chunk-OFUUQVMR.js";import{c as X,h as W}from"./chunk-PSPPBZWI.js";import"./chunk-AU7IKHOH.js";import{a as t,b as k,d as _}from"./chunk-64RSHJUE.js";import{a as v}from"./chunk-3SSKC3VN.js";import"./chunk-OSW76XDF.js";import"./chunk-ED5JPB3S.js";import"./chunk-LEYMRMBK.js";import"./chunk-VTAIKJXX.js";var V=32767,it=Math.cos(v.toRadians(150)),ct=new k,rt=new t;function at(e,o,c,i,s,A,h){let g=e.length,f=new Float64Array(g*3);for(let d=0;d<g;++d){let l=e[d],r=o[d],E=c[d],n=v.lerp(i.west,i.east,l/V),p=v.lerp(i.south,i.north,r/V),w=v.lerp(s,A,E/V),x=k.fromRadians(n,p,w,ct),P=h.cartographicToCartesian(x,rt);t.pack(P,f,d*3)}return f}function dt(e){let o=e.length,c=new Uint32Array(o+1),i=0;for(let s=0;s<o;++s)c[s]=i,i+=e[s];return c[o]=i,c}var lt=new k,ht=new k;function ft(e,o,c,i){let s=i.length,A=e.length,h=new Uint8Array(A),g=lt,f=ht,d=0;for(let r=0;r<s;r++){let E=i[r],n=E;for(let p=1;p<E;p++){let w=d+p,x=w-1;f.longitude=e[w],f.latitude=o[w],g.longitude=e[x],g.latitude=o[x],k.equals(f,g)&&(n--,h[x]=1)}i[r]=n,d+=E}let l=0;for(let r=0;r<A;r++)h[r]!==1&&(e[l]=e[r],o[l]=o[r],c[l]=c[r],l++)}function ot(e){let o=e*8,c=o*3,i=o*4;this.startEllipsoidNormals=new Float32Array(c),this.endEllipsoidNormals=new Float32Array(c),this.startPositionAndHeights=new Float32Array(i),this.startFaceNormalAndVertexCornerIds=new Float32Array(i),this.endPositionAndHeights=new Float32Array(i),this.endFaceNormalAndHalfWidths=new Float32Array(i),this.vertexBatchIds=new Uint16Array(o),this.indices=B.createTypedArray(o,36*e),this.vec3Offset=0,this.vec4Offset=0,this.batchIdOffset=0,this.indexOffset=0,this.volumeStartIndex=0}var Q=new t,pt=new t;function $(e,o,c,i,s){let A=t.subtract(c,o,pt),h=t.subtract(o,e,Q);return t.normalize(A,A),t.normalize(h,h),t.dot(A,h)<it&&(h=t.multiplyByScalar(h,-1,Q)),t.add(A,h,s),t.equals(s,t.ZERO)&&(s=t.subtract(e,o)),t.cross(s,i,s),t.cross(i,s,s),t.normalize(s,s),s}var st=[0,2,6,0,6,4,0,1,3,0,3,2,0,4,5,0,5,1,5,3,1,5,7,3,7,5,4,7,4,6,7,6,2,7,2,3],j=st.length,tt=new t,ut=new t,mt=new t,At=new t,Nt=new t;ot.prototype.addVolume=function(e,o,c,i,s,A,h,g,f,d){let l=t.add(o,f,tt),r=d.geodeticSurfaceNormal(l,ut);l=t.add(c,f,tt);let E=d.geodeticSurfaceNormal(l,At),n=$(e,o,c,r,mt),p=$(i,c,o,E,Nt),w=this.startEllipsoidNormals,x=this.endEllipsoidNormals,P=this.startPositionAndHeights,H=this.startFaceNormalAndVertexCornerIds,b=this.endPositionAndHeights,a=this.endFaceNormalAndHalfWidths,F=this.vertexBatchIds,m=this.batchIdOffset,I=this.vec3Offset,u=this.vec4Offset,N;for(N=0;N<8;N++)t.pack(r,w,I),t.pack(E,x,I),t.pack(o,P,u),P[u+3]=s,t.pack(c,b,u),b[u+3]=A,t.pack(n,H,u),H[u+3]=N,t.pack(p,a,u),a[u+3]=h,F[m++]=g,I+=3,u+=4;this.batchIdOffset=m,this.vec3Offset=I,this.vec4Offset=u;let C=this.indices,y=this.volumeStartIndex,z=this.indexOffset;for(N=0;N<j;N++)C[z+N]=st[N]+y;this.volumeStartIndex+=8,this.indexOffset+=j};var gt=new W,Et=new _,wt=new t,M=new t,It=new t,xt=new t,T=new t;function Pt(e,o){let c=new Uint16Array(e.positions),i=new Uint16Array(e.widths),s=new Uint32Array(e.counts),A=new Uint16Array(e.batchIds),h=gt,g=Et,f=wt,d=new Float64Array(e.packedBuffer),l=0,r=d[l++],E=d[l++];W.unpack(d,l,h),l+=W.packedLength,_.unpack(d,l,g),l+=_.packedLength,t.unpack(d,l,f);let n,p=c.length/3,w=c.subarray(0,p),x=c.subarray(p,2*p),P=c.subarray(2*p,3*p);Y.zigZagDeltaDecode(w,x,P),ft(w,x,P,s);let H=s.length,b=0;for(n=0;n<H;n++){let y=s[n];b+=y-1}let a=new ot(b),F=at(w,x,P,h,r,E,g,f);p=w.length;let m=new Float32Array(p*3);for(n=0;n<p;++n)m[n*3]=F[n*3]-f.x,m[n*3+1]=F[n*3+1]-f.y,m[n*3+2]=F[n*3+2]-f.z;let I=0,u=0;for(n=0;n<H;n++){let y=s[n]-1,z=i[n]*.5,et=A[n],q=I;for(let D=0;D<y;D++){let S=t.unpack(m,I,It),O=t.unpack(m,I+3,xt),G=P[u],Z=P[u+1];G=v.lerp(r,E,G/V),Z=v.lerp(r,E,Z/V),u++;let L=M,R=T;if(D===0){let U=q+y*3,K=t.unpack(m,U,M);if(t.equals(K,S))t.unpack(m,U-3,L);else{let nt=t.subtract(S,O,M);L=t.add(nt,S,M)}}else t.unpack(m,I-3,L);if(D===y-1){let U=t.unpack(m,q,T);if(t.equals(U,O))t.unpack(m,q+3,R);else{let K=t.subtract(O,S,T);R=t.add(K,O,T)}}else t.unpack(m,I+6,R);a.addVolume(L,S,O,R,G,Z,z,et,f,g),I+=3}I+=3,u++}let N=a.indices;o.push(a.startEllipsoidNormals.buffer),o.push(a.endEllipsoidNormals.buffer),o.push(a.startPositionAndHeights.buffer),o.push(a.startFaceNormalAndVertexCornerIds.buffer),o.push(a.endPositionAndHeights.buffer),o.push(a.endFaceNormalAndHalfWidths.buffer),o.push(a.vertexBatchIds.buffer),o.push(N.buffer);let C={indexDatatype:N.BYTES_PER_ELEMENT===2?B.UNSIGNED_SHORT:B.UNSIGNED_INT,startEllipsoidNormals:a.startEllipsoidNormals.buffer,endEllipsoidNormals:a.endEllipsoidNormals.buffer,startPositionAndHeights:a.startPositionAndHeights.buffer,startFaceNormalAndVertexCornerIds:a.startFaceNormalAndVertexCornerIds.buffer,endPositionAndHeights:a.endPositionAndHeights.buffer,endFaceNormalAndHalfWidths:a.endFaceNormalAndHalfWidths.buffer,vertexBatchIds:a.vertexBatchIds.buffer,indices:N.buffer};if(e.keepDecodedPositions){let y=dt(s);o.push(F.buffer,y.buffer),C=X(C,{decodedPositions:F.buffer,decodedPositionOffsets:y.buffer})}return C}var Vt=J(Pt);export{Vt as default};