@loaders.gl/terrain 4.0.0-alpha.4 → 4.0.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/terrain",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.5",
   "description": "Framework-independent loader for terrain raster formats",
   "license": "MIT",
   "publishConfig": {
@@ -18,7 +18,7 @@
     "point cloud",
     "OBJ"
   ],
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "sideEffects": false,
@@ -29,15 +29,15 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker2 && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/terrain-worker.js --bundle --outfile=dist/terrain-worker.js",
-    "build-worker2": "esbuild src/workers/quantized-mesh-worker.js --bundle --outfile=dist/quantized-mesh-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/terrain-worker.js --bundle --outfile=dist/terrain-worker.js --define:__VERSION__=\\\"$npm_package_version\\\"",
+    "build-worker2": "esbuild src/workers/quantized-mesh-worker.js --bundle --outfile=dist/quantized-mesh-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
-    "@loaders.gl/schema": "4.0.0-alpha.4",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
+    "@loaders.gl/schema": "4.0.0-alpha.5",
     "@mapbox/martini": "^0.2.0"
   },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
 }

package/src/lib/parse-terrain.ts

@@ -198,6 +198,7 @@ function getMartiniTileMesh(meshMaxError, width, terrain) {
 function getDelatinTileMesh(meshMaxError, width, height, terrain) {
   const tin = new Delatin(terrain, width + 1, height + 1);
   tin.run(meshMaxError);
+  // @ts-expect-error
   const {coords, triangles} = tin;
   const vertices = coords;
   return {vertices, triangles};

package/src/workers/quantized-mesh-worker.js

@@ -1,4 +1,3 @@
 import {createLoaderWorker} from '@loaders.gl/loader-utils';
 import {QuantizedMeshLoader} from '../index';
-
 createLoaderWorker(QuantizedMeshLoader);

package/src/workers/terrain-worker.js

@@ -1,4 +1,3 @@
 import {createLoaderWorker} from '@loaders.gl/loader-utils';
 import {TerrainLoader} from '../index';
-
 createLoaderWorker(TerrainLoader);

package/src/lib/decode-quantized-mesh.js

@@ -1,320 +0,0 @@
-// Copyright (C) 2018-2019 HERE Europe B.V.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-const QUANTIZED_MESH_HEADER = new Map([
-  ['centerX', Float64Array.BYTES_PER_ELEMENT],
-  ['centerY', Float64Array.BYTES_PER_ELEMENT],
-  ['centerZ', Float64Array.BYTES_PER_ELEMENT],
-
-  ['minHeight', Float32Array.BYTES_PER_ELEMENT],
-  ['maxHeight', Float32Array.BYTES_PER_ELEMENT],
-
-  ['boundingSphereCenterX', Float64Array.BYTES_PER_ELEMENT],
-  ['boundingSphereCenterY', Float64Array.BYTES_PER_ELEMENT],
-  ['boundingSphereCenterZ', Float64Array.BYTES_PER_ELEMENT],
-  ['boundingSphereRadius', Float64Array.BYTES_PER_ELEMENT],
-
-  ['horizonOcclusionPointX', Float64Array.BYTES_PER_ELEMENT],
-  ['horizonOcclusionPointY', Float64Array.BYTES_PER_ELEMENT],
-  ['horizonOcclusionPointZ', Float64Array.BYTES_PER_ELEMENT]
-]);
-
-function decodeZigZag(value) {
-  return (value >> 1) ^ -(value & 1);
-}
-
-function decodeHeader(dataView) {
-  let position = 0;
-  const header = {};
-
-  for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {
-    const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;
-
-    header[key] = getter.call(dataView, position, true);
-    position += bytesCount;
-  }
-
-  return {header, headerEndPosition: position};
-}
-
-function decodeVertexData(dataView, headerEndPosition) {
-  let position = headerEndPosition;
-  const elementsPerVertex = 3;
-  const vertexCount = dataView.getUint32(position, true);
-  const vertexData = new Uint16Array(vertexCount * elementsPerVertex);
-
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
-  const elementArrayLength = vertexCount * bytesPerArrayElement;
-  const uArrayStartPosition = position;
-  const vArrayStartPosition = uArrayStartPosition + elementArrayLength;
-  const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
-
-  let u = 0;
-  let v = 0;
-  let height = 0;
-
-  for (let i = 0; i < vertexCount; i++) {
-    u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));
-    v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));
-    height += decodeZigZag(
-      dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true)
-    );
-
-    vertexData[i] = u;
-    vertexData[i + vertexCount] = v;
-    vertexData[i + vertexCount * 2] = height;
-  }
-
-  position += elementArrayLength * 3;
-
-  return {vertexData, vertexDataEndPosition: position};
-}
-
-function decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {
-  let indices;
-
-  if (bytesPerIndex === 2) {
-    indices = new Uint16Array(buffer, position, indicesCount);
-  } else {
-    indices = new Uint32Array(buffer, position, indicesCount);
-  }
-
-  if (!encoded) {
-    return indices;
-  }
-
-  let highest = 0;
-
-  for (let i = 0; i < indices.length; ++i) {
-    const code = indices[i];
-
-    indices[i] = highest - code;
-
-    if (code === 0) {
-      ++highest;
-    }
-  }
-
-  return indices;
-}
-
-function decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {
-  let position = vertexDataEndPosition;
-  const elementsPerVertex = 3;
-  const vertexCount = vertexData.length / elementsPerVertex;
-  const bytesPerIndex =
-    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
-
-  if (position % bytesPerIndex !== 0) {
-    position += bytesPerIndex - (position % bytesPerIndex);
-  }
-
-  const triangleCount = dataView.getUint32(position, true);
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const triangleIndicesCount = triangleCount * 3;
-  const triangleIndices = decodeIndex(
-    dataView.buffer,
-    position,
-    triangleIndicesCount,
-    bytesPerIndex
-  );
-  position += triangleIndicesCount * bytesPerIndex;
-
-  return {
-    triangleIndicesEndPosition: position,
-    triangleIndices
-  };
-}
-
-function decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {
-  let position = triangleIndicesEndPosition;
-  const elementsPerVertex = 3;
-  const vertexCount = vertexData.length / elementsPerVertex;
-  const bytesPerIndex =
-    vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
-
-  const westVertexCount = dataView.getUint32(position, true);
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);
-  position += westVertexCount * bytesPerIndex;
-
-  const southVertexCount = dataView.getUint32(position, true);
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const southIndices = decodeIndex(
-    dataView.buffer,
-    position,
-    southVertexCount,
-    bytesPerIndex,
-    false
-  );
-  position += southVertexCount * bytesPerIndex;
-
-  const eastVertexCount = dataView.getUint32(position, true);
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);
-  position += eastVertexCount * bytesPerIndex;
-
-  const northVertexCount = dataView.getUint32(position, true);
-  position += Uint32Array.BYTES_PER_ELEMENT;
-
-  const northIndices = decodeIndex(
-    dataView.buffer,
-    position,
-    northVertexCount,
-    bytesPerIndex,
-    false
-  );
-  position += northVertexCount * bytesPerIndex;
-
-  return {
-    edgeIndicesEndPosition: position,
-    westIndices,
-    southIndices,
-    eastIndices,
-    northIndices
-  };
-}
-
-function decodeVertexNormalsExtension(extensionDataView) {
-  return new Uint8Array(
-    extensionDataView.buffer,
-    extensionDataView.byteOffset,
-    extensionDataView.byteLength
-  );
-}
-
-function decodeWaterMaskExtension(extensionDataView) {
-  return extensionDataView.buffer.slice(
-    extensionDataView.byteOffset,
-    extensionDataView.byteOffset + extensionDataView.byteLength
-  );
-}
-
-function decodeExtensions(dataView, indicesEndPosition) {
-  const extensions = {};
-
-  if (dataView.byteLength <= indicesEndPosition) {
-    return {extensions, extensionsEndPosition: indicesEndPosition};
-  }
-
-  let position = indicesEndPosition;
-
-  while (position < dataView.byteLength) {
-    const extensionId = dataView.getUint8(position, true);
-    position += Uint8Array.BYTES_PER_ELEMENT;
-
-    const extensionLength = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-
-    const extensionView = new DataView(dataView.buffer, position, extensionLength);
-
-    switch (extensionId) {
-      case 1: {
-        extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);
-
-        break;
-      }
-      case 2: {
-        extensions.waterMask = decodeWaterMaskExtension(extensionView);
-
-        break;
-      }
-      default: {
-        // console.warn(`Unknown extension with id ${extensionId}`)
-      }
-    }
-
-    position += extensionLength;
-  }
-
-  return {extensions, extensionsEndPosition: position};
-}
-
-export const DECODING_STEPS = {
-  header: 0,
-  vertices: 1,
-  triangleIndices: 2,
-  edgeIndices: 3,
-  extensions: 4
-};
-
-const DEFAULT_OPTIONS = {
-  maxDecodingStep: DECODING_STEPS.extensions
-};
-
-export default function decode(data, userOptions) {
-  const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
-  const view = new DataView(data);
-  const {header, headerEndPosition} = decodeHeader(view);
-
-  if (options.maxDecodingStep < DECODING_STEPS.vertices) {
-    return {header};
-  }
-
-  const {vertexData, vertexDataEndPosition} = decodeVertexData(view, headerEndPosition);
-
-  if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
-    return {header, vertexData};
-  }
-
-  const {triangleIndices, triangleIndicesEndPosition} = decodeTriangleIndices(
-    view,
-    vertexData,
-    vertexDataEndPosition
-  );
-
-  if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
-    return {header, vertexData, triangleIndices};
-  }
-
-  const {westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition} =
-    decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
-
-  if (options.maxDecodingStep < DECODING_STEPS.extensions) {
-    return {
-      header,
-      vertexData,
-      triangleIndices,
-      westIndices,
-      northIndices,
-      eastIndices,
-      southIndices
-    };
-  }
-
-  const {extensions} = decodeExtensions(view, edgeIndicesEndPosition);
-
-  return {
-    header,
-    vertexData,
-    triangleIndices,
-    westIndices,
-    northIndices,
-    eastIndices,
-    southIndices,
-    extensions
-  };
-}

package/src/lib/helpers/skirt.js

@@ -1,161 +0,0 @@
-import {concatenateTypedArrays} from '@loaders.gl/loader-utils';
-
-/**
- * Add skirt to existing mesh
- * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
- * @param {any} triangles - indices array of the mesh geometry
- * @param {number} skirtHeight - height of the skirt geometry
- * @param {object} outsideIndices - edge indices from quantized mesh data
- * @returns - geometry data with added skirt
- */
-export function addSkirt(attributes, triangles, skirtHeight, outsideIndices = null) {
-  const outsideEdges = outsideIndices
-    ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value)
-    : getOutsideEdgesFromTriangles(triangles);
-
-  // 2 new vertices for each outside edge
-  const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
-  const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
-
-  // 2 new triangles for each outside edge
-  const newTriangles = new triangles.constructor(outsideEdges.length * 6);
-
-  for (let i = 0; i < outsideEdges.length; i++) {
-    const edge = outsideEdges[i];
-
-    updateAttributesForNewEdge({
-      edge,
-      edgeIndex: i,
-      attributes,
-      skirtHeight,
-      newPosition,
-      newTexcoord0,
-      newTriangles
-    });
-  }
-
-  attributes.POSITION.value = concatenateTypedArrays(attributes.POSITION.value, newPosition);
-  attributes.TEXCOORD_0.value = concatenateTypedArrays(attributes.TEXCOORD_0.value, newTexcoord0);
-  const resultTriangles =
-    triangles instanceof Array
-      ? triangles.concat(newTriangles)
-      : concatenateTypedArrays(triangles, newTriangles);
-
-  return {
-    attributes,
-    triangles: resultTriangles
-  };
-}
-
-/**
- * Get geometry edges that located on a border of the mesh
- * @param {any} triangles - indices array of the mesh geometry
- * @returns {number[][]} - outside edges data
- */
-function getOutsideEdgesFromTriangles(triangles) {
-  const edges = [];
-  for (let i = 0; i < triangles.length; i += 3) {
-    edges.push([triangles[i], triangles[i + 1]]);
-    edges.push([triangles[i + 1], triangles[i + 2]]);
-    edges.push([triangles[i + 2], triangles[i]]);
-  }
-
-  edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
-
-  const outsideEdges = [];
-  let index = 1;
-  while (index < edges.length) {
-    if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
-      index += 2;
-    } else {
-      outsideEdges.push(edges[index - 1]);
-      index++;
-    }
-  }
-  return outsideEdges;
-}
-
-/**
- * Get geometry edges that located on a border of the mesh
- * @param {object} indices - edge indices from quantized mesh data
- * @param {TypedArray} position - position attribute geometry data
- * @returns {number[][]} - outside edges data
- */
-function getOutsideEdgesFromIndices(indices, position) {
-  // Sort skirt indices to create adjacent triangles
-  indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
-  // Reverse (b - a) to match triangle winding
-  indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
-  indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
-  // Reverse (b - a) to match triangle winding
-  indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
-
-  const edges = [];
-  for (const index in indices) {
-    const indexGroup = indices[index];
-    for (let i = 0; i < indexGroup.length - 1; i++) {
-      edges.push([indexGroup[i], indexGroup[i + 1]]);
-    }
-  }
-  return edges;
-}
-
-/**
- * Get geometry edges that located on a border of the mesh
- * @param {object} args
- * @param {number[]} args.edge - edge indices in geometry
- * @param {number} args.edgeIndex - edge index in outsideEdges array
- * @param {object} args.attributes - POSITION and TEXCOORD_0 attributes
- * @param {number} args.skirtHeight - height of the skirt geometry
- * @param {TypedArray} args.newPosition - POSITION array for skirt data
- * @param {TypedArray} args.newTexcoord0 - TEXCOORD_0 array for skirt data
- * @param {TypedArray | Array} args.newTriangles - trinagle indices array for skirt data
- * @returns {void}
- */
-function updateAttributesForNewEdge({
-  edge,
-  edgeIndex,
-  attributes,
-  skirtHeight,
-  newPosition,
-  newTexcoord0,
-  newTriangles
-}) {
-  const positionsLength = attributes.POSITION.value.length;
-  const vertex1Offset = edgeIndex * 2;
-  const vertex2Offset = edgeIndex * 2 + 1;
-
-  // Define POSITION for new 1st vertex
-  newPosition.set(
-    attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3),
-    vertex1Offset * 3
-  );
-  newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
-
-  // Define POSITION for new 2nd vertex
-  newPosition.set(
-    attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3),
-    vertex2Offset * 3
-  );
-  newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
-
-  // Use same TEXCOORDS for skirt vertices
-  newTexcoord0.set(
-    attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2),
-    vertex1Offset * 2
-  );
-  newTexcoord0.set(
-    attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2),
-    vertex2Offset * 2
-  );
-
-  // Define new triangles
-  const triangle1Offset = edgeIndex * 2 * 3;
-  newTriangles[triangle1Offset] = edge[0];
-  newTriangles[triangle1Offset + 1] = edge[1];
-  newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
-
-  newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
-  newTriangles[triangle1Offset + 5] = edge[0];
-}

