@vcmap/ui 5.0.0-rc.8 → 5.0.0

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

@@ -1 +1,386 @@
-define(["./Transforms-c8cb8f43","./BoxGeometry-f8f9c981","./Matrix2-47e98d76","./Color-de06a177","./CylinderGeometry-82a8cbe6","./defaultValue-81eec7ed","./EllipsoidGeometry-7c99fc81","./IndexDatatype-f1dcdf35","./createTaskProcessorWorker","./RuntimeError-8952249c","./ComponentDatatype-a15c9a19","./WebGLConstants-508b9636","./_commonjsHelpers-3aae1032-26891ab7","./combine-3c023bda","./GeometryOffsetAttribute-8c5e10db","./GeometryAttribute-89a520b9","./GeometryAttributes-32b29525","./VertexFormat-a0b706b0","./CylinderGeometryLibrary-76cda53e"],(function(e,t,n,r,a,i,o,s,c,d,l,f,u,h,b,p,y,x,g){"use strict";function m(e){this.offset=e.offset,this.count=e.count,this.color=e.color,this.batchIds=e.batchIds}const C=new n.Cartesian3,I=n.Matrix4.packedLength+n.Cartesian3.packedLength,k=n.Matrix4.packedLength+2,M=n.Matrix4.packedLength+n.Cartesian3.packedLength,B=n.Cartesian3.packedLength+1,w={modelMatrix:new n.Matrix4,boundingVolume:new e.BoundingSphere};function A(e,t){let r=t*I;const a=n.Cartesian3.unpack(e,r,C);r+=n.Cartesian3.packedLength;const i=n.Matrix4.unpack(e,r,w.modelMatrix);n.Matrix4.multiplyByScale(i,a,i);const o=w.boundingVolume;return n.Cartesian3.clone(n.Cartesian3.ZERO,o.center),o.radius=Math.sqrt(3),w}function O(e,t){let r=t*k;const a=e[r++],i=e[r++],o=n.Cartesian3.fromElements(a,a,i,C),s=n.Matrix4.unpack(e,r,w.modelMatrix);n.Matrix4.multiplyByScale(s,o,s);const c=w.boundingVolume;return n.Cartesian3.clone(n.Cartesian3.ZERO,c.center),c.radius=Math.sqrt(2),w}function L(e,t){let r=t*M;const a=n.Cartesian3.unpack(e,r,C);r+=n.Cartesian3.packedLength;const i=n.Matrix4.unpack(e,r,w.modelMatrix);n.Matrix4.multiplyByScale(i,a,i);const o=w.boundingVolume;return n.Cartesian3.clone(n.Cartesian3.ZERO,o.center),o.radius=1,w}function v(e,t){let r=t*B;const a=e[r++],i=n.Cartesian3.unpack(e,r,C),o=n.Matrix4.fromTranslation(i,w.modelMatrix);n.Matrix4.multiplyByUniformScale(o,a,o);const s=w.boundingVolume;return n.Cartesian3.clone(n.Cartesian3.ZERO,s.center),s.radius=1,w}const E=new n.Cartesian3;function U(t,a,o,s,c){if(!i.defined(a))return;const d=o.length,l=s.attributes.position.values,f=s.indices,u=t.positions,h=t.vertexBatchIds,b=t.indices,p=t.batchIds,y=t.batchTableColors,x=t.batchedIndices,g=t.indexOffsets,C=t.indexCounts,I=t.boundingVolumes,k=t.modelMatrix,M=t.center;let B=t.positionOffset,w=t.batchIdIndex,A=t.indexOffset;const O=t.batchedIndicesOffset;for(let t=0;t<d;++t){const i=c(a,t),s=i.modelMatrix;n.Matrix4.multiply(k,s,s);const d=o[t],L=l.length;for(let e=0;e<L;e+=3){const t=n.Cartesian3.unpack(l,e,E);n.Matrix4.multiplyByPoint(s,t,t),n.Cartesian3.subtract(t,M,t),n.Cartesian3.pack(t,u,3*B+e),h[w++]=d}const v=f.length;for(let e=0;e<v;++e)b[A+e]=f[e]+B;const U=t+O;x[U]=new m({offset:A,count:v,color:r.Color.fromRgba(y[d]),batchIds:[d]}),p[U]=d,g[U]=A,C[U]=v,I[U]=e.BoundingSphere.transform(i.boundingVolume,s),B+=L/3,A+=v}t.positionOffset=B,t.batchIdIndex=w,t.indexOffset=A,t.batchedIndicesOffset+=d}const G=new n.Cartesian3,S=new n.Matrix4;function V(t,n,a){const i=a.length,o=2+i*e.BoundingSphere.packedLength+1+function(e){const t=e.length;let n=0;for(let a=0;a<t;++a)n+=r.Color.packedLength+3+e[a].batchIds.length;return n}(n),s=new Float64Array(o);let c=0;s[c++]=t,s[c++]=i;for(let t=0;t<i;++t)e.BoundingSphere.pack(a[t],s,c),c+=e.BoundingSphere.packedLength;const d=n.length;s[c++]=d;for(let e=0;e<d;++e){const t=n[e];r.Color.pack(t.color,s,c),c+=r.Color.packedLength,s[c++]=t.offset,s[c++]=t.count;const a=t.batchIds,i=a.length;s[c++]=i;for(let e=0;e<i;++e)s[c++]=a[e]}return s}return c((function(e,r){const c=i.defined(e.boxes)?new Float32Array(e.boxes):void 0,d=i.defined(e.boxBatchIds)?new Uint16Array(e.boxBatchIds):void 0,l=i.defined(e.cylinders)?new Float32Array(e.cylinders):void 0,f=i.defined(e.cylinderBatchIds)?new Uint16Array(e.cylinderBatchIds):void 0,u=i.defined(e.ellipsoids)?new Float32Array(e.ellipsoids):void 0,h=i.defined(e.ellipsoidBatchIds)?new Uint16Array(e.ellipsoidBatchIds):void 0,b=i.defined(e.spheres)?new Float32Array(e.spheres):void 0,p=i.defined(e.sphereBatchIds)?new Uint16Array(e.sphereBatchIds):void 0,y=i.defined(c)?d.length:0,x=i.defined(l)?f.length:0,g=i.defined(u)?h.length:0,m=i.defined(b)?p.length:0,C=t.BoxGeometry.getUnitBox(),I=a.CylinderGeometry.getUnitCylinder(),k=o.EllipsoidGeometry.getUnitEllipsoid(),M=C.attributes.position.values,B=I.attributes.position.values,w=k.attributes.position.values;let E=M.length*y;E+=B.length*x,E+=w.length*(g+m);const T=C.indices,F=I.indices,R=k.indices;let Z=T.length*y;Z+=F.length*x,Z+=R.length*(g+m);const D=new Float32Array(E),P=new Uint16Array(E/3),_=s.IndexDatatype.createTypedArray(E/3,Z),q=y+x+g+m,W=new Uint16Array(q),j=new Array(q),H=new Uint32Array(q),N=new Uint32Array(q),Y=new Array(q);!function(e){const t=new Float64Array(e);let r=0;n.Cartesian3.unpack(t,r,G),r+=n.Cartesian3.packedLength,n.Matrix4.unpack(t,r,S)}(e.packedBuffer);const z={batchTableColors:new Uint32Array(e.batchTableColors),positions:D,vertexBatchIds:P,indices:_,batchIds:W,batchedIndices:j,indexOffsets:H,indexCounts:N,boundingVolumes:Y,positionOffset:0,batchIdIndex:0,indexOffset:0,batchedIndicesOffset:0,modelMatrix:S,center:G};U(z,c,d,C,A),U(z,l,f,I,O),U(z,u,h,k,L),U(z,b,p,k,v);const J=V(_.BYTES_PER_ELEMENT,j,Y);return r.push(D.buffer,P.buffer,_.buffer),r.push(W.buffer,H.buffer,N.buffer),r.push(J.buffer),{positions:D.buffer,vertexBatchIds:P.buffer,indices:_.buffer,indexOffsets:H.buffer,indexCounts:N.buffer,batchIds:W.buffer,packedBuffer:J.buffer}}))}));
+/**
+ * @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 {
+  Color_default
+} from "./chunk-JS3AW5BK.js";
+import {
+  CylinderGeometry_default
+} from "./chunk-KD4Y7CZL.js";
+import "./chunk-ZFOBYDGF.js";
+import {
+  EllipsoidGeometry_default
+} from "./chunk-XY7MGBKC.js";
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  BoxGeometry_default
+} from "./chunk-ZA25DG4Y.js";
+import "./chunk-MPAZH4BF.js";
+import "./chunk-QMEMZIJI.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import "./chunk-EW2GWJYB.js";
+import "./chunk-X4SU25DT.js";
+import {
+  BoundingSphere_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import {
+  Matrix4_default
+} from "./chunk-DUHWWBQQ.js";
+import "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default
+} from "./chunk-PCJWUS4M.js";
+import "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import "./chunk-WXTV4ATB.js";
+import "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Scene/Vector3DTileBatch.js
+function Vector3DTileBatch(options) {
+  this.offset = options.offset;
+  this.count = options.count;
+  this.color = options.color;
+  this.batchIds = options.batchIds;
+}
+var Vector3DTileBatch_default = Vector3DTileBatch;
+
+// packages/engine/Source/Workers/createVectorTileGeometries.js
+var scratchCartesian = new Cartesian3_default();
+var packedBoxLength = Matrix4_default.packedLength + Cartesian3_default.packedLength;
+var packedCylinderLength = Matrix4_default.packedLength + 2;
+var packedEllipsoidLength = Matrix4_default.packedLength + Cartesian3_default.packedLength;
+var packedSphereLength = Cartesian3_default.packedLength + 1;
+var scratchModelMatrixAndBV = {
+  modelMatrix: new Matrix4_default(),
+  boundingVolume: new BoundingSphere_default()
+};
+function boxModelMatrixAndBoundingVolume(boxes, index) {
+  let boxIndex = index * packedBoxLength;
+  const dimensions = Cartesian3_default.unpack(boxes, boxIndex, scratchCartesian);
+  boxIndex += Cartesian3_default.packedLength;
+  const boxModelMatrix = Matrix4_default.unpack(
+    boxes,
+    boxIndex,
+    scratchModelMatrixAndBV.modelMatrix
+  );
+  Matrix4_default.multiplyByScale(boxModelMatrix, dimensions, boxModelMatrix);
+  const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+  Cartesian3_default.clone(Cartesian3_default.ZERO, boundingVolume.center);
+  boundingVolume.radius = Math.sqrt(3);
+  return scratchModelMatrixAndBV;
+}
+function cylinderModelMatrixAndBoundingVolume(cylinders, index) {
+  let cylinderIndex = index * packedCylinderLength;
+  const cylinderRadius = cylinders[cylinderIndex++];
+  const length = cylinders[cylinderIndex++];
+  const scale = Cartesian3_default.fromElements(
+    cylinderRadius,
+    cylinderRadius,
+    length,
+    scratchCartesian
+  );
+  const cylinderModelMatrix = Matrix4_default.unpack(
+    cylinders,
+    cylinderIndex,
+    scratchModelMatrixAndBV.modelMatrix
+  );
+  Matrix4_default.multiplyByScale(cylinderModelMatrix, scale, cylinderModelMatrix);
+  const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+  Cartesian3_default.clone(Cartesian3_default.ZERO, boundingVolume.center);
+  boundingVolume.radius = Math.sqrt(2);
+  return scratchModelMatrixAndBV;
+}
+function ellipsoidModelMatrixAndBoundingVolume(ellipsoids, index) {
+  let ellipsoidIndex = index * packedEllipsoidLength;
+  const radii = Cartesian3_default.unpack(ellipsoids, ellipsoidIndex, scratchCartesian);
+  ellipsoidIndex += Cartesian3_default.packedLength;
+  const ellipsoidModelMatrix = Matrix4_default.unpack(
+    ellipsoids,
+    ellipsoidIndex,
+    scratchModelMatrixAndBV.modelMatrix
+  );
+  Matrix4_default.multiplyByScale(ellipsoidModelMatrix, radii, ellipsoidModelMatrix);
+  const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+  Cartesian3_default.clone(Cartesian3_default.ZERO, boundingVolume.center);
+  boundingVolume.radius = 1;
+  return scratchModelMatrixAndBV;
+}
+function sphereModelMatrixAndBoundingVolume(spheres, index) {
+  let sphereIndex = index * packedSphereLength;
+  const sphereRadius = spheres[sphereIndex++];
+  const sphereTranslation = Cartesian3_default.unpack(
+    spheres,
+    sphereIndex,
+    scratchCartesian
+  );
+  const sphereModelMatrix = Matrix4_default.fromTranslation(
+    sphereTranslation,
+    scratchModelMatrixAndBV.modelMatrix
+  );
+  Matrix4_default.multiplyByUniformScale(
+    sphereModelMatrix,
+    sphereRadius,
+    sphereModelMatrix
+  );
+  const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+  Cartesian3_default.clone(Cartesian3_default.ZERO, boundingVolume.center);
+  boundingVolume.radius = 1;
+  return scratchModelMatrixAndBV;
+}
+var scratchPosition = new Cartesian3_default();
+function createPrimitive(options, primitive, primitiveBatchIds, geometry, getModelMatrixAndBoundingVolume) {
+  if (!defined_default(primitive)) {
+    return;
+  }
+  const numberOfPrimitives = primitiveBatchIds.length;
+  const geometryPositions = geometry.attributes.position.values;
+  const geometryIndices = geometry.indices;
+  const positions = options.positions;
+  const vertexBatchIds = options.vertexBatchIds;
+  const indices = options.indices;
+  const batchIds = options.batchIds;
+  const batchTableColors = options.batchTableColors;
+  const batchedIndices = options.batchedIndices;
+  const indexOffsets = options.indexOffsets;
+  const indexCounts = options.indexCounts;
+  const boundingVolumes = options.boundingVolumes;
+  const modelMatrix = options.modelMatrix;
+  const center = options.center;
+  let positionOffset = options.positionOffset;
+  let batchIdIndex = options.batchIdIndex;
+  let indexOffset = options.indexOffset;
+  const batchedIndicesOffset = options.batchedIndicesOffset;
+  for (let i = 0; i < numberOfPrimitives; ++i) {
+    const primitiveModelMatrixAndBV = getModelMatrixAndBoundingVolume(
+      primitive,
+      i
+    );
+    const primitiveModelMatrix = primitiveModelMatrixAndBV.modelMatrix;
+    Matrix4_default.multiply(modelMatrix, primitiveModelMatrix, primitiveModelMatrix);
+    const batchId = primitiveBatchIds[i];
+    const positionsLength = geometryPositions.length;
+    for (let j = 0; j < positionsLength; j += 3) {
+      const position = Cartesian3_default.unpack(geometryPositions, j, scratchPosition);
+      Matrix4_default.multiplyByPoint(primitiveModelMatrix, position, position);
+      Cartesian3_default.subtract(position, center, position);
+      Cartesian3_default.pack(position, positions, positionOffset * 3 + j);
+      vertexBatchIds[batchIdIndex++] = batchId;
+    }
+    const indicesLength = geometryIndices.length;
+    for (let k = 0; k < indicesLength; ++k) {
+      indices[indexOffset + k] = geometryIndices[k] + positionOffset;
+    }
+    const offset = i + batchedIndicesOffset;
+    batchedIndices[offset] = new Vector3DTileBatch_default({
+      offset: indexOffset,
+      count: indicesLength,
+      color: Color_default.fromRgba(batchTableColors[batchId]),
+      batchIds: [batchId]
+    });
+    batchIds[offset] = batchId;
+    indexOffsets[offset] = indexOffset;
+    indexCounts[offset] = indicesLength;
+    boundingVolumes[offset] = BoundingSphere_default.transform(
+      primitiveModelMatrixAndBV.boundingVolume,
+      primitiveModelMatrix
+    );
+    positionOffset += positionsLength / 3;
+    indexOffset += indicesLength;
+  }
+  options.positionOffset = positionOffset;
+  options.batchIdIndex = batchIdIndex;
+  options.indexOffset = indexOffset;
+  options.batchedIndicesOffset += numberOfPrimitives;
+}
+var scratchCenter = new Cartesian3_default();
+var scratchMatrix4 = new Matrix4_default();
+function unpackBuffer(buffer) {
+  const packedBuffer = new Float64Array(buffer);
+  let offset = 0;
+  Cartesian3_default.unpack(packedBuffer, offset, scratchCenter);
+  offset += Cartesian3_default.packedLength;
+  Matrix4_default.unpack(packedBuffer, offset, scratchMatrix4);
+}
+function packedBatchedIndicesLength(batchedIndices) {
+  const length = batchedIndices.length;
+  let count = 0;
+  for (let i = 0; i < length; ++i) {
+    count += Color_default.packedLength + 3 + batchedIndices[i].batchIds.length;
+  }
+  return count;
+}
+function packBuffer(indicesBytesPerElement, batchedIndices, boundingVolumes) {
+  const numBVs = boundingVolumes.length;
+  const length = 1 + 1 + numBVs * BoundingSphere_default.packedLength + 1 + packedBatchedIndicesLength(batchedIndices);
+  const packedBuffer = new Float64Array(length);
+  let offset = 0;
+  packedBuffer[offset++] = indicesBytesPerElement;
+  packedBuffer[offset++] = numBVs;
+  for (let i = 0; i < numBVs; ++i) {
+    BoundingSphere_default.pack(boundingVolumes[i], packedBuffer, offset);
+    offset += BoundingSphere_default.packedLength;
+  }
+  const indicesLength = batchedIndices.length;
+  packedBuffer[offset++] = indicesLength;
+  for (let j = 0; j < indicesLength; ++j) {
+    const batchedIndex = batchedIndices[j];
+    Color_default.pack(batchedIndex.color, packedBuffer, offset);
+    offset += Color_default.packedLength;
+    packedBuffer[offset++] = batchedIndex.offset;
+    packedBuffer[offset++] = batchedIndex.count;
+    const batchIds = batchedIndex.batchIds;
+    const batchIdsLength = batchIds.length;
+    packedBuffer[offset++] = batchIdsLength;
+    for (let k = 0; k < batchIdsLength; ++k) {
+      packedBuffer[offset++] = batchIds[k];
+    }
+  }
+  return packedBuffer;
+}
+function createVectorTileGeometries(parameters, transferableObjects) {
+  const boxes = defined_default(parameters.boxes) ? new Float32Array(parameters.boxes) : void 0;
+  const boxBatchIds = defined_default(parameters.boxBatchIds) ? new Uint16Array(parameters.boxBatchIds) : void 0;
+  const cylinders = defined_default(parameters.cylinders) ? new Float32Array(parameters.cylinders) : void 0;
+  const cylinderBatchIds = defined_default(parameters.cylinderBatchIds) ? new Uint16Array(parameters.cylinderBatchIds) : void 0;
+  const ellipsoids = defined_default(parameters.ellipsoids) ? new Float32Array(parameters.ellipsoids) : void 0;
+  const ellipsoidBatchIds = defined_default(parameters.ellipsoidBatchIds) ? new Uint16Array(parameters.ellipsoidBatchIds) : void 0;
+  const spheres = defined_default(parameters.spheres) ? new Float32Array(parameters.spheres) : void 0;
+  const sphereBatchIds = defined_default(parameters.sphereBatchIds) ? new Uint16Array(parameters.sphereBatchIds) : void 0;
+  const numberOfBoxes = defined_default(boxes) ? boxBatchIds.length : 0;
+  const numberOfCylinders = defined_default(cylinders) ? cylinderBatchIds.length : 0;
+  const numberOfEllipsoids = defined_default(ellipsoids) ? ellipsoidBatchIds.length : 0;
+  const numberOfSpheres = defined_default(spheres) ? sphereBatchIds.length : 0;
+  const boxGeometry = BoxGeometry_default.getUnitBox();
+  const cylinderGeometry = CylinderGeometry_default.getUnitCylinder();
+  const ellipsoidGeometry = EllipsoidGeometry_default.getUnitEllipsoid();
+  const boxPositions = boxGeometry.attributes.position.values;
+  const cylinderPositions = cylinderGeometry.attributes.position.values;
+  const ellipsoidPositions = ellipsoidGeometry.attributes.position.values;
+  let numberOfPositions = boxPositions.length * numberOfBoxes;
+  numberOfPositions += cylinderPositions.length * numberOfCylinders;
+  numberOfPositions += ellipsoidPositions.length * (numberOfEllipsoids + numberOfSpheres);
+  const boxIndices = boxGeometry.indices;
+  const cylinderIndices = cylinderGeometry.indices;
+  const ellipsoidIndices = ellipsoidGeometry.indices;
+  let numberOfIndices = boxIndices.length * numberOfBoxes;
+  numberOfIndices += cylinderIndices.length * numberOfCylinders;
+  numberOfIndices += ellipsoidIndices.length * (numberOfEllipsoids + numberOfSpheres);
+  const positions = new Float32Array(numberOfPositions);
+  const vertexBatchIds = new Uint16Array(numberOfPositions / 3);
+  const indices = IndexDatatype_default.createTypedArray(
+    numberOfPositions / 3,
+    numberOfIndices
+  );
+  const numberOfGeometries = numberOfBoxes + numberOfCylinders + numberOfEllipsoids + numberOfSpheres;
+  const batchIds = new Uint16Array(numberOfGeometries);
+  const batchedIndices = new Array(numberOfGeometries);
+  const indexOffsets = new Uint32Array(numberOfGeometries);
+  const indexCounts = new Uint32Array(numberOfGeometries);
+  const boundingVolumes = new Array(numberOfGeometries);
+  unpackBuffer(parameters.packedBuffer);
+  const options = {
+    batchTableColors: new Uint32Array(parameters.batchTableColors),
+    positions,
+    vertexBatchIds,
+    indices,
+    batchIds,
+    batchedIndices,
+    indexOffsets,
+    indexCounts,
+    boundingVolumes,
+    positionOffset: 0,
+    batchIdIndex: 0,
+    indexOffset: 0,
+    batchedIndicesOffset: 0,
+    modelMatrix: scratchMatrix4,
+    center: scratchCenter
+  };
+  createPrimitive(
+    options,
+    boxes,
+    boxBatchIds,
+    boxGeometry,
+    boxModelMatrixAndBoundingVolume
+  );
+  createPrimitive(
+    options,
+    cylinders,
+    cylinderBatchIds,
+    cylinderGeometry,
+    cylinderModelMatrixAndBoundingVolume
+  );
+  createPrimitive(
+    options,
+    ellipsoids,
+    ellipsoidBatchIds,
+    ellipsoidGeometry,
+    ellipsoidModelMatrixAndBoundingVolume
+  );
+  createPrimitive(
+    options,
+    spheres,
+    sphereBatchIds,
+    ellipsoidGeometry,
+    sphereModelMatrixAndBoundingVolume
+  );
+  const packedBuffer = packBuffer(
+    indices.BYTES_PER_ELEMENT,
+    batchedIndices,
+    boundingVolumes
+  );
+  transferableObjects.push(
+    positions.buffer,
+    vertexBatchIds.buffer,
+    indices.buffer
+  );
+  transferableObjects.push(
+    batchIds.buffer,
+    indexOffsets.buffer,
+    indexCounts.buffer
+  );
+  transferableObjects.push(packedBuffer.buffer);
+  return {
+    positions: positions.buffer,
+    vertexBatchIds: vertexBatchIds.buffer,
+    indices: indices.buffer,
+    indexOffsets: indexOffsets.buffer,
+    indexCounts: indexCounts.buffer,
+    batchIds: batchIds.buffer,
+    packedBuffer: packedBuffer.buffer
+  };
+}
+var createVectorTileGeometries_default = createTaskProcessorWorker_default(createVectorTileGeometries);
+export {
+  createVectorTileGeometries_default as default
+};

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

@@ -1 +1,112 @@
-define(["./AttributeCompression-80665726","./Matrix2-47e98d76","./ComponentDatatype-a15c9a19","./createTaskProcessorWorker","./RuntimeError-8952249c","./defaultValue-81eec7ed","./WebGLConstants-508b9636"],(function(e,t,a,r,n,o,i){"use strict";const s=32767,c=new t.Cartographic,u=new t.Cartesian3,p=new t.Rectangle,l=new t.Ellipsoid,m={min:void 0,max:void 0};return r((function(r,n){const o=new Uint16Array(r.positions);!function(e){e=new Float64Array(e);let a=0;m.min=e[a++],m.max=e[a++],t.Rectangle.unpack(e,a,p),a+=t.Rectangle.packedLength,t.Ellipsoid.unpack(e,a,l)}(r.packedBuffer);const i=p,f=l,d=m.min,h=m.max,C=o.length/3,g=o.subarray(0,C),b=o.subarray(C,2*C),w=o.subarray(2*C,3*C);e.AttributeCompression.zigZagDeltaDecode(g,b,w);const k=new Float64Array(o.length);for(let e=0;e<C;++e){const r=g[e],n=b[e],o=w[e],p=a.CesiumMath.lerp(i.west,i.east,r/s),l=a.CesiumMath.lerp(i.south,i.north,n/s),m=a.CesiumMath.lerp(d,h,o/s),C=t.Cartographic.fromRadians(p,l,m,c),y=f.cartographicToCartesian(C,u);t.Cartesian3.pack(y,k,3*e)}return n.push(k.buffer),{positions:k.buffer}}))}));
+/**
+ * @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 {
+  createTaskProcessorWorker_default
+} from "./chunk-A4JVFBQ3.js";
+import {
+  AttributeCompression_default
+} from "./chunk-O5AMBQ36.js";
+import {
+  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 "./chunk-4MFFIWUA.js";
+import "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Workers/createVectorTilePoints.js
+var maxShort = 32767;
+var scratchBVCartographic = new Cartographic_default();
+var scratchEncodedPosition = new Cartesian3_default();
+var scratchRectangle = new Rectangle_default();
+var scratchEllipsoid = new Ellipsoid_default();
+var scratchMinMaxHeights = {
+  min: void 0,
+  max: void 0
+};
+function unpackBuffer(packedBuffer) {
+  packedBuffer = new Float64Array(packedBuffer);
+  let offset = 0;
+  scratchMinMaxHeights.min = packedBuffer[offset++];
+  scratchMinMaxHeights.max = packedBuffer[offset++];
+  Rectangle_default.unpack(packedBuffer, offset, scratchRectangle);
+  offset += Rectangle_default.packedLength;
+  Ellipsoid_default.unpack(packedBuffer, offset, scratchEllipsoid);
+}
+function createVectorTilePoints(parameters, transferableObjects) {
+  const positions = new Uint16Array(parameters.positions);
+  unpackBuffer(parameters.packedBuffer);
+  const rectangle = scratchRectangle;
+  const ellipsoid = scratchEllipsoid;
+  const minimumHeight = scratchMinMaxHeights.min;
+  const maximumHeight = scratchMinMaxHeights.max;
+  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_default.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_default.lerp(rectangle.west, rectangle.east, u / maxShort);
+    const lat = Math_default.lerp(rectangle.south, rectangle.north, v / maxShort);
+    const alt = Math_default.lerp(minimumHeight, maximumHeight, h / maxShort);
+    const cartographic = Cartographic_default.fromRadians(
+      lon,
+      lat,
+      alt,
+      scratchBVCartographic
+    );
+    const decodedPosition = ellipsoid.cartographicToCartesian(
+      cartographic,
+      scratchEncodedPosition
+    );
+    Cartesian3_default.pack(decodedPosition, decoded, i * 3);
+  }
+  transferableObjects.push(decoded.buffer);
+  return {
+    positions: decoded.buffer
+  };
+}
+var createVectorTilePoints_default = createTaskProcessorWorker_default(createVectorTilePoints);
+export {
+  createVectorTilePoints_default as default
+};