@loaders.gl/terrain 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/esm/lib/parse-quantized-mesh.js

@@ -0,0 +1,96 @@
+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;
+  const positions = new Float32Array(nCoords * 3);
+  const texCoords = new Float32Array(nCoords * 2);
+
+  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
+    }
+  };
+}
+
+function getTileMesh(arrayBuffer, options) {
+  if (!arrayBuffer) {
+    return null;
+  }
+
+  const {
+    bounds
+  } = options;
+  const {
+    header,
+    vertexData,
+    triangleIndices: originalTriangleIndices,
+    westIndices,
+    northIndices,
+    eastIndices,
+    southIndices
+  } = decode(arrayBuffer, DECODING_STEPS.triangleIndices);
+  let triangleIndices = originalTriangleIndices;
+  let attributes = getMeshAttributes(vertexData, header, bounds);
+  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 {
+    loaderData: {
+      header: {}
+    },
+    header: {
+      vertexCount: triangleIndices.length,
+      boundingBox
+    },
+    mode: 4,
+    indices: {
+      value: triangleIndices,
+      size: 1
+    },
+    attributes
+  };
+}
+
+export default function loadQuantizedMesh(arrayBuffer, options) {
+  return getTileMesh(arrayBuffer, options['quantized-mesh']);
+}
+//# sourceMappingURL=parse-quantized-mesh.js.map

package/dist/esm/lib/parse-quantized-mesh.js.map

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

package/dist/esm/lib/parse-terrain.js

@@ -0,0 +1,180 @@
+import { getMeshBoundingBox } from '@loaders.gl/schema';
+import Martini from '@mapbox/martini';
+import Delatin from './delatin';
+import { addSkirt } from './helpers/skirt';
+
+function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
+  const {
+    rScaler,
+    bScaler,
+    gScaler,
+    offset
+  } = elevationDecoder;
+  const terrain = new Float32Array((width + 1) * (height + 1));
+
+  for (let i = 0, y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++, i++) {
+      const k = i * 4;
+      const r = imageData[k + 0];
+      const g = imageData[k + 1];
+      const b = imageData[k + 2];
+      terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
+    }
+  }
+
+  if (tesselator === 'martini') {
+    for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
+      terrain[i] = terrain[i - width - 1];
+    }
+
+    for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
+      terrain[i] = terrain[i - 1];
+    }
+  }
+
+  return terrain;
+}
+
+function getMeshAttributes(vertices, terrain, width, height, bounds) {
+  const gridSize = width + 1;
+  const numOfVerticies = vertices.length / 2;
+  const positions = new Float32Array(numOfVerticies * 3);
+  const texCoords = new Float32Array(numOfVerticies * 2);
+  const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
+  const xScale = (maxX - minX) / width;
+  const yScale = (maxY - minY) / height;
+
+  for (let i = 0; i < numOfVerticies; i++) {
+    const x = vertices[i * 2];
+    const y = vertices[i * 2 + 1];
+    const pixelIdx = y * gridSize + x;
+    positions[3 * i + 0] = x * xScale + minX;
+    positions[3 * i + 1] = -y * yScale + maxY;
+    positions[3 * i + 2] = terrain[pixelIdx];
+    texCoords[2 * i + 0] = x / width;
+    texCoords[2 * i + 1] = y / height;
+  }
+
+  return {
+    POSITION: {
+      value: positions,
+      size: 3
+    },
+    TEXCOORD_0: {
+      value: texCoords,
+      size: 2
+    }
+  };
+}
+
+function getMesh(terrainImage, terrainOptions) {
+  if (terrainImage === null) {
+    return null;
+  }
+
+  const {
+    meshMaxError,
+    bounds,
+    elevationDecoder
+  } = terrainOptions;
+  const {
+    data,
+    width,
+    height
+  } = terrainImage;
+  let terrain;
+  let mesh;
+
+  switch (terrainOptions.tesselator) {
+    case 'martini':
+      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
+      mesh = getMartiniTileMesh(meshMaxError, width, terrain);
+      break;
+
+    case 'delatin':
+      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
+      mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
+      break;
+
+    default:
+      if (width === height && !(height & width - 1)) {
+        terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
+        mesh = getMartiniTileMesh(meshMaxError, width, terrain);
+      } else {
+        terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');
+        mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
+      }
+
+      break;
+  }
+
+  const {
+    vertices
+  } = mesh;
+  let {
+    triangles
+  } = mesh;
+  let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);
+  const boundingBox = getMeshBoundingBox(attributes);
+
+  if (terrainOptions.skirtHeight) {
+    const {
+      attributes: newAttributes,
+      triangles: newTriangles
+    } = addSkirt(attributes, triangles, terrainOptions.skirtHeight);
+    attributes = newAttributes;
+    triangles = newTriangles;
+  }
+
+  return {
+    loaderData: {
+      header: {}
+    },
+    header: {
+      vertexCount: triangles.length,
+      boundingBox
+    },
+    mode: 4,
+    indices: {
+      value: Uint32Array.from(triangles),
+      size: 1
+    },
+    attributes
+  };
+}
+
+function getMartiniTileMesh(meshMaxError, width, terrain) {
+  const gridSize = width + 1;
+  const martini = new Martini(gridSize);
+  const tile = martini.createTile(terrain);
+  const {
+    vertices,
+    triangles
+  } = tile.getMesh(meshMaxError);
+  return {
+    vertices,
+    triangles
+  };
+}
+
+function getDelatinTileMesh(meshMaxError, width, height, terrain) {
+  const tin = new Delatin(terrain, width + 1, height + 1);
+  tin.run(meshMaxError);
+  const {
+    coords,
+    triangles
+  } = tin;
+  const vertices = coords;
+  return {
+    vertices,
+    triangles
+  };
+}
+
+export default async function loadTerrain(arrayBuffer, options, context) {
+  options.image = options.image || {};
+  options.image.type = 'data';
+  const image = await context.parse(arrayBuffer, options, options.baseUri);
+  return getMesh(image, options.terrain);
+}
+//# sourceMappingURL=parse-terrain.js.map

package/dist/esm/lib/parse-terrain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/parse-terrain.ts"],"names":["getMeshBoundingBox","Martini","Delatin","addSkirt","getTerrain","imageData","width","height","elevationDecoder","tesselator","rScaler","bScaler","gScaler","offset","terrain","Float32Array","i","y","x","k","r","g","b","getMeshAttributes","vertices","bounds","gridSize","numOfVerticies","length","positions","texCoords","minX","minY","maxX","maxY","xScale","yScale","pixelIdx","POSITION","value","size","TEXCOORD_0","getMesh","terrainImage","terrainOptions","meshMaxError","data","mesh","getMartiniTileMesh","getDelatinTileMesh","triangles","attributes","boundingBox","skirtHeight","newAttributes","newTriangles","loaderData","header","vertexCount","mode","indices","Uint32Array","from","martini","tile","createTile","tin","run","coords","loadTerrain","arrayBuffer","options","context","image","type","parse","baseUri"],"mappings":"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","sourcesContent":["import {getMeshBoundingBox} from '@loaders.gl/schema';\nimport Martini from '@mapbox/martini';\nimport Delatin from './delatin';\nimport {addSkirt} from './helpers/skirt';\n\ntype TerrainOptions = {\n  meshMaxError: number;\n  bounds: number[];\n  elevationDecoder: ElevationDecoder;\n  tesselator: 'martini' | 'delatin';\n  skirtHeight?: number;\n};\n\ntype TerrainImage = {\n  data: Uint8Array;\n  width: number;\n  height: number;\n};\n\ntype ElevationDecoder = {\n  rScaler: any;\n  bScaler: any;\n  gScaler: any;\n  offset: number;\n};\n\nfunction getTerrain(\n  imageData: Uint8Array,\n  width: number,\n  height: number,\n  elevationDecoder: ElevationDecoder,\n  tesselator: 'martini' | 'delatin'\n) {\n  const {rScaler, bScaler, gScaler, offset} = elevationDecoder;\n\n  // From Martini demo\n  // https://observablehq.com/@mourner/martin-real-time-rtin-terrain-mesh\n  const terrain = new Float32Array((width + 1) * (height + 1));\n  // decode terrain values\n  for (let i = 0, y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++, i++) {\n      const k = i * 4;\n      const r = imageData[k + 0];\n      const g = imageData[k + 1];\n      const b = imageData[k + 2];\n      terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;\n    }\n  }\n\n  if (tesselator === 'martini') {\n    // backfill bottom border\n    for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {\n      terrain[i] = terrain[i - width - 1];\n    }\n    // backfill right border\n    for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {\n      terrain[i] = terrain[i - 1];\n    }\n  }\n\n  return terrain;\n}\n\nfunction getMeshAttributes(\n  vertices,\n  terrain: Uint8Array,\n  width: number,\n  height: number,\n  bounds: number[]\n) {\n  const gridSize = width + 1;\n  const numOfVerticies = vertices.length / 2;\n  // vec3. x, y in pixels, z in meters\n  const positions = new Float32Array(numOfVerticies * 3);\n  // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.\n  const texCoords = new Float32Array(numOfVerticies * 2);\n\n  const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];\n  const xScale = (maxX - minX) / width;\n  const yScale = (maxY - minY) / height;\n\n  for (let i = 0; i < numOfVerticies; i++) {\n    const x = vertices[i * 2];\n    const y = vertices[i * 2 + 1];\n    const pixelIdx = y * gridSize + x;\n\n    positions[3 * i + 0] = x * xScale + minX;\n    positions[3 * i + 1] = -y * yScale + maxY;\n    positions[3 * i + 2] = terrain[pixelIdx];\n\n    texCoords[2 * i + 0] = x / width;\n    texCoords[2 * i + 1] = y / height;\n  }\n\n  return {\n    POSITION: {value: positions, size: 3},\n    TEXCOORD_0: {value: texCoords, size: 2}\n    // NORMAL: {}, - optional, but creates the high poly look with lighting\n  };\n}\n\n/**\n * Returns generated mesh object from image data\n *\n * @param {object} terrainImage terrain image data\n * @param {object} terrainOptions terrain options\n * @returns mesh object\n */\nfunction getMesh(terrainImage: TerrainImage, terrainOptions: TerrainOptions) {\n  if (terrainImage === null) {\n    return null;\n  }\n  const {meshMaxError, bounds, elevationDecoder} = terrainOptions;\n\n  const {data, width, height} = terrainImage;\n\n  let terrain;\n  let mesh;\n  switch (terrainOptions.tesselator) {\n    case 'martini':\n      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);\n      mesh = getMartiniTileMesh(meshMaxError, width, terrain);\n      break;\n    case 'delatin':\n      terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);\n      mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);\n      break;\n    // auto\n    default:\n      if (width === height && !(height & (width - 1))) {\n        terrain = getTerrain(data, width, height, elevationDecoder, 'martini');\n        mesh = getMartiniTileMesh(meshMaxError, width, terrain);\n      } else {\n        terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');\n        mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);\n      }\n      break;\n  }\n\n  const {vertices} = mesh;\n  let {triangles} = mesh;\n  let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);\n\n  // Compute bounding box before adding skirt so that z values are not skewed\n  const boundingBox = getMeshBoundingBox(attributes);\n\n  if (terrainOptions.skirtHeight) {\n    const {attributes: newAttributes, triangles: newTriangles} = addSkirt(\n      attributes,\n      triangles,\n      terrainOptions.skirtHeight\n    );\n    attributes = newAttributes;\n    triangles = newTriangles;\n  }\n\n  return {\n    // Data return by this loader implementation\n    loaderData: {\n      header: {}\n    },\n    header: {\n      vertexCount: triangles.length,\n      boundingBox\n    },\n    mode: 4, // TRIANGLES\n    indices: {value: Uint32Array.from(triangles), size: 1},\n    attributes\n  };\n}\n\n/**\n * Get Martini generated vertices and triangles\n *\n * @param {number} meshMaxError threshold for simplifying mesh\n * @param {number} width width of the input data\n * @param {number[] | Float32Array} terrain elevation data\n * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data\n */\nfunction getMartiniTileMesh(meshMaxError, width, terrain) {\n  const gridSize = width + 1;\n  const martini = new Martini(gridSize);\n  const tile = martini.createTile(terrain);\n  const {vertices, triangles} = tile.getMesh(meshMaxError);\n\n  return {vertices, triangles};\n}\n\n/**\n * Get Delatin generated vertices and triangles\n *\n * @param {number} meshMaxError threshold for simplifying mesh\n * @param {number} width width of the input data array\n * @param {number} height height of the input data array\n * @param {number[] | Float32Array} terrain elevation data\n * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data\n */\nfunction getDelatinTileMesh(meshMaxError, width, height, terrain) {\n  const tin = new Delatin(terrain, width + 1, height + 1);\n  tin.run(meshMaxError);\n  // @ts-expect-error\n  const {coords, triangles} = tin;\n  const vertices = coords;\n  return {vertices, triangles};\n}\n\nexport default async function loadTerrain(arrayBuffer, options, context) {\n  options.image = options.image || {};\n  options.image.type = 'data';\n  const image = await context.parse(arrayBuffer, options, options.baseUri);\n  // Extend function to support additional mesh generation options (square grid or delatin)\n  return getMesh(image, options.terrain);\n}\n"],"file":"parse-terrain.js"}

package/dist/esm/lib/utils/version.js

@@ -0,0 +1,2 @@
+export const VERSION = typeof "3.1.0-beta.1" !== 'undefined' ? "3.1.0-beta.1" : 'latest';
+//# sourceMappingURL=version.js.map

package/dist/esm/lib/utils/version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":"AAGA,OAAO,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n"],"file":"version.js"}

package/dist/esm/quantized-mesh-loader.js

@@ -0,0 +1,18 @@
+import { VERSION } from './lib/utils/version';
+export const QuantizedMeshLoader = {
+  name: 'Quantized Mesh',
+  id: 'quantized-mesh',
+  module: 'terrain',
+  version: VERSION,
+  worker: true,
+  extensions: ['terrain'],
+  mimeTypes: ['application/vnd.quantized-mesh'],
+  options: {
+    'quantized-mesh': {
+      bounds: [0, 0, 1, 1],
+      skirtHeight: null
+    }
+  }
+};
+export const _typecheckQuantizedMeshLoader = QuantizedMeshLoader;
+//# sourceMappingURL=quantized-mesh-loader.js.map

package/dist/esm/quantized-mesh-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/quantized-mesh-loader.ts"],"names":["VERSION","QuantizedMeshLoader","name","id","module","version","worker","extensions","mimeTypes","options","bounds","skirtHeight","_typecheckQuantizedMeshLoader"],"mappings":"AACA,SAAQA,OAAR,QAAsB,qBAAtB;AAKA,OAAO,MAAMC,mBAAmB,GAAG;AACjCC,EAAAA,IAAI,EAAE,gBAD2B;AAEjCC,EAAAA,EAAE,EAAE,gBAF6B;AAGjCC,EAAAA,MAAM,EAAE,SAHyB;AAIjCC,EAAAA,OAAO,EAAEL,OAJwB;AAKjCM,EAAAA,MAAM,EAAE,IALyB;AAMjCC,EAAAA,UAAU,EAAE,CAAC,SAAD,CANqB;AAOjCC,EAAAA,SAAS,EAAE,CAAC,gCAAD,CAPsB;AAQjCC,EAAAA,OAAO,EAAE;AACP,sBAAkB;AAChBC,MAAAA,MAAM,EAAE,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CADQ;AAEhBC,MAAAA,WAAW,EAAE;AAFG;AADX;AARwB,CAA5B;AAgBP,OAAO,MAAMC,6BAAqC,GAAGX,mBAA9C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\n\n/**\n * Worker loader for quantized meshes\n */\nexport const QuantizedMeshLoader = {\n  name: 'Quantized Mesh',\n  id: 'quantized-mesh',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['terrain'],\n  mimeTypes: ['application/vnd.quantized-mesh'],\n  options: {\n    'quantized-mesh': {\n      bounds: [0, 0, 1, 1],\n      skirtHeight: null\n    }\n  }\n};\n\nexport const _typecheckQuantizedMeshLoader: Loader = QuantizedMeshLoader;\n"],"file":"quantized-mesh-loader.js"}

package/dist/esm/terrain-loader.js

@@ -0,0 +1,26 @@
+import { VERSION } from './lib/utils/version';
+export const TerrainLoader = {
+  name: 'Terrain',
+  id: 'terrain',
+  module: 'terrain',
+  version: VERSION,
+  worker: true,
+  extensions: ['png', 'pngraw'],
+  mimeTypes: ['image/png'],
+  options: {
+    terrain: {
+      tesselator: 'auto',
+      bounds: null,
+      meshMaxError: 10,
+      elevationDecoder: {
+        rScaler: 1,
+        gScaler: 0,
+        bScaler: 0,
+        offset: 0
+      },
+      skirtHeight: null
+    }
+  }
+};
+export const _typecheckTerrainWorkerLoader = TerrainLoader;
+//# sourceMappingURL=terrain-loader.js.map

package/dist/esm/terrain-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/terrain-loader.ts"],"names":["VERSION","TerrainLoader","name","id","module","version","worker","extensions","mimeTypes","options","terrain","tesselator","bounds","meshMaxError","elevationDecoder","rScaler","gScaler","bScaler","offset","skirtHeight","_typecheckTerrainWorkerLoader"],"mappings":"AACA,SAAQA,OAAR,QAAsB,qBAAtB;AAKA,OAAO,MAAMC,aAAa,GAAG;AAC3BC,EAAAA,IAAI,EAAE,SADqB;AAE3BC,EAAAA,EAAE,EAAE,SAFuB;AAG3BC,EAAAA,MAAM,EAAE,SAHmB;AAI3BC,EAAAA,OAAO,EAAEL,OAJkB;AAK3BM,EAAAA,MAAM,EAAE,IALmB;AAM3BC,EAAAA,UAAU,EAAE,CAAC,KAAD,EAAQ,QAAR,CANe;AAO3BC,EAAAA,SAAS,EAAE,CAAC,WAAD,CAPgB;AAQ3BC,EAAAA,OAAO,EAAE;AACPC,IAAAA,OAAO,EAAE;AACPC,MAAAA,UAAU,EAAE,MADL;AAEPC,MAAAA,MAAM,EAAE,IAFD;AAGPC,MAAAA,YAAY,EAAE,EAHP;AAIPC,MAAAA,gBAAgB,EAAE;AAChBC,QAAAA,OAAO,EAAE,CADO;AAEhBC,QAAAA,OAAO,EAAE,CAFO;AAGhBC,QAAAA,OAAO,EAAE,CAHO;AAIhBC,QAAAA,MAAM,EAAE;AAJQ,OAJX;AAUPC,MAAAA,WAAW,EAAE;AAVN;AADF;AARkB,CAAtB;AA2BP,OAAO,MAAMC,6BAAqC,GAAGnB,aAA9C","sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\n\n/**\n * Worker loader for quantized meshes\n */\nexport const TerrainLoader = {\n  name: 'Terrain',\n  id: 'terrain',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['png', 'pngraw'],\n  mimeTypes: ['image/png'],\n  options: {\n    terrain: {\n      tesselator: 'auto',\n      bounds: null,\n      meshMaxError: 10,\n      elevationDecoder: {\n        rScaler: 1,\n        gScaler: 0,\n        bScaler: 0,\n        offset: 0\n      },\n      skirtHeight: null\n    }\n  }\n};\n\n/**\n * Loader for quantized meshes\n */\nexport const _typecheckTerrainWorkerLoader: Loader = TerrainLoader;\n"],"file":"terrain-loader.js"}

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

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

package/dist/esm/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/esm/workers/terrain-worker.js

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

package/dist/esm/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/dist/index.d.ts

@@ -0,0 +1,77 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import parseQuantizedMesh from './lib/parse-quantized-mesh';
+import loadTerrain from './lib/parse-terrain';
+import { TerrainLoader as TerrainWorkerLoader } from './terrain-loader';
+import { QuantizedMeshLoader as QuantizedMeshWorkerLoader } from './quantized-mesh-loader';
+export { TerrainWorkerLoader };
+export declare const TerrainLoader: {
+    parse: typeof loadTerrain;
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    options: {
+        terrain: {
+            tesselator: string;
+            bounds: null;
+            meshMaxError: number;
+            elevationDecoder: {
+                rScaler: number;
+                gScaler: number;
+                bScaler: number;
+                offset: number;
+            };
+            skirtHeight: null;
+        };
+    };
+};
+export declare const _typecheckTerrainLoader: LoaderWithParser;
+export { QuantizedMeshWorkerLoader };
+/**
+ * Loader for quantized meshes
+ */
+export declare const QuantizedMeshLoader: {
+    parseSync: typeof parseQuantizedMesh;
+    parse: (arrayBuffer: any, options: any) => Promise<{
+        loaderData: {
+            header: {};
+        };
+        header: {
+            vertexCount: any;
+            boundingBox: [[number, number, number], [number, number, number]];
+        };
+        mode: number;
+        indices: {
+            value: any;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array;
+                size: number;
+            };
+        };
+    } | null>;
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    options: {
+        'quantized-mesh': {
+            bounds: number[];
+            skirtHeight: null;
+        };
+    };
+};
+export declare const _typecheckQuantizedMeshLoader: LoaderWithParser;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,WAAW,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,mBAAmB,IAAI,yBAAyB,EAAC,MAAM,yBAAyB,CAAC;AAIzF,OAAO,EAAC,mBAAmB,EAAC,CAAC;AAE7B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAGzB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,gBAAgC,CAAC;AAIvE,OAAO,EAAC,yBAAyB,EAAC,CAAC;AAEnC;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,gBAAsC,CAAC"}

