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

package/{src → dist/esm}/lib/parse-terrain.js

@@ -1,86 +1,18 @@
-import {getMeshBoundingBox} from '@loaders.gl/schema';
+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;
-
-  // From Martini demo
-  // https://observablehq.com/@mourner/martin-real-time-rtin-terrain-mesh
-  const terrain = new Float32Array((width + 1) * (height + 1));
-  // decode terrain values
-  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') {
-    // backfill bottom border
-    for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
-      terrain[i] = terrain[i - width - 1];
-    }
-    // backfill right border
-    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;
-  // vec3. x, y in pixels, z in meters
-  const positions = new Float32Array(numOfVerticies * 3);
-  // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
-  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}
-    // NORMAL: {}, - optional, but creates the high poly look with lighting
-  };
-}
-
-/**
- * Returns generated mesh object from image data
- *
- * @param {object} terrainImage terrain image data
- * @param {object} terrainOptions terrain options
- * @returns mesh object
- */
-function getMesh(terrainImage, terrainOptions) {
-  if (terrainImage === null) {
-    return null;
-  }
-  const {meshMaxError, bounds, elevationDecoder} = terrainOptions;
-
-  const {data, width, height} = terrainImage;
-
+import { addSkirt } from './helpers/skirt';
+export function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
+  const {
+    meshMaxError,
+    bounds,
+    elevationDecoder
+  } = terrainOptions;
+  const {
+    data,
+    width,
+    height
+  } = terrainImage;
   let terrain;
   let mesh;
   switch (terrainOptions.tesselator) {
@@ -92,9 +24,8 @@ function getMesh(terrainImage, terrainOptions) {
       terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
       mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
       break;
-    // auto
     default:
-      if (width === height && !(height & (width - 1))) {
+      if (width === height && !(height & width - 1)) {
         terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
         mesh = getMartiniTileMesh(meshMaxError, width, terrain);
       } else {
@@ -103,26 +34,23 @@ function getMesh(terrainImage, terrainOptions) {
       }
       break;
   }
-
-  const {vertices} = mesh;
-  let {triangles} = mesh;
+  const {
+    vertices
+  } = mesh;
+  let {
+    triangles
+  } = mesh;
   let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);
-
-  // Compute bounding box before adding skirt so that z values are not skewed
   const boundingBox = getMeshBoundingBox(attributes);
-
   if (terrainOptions.skirtHeight) {
-    const {attributes: newAttributes, triangles: newTriangles} = addSkirt(
-      attributes,
-      triangles,
-      terrainOptions.skirtHeight
-    );
+    const {
+      attributes: newAttributes,
+      triangles: newTriangles
+    } = addSkirt(attributes, triangles, terrainOptions.skirtHeight);
     attributes = newAttributes;
     triangles = newTriangles;
   }
-
   return {
-    // Data return by this loader implementation
     loaderData: {
       header: {}
     },
@@ -130,50 +58,94 @@ function getMesh(terrainImage, terrainOptions) {
       vertexCount: triangles.length,
       boundingBox
     },
-    mode: 4, // TRIANGLES
-    indices: {value: Uint32Array.from(triangles), size: 1},
+    mode: 4,
+    indices: {
+      value: Uint32Array.from(triangles),
+      size: 1
+    },
     attributes
   };
 }
-
-/**
- * Get Martini generated vertices and triangles
- *
- * @param {number} meshMaxError threshold for simplifying mesh
- * @param {number} width width of the input data
- * @param {number[] | Float32Array} terrain elevation data
- * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data
- */
 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};
+  const {
+    vertices,
+    triangles
+  } = tile.getMesh(meshMaxError);
+  return {
+    vertices,
+    triangles
+  };
 }
-
-/**
- * Get Delatin generated vertices and triangles
- *
- * @param {number} meshMaxError threshold for simplifying mesh
- * @param {number} width width of the input data array
- * @param {number} height height of the input data array
- * @param {number[] | Float32Array} terrain elevation data
- * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data
- */
 function getDelatinTileMesh(meshMaxError, width, height, terrain) {
   const tin = new Delatin(terrain, width + 1, height + 1);
   tin.run(meshMaxError);
-  const {coords, triangles} = tin;
+  const {
+    coords,
+    triangles
+  } = tin;
   const vertices = coords;
-  return {vertices, triangles};
+  return {
+    vertices,
+    triangles
+  };
+}
+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;
 }
-
-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);
-  // Extend function to support additional mesh generation options (square grid or delatin)
-  return getMesh(image, options.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
+    }
+  };
 }
