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

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

@@ -1,25 +1,445 @@
-/**
- * @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(["./Transforms-d2e5867e","./BoxGeometry-4985457c","./Matrix2-eefef8eb","./Color-cc8c18b3","./CylinderGeometry-57a1051a","./defaultValue-0c475b81","./EllipsoidGeometry-377329b9","./IndexDatatype-e713bfd2","./createTaskProcessorWorker","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./_commonjsHelpers-bc29abbc","./combine-7533016d","./RuntimeError-5baf5c66","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./VertexFormat-5ec0d9ff","./CylinderGeometryLibrary-62ce5a1f"],(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}}))}));
+define(['./Transforms-40229881', './BoxGeometry-12eeccaf', './Matrix3-315394f6', './Color-a84038cb', './CylinderGeometry-7c5da648', './defaultValue-0a909f67', './EllipsoidGeometry-21c0e3a5', './IndexDatatype-a55ceaa1', './Matrix2-13178034', './createTaskProcessorWorker', './Check-666ab1a0', './Math-2dbd6b93', './combine-ca22a614', './RuntimeError-06c93819', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './VertexFormat-6b480673', './CylinderGeometryLibrary-372c07d8'], (function (Transforms, BoxGeometry, Matrix3, Color, CylinderGeometry, defaultValue, EllipsoidGeometry, IndexDatatype, Matrix2, createTaskProcessorWorker, Check, Math$1, combine, RuntimeError, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, VertexFormat, CylinderGeometryLibrary) { 'use strict';
+
+  /**
+   * Describes a renderable batch of geometry.
+   *
+   * @alias Vector3DTileBatch
+   * @constructor
+   *
+   * @param {Object} options An object with the following properties:
+   * @param {Number} options.offset The offset of the batch into the indices buffer.
+   * @param {Number} options.count The number of indices in the batch.
+   * @param {Color} options.color The color of the geometry in the batch.
+   * @param {Number[]} options.batchIds An array where each element is the batch id of the geometry in the batch.
+   *
+   * @private
+   */
+  function Vector3DTileBatch(options) {
+    /**
+     * The offset of the batch into the indices buffer.
+     * @type {Number}
+     */
+    this.offset = options.offset;
+    /**
+     * The number of indices in the batch.
+     * @type {Number}
+     */
+    this.count = options.count;
+    /**
+     * The color of the geometry in the batch.
+     * @type {Color}
+     */
+    this.color = options.color;
+    /**
+     * An array where each element is the batch id of the geometry in the batch.
+     * @type {Number[]}
+     */
+    this.batchIds = options.batchIds;
+  }
+
+  const scratchCartesian = new Matrix3.Cartesian3();
+
+  const packedBoxLength = Matrix2.Matrix4.packedLength + Matrix3.Cartesian3.packedLength;
+  const packedCylinderLength = Matrix2.Matrix4.packedLength + 2;
+  const packedEllipsoidLength = Matrix2.Matrix4.packedLength + Matrix3.Cartesian3.packedLength;
+  const packedSphereLength = Matrix3.Cartesian3.packedLength + 1;
+
+  const scratchModelMatrixAndBV = {
+    modelMatrix: new Matrix2.Matrix4(),
+    boundingVolume: new Transforms.BoundingSphere(),
+  };
+
+  function boxModelMatrixAndBoundingVolume(boxes, index) {
+    let boxIndex = index * packedBoxLength;
+
+    const dimensions = Matrix3.Cartesian3.unpack(boxes, boxIndex, scratchCartesian);
+    boxIndex += Matrix3.Cartesian3.packedLength;
+
+    const boxModelMatrix = Matrix2.Matrix4.unpack(
+      boxes,
+      boxIndex,
+      scratchModelMatrixAndBV.modelMatrix
+    );
+    Matrix2.Matrix4.multiplyByScale(boxModelMatrix, dimensions, boxModelMatrix);
+
+    const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+    Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, boundingVolume.center);
+    boundingVolume.radius = Math.sqrt(3.0);
+
+    return scratchModelMatrixAndBV;
+  }
+
+  function cylinderModelMatrixAndBoundingVolume(cylinders, index) {
+    let cylinderIndex = index * packedCylinderLength;
+
+    const cylinderRadius = cylinders[cylinderIndex++];
+    const length = cylinders[cylinderIndex++];
+    const scale = Matrix3.Cartesian3.fromElements(
+      cylinderRadius,
+      cylinderRadius,
+      length,
+      scratchCartesian
+    );
+
+    const cylinderModelMatrix = Matrix2.Matrix4.unpack(
+      cylinders,
+      cylinderIndex,
+      scratchModelMatrixAndBV.modelMatrix
+    );
+    Matrix2.Matrix4.multiplyByScale(cylinderModelMatrix, scale, cylinderModelMatrix);
+
+    const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+    Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, boundingVolume.center);
+    boundingVolume.radius = Math.sqrt(2.0);
+
+    return scratchModelMatrixAndBV;
+  }
+
+  function ellipsoidModelMatrixAndBoundingVolume(ellipsoids, index) {
+    let ellipsoidIndex = index * packedEllipsoidLength;
+
+    const radii = Matrix3.Cartesian3.unpack(ellipsoids, ellipsoidIndex, scratchCartesian);
+    ellipsoidIndex += Matrix3.Cartesian3.packedLength;
+
+    const ellipsoidModelMatrix = Matrix2.Matrix4.unpack(
+      ellipsoids,
+      ellipsoidIndex,
+      scratchModelMatrixAndBV.modelMatrix
+    );
+    Matrix2.Matrix4.multiplyByScale(ellipsoidModelMatrix, radii, ellipsoidModelMatrix);
+
+    const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+    Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, boundingVolume.center);
+    boundingVolume.radius = 1.0;
+
+    return scratchModelMatrixAndBV;
+  }
+
+  function sphereModelMatrixAndBoundingVolume(spheres, index) {
+    let sphereIndex = index * packedSphereLength;
+
+    const sphereRadius = spheres[sphereIndex++];
+
+    const sphereTranslation = Matrix3.Cartesian3.unpack(
+      spheres,
+      sphereIndex,
+      scratchCartesian
+    );
+    const sphereModelMatrix = Matrix2.Matrix4.fromTranslation(
+      sphereTranslation,
+      scratchModelMatrixAndBV.modelMatrix
+    );
+    Matrix2.Matrix4.multiplyByUniformScale(
+      sphereModelMatrix,
+      sphereRadius,
+      sphereModelMatrix
+    );
+
+    const boundingVolume = scratchModelMatrixAndBV.boundingVolume;
+    Matrix3.Cartesian3.clone(Matrix3.Cartesian3.ZERO, boundingVolume.center);
+    boundingVolume.radius = 1.0;
+
+    return scratchModelMatrixAndBV;
+  }
+
+  const scratchPosition = new Matrix3.Cartesian3();
+
+  function createPrimitive(
+    options,
+    primitive,
+    primitiveBatchIds,
+    geometry,
+    getModelMatrixAndBoundingVolume
+  ) {
+    if (!defaultValue.defined(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;
+      Matrix2.Matrix4.multiply(modelMatrix, primitiveModelMatrix, primitiveModelMatrix);
+
+      const batchId = primitiveBatchIds[i];
+
+      const positionsLength = geometryPositions.length;
+      for (let j = 0; j < positionsLength; j += 3) {
+        const position = Matrix3.Cartesian3.unpack(geometryPositions, j, scratchPosition);
+        Matrix2.Matrix4.multiplyByPoint(primitiveModelMatrix, position, position);
+        Matrix3.Cartesian3.subtract(position, center, position);
+
+        Matrix3.Cartesian3.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({
+        offset: indexOffset,
+        count: indicesLength,
+        color: Color.Color.fromRgba(batchTableColors[batchId]),
+        batchIds: [batchId],
+      });
+      batchIds[offset] = batchId;
+      indexOffsets[offset] = indexOffset;
+      indexCounts[offset] = indicesLength;
+      boundingVolumes[offset] = Transforms.BoundingSphere.transform(
+        primitiveModelMatrixAndBV.boundingVolume,
+        primitiveModelMatrix
+      );
+
+      positionOffset += positionsLength / 3;
+      indexOffset += indicesLength;
+    }
+
+    options.positionOffset = positionOffset;
+    options.batchIdIndex = batchIdIndex;
+    options.indexOffset = indexOffset;
+    options.batchedIndicesOffset += numberOfPrimitives;
+  }
+
+  const scratchCenter = new Matrix3.Cartesian3();
+  const scratchMatrix4 = new Matrix2.Matrix4();
+
+  function unpackBuffer(buffer) {
+    const packedBuffer = new Float64Array(buffer);
+
+    let offset = 0;
+    Matrix3.Cartesian3.unpack(packedBuffer, offset, scratchCenter);
+    offset += Matrix3.Cartesian3.packedLength;
+
+    Matrix2.Matrix4.unpack(packedBuffer, offset, scratchMatrix4);
+  }
+
+  function packedBatchedIndicesLength(batchedIndices) {
+    const length = batchedIndices.length;
+    let count = 0;
+    for (let i = 0; i < length; ++i) {
+      count += Color.Color.packedLength + 3 + batchedIndices[i].batchIds.length;
+    }
+    return count;
+  }
+
+  function packBuffer(indicesBytesPerElement, batchedIndices, boundingVolumes) {
+    const numBVs = boundingVolumes.length;
+    const length =
+      1 +
+      1 +
+      numBVs * Transforms.BoundingSphere.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) {
+      Transforms.BoundingSphere.pack(boundingVolumes[i], packedBuffer, offset);
+      offset += Transforms.BoundingSphere.packedLength;
+    }
+
+    const indicesLength = batchedIndices.length;
+    packedBuffer[offset++] = indicesLength;
+
+    for (let j = 0; j < indicesLength; ++j) {
+      const batchedIndex = batchedIndices[j];
+
+      Color.Color.pack(batchedIndex.color, packedBuffer, offset);
+      offset += Color.Color.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 = defaultValue.defined(parameters.boxes)
+      ? new Float32Array(parameters.boxes)
+      : undefined;
+    const boxBatchIds = defaultValue.defined(parameters.boxBatchIds)
+      ? new Uint16Array(parameters.boxBatchIds)
+      : undefined;
+    const cylinders = defaultValue.defined(parameters.cylinders)
+      ? new Float32Array(parameters.cylinders)
+      : undefined;
+    const cylinderBatchIds = defaultValue.defined(parameters.cylinderBatchIds)
+      ? new Uint16Array(parameters.cylinderBatchIds)
+      : undefined;
+    const ellipsoids = defaultValue.defined(parameters.ellipsoids)
+      ? new Float32Array(parameters.ellipsoids)
+      : undefined;
+    const ellipsoidBatchIds = defaultValue.defined(parameters.ellipsoidBatchIds)
+      ? new Uint16Array(parameters.ellipsoidBatchIds)
+      : undefined;
+    const spheres = defaultValue.defined(parameters.spheres)
+      ? new Float32Array(parameters.spheres)
+      : undefined;
+    const sphereBatchIds = defaultValue.defined(parameters.sphereBatchIds)
+      ? new Uint16Array(parameters.sphereBatchIds)
+      : undefined;
+
+    const numberOfBoxes = defaultValue.defined(boxes) ? boxBatchIds.length : 0;
+    const numberOfCylinders = defaultValue.defined(cylinders) ? cylinderBatchIds.length : 0;
+    const numberOfEllipsoids = defaultValue.defined(ellipsoids) ? ellipsoidBatchIds.length : 0;
+    const numberOfSpheres = defaultValue.defined(spheres) ? sphereBatchIds.length : 0;
+
+    const boxGeometry = BoxGeometry.BoxGeometry.getUnitBox();
+    const cylinderGeometry = CylinderGeometry.CylinderGeometry.getUnitCylinder();
+    const ellipsoidGeometry = EllipsoidGeometry.EllipsoidGeometry.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.IndexDatatype.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: positions,
+      vertexBatchIds: vertexBatchIds,
+      indices: indices,
+      batchIds: batchIds,
+      batchedIndices: batchedIndices,
+      indexOffsets: indexOffsets,
+      indexCounts: indexCounts,
+      boundingVolumes: 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$1 = createTaskProcessorWorker(createVectorTileGeometries);
+
+  return createVectorTileGeometries$1;
+
+}));

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