package/dist/index.js

@@ -1,16 +1,26 @@
-import parseQuantizedMesh from './lib/parse-quantized-mesh';
-import loadTerrain from './lib/parse-terrain';
-import { TerrainLoader as TerrainWorkerLoader } from './terrain-loader';
-import { QuantizedMeshLoader as QuantizedMeshWorkerLoader } from './quantized-mesh-loader';
-export { TerrainWorkerLoader };
-export const TerrainLoader = { ...TerrainWorkerLoader,
-  parse: loadTerrain
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-export const _typecheckTerrainLoader = TerrainLoader;
-export { QuantizedMeshWorkerLoader };
-export const QuantizedMeshLoader = { ...QuantizedMeshWorkerLoader,
-  parseSync: parseQuantizedMesh,
-  parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader = exports.QuantizedMeshWorkerLoader = exports._typecheckTerrainLoader = exports.TerrainLoader = exports.TerrainWorkerLoader = void 0;
+const parse_quantized_mesh_1 = __importDefault(require("./lib/parse-quantized-mesh"));
+const parse_terrain_1 = __importDefault(require("./lib/parse-terrain"));
+const terrain_loader_1 = require("./terrain-loader");
+Object.defineProperty(exports, "TerrainWorkerLoader", { enumerable: true, get: function () { return terrain_loader_1.TerrainLoader; } });
+const quantized_mesh_loader_1 = require("./quantized-mesh-loader");
+Object.defineProperty(exports, "QuantizedMeshWorkerLoader", { enumerable: true, get: function () { return quantized_mesh_loader_1.QuantizedMeshLoader; } });
+exports.TerrainLoader = {
+    ...terrain_loader_1.TerrainLoader,
+    parse: parse_terrain_1.default
 };
-export const _typecheckQuantizedMeshLoader = QuantizedMeshLoader;
-//# sourceMappingURL=index.js.map
+exports._typecheckTerrainLoader = exports.TerrainLoader; // eslint-disable-line
+/**
+ * Loader for quantized meshes
+ */
+exports.QuantizedMeshLoader = {
+    ...quantized_mesh_loader_1.QuantizedMeshLoader,
+    parseSync: parse_quantized_mesh_1.default,
+    parse: async (arrayBuffer, options) => (0, parse_quantized_mesh_1.default)(arrayBuffer, options)
+};
+exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader;

package/dist/lib/decode-quantized-mesh.d.ts

@@ -0,0 +1,59 @@
+declare type Extensions = {
+    vertexNormals?: any;
+    waterMask?: any;
+};
+export declare const DECODING_STEPS: {
+    header: number;
+    vertices: number;
+    triangleIndices: number;
+    edgeIndices: number;
+    extensions: number;
+};
+export default function decode(data: any, userOptions: any): {
+    header: {};
+    vertexData?: undefined;
+    triangleIndices?: undefined;
+    westIndices?: undefined;
+    northIndices?: undefined;
+    eastIndices?: undefined;
+    southIndices?: undefined;
+    extensions?: undefined;
+} | {
+    header: {};
+    vertexData: Uint16Array;
+    triangleIndices?: undefined;
+    westIndices?: undefined;
+    northIndices?: undefined;
+    eastIndices?: undefined;
+    southIndices?: undefined;
+    extensions?: undefined;
+} | {
+    header: {};
+    vertexData: Uint16Array;
+    triangleIndices: any;
+    westIndices?: undefined;
+    northIndices?: undefined;
+    eastIndices?: undefined;
+    southIndices?: undefined;
+    extensions?: undefined;
+} | {
+    header: {};
+    vertexData: Uint16Array;
+    triangleIndices: any;
+    westIndices: any;
+    northIndices: any;
+    eastIndices: any;
+    southIndices: any;
+    extensions?: undefined;
+} | {
+    header: {};
+    vertexData: Uint16Array;
+    triangleIndices: any;
+    westIndices: any;
+    northIndices: any;
+    eastIndices: any;
+    southIndices: any;
+    extensions: Extensions;
+};
+export {};
+//# sourceMappingURL=decode-quantized-mesh.d.ts.map

package/dist/lib/decode-quantized-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-quantized-mesh.d.ts","sourceRoot":"","sources":["../../src/lib/decode-quantized-mesh.ts"],"names":[],"mappings":"AAuNA,aAAK,UAAU,GAAG;IAChB,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AA0CF,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAC;AAMF,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD/C"}