+//# sourceMappingURL=parse-terrain.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-terrain.js","names":["getMeshBoundingBox","Martini","Delatin","addSkirt","makeTerrainMeshFromImage","terrainImage","terrainOptions","meshMaxError","bounds","elevationDecoder","data","width","height","terrain","mesh","tesselator","getTerrain","getMartiniTileMesh","getDelatinTileMesh","vertices","triangles","attributes","getMeshAttributes","boundingBox","skirtHeight","newAttributes","newTriangles","loaderData","header","vertexCount","length","mode","indices","value","Uint32Array","from","size","gridSize","martini","tile","createTile","getMesh","tin","run","coords","imageData","rScaler","bScaler","gScaler","offset","Float32Array","i","y","x","k","r","g","b","numOfVerticies","positions","texCoords","minX","minY","maxX","maxY","xScale","yScale","pixelIdx","POSITION","TEXCOORD_0"],"sources":["../../../src/lib/parse-terrain.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport Martini from '@mapbox/martini';\nimport Delatin from './delatin';\nimport {addSkirt} from './helpers/skirt';\n\nexport type TerrainOptions = {\n  meshMaxError: number;\n  bounds: number[];\n  elevationDecoder: ElevationDecoder;\n  tesselator: 'martini' | 'delatin' | 'auto';\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\n/**\n * Returns generated mesh object from image data\n *\n * @param terrainImage terrain image data\n * @param terrainOptions terrain options\n * @returns mesh object\n */\nexport function makeTerrainMeshFromImage(\n  terrainImage: TerrainImage,\n  terrainOptions: TerrainOptions\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\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"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","names":["VERSION"],"sources":["../../../../src/lib/utils/version.ts"],"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"],"mappings":"AAGA,OAAO,MAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ"}

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

@@ -0,0 +1,17 @@
+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
+    }
+  }
+};
+//# sourceMappingURL=quantized-mesh-loader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quantized-mesh-loader.js","names":["VERSION","QuantizedMeshLoader","name","id","module","version","worker","extensions","mimeTypes","options","bounds","skirtHeight"],"sources":["../../src/quantized-mesh-loader.ts"],"sourcesContent":["import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\n\nexport type QuantizedMeshLoaderOptions = LoaderOptions & {\n  'quantized-mesh'?: {\n    bounds?: [number, number, number, number];\n    skirtHeight?: number | null;\n  };\n};\n\n/**\n * Worker loader for quantized meshes\n */\nexport const QuantizedMeshLoader: Loader<any, never, QuantizedMeshLoaderOptions> = {\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"],"mappings":"AACA,SAAQA,OAAO,QAAO,qBAAqB;AAY3C,OAAO,MAAMC,mBAAmE,GAAG;EACjFC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,gBAAgB;EACpBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEL,OAAO;EAChBM,MAAM,EAAE,IAAI;EACZC,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,gCAAgC,CAAC;EAC7CC,OAAO,EAAE;IACP,gBAAgB,EAAE;MAChBC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;MACpBC,WAAW,EAAE;IACf;EACF;AACF,CAAC"}

package/dist/esm/terrain-loader.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-loader.js","names":["VERSION","TerrainLoader","name","id","module","version","worker","extensions","mimeTypes","options","terrain","tesselator","bounds","undefined","meshMaxError","elevationDecoder","rScaler","gScaler","bScaler","offset","skirtHeight"],"sources":["../../src/terrain-loader.ts"],"sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\nimport type {ImageLoaderOptions} from '@loaders.gl/images';\nimport {VERSION} from './lib/utils/version';\n\nimport {TerrainOptions} from './lib/parse-terrain';\nimport {Mesh} from '@loaders.gl/schema';\n\nexport type TerrainLoaderOptions = ImageLoaderOptions & {\n  terrain?: TerrainOptions;\n};\n\n/**\n * Worker loader for image encoded terrain\n */\nexport const TerrainLoader: Loader<Mesh, never, TerrainLoaderOptions> = {\n  name: 'Terrain',\n  id: 'terrain',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['png', 'pngraw', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'],\n  mimeTypes: ['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/bmp'],\n  options: {\n    terrain: {\n      tesselator: 'auto',\n      bounds: undefined!,\n      meshMaxError: 10,\n      elevationDecoder: {\n        rScaler: 1,\n        gScaler: 0,\n        bScaler: 0,\n        offset: 0\n      },\n      skirtHeight: undefined\n    }\n  }\n};\n"],"mappings":"AAEA,SAAQA,OAAO,QAAO,qBAAqB;AAY3C,OAAO,MAAMC,aAAwD,GAAG;EACtEC,IAAI,EAAE,SAAS;EACfC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEL,OAAO;EAChBM,MAAM,EAAE,IAAI;EACZC,UAAU,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC;EAClEC,SAAS,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,CAAC;EAC9EC,OAAO,EAAE;IACPC,OAAO,EAAE;MACPC,UAAU,EAAE,MAAM;MAClBC,MAAM,EAAEC,SAAU;MAClBC,YAAY,EAAE,EAAE;MAChBC,gBAAgB,EAAE;QAChBC,OAAO,EAAE,CAAC;QACVC,OAAO,EAAE,CAAC;QACVC,OAAO,EAAE,CAAC;QACVC,MAAM,EAAE;MACV,CAAC;MACDC,WAAW,EAAEP;IACf;EACF;AACF,CAAC"}

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,"file":"quantized-mesh-worker.js","names":["createLoaderWorker","QuantizedMeshLoader"],"sources":["../../../src/workers/quantized-mesh-worker.ts"],"sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {QuantizedMeshLoader} from '../index';\n\ncreateLoaderWorker(QuantizedMeshLoader);\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,0BAA0B;AAC3D,SAAQC,mBAAmB,QAAO,UAAU;AAE5CD,kBAAkB,CAACC,mBAAmB,CAAC"}

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,"file":"terrain-worker.js","names":["createLoaderWorker","TerrainLoader"],"sources":["../../../src/workers/terrain-worker.ts"],"sourcesContent":["import {createLoaderWorker} from '@loaders.gl/loader-utils';\nimport {TerrainLoader} from '../index';\n\ncreateLoaderWorker(TerrainLoader);\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,0BAA0B;AAC3D,SAAQC,aAAa,QAAO,UAAU;AAEtCD,kBAAkB,CAACC,aAAa,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import type { LoaderContext, LoaderWithParser } from '@loaders.gl/loader-utils';
+import { TerrainLoader as TerrainWorkerLoader, TerrainLoaderOptions } from './terrain-loader';
+import { QuantizedMeshLoader as QuantizedMeshWorkerLoader, QuantizedMeshLoaderOptions } from './quantized-mesh-loader';
+export { TerrainWorkerLoader };
+export declare const TerrainLoader: LoaderWithParser<any, never, TerrainLoaderOptions>;
+export declare function parseTerrain(arrayBuffer: ArrayBuffer, options?: TerrainLoaderOptions, context?: LoaderContext): Promise<{
+    loaderData: {
+        header: {};
+    };
+    header: {
+        vertexCount: any;
+        boundingBox: [[number, number, number], [number, number, number]];
+    };
+    mode: number;
+    indices: {
+        value: Uint32Array;
+        size: number;
+    };
+    attributes: {
+        POSITION: {
+            value: Float32Array;
+            size: number;
+        };
+        TEXCOORD_0: {
+            value: Float32Array;
+            size: number;
+        };
+    };
+}>;
+export { QuantizedMeshWorkerLoader };
+/**
+ * Loader for quantized meshes
+ */
+export declare const QuantizedMeshLoader: LoaderWithParser<any, never, QuantizedMeshLoaderOptions>;
+//# 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,aAAa,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI9E,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAE,oBAAoB,EAAC,MAAM,kBAAkB,CAAC;AAC5F,OAAO,EACL,mBAAmB,IAAI,yBAAyB,EAChD,0BAA0B,EAC3B,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAAC,mBAAmB,EAAC,CAAC;AAE7B,eAAO,MAAM,aAAa,EAAE,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,oBAAoB,CAG5E,CAAC;AAEF,wBAAsB,YAAY,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;GAWxB;AAID,OAAO,EAAC,yBAAyB,EAAC,CAAC;AAEnC;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,0BAA0B,CAKxF,CAAC"}

package/dist/index.js

@@ -1,16 +1,33 @@
-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";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantizedMeshLoader = exports.QuantizedMeshWorkerLoader = exports.parseTerrain = exports.TerrainLoader = exports.TerrainWorkerLoader = void 0;
+const parse_quantized_mesh_1 = require("./lib/parse-quantized-mesh");
+const parse_terrain_1 = 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: parseTerrain
 };
-export const _typecheckTerrainLoader = TerrainLoader;
-export { QuantizedMeshWorkerLoader };
-export const QuantizedMeshLoader = { ...QuantizedMeshWorkerLoader,
-  parseSync: parseQuantizedMesh,
-  parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options)
+async function parseTerrain(arrayBuffer, options, context) {
+    const loadImageOptions = {
+        ...options,
+        mimeType: 'application/x.image',
+        image: { ...options?.image, type: 'data' }
+    };
+    const image = await context?.parse(arrayBuffer, loadImageOptions);
+    // Extend function to support additional mesh generation options (square grid or delatin)
+    const terrainOptions = { ...exports.TerrainLoader.options.terrain, ...options?.terrain };
+    return (0, parse_terrain_1.makeTerrainMeshFromImage)(image, terrainOptions);
+}
+exports.parseTerrain = parseTerrain;
+/**
+ * Loader for quantized meshes
+ */
+exports.QuantizedMeshLoader = {
+    ...quantized_mesh_loader_1.QuantizedMeshLoader,
+    parseSync: (arrayBuffer, options) => (0, parse_quantized_mesh_1.parseQuantizedMesh)(arrayBuffer, options?.['quantized-mesh']),
+    parse: async (arrayBuffer, options) => (0, parse_quantized_mesh_1.parseQuantizedMesh)(arrayBuffer, options?.['quantized-mesh'])
 };
-export const _typecheckQuantizedMeshLoader = QuantizedMeshLoader;
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,59 @@
+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,KAAK,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"}