Cesium-Prequel/Source/WorkersES6/createVectorTileGeometries.js

import BoundingSphere from "../Core/BoundingSphere.js";
import BoxGeometry from "../Core/BoxGeometry.js";
import Cartesian3 from "../Core/Cartesian3.js";
import Color from "../Core/Color.js";
import CylinderGeometry from "../Core/CylinderGeometry.js";
import defined from "../Core/defined.js";
import EllipsoidGeometry from "../Core/EllipsoidGeometry.js";
import IndexDatatype from "../Core/IndexDatatype.js";
import Matrix4 from "../Core/Matrix4.js";
import Vector3DTileBatch from "../Scene/Vector3DTileBatch.js";
import createTaskProcessorWorker from "./createTaskProcessorWorker.js";

var scratchCartesian = new Cartesian3();

var packedBoxLength = Matrix4.packedLength + Cartesian3.packedLength;
var packedCylinderLength = Matrix4.packedLength + 2;
var packedEllipsoidLength = Matrix4.packedLength + Cartesian3.packedLength;
var packedSphereLength = Cartesian3.packedLength + 1;

var scratchModelMatrixAndBV = {
  modelMatrix: new Matrix4(),
  boundingVolume: new BoundingSphere(),
};

function boxModelMatrixAndBoundingVolume(boxes, index) {
  var boxIndex = index * packedBoxLength;

  var dimensions = Cartesian3.unpack(boxes, boxIndex, scratchCartesian);
  boxIndex += Cartesian3.packedLength;

  var boxModelMatrix = Matrix4.unpack(
    boxes,
    boxIndex,
    scratchModelMatrixAndBV.modelMatrix
  );
  Matrix4.multiplyByScale(boxModelMatrix, dimensions, boxModelMatrix);

  var boundingVolume = scratchModelMatrixAndBV.boundingVolume;
  Cartesian3.clone(Cartesian3.ZERO, boundingVolume.center);
  boundingVolume.radius = Math.sqrt(3.0);

  return scratchModelMatrixAndBV;
}

function cylinderModelMatrixAndBoundingVolume(cylinders, index) {
  var cylinderIndex = index * packedCylinderLength;

  var cylinderRadius = cylinders[cylinderIndex++];
  var length = cylinders[cylinderIndex++];
  var scale = Cartesian3.fromElements(
    cylinderRadius,
    cylinderRadius,
    length,
    scratchCartesian
  );

  var cylinderModelMatrix = Matrix4.unpack(
    cylinders,
    cylinderIndex,
    scratchModelMatrixAndBV.modelMatrix
  );
  Matrix4.multiplyByScale(cylinderModelMatrix, scale, cylinderModelMatrix);

  var boundingVolume = scratchModelMatrixAndBV.boundingVolume;
  Cartesian3.clone(Cartesian3.ZERO, boundingVolume.center);
  boundingVolume.radius = Math.sqrt(2.0);

  return scratchModelMatrixAndBV;
}

function ellipsoidModelMatrixAndBoundingVolume(ellipsoids, index) {
  var ellipsoidIndex = index * packedEllipsoidLength;

  var radii = Cartesian3.unpack(ellipsoids, ellipsoidIndex, scratchCartesian);
  ellipsoidIndex += Cartesian3.packedLength;

  var ellipsoidModelMatrix = Matrix4.unpack(
    ellipsoids,
    ellipsoidIndex,
    scratchModelMatrixAndBV.modelMatrix
  );
  Matrix4.multiplyByScale(ellipsoidModelMatrix, radii, ellipsoidModelMatrix);

  var boundingVolume = scratchModelMatrixAndBV.boundingVolume;
  Cartesian3.clone(Cartesian3.ZERO, boundingVolume.center);
  boundingVolume.radius = 1.0;

  return scratchModelMatrixAndBV;
}

function sphereModelMatrixAndBoundingVolume(spheres, index) {
  var sphereIndex = index * packedSphereLength;

  var sphereRadius = spheres[sphereIndex++];

  var sphereTranslation = Cartesian3.unpack(
    spheres,
    sphereIndex,
    scratchCartesian
  );
  var sphereModelMatrix = Matrix4.fromTranslation(
    sphereTranslation,
    scratchModelMatrixAndBV.modelMatrix
  );
  Matrix4.multiplyByUniformScale(
    sphereModelMatrix,
    sphereRadius,
    sphereModelMatrix
  );

  var boundingVolume = scratchModelMatrixAndBV.boundingVolume;
  Cartesian3.clone(Cartesian3.ZERO, boundingVolume.center);
  boundingVolume.radius = 1.0;

  return scratchModelMatrixAndBV;
}

