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

package/dist/lib/parse-terrain.js

@@ -1,180 +1,162 @@
-import { getMeshBoundingBox } from '@loaders.gl/schema';
-import Martini from '@mapbox/martini';
-import Delatin from './delatin';
-import { addSkirt } from './helpers/skirt';
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@loaders.gl/schema");
+const martini_1 = __importDefault(require("@mapbox/martini"));
+const delatin_1 = __importDefault(require("./delatin"));
+const skirt_1 = require("./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;
+    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') {
-    for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
-      terrain[i] = terrain[i - width - 1];
+    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];
+        }
     }
-
-    for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
-      terrain[i] = terrain[i - 1];
-    }
-  }
-
-  return terrain;
+    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
+    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;
-  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
-  };
+    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;
+        // auto
+        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);
+    // Compute bounding box before adding skirt so that z values are not skewed
+    const boundingBox = (0, schema_1.getMeshBoundingBox)(attributes);
+    if (terrainOptions.skirtHeight) {
+        const { attributes: newAttributes, triangles: newTriangles } = (0, skirt_1.addSkirt)(attributes, triangles, terrainOptions.skirtHeight);
+        attributes = newAttributes;
+        triangles = newTriangles;
+    }
+    return {
+        // Data return by this loader implementation
+        loaderData: {
+            header: {}
+        },
+        header: {
+            vertexCount: triangles.length,
+            boundingBox
+        },
+        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 gridSize = width + 1;
+    const martini = new martini_1.default(gridSize);
+    const tile = martini.createTile(terrain);
+    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 vertices = coords;
-  return {
-    vertices,
-    triangles
-  };
+    const tin = new delatin_1.default(terrain, width + 1, height + 1);
+    tin.run(meshMaxError);
+    // @ts-expect-error
+    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);
+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);
 }
-//# sourceMappingURL=parse-terrain.js.map
+exports.default = loadTerrain;

package/dist/lib/utils/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION: any;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,KAA8D,CAAC"}

package/dist/lib/utils/version.js

@@ -1,2 +1,7 @@
-export const VERSION = typeof "3.1.0-alpha.3" !== 'undefined' ? "3.1.0-alpha.3" : 'latest';
-//# sourceMappingURL=version.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/quantized-mesh-loader.d.ts

@@ -0,0 +1,21 @@
+import type { Loader } from '@loaders.gl/loader-utils';
+/**
+ * Worker loader for quantized meshes
+ */
+export declare const QuantizedMeshLoader: {
+    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: Loader;
+//# sourceMappingURL=quantized-mesh-loader.d.ts.map

package/dist/quantized-mesh-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantized-mesh-loader.d.ts","sourceRoot":"","sources":["../src/quantized-mesh-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;CAc/B,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,MAA4B,CAAC"}

package/dist/quantized-mesh-loader.js

@@ -1,18 +1,23 @@
-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
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader = void 0;
+const version_1 = require("./lib/utils/version");
+/**
+ * Worker loader for quantized meshes
+ */
+exports.QuantizedMeshLoader = {
+    name: 'Quantized Mesh',
+    id: 'quantized-mesh',
+    module: 'terrain',
+    version: version_1.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
+exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader;