@loaders.gl/terrain 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/lib/helpers/skirt.js

@@ -1,89 +1,126 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { concatenateTypedArrays } from '@loaders.gl/loader-utils';
+/**
+ * Add skirt to existing mesh
+ * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
+ * @param {any} triangles - indices array of the mesh geometry
+ * @param 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, outsideIndices) {
-  const outsideEdges = outsideIndices ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value) : getOutsideEdgesFromTriangles(triangles);
-  const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
-  const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
-  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
-  };
+    const outsideEdges = outsideIndices
+        ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value)
+        : getOutsideEdgesFromTriangles(triangles);
+    // 2 new vertices for each outside edge
+    const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
+    const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
+    // 2 new triangles for each outside edge
+    const newTriangles = new triangles.constructor(outsideEdges.length * 6);
+    for (let i = 0; i < outsideEdges.length; i++) {
+        const edge = outsideEdges[i];
+        updateAttributesForNewEdge({
+            edge,
+            edgeIndex: i,
+            attributes,
+            skirtHeight,
+            newPosition,
+            newTexcoord0,
+            newTriangles
+        });
+    }
+    attributes.POSITION.value = concatenateTypedArrays(attributes.POSITION.value, newPosition);
+    attributes.TEXCOORD_0.value = concatenateTypedArrays(attributes.TEXCOORD_0.value, newTexcoord0);
+    const resultTriangles = triangles instanceof Array
+        ? triangles.concat(newTriangles)
+        : concatenateTypedArrays(triangles, newTriangles);
+    return {
+        attributes,
+        triangles: resultTriangles
+    };
 }
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {any} triangles - indices array of the mesh geometry
+ * @returns {number[][]} - outside edges data
+ */
 function getOutsideEdgesFromTriangles(triangles) {
-  const edges = [];
-  for (let i = 0; i < triangles.length; i += 3) {
-    edges.push([triangles[i], triangles[i + 1]]);
-    edges.push([triangles[i + 1], triangles[i + 2]]);
-    edges.push([triangles[i + 2], triangles[i]]);
-  }
-  edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
-  const outsideEdges = [];
-  let index = 0;
-  while (index < edges.length) {
-    var _edges, _edges2;
-    if (edges[index][0] === ((_edges = edges[index + 1]) === null || _edges === void 0 ? void 0 : _edges[1]) && edges[index][1] === ((_edges2 = edges[index + 1]) === null || _edges2 === void 0 ? void 0 : _edges2[0])) {
-      index += 2;
-    } else {
-      outsideEdges.push(edges[index]);
-      index++;
+    const edges = [];
+    for (let i = 0; i < triangles.length; i += 3) {
+        edges.push([triangles[i], triangles[i + 1]]);
+        edges.push([triangles[i + 1], triangles[i + 2]]);
+        edges.push([triangles[i + 2], triangles[i]]);
+    }
+    edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
+    const outsideEdges = [];
+    let index = 0;
+    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]);
+            index++;
+        }
     }
-  }
-  return outsideEdges;
+    return outsideEdges;
 }
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {object} indices - edge indices from quantized mesh data
+ * @param {TypedArray} position - position attribute geometry data
+ * @returns {number[][]} - outside edges data
+ */
 function getOutsideEdgesFromIndices(indices, position) {
-  indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
-  indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
-  indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
-  indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
-  const edges = [];
-  for (const index in indices) {
-    const indexGroup = indices[index];
-    for (let i = 0; i < indexGroup.length - 1; i++) {
-      edges.push([indexGroup[i], indexGroup[i + 1]]);
+    // Sort skirt indices to create adjacent triangles
+    indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
+    // Reverse (b - a) to match triangle winding
+    indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
+    indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
+    // Reverse (b - a) to match triangle winding
+    indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
+    const edges = [];
+    for (const index in indices) {
+        const indexGroup = indices[index];
+        for (let i = 0; i < indexGroup.length - 1; i++) {
+            edges.push([indexGroup[i], indexGroup[i + 1]]);
+        }
     }
-  }
-  return edges;
+    return edges;
 }
-function updateAttributesForNewEdge(_ref) {
-  let {
-    edge,
-    edgeIndex,
-    attributes,
-    skirtHeight,
-    newPosition,
-    newTexcoord0,
-    newTriangles
-  } = _ref;
-  const positionsLength = attributes.POSITION.value.length;
-  const vertex1Offset = edgeIndex * 2;
-  const vertex2Offset = edgeIndex * 2 + 1;
-  newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
-  newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight;
-  newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
-  newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight;
-  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);
-  const triangle1Offset = edgeIndex * 2 * 3;
-  newTriangles[triangle1Offset] = edge[0];
-  newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 2] = edge[1];
-  newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 4] = edge[0];
-  newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
+/**
+ * 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] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 2] = edge[1];
+    newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 4] = edge[0];
+    newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
 }
-//# sourceMappingURL=skirt.js.map

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

@@ -1,85 +1,73 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { getMeshBoundingBox } from '@loaders.gl/schema';
 import decode, { DECODING_STEPS } from "./decode-quantized-mesh.js";
 import { addSkirt } from "./helpers/skirt.js";
-export function parseQuantizedMesh(arrayBuffer) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  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 !== null && options !== void 0 && 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
-    },
-    schema: undefined,
-    topology: 'triangle-list',
-    mode: 4,
-    indices: {
-      value: triangleIndices,
-      size: 1
-    },
-    attributes
-  };
+export function parseQuantizedMesh(arrayBuffer, options = {}) {
+    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
+        },
+        // TODO
+        schema: undefined,
+        topology: 'triangle-list',
+        mode: 4, // TRIANGLES
+        indices: { value: triangleIndices, size: 1 },
+        attributes
+    };
 }
 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
+    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
+    };
 }
-//# sourceMappingURL=parse-quantized-mesh.js.map

package/dist/lib/parse-terrain.js

@@ -1,151 +1,149 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { getMeshBoundingBox } from '@loaders.gl/schema';
 import Martini from '@mapbox/martini';
 import Delatin from "./delatin/index.js";
 import { addSkirt } from "./helpers/skirt.js";
+/**
+ * Returns generated mesh object from image data
+ *
+ * @param terrainImage terrain image data
+ * @param terrainOptions terrain options
+ * @returns mesh object
+ */
 export function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
-  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
-  };
+    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 = getMeshBoundingBox(attributes);
+    if (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: {}
+        },
+        header: {
+            vertexCount: triangles.length,
+            boundingBox
+        },
+        mode: 4, // TRIANGLES
+        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(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(terrain, width + 1, height + 1);
+    tin.run(meshMaxError);
+    // @ts-expect-error
+    const { coords, triangles } = tin;
+    const vertices = coords;
+    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];
+    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;
+        }
     }
-    for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
-      terrain[i] = terrain[i - 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];
+        }
     }
-  }
-  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
+    };
 }
-//# sourceMappingURL=parse-terrain.js.map