var scratchPosition = new Cartesian3();

function createPrimitive(
  options,
  primitive,
  primitiveBatchIds,
  geometry,
  getModelMatrixAndBoundingVolume
) {
  if (!defined(primitive)) {
    return;
  }

  var numberOfPrimitives = primitiveBatchIds.length;
  var geometryPositions = geometry.attributes.position.values;
  var geometryIndices = geometry.indices;

  var positions = options.positions;
  var vertexBatchIds = options.vertexBatchIds;
  var indices = options.indices;

  var batchIds = options.batchIds;
  var batchTableColors = options.batchTableColors;
  var batchedIndices = options.batchedIndices;
  var indexOffsets = options.indexOffsets;
  var indexCounts = options.indexCounts;
  var boundingVolumes = options.boundingVolumes;

  var modelMatrix = options.modelMatrix;
  var center = options.center;

  var positionOffset = options.positionOffset;
  var batchIdIndex = options.batchIdIndex;
  var indexOffset = options.indexOffset;
  var batchedIndicesOffset = options.batchedIndicesOffset;

  for (var i = 0; i < numberOfPrimitives; ++i) {
    var primitiveModelMatrixAndBV = getModelMatrixAndBoundingVolume(
      primitive,
      i
    );
    var primitiveModelMatrix = primitiveModelMatrixAndBV.modelMatrix;
    Matrix4.multiply(modelMatrix, primitiveModelMatrix, primitiveModelMatrix);

    var batchId = primitiveBatchIds[i];

    var positionsLength = geometryPositions.length;
    for (var j = 0; j < positionsLength; j += 3) {
      var position = Cartesian3.unpack(geometryPositions, j, scratchPosition);
      Matrix4.multiplyByPoint(primitiveModelMatrix, position, position);
      Cartesian3.subtract(position, center, position);

      Cartesian3.pack(position, positions, positionOffset * 3 + j);
      vertexBatchIds[batchIdIndex++] = batchId;
    }

    var indicesLength = geometryIndices.length;
    for (var k = 0; k < indicesLength; ++k) {
      indices[indexOffset + k] = geometryIndices[k] + positionOffset;
    }

    var offset = i + batchedIndicesOffset;
    batchedIndices[offset] = new Vector3DTileBatch({
      offset: indexOffset,
      count: indicesLength,
      color: Color.fromRgba(batchTableColors[batchId]),
      batchIds: [batchId],
    });
    batchIds[offset] = batchId;
    indexOffsets[offset] = indexOffset;
    indexCounts[offset] = indicesLength;
    boundingVolumes[offset] = BoundingSphere.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();
var scratchMatrix4 = new Matrix4();

function unpackBuffer(buffer) {
  var packedBuffer = new Float64Array(buffer);

  var offset = 0;
  Cartesian3.unpack(packedBuffer, offset, scratchCenter);
  offset += Cartesian3.packedLength;

  Matrix4.unpack(packedBuffer, offset, scratchMatrix4);
}

function packedBatchedIndicesLength(batchedIndices) {
  var length = batchedIndices.length;
  var count = 0;
  for (var i = 0; i < length; ++i) {
    count += Color.packedLength + 3 + batchedIndices[i].batchIds.length;
  }
  return count;
}

function packBuffer(indicesBytesPerElement, batchedIndices, boundingVolumes) {
  var numBVs = boundingVolumes.length;
  var length =
    1 +
    1 +
    numBVs * BoundingSphere.packedLength +
    1 +
    packedBatchedIndicesLength(batchedIndices);

  var packedBuffer = new Float64Array(length);

  var offset = 0;
  packedBuffer[offset++] = indicesBytesPerElement;
  packedBuffer[offset++] = numBVs;

  for (var i = 0; i < numBVs; ++i) {
    BoundingSphere.pack(boundingVolumes[i], packedBuffer, offset);
    offset += BoundingSphere.packedLength;
  }

  var indicesLength = batchedIndices.length;
  packedBuffer[offset++] = indicesLength;

  for (var j = 0; j < indicesLength; ++j) {
    var batchedIndex = batchedIndices[j];

    Color.pack(batchedIndex.color, packedBuffer, offset);
    offset += Color.packedLength;

    packedBuffer[offset++] = batchedIndex.offset;
    packedBuffer[offset++] = batchedIndex.count;

    var batchIds = batchedIndex.batchIds;
    var batchIdsLength = batchIds.length;
    packedBuffer[offset++] = batchIdsLength;

    for (var k = 0; k < batchIdsLength; ++k) {
      packedBuffer[offset++] = batchIds[k];
    }
  }

  return packedBuffer;
}

function createVectorTileGeometries(parameters, transferableObjects) {
  var boxes = defined(parameters.boxes)
    ? new Float32Array(parameters.boxes)
    : undefined;
  var boxBatchIds = defined(parameters.boxBatchIds)
    ? new Uint16Array(parameters.boxBatchIds)
    : undefined;
  var cylinders = defined(parameters.cylinders)
    ? new Float32Array(parameters.cylinders)
    : undefined;
  var cylinderBatchIds = defined(parameters.cylinderBatchIds)
    ? new Uint16Array(parameters.cylinderBatchIds)
    : undefined;
  var ellipsoids = defined(parameters.ellipsoids)
    ? new Float32Array(parameters.ellipsoids)
    : undefined;
  var ellipsoidBatchIds = defined(parameters.ellipsoidBatchIds)
    ? new Uint16Array(parameters.ellipsoidBatchIds)
    : undefined;
  var spheres = defined(parameters.spheres)
    ? new Float32Array(parameters.spheres)
    : undefined;
  var sphereBatchIds = defined(parameters.sphereBatchIds)
    ? new Uint16Array(parameters.sphereBatchIds)
    : undefined;

  var numberOfBoxes = defined(boxes) ? boxBatchIds.length : 0;
  var numberOfCylinders = defined(cylinders) ? cylinderBatchIds.length : 0;
  var numberOfEllipsoids = defined(ellipsoids) ? ellipsoidBatchIds.length : 0;
  var numberOfSpheres = defined(spheres) ? sphereBatchIds.length : 0;

  var boxGeometry = BoxGeometry.getUnitBox();
  var cylinderGeometry = CylinderGeometry.getUnitCylinder();
  var ellipsoidGeometry = EllipsoidGeometry.getUnitEllipsoid();

  var boxPositions = boxGeometry.attributes.position.values;
  var cylinderPositions = cylinderGeometry.attributes.position.values;
  var ellipsoidPositions = ellipsoidGeometry.attributes.position.values;

  var numberOfPositions = boxPositions.length * numberOfBoxes;
  numberOfPositions += cylinderPositions.length * numberOfCylinders;
  numberOfPositions +=
    ellipsoidPositions.length * (numberOfEllipsoids + numberOfSpheres);

  var boxIndices = boxGeometry.indices;
  var cylinderIndices = cylinderGeometry.indices;
  var ellipsoidIndices = ellipsoidGeometry.indices;

  var numberOfIndices = boxIndices.length * numberOfBoxes;
  numberOfIndices += cylinderIndices.length * numberOfCylinders;
  numberOfIndices +=
    ellipsoidIndices.length * (numberOfEllipsoids + numberOfSpheres);

  var positions = new Float32Array(numberOfPositions);
  var vertexBatchIds = new Uint16Array(numberOfPositions / 3);
  var indices = IndexDatatype.createTypedArray(
    numberOfPositions / 3,
    numberOfIndices
  );

  var numberOfGeometries =
    numberOfBoxes + numberOfCylinders + numberOfEllipsoids + numberOfSpheres;
  var batchIds = new Uint16Array(numberOfGeometries);
  var batchedIndices = new Array(numberOfGeometries);
  var indexOffsets = new Uint32Array(numberOfGeometries);
  var indexCounts = new Uint32Array(numberOfGeometries);
  var boundingVolumes = new Array(numberOfGeometries);

  unpackBuffer(parameters.packedBuffer);

  var 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
  );

  var 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,
  };
}
export default createTaskProcessorWorker(createVectorTileGeometries);