Add existing to tracked

node_modules/@cesium/engine/Source/Workers/upsampleQuantizedTerrainMesh.js

@@ -0,0 +1,681 @@
+import AttributeCompression from "../Core/AttributeCompression.js";
+import BoundingSphere from "../Core/BoundingSphere.js";
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Cartographic from "../Core/Cartographic.js";
+import defined from "../Core/defined.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import EllipsoidalOccluder from "../Core/EllipsoidalOccluder.js";
+import IndexDatatype from "../Core/IndexDatatype.js";
+import Intersections2D from "../Core/Intersections2D.js";
+import CesiumMath from "../Core/Math.js";
+import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
+import Rectangle from "../Core/Rectangle.js";
+import TerrainEncoding from "../Core/TerrainEncoding.js";
+import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
+
+const maxShort = 32767;
+const halfMaxShort = (maxShort / 2) | 0;
+
+const clipScratch = [];
+const clipScratch2 = [];
+const verticesScratch = [];
+const cartographicScratch = new Cartographic();
+let cartesian3Scratch = new Cartesian3();
+const uScratch = [];
+const vScratch = [];
+const heightScratch = [];
+const indicesScratch = [];
+const normalsScratch = [];
+const horizonOcclusionPointScratch = new Cartesian3();
+const boundingSphereScratch = new BoundingSphere();
+const orientedBoundingBoxScratch = new OrientedBoundingBox();
+const decodeTexCoordsScratch = new Cartesian2();
+const octEncodedNormalScratch = new Cartesian3();
+
+function upsampleQuantizedTerrainMesh(parameters, transferableObjects) {
+  const isEastChild = parameters.isEastChild;
+  const isNorthChild = parameters.isNorthChild;
+
+  const minU = isEastChild ? halfMaxShort : 0;
+  const maxU = isEastChild ? maxShort : halfMaxShort;
+  const minV = isNorthChild ? halfMaxShort : 0;
+  const maxV = isNorthChild ? maxShort : halfMaxShort;
+
+  const uBuffer = uScratch;
+  const vBuffer = vScratch;
+  const heightBuffer = heightScratch;
+  const normalBuffer = normalsScratch;
+
+  uBuffer.length = 0;
+  vBuffer.length = 0;
+  heightBuffer.length = 0;
+  normalBuffer.length = 0;
+
+  const indices = indicesScratch;
+  indices.length = 0;
+
+  const vertexMap = {};
+
+  const parentVertices = parameters.vertices;
+  let parentIndices = parameters.indices;
+  parentIndices = parentIndices.subarray(0, parameters.indexCountWithoutSkirts);
+
+  const encoding = TerrainEncoding.clone(parameters.encoding);
+  const hasVertexNormals = encoding.hasVertexNormals;
+
+  let vertexCount = 0;
+  const quantizedVertexCount = parameters.vertexCountWithoutSkirts;
+
+  const parentMinimumHeight = parameters.minimumHeight;
+  const parentMaximumHeight = parameters.maximumHeight;
+
+  const parentUBuffer = new Array(quantizedVertexCount);
+  const parentVBuffer = new Array(quantizedVertexCount);
+  const parentHeightBuffer = new Array(quantizedVertexCount);
+  const parentNormalBuffer = hasVertexNormals
+    ? new Array(quantizedVertexCount * 2)
+    : undefined;
+
+  const threshold = 20;
+  let height;
+
+  let i, n;
+  let u, v;
+  for (i = 0, n = 0; i < quantizedVertexCount; ++i, n += 2) {
+    const texCoords = encoding.decodeTextureCoordinates(
+      parentVertices,
+      i,
+      decodeTexCoordsScratch,
+    );
+    height = encoding.decodeHeight(parentVertices, i);
+
+    u = CesiumMath.clamp((texCoords.x * maxShort) | 0, 0, maxShort);
+    v = CesiumMath.clamp((texCoords.y * maxShort) | 0, 0, maxShort);
+    parentHeightBuffer[i] = CesiumMath.clamp(
+      (((height - parentMinimumHeight) /
+        (parentMaximumHeight - parentMinimumHeight)) *
+        maxShort) |
+        0,
+      0,
+      maxShort,
+    );
+
+    if (u < threshold) {
+      u = 0;
+    }
+
+    if (v < threshold) {
+      v = 0;
+    }
+
+    if (maxShort - u < threshold) {
+      u = maxShort;
+    }
+
+    if (maxShort - v < threshold) {
+      v = maxShort;
+    }
+
+    parentUBuffer[i] = u;
+    parentVBuffer[i] = v;
+
+    if (hasVertexNormals) {
+      const encodedNormal = encoding.getOctEncodedNormal(
+        parentVertices,
+        i,
+        octEncodedNormalScratch,
+      );
+      parentNormalBuffer[n] = encodedNormal.x;
+      parentNormalBuffer[n + 1] = encodedNormal.y;
+    }
+
+    if (
+      ((isEastChild && u >= halfMaxShort) ||
+        (!isEastChild && u <= halfMaxShort)) &&
+      ((isNorthChild && v >= halfMaxShort) ||
+        (!isNorthChild && v <= halfMaxShort))
+    ) {
+      vertexMap[i] = vertexCount;
+      uBuffer.push(u);
+      vBuffer.push(v);
+      heightBuffer.push(parentHeightBuffer[i]);
+      if (hasVertexNormals) {
+        normalBuffer.push(parentNormalBuffer[n]);
+        normalBuffer.push(parentNormalBuffer[n + 1]);
+      }
+
+      ++vertexCount;
+    }
+  }
+
+  const triangleVertices = [];
+  triangleVertices.push(new Vertex());
+  triangleVertices.push(new Vertex());
+  triangleVertices.push(new Vertex());
+
+  const clippedTriangleVertices = [];
+  clippedTriangleVertices.push(new Vertex());
+  clippedTriangleVertices.push(new Vertex());
+  clippedTriangleVertices.push(new Vertex());
+
+  let clippedIndex;
+  let clipped2;
+
+  for (i = 0; i < parentIndices.length; i += 3) {
+    const i0 = parentIndices[i];
+    const i1 = parentIndices[i + 1];
+    const i2 = parentIndices[i + 2];
+
+    const u0 = parentUBuffer[i0];
+    const u1 = parentUBuffer[i1];
+    const u2 = parentUBuffer[i2];
+
+    triangleVertices[0].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i0,
+    );
+    triangleVertices[1].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i1,
+    );
+    triangleVertices[2].initializeIndexed(
+      parentUBuffer,
+      parentVBuffer,
+      parentHeightBuffer,
+      parentNormalBuffer,
+      i2,
+    );
+
+    // Clip triangle on the east-west boundary.
+    const clipped = Intersections2D.clipTriangleAtAxisAlignedThreshold(
+      halfMaxShort,
+      isEastChild,
+      u0,
+      u1,
+      u2,
+      clipScratch,
+    );
+
+    // Get the first clipped triangle, if any.
+    clippedIndex = 0;
+
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[0].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices,
+    );
+
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[1].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices,
+    );
+
+    if (clippedIndex >= clipped.length) {
+      continue;
+    }
+    clippedIndex = clippedTriangleVertices[2].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices,
+    );
+
+    // Clip the triangle against the North-south boundary.
+    clipped2 = Intersections2D.clipTriangleAtAxisAlignedThreshold(
+      halfMaxShort,
+      isNorthChild,
+      clippedTriangleVertices[0].getV(),
+      clippedTriangleVertices[1].getV(),
+      clippedTriangleVertices[2].getV(),
+      clipScratch2,
+    );
+    addClippedPolygon(
+      uBuffer,
+      vBuffer,
+      heightBuffer,
+      normalBuffer,
+      indices,
+      vertexMap,
+      clipped2,
+      clippedTriangleVertices,
+      hasVertexNormals,
+    );
+
+    // If there's another vertex in the original clipped result,
+    // it forms a second triangle.  Clip it as well.
+    if (clippedIndex < clipped.length) {
+      clippedTriangleVertices[2].clone(clippedTriangleVertices[1]);
+      clippedTriangleVertices[2].initializeFromClipResult(
+        clipped,
+        clippedIndex,
+        triangleVertices,
+      );
+
+      clipped2 = Intersections2D.clipTriangleAtAxisAlignedThreshold(
+        halfMaxShort,
+        isNorthChild,
+        clippedTriangleVertices[0].getV(),
+        clippedTriangleVertices[1].getV(),
+        clippedTriangleVertices[2].getV(),
+        clipScratch2,
+      );
+      addClippedPolygon(
+        uBuffer,
+        vBuffer,
+        heightBuffer,
+        normalBuffer,
+        indices,
+        vertexMap,
+        clipped2,
+        clippedTriangleVertices,
+        hasVertexNormals,
+      );
+    }
+  }
+
+  const uOffset = isEastChild ? -maxShort : 0;
+  const vOffset = isNorthChild ? -maxShort : 0;
+
+  const westIndices = [];
+  const southIndices = [];
+  const eastIndices = [];
+  const northIndices = [];
+
+  let minimumHeight = Number.MAX_VALUE;
+  let maximumHeight = -minimumHeight;
+
+  const cartesianVertices = verticesScratch;
+  cartesianVertices.length = 0;
+
+  const ellipsoid = Ellipsoid.clone(parameters.ellipsoid);
+  const rectangle = Rectangle.clone(parameters.childRectangle);
+
+  const north = rectangle.north;
+  const south = rectangle.south;
+  let east = rectangle.east;
+  const west = rectangle.west;
+
+  if (east < west) {
+    east += CesiumMath.TWO_PI;
+  }
+
+  for (i = 0; i < uBuffer.length; ++i) {
+    u = Math.round(uBuffer[i]);
+    if (u <= minU) {
+      westIndices.push(i);
+      u = 0;
+    } else if (u >= maxU) {
+      eastIndices.push(i);
+      u = maxShort;
+    } else {
+      u = u * 2 + uOffset;
+    }
+
+    uBuffer[i] = u;
+
+    v = Math.round(vBuffer[i]);
+    if (v <= minV) {
+      southIndices.push(i);
+      v = 0;
+    } else if (v >= maxV) {
+      northIndices.push(i);
+      v = maxShort;
+    } else {
+      v = v * 2 + vOffset;
+    }
+
+    vBuffer[i] = v;
+
+    height = CesiumMath.lerp(
+      parentMinimumHeight,
+      parentMaximumHeight,
+      heightBuffer[i] / maxShort,
+    );
+    if (height < minimumHeight) {
+      minimumHeight = height;
+    }
+    if (height > maximumHeight) {
+      maximumHeight = height;
+    }
+
+    heightBuffer[i] = height;
+
+    cartographicScratch.longitude = CesiumMath.lerp(west, east, u / maxShort);
+    cartographicScratch.latitude = CesiumMath.lerp(south, north, v / maxShort);
+    cartographicScratch.height = height;
+
+    ellipsoid.cartographicToCartesian(cartographicScratch, cartesian3Scratch);
+
+    cartesianVertices.push(cartesian3Scratch.x);
+    cartesianVertices.push(cartesian3Scratch.y);
+    cartesianVertices.push(cartesian3Scratch.z);
+  }
+
+  const boundingSphere = BoundingSphere.fromVertices(
+    cartesianVertices,
+    Cartesian3.ZERO,
+    3,
+    boundingSphereScratch,
+  );
+  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    ellipsoid,
+    orientedBoundingBoxScratch,
+  );
+
+  const occluder = new EllipsoidalOccluder(ellipsoid);
+  const horizonOcclusionPoint =
+    occluder.computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid(
+      boundingSphere.center,
+      cartesianVertices,
+      3,
+      boundingSphere.center,
+      minimumHeight,
+      horizonOcclusionPointScratch,
+    );
+
+  const heightRange = maximumHeight - minimumHeight;
+
+  const vertices = new Uint16Array(
+    uBuffer.length + vBuffer.length + heightBuffer.length,
+  );
+
+  for (i = 0; i < uBuffer.length; ++i) {
+    vertices[i] = uBuffer[i];
+  }
+
+  let start = uBuffer.length;
+
+  for (i = 0; i < vBuffer.length; ++i) {
+    vertices[start + i] = vBuffer[i];
+  }
+
+  start += vBuffer.length;
+
+  for (i = 0; i < heightBuffer.length; ++i) {
+    vertices[start + i] =
+      (maxShort * (heightBuffer[i] - minimumHeight)) / heightRange;
+  }
+
+  const indicesTypedArray = IndexDatatype.createTypedArray(
+    uBuffer.length,
+    indices,
+  );
+
+  let encodedNormals;
+  if (hasVertexNormals) {
+    const normalArray = new Uint8Array(normalBuffer);
+    transferableObjects.push(
+      vertices.buffer,
+      indicesTypedArray.buffer,
+      normalArray.buffer,
+    );
+    encodedNormals = normalArray.buffer;
+  } else {
+    transferableObjects.push(vertices.buffer, indicesTypedArray.buffer);
+  }
+
+  return {
+    vertices: vertices.buffer,
+    encodedNormals: encodedNormals,
+    indices: indicesTypedArray.buffer,
+    minimumHeight: minimumHeight,
+    maximumHeight: maximumHeight,
+    westIndices: westIndices,
+    southIndices: southIndices,
+    eastIndices: eastIndices,
+    northIndices: northIndices,
+    boundingSphere: boundingSphere,
+    orientedBoundingBox: orientedBoundingBox,
+    horizonOcclusionPoint: horizonOcclusionPoint,
+  };
+}
+
+function Vertex() {
+  this.vertexBuffer = undefined;
+  this.index = undefined;
+  this.first = undefined;
+  this.second = undefined;
+  this.ratio = undefined;
+}
+
+Vertex.prototype.clone = function (result) {
+  if (!defined(result)) {
+    result = new Vertex();
+  }
+
+  result.uBuffer = this.uBuffer;
+  result.vBuffer = this.vBuffer;
+  result.heightBuffer = this.heightBuffer;
+  result.normalBuffer = this.normalBuffer;
+  result.index = this.index;
+  result.first = this.first;
+  result.second = this.second;
+  result.ratio = this.ratio;
+
+  return result;
+};
+
+Vertex.prototype.initializeIndexed = function (
+  uBuffer,
+  vBuffer,
+  heightBuffer,
+  normalBuffer,
+  index,
+) {
+  this.uBuffer = uBuffer;
+  this.vBuffer = vBuffer;
+  this.heightBuffer = heightBuffer;
+  this.normalBuffer = normalBuffer;
+  this.index = index;
+  this.first = undefined;
+  this.second = undefined;
+  this.ratio = undefined;
+};
+
+Vertex.prototype.initializeFromClipResult = function (
+  clipResult,
+  index,
+  vertices,
+) {
+  let nextIndex = index + 1;
+
+  if (clipResult[index] !== -1) {
+    vertices[clipResult[index]].clone(this);
+  } else {
+    this.vertexBuffer = undefined;
+    this.index = undefined;
+    this.first = vertices[clipResult[nextIndex]];
+    ++nextIndex;
+    this.second = vertices[clipResult[nextIndex]];
+    ++nextIndex;
+    this.ratio = clipResult[nextIndex];
+    ++nextIndex;
+  }
+
+  return nextIndex;
+};
+
+Vertex.prototype.getKey = function () {
+  if (this.isIndexed()) {
+    return this.index;
+  }
+  return JSON.stringify({
+    first: this.first.getKey(),
+    second: this.second.getKey(),
+    ratio: this.ratio,
+  });
+};
+
+Vertex.prototype.isIndexed = function () {
+  return defined(this.index);
+};
+
+Vertex.prototype.getH = function () {
+  if (defined(this.index)) {
+    return this.heightBuffer[this.index];
+  }
+  return CesiumMath.lerp(this.first.getH(), this.second.getH(), this.ratio);
+};
+
+Vertex.prototype.getU = function () {
+  if (defined(this.index)) {
+    return this.uBuffer[this.index];
+  }
+  return CesiumMath.lerp(this.first.getU(), this.second.getU(), this.ratio);
+};
+
+Vertex.prototype.getV = function () {
+  if (defined(this.index)) {
+    return this.vBuffer[this.index];
+  }
+  return CesiumMath.lerp(this.first.getV(), this.second.getV(), this.ratio);
+};
+
+let encodedScratch = new Cartesian2();
+// An upsampled triangle may be clipped twice before it is assigned an index
+// In this case, we need a buffer to handle the recursion of getNormalX() and getNormalY().
+let depth = -1;
+const cartesianScratch1 = [new Cartesian3(), new Cartesian3()];
+const cartesianScratch2 = [new Cartesian3(), new Cartesian3()];
+function lerpOctEncodedNormal(vertex, result) {
+  ++depth;
+
+  let first = cartesianScratch1[depth];
+  let second = cartesianScratch2[depth];
+
+  first = AttributeCompression.octDecode(
+    vertex.first.getNormalX(),
+    vertex.first.getNormalY(),
+    first,
+  );
+  second = AttributeCompression.octDecode(
+    vertex.second.getNormalX(),
+    vertex.second.getNormalY(),
+    second,
+  );
+  cartesian3Scratch = Cartesian3.lerp(
+    first,
+    second,
+    vertex.ratio,
+    cartesian3Scratch,
+  );
+  Cartesian3.normalize(cartesian3Scratch, cartesian3Scratch);
+
+  AttributeCompression.octEncode(cartesian3Scratch, result);
+
+  --depth;
+
+  return result;
+}
+
+Vertex.prototype.getNormalX = function () {
+  if (defined(this.index)) {
+    return this.normalBuffer[this.index * 2];
+  }
+
+  encodedScratch = lerpOctEncodedNormal(this, encodedScratch);
+  return encodedScratch.x;
+};
+
+Vertex.prototype.getNormalY = function () {
+  if (defined(this.index)) {
+    return this.normalBuffer[this.index * 2 + 1];
+  }
+
+  encodedScratch = lerpOctEncodedNormal(this, encodedScratch);
+  return encodedScratch.y;
+};
+
+const polygonVertices = [];
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+polygonVertices.push(new Vertex());
+
+function addClippedPolygon(
+  uBuffer,
+  vBuffer,
+  heightBuffer,
+  normalBuffer,
+  indices,
+  vertexMap,
+  clipped,
+  triangleVertices,
+  hasVertexNormals,
+) {
+  if (clipped.length === 0) {
+    return;
+  }
+
+  let numVertices = 0;
+  let clippedIndex = 0;
+  while (clippedIndex < clipped.length) {
+    clippedIndex = polygonVertices[numVertices++].initializeFromClipResult(
+      clipped,
+      clippedIndex,
+      triangleVertices,
+    );
+  }
+
+  for (let i = 0; i < numVertices; ++i) {
+    const polygonVertex = polygonVertices[i];
+    if (!polygonVertex.isIndexed()) {
+      const key = polygonVertex.getKey();
+      if (defined(vertexMap[key])) {
+        polygonVertex.newIndex = vertexMap[key];
+      } else {
+        const newIndex = uBuffer.length;
+        uBuffer.push(polygonVertex.getU());
+        vBuffer.push(polygonVertex.getV());
+        heightBuffer.push(polygonVertex.getH());
+        if (hasVertexNormals) {
+          normalBuffer.push(polygonVertex.getNormalX());
+          normalBuffer.push(polygonVertex.getNormalY());
+        }
+        polygonVertex.newIndex = newIndex;
+        vertexMap[key] = newIndex;
+      }
+    } else {
+      polygonVertex.newIndex = vertexMap[polygonVertex.index];
+      polygonVertex.uBuffer = uBuffer;
+      polygonVertex.vBuffer = vBuffer;
+      polygonVertex.heightBuffer = heightBuffer;
+      if (hasVertexNormals) {
+        polygonVertex.normalBuffer = normalBuffer;
+      }
+    }
+  }
+
+  if (numVertices === 3) {
+    // A triangle.
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[1].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+  } else if (numVertices === 4) {
+    // A quad - two triangles.
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[1].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+
+    indices.push(polygonVertices[0].newIndex);
+    indices.push(polygonVertices[2].newIndex);
+    indices.push(polygonVertices[3].newIndex);
+  }
+}
+export default createTaskProcessorWorker(upsampleQuantizedTerrainMesh);