@loaders.gl/terrain 3.1.0-alpha.3 → 4.0.0-alpha.4

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

@@ -1,4 +1,4 @@
-import {createLoaderWorker} from '@loaders.gl/loader-utils';
-import {QuantizedMeshLoader} from '../index';
-
+import { createLoaderWorker } from '@loaders.gl/loader-utils';
+import { QuantizedMeshLoader } from '../index';
 createLoaderWorker(QuantizedMeshLoader);
+//# sourceMappingURL=quantized-mesh-worker.js.map

package/dist/workers/quantized-mesh-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workers/quantized-mesh-worker.ts"],"names":["createLoaderWorker","QuantizedMeshLoader"],"mappings":"AAAA,SAAQA,kBAAR,QAAiC,0BAAjC;AACA,SAAQC,mBAAR,QAAkC,UAAlC;AAEAD,kBAAkB,CAACC,mBAAD,CAAlB","sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {QuantizedMeshLoader} from '../index';\n\ncreateLoaderWorker(QuantizedMeshLoader);\n"],"file":"quantized-mesh-worker.js"}

package/dist/workers/terrain-worker.js

@@ -1,4 +1,4 @@
-import {createLoaderWorker} from '@loaders.gl/loader-utils';
-import {TerrainLoader} from '../index';
-
+import { createLoaderWorker } from '@loaders.gl/loader-utils';
+import { TerrainLoader } from '../index';
 createLoaderWorker(TerrainLoader);
+//# sourceMappingURL=terrain-worker.js.map

package/dist/workers/terrain-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workers/terrain-worker.ts"],"names":["createLoaderWorker","TerrainLoader"],"mappings":"AAAA,SAAQA,kBAAR,QAAiC,0BAAjC;AACA,SAAQC,aAAR,QAA4B,UAA5B;AAEAD,kBAAkB,CAACC,aAAD,CAAlB","sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {TerrainLoader} from '../index';\n\ncreateLoaderWorker(TerrainLoader);\n"],"file":"terrain-worker.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/terrain",
-  "version": "3.1.0-alpha.3",
+  "version": "4.0.0-alpha.4",
   "description": "Framework-independent loader for terrain raster formats",
   "license": "MIT",
   "publishConfig": {
@@ -29,15 +29,15 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker2 && npm run build-bundle",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js",
-    "build-worker": "webpack --entry ./src/workers/terrain-worker.js --output ./dist/terrain-worker.js --config ../../scripts/webpack/worker.js",
-    "build-worker2": "webpack --entry ./src/workers/quantized-mesh-worker.js --output ./dist/quantized-mesh-worker.js --config ../../scripts/webpack/worker.js"
+    "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"
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.1.0-alpha.3",
-    "@loaders.gl/schema": "3.1.0-alpha.3",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
+    "@loaders.gl/schema": "4.0.0-alpha.4",
     "@mapbox/martini": "^0.2.0"
   },
-  "gitHead": "68e1c443d1b63aa2515436a7411ed0a029b42c15"
+  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
 }

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

@@ -0,0 +1,325 @@
+// 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
+  );
+}
+
+type Extensions = {
+  vertexNormals?: any;
+  waterMask?: any;
+};
+
+function decodeExtensions(dataView, indicesEndPosition) {
+  const extensions: 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/delatin/index.js

@@ -14,6 +14,8 @@
 // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
 // THIS SOFTWARE.
 
+// @ts-nocheck
+
 /* eslint-disable complexity, max-params, max-statements, max-depth, no-constant-condition */
 export default class Delatin {
   constructor(data, width, height = width) {

package/src/lib/helpers/skirt.ts

@@ -0,0 +1,168 @@
+import {concatenateTypedArrays} from '@loaders.gl/loader-utils';
+
+export type EdgeIndices = {
+  westIndices: number[];
+  northIndices: number[];
+  eastIndices: number[];
+  southIndices: number[];
+};
+
+/**
+ * Add skirt to existing mesh
+ * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
+ * @param {any} triangles - indices array of the mesh geometry
+ * @param skirtHeight - height of the skirt geometry
+ * @param outsideIndices - edge indices from quantized mesh data
+ * @returns - geometry data with added skirt
+ */
+export function addSkirt(attributes, triangles, skirtHeight: number, outsideIndices?: EdgeIndices) {
+  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: number[][] = [];
+  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: number[][] = [];
+  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: EdgeIndices, 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: number[][] = [];
+  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.ts

@@ -0,0 +1,98 @@
+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']);
+}