@@ -1,25 +1,79 @@
-/**
- * @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(["./AttributeCompression-7b0f288d","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./createTaskProcessorWorker","./defaultValue-0c475b81","./RuntimeError-5baf5c66","./WebGLConstants-5b50ced1"],(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,f={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;f.min=e[a++],f.max=e[a++],t.Rectangle.unpack(e,a,p),a+=t.Rectangle.packedLength,t.Ellipsoid.unpack(e,a,l)}(r.packedBuffer);const i=p,b=l,m=f.min,d=f.max,h=o.length/3,C=o.subarray(0,h),g=o.subarray(h,2*h),w=o.subarray(2*h,3*h);e.AttributeCompression.zigZagDeltaDecode(C,g,w);const k=new Float64Array(o.length);for(let e=0;e<h;++e){const r=C[e],n=g[e],o=w[e],p=a.CesiumMath.lerp(i.west,i.east,r/s),l=a.CesiumMath.lerp(i.south,i.north,n/s),f=a.CesiumMath.lerp(m,d,o/s),h=t.Cartographic.fromRadians(p,l,f,c),y=b.cartographicToCartesian(h,u);t.Cartesian3.pack(y,k,3*e)}return n.push(k.buffer),{positions:k.buffer}}))}));
+define(['./AttributeCompression-b646d393', './Matrix3-315394f6', './Math-2dbd6b93', './Matrix2-13178034', './createTaskProcessorWorker', './ComponentDatatype-f7b11d02', './defaultValue-0a909f67', './Check-666ab1a0', './WebGLConstants-a8cc3e8c', './RuntimeError-06c93819'], (function (AttributeCompression, Matrix3, Math, Matrix2, createTaskProcessorWorker, ComponentDatatype, defaultValue, Check, WebGLConstants, RuntimeError) { 'use strict';
+
+  const maxShort = 32767;
+
+  const scratchBVCartographic = new Matrix3.Cartographic();
+  const scratchEncodedPosition = new Matrix3.Cartesian3();
+
+  const scratchRectangle = new Matrix2.Rectangle();
+  const scratchEllipsoid = new Matrix3.Ellipsoid();
+  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);
+  }
+
+  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.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);
+    }
+
+    transferableObjects.push(decoded.buffer);
+
+    return {
+      positions: decoded.buffer,
+    };
+  }
+  var createVectorTilePoints$1 = createTaskProcessorWorker(createVectorTilePoints);
+
+  return createVectorTilePoints$1;
+
+}));