package/src/lib/parse-quantized-mesh.js

@@ -1,98 +0,0 @@
-import {getMeshBoundingBox} from '@loaders.gl/schema';
-import decode, {DECODING_STEPS} from './decode-quantized-mesh';
-import {addSkirt} from './helpers/skirt';
-
-function getMeshAttributes(vertexData, header, bounds) {
-  const {minHeight, maxHeight} = header;
-  const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
-  const xScale = maxX - minX;
-  const yScale = maxY - minY;
-  const zScale = maxHeight - minHeight;
-
-  const nCoords = vertexData.length / 3;
-  // vec3. x, y defined by bounds, z in meters
-  const positions = new Float32Array(nCoords * 3);
-
-  // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
-  const texCoords = new Float32Array(nCoords * 2);
-
-  // Data is not interleaved; all u, then all v, then all heights
-  for (let i = 0; i < nCoords; i++) {
-    const x = vertexData[i] / 32767;
-    const y = vertexData[i + nCoords] / 32767;
-    const z = vertexData[i + nCoords * 2] / 32767;
-
-    positions[3 * i + 0] = x * xScale + minX;
-    positions[3 * i + 1] = y * yScale + minY;
-    positions[3 * i + 2] = z * zScale + minHeight;
-
-    texCoords[2 * i + 0] = x;
-    texCoords[2 * i + 1] = y;
-  }
-
-  return {
-    POSITION: {value: positions, size: 3},
-    TEXCOORD_0: {value: texCoords, size: 2}
-    // TODO: Parse normals if they exist in the file
-    // NORMAL: {}, - optional, but creates the high poly look with lighting
-  };
-}
-
-function getTileMesh(arrayBuffer, options) {
-  if (!arrayBuffer) {
-    return null;
-  }
-  const {bounds} = options;
-  // Don't parse edge indices or format extensions
-  const {
-    header,
-    vertexData,
-    triangleIndices: originalTriangleIndices,
-    westIndices,
-    northIndices,
-    eastIndices,
-    southIndices
-  } = decode(arrayBuffer, DECODING_STEPS.triangleIndices);
-  let triangleIndices = originalTriangleIndices;
-  let attributes = getMeshAttributes(vertexData, header, bounds);
-
-  // Compute bounding box before adding skirt so that z values are not skewed
-  // TODO: Find bounding box from header, instead of doing extra pass over
-  // vertices.
-  const boundingBox = getMeshBoundingBox(attributes);
-
-  if (options.skirtHeight) {
-    const {attributes: newAttributes, triangles: newTriangles} = addSkirt(
-      attributes,
-      triangleIndices,
-      options.skirtHeight,
-      {
-        westIndices,
-        northIndices,
-        eastIndices,
-        southIndices
-      }
-    );
-    attributes = newAttributes;
-    triangleIndices = newTriangles;
-  }
-
-  return {
-    // Data return by this loader implementation
-    loaderData: {
-      header: {}
-    },
-    header: {
-      // @ts-ignore
-      vertexCount: triangleIndices.length,
-      boundingBox
-    },
-    mode: 4, // TRIANGLES
-    indices: {value: triangleIndices, size: 1},
-    attributes
-  };
-}
-
-export default function loadQuantizedMesh(arrayBuffer, options) {
-  return getTileMesh(arrayBuffer, options['quantized-mesh']);
-}