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

package/dist/lib/helpers/skirt.d.ts

@@ -0,0 +1,19 @@
+export declare type EdgeIndices = {
+    westIndices: number[];
+    northIndices: number[];
+    eastIndices: number[];
+    southIndices: number[];
+};
+/**
+ * Add skirt to existing mesh
+ * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
+ * @param {any} triangles - indices array of the mesh geometry
+ * @param skirtHeight - height of the skirt geometry
+ * @param outsideIndices - edge indices from quantized mesh data
+ * @returns - geometry data with added skirt
+ */
+export declare function addSkirt(attributes: any, triangles: any, skirtHeight: number, outsideIndices?: EdgeIndices): {
+    attributes: any;
+    triangles: any;
+};
+//# sourceMappingURL=skirt.d.ts.map

package/dist/lib/helpers/skirt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skirt.d.ts","sourceRoot":"","sources":["../../../src/lib/helpers/skirt.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW,GAAG;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,UAAU,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW;;;EAqChG"}

package/dist/lib/helpers/skirt.js

@@ -1,99 +1,127 @@
-import { concatenateTypedArrays } from '@loaders.gl/loader-utils';
-export function addSkirt(attributes, triangles, skirtHeight, outsideIndices = null) {
-  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
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSkirt = void 0;
+const loader_utils_1 = require("@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
+ */
+function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
+    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 = (0, loader_utils_1.concatenateTypedArrays)(attributes.POSITION.value, newPosition);
+    attributes.TEXCOORD_0.value = (0, loader_utils_1.concatenateTypedArrays)(attributes.TEXCOORD_0.value, newTexcoord0);
+    const resultTriangles = triangles instanceof Array
+        ? triangles.concat(newTriangles)
+        : (0, loader_utils_1.concatenateTypedArrays)(triangles, newTriangles);
+    return {
+        attributes,
+        triangles: resultTriangles
+    };
 }
-
+exports.addSkirt = addSkirt;
+/**
+ * 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 = 1;
-
-  while (index < edges.length) {
-    if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
-      index += 2;
-    } else {
-      outsideEdges.push(edges[index - 1]);
-      index++;
+    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 = 1;
+    while (index < edges.length) {
+        if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
+            index += 2;
+        }
+        else {
+            outsideEdges.push(edges[index - 1]);
+            index++;
+        }
     }
-  }
-
-  return outsideEdges;
+    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({
-  edge,
-  edgeIndex,
-  attributes,
-  skirtHeight,
-  newPosition,
-  newTexcoord0,
-  newTriangles
-}) {
-  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] = edge[1];
-  newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
-  newTriangles[triangle1Offset + 5] = edge[0];
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {object} args
+ * @param {number[]} args.edge - edge indices in geometry
+ * @param {number} args.edgeIndex - edge index in outsideEdges array
+ * @param {object} args.attributes - POSITION and TEXCOORD_0 attributes
+ * @param {number} args.skirtHeight - height of the skirt geometry
+ * @param {TypedArray} args.newPosition - POSITION array for skirt data
+ * @param {TypedArray} args.newTexcoord0 - TEXCOORD_0 array for skirt data
+ * @param {TypedArray | Array} args.newTriangles - trinagle indices array for skirt data
+ * @returns {void}
+ */
+function updateAttributesForNewEdge({ edge, edgeIndex, attributes, skirtHeight, newPosition, newTexcoord0, newTriangles }) {
+    const positionsLength = attributes.POSITION.value.length;
+    const vertex1Offset = edgeIndex * 2;
+    const vertex2Offset = edgeIndex * 2 + 1;
+    // Define POSITION for new 1st vertex
+    newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
+    newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
+    // Define POSITION for new 2nd vertex
+    newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
+    newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
+    // Use same TEXCOORDS for skirt vertices
+    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2), vertex1Offset * 2);
+    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
+    // Define new triangles
+    const triangle1Offset = edgeIndex * 2 * 3;
+    newTriangles[triangle1Offset] = edge[0];
+    newTriangles[triangle1Offset + 1] = edge[1];
+    newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
+    newTriangles[triangle1Offset + 5] = edge[0];
 }
-//# sourceMappingURL=skirt.js.map

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

@@ -0,0 +1,25 @@
+export default function loadQuantizedMesh(arrayBuffer: any, options: any): {
+    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;
+//# sourceMappingURL=parse-quantized-mesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-quantized-mesh.d.ts","sourceRoot":"","sources":["../../src/lib/parse-quantized-mesh.ts"],"names":[],"mappings":"AA+FA,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,WAAW,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;SAE7D"}

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

@@ -1,96 +1,95 @@
-import { getMeshBoundingBox } from '@loaders.gl/schema';
-import decode, { DECODING_STEPS } from './decode-quantized-mesh';
-import { addSkirt } from './helpers/skirt';
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@loaders.gl/schema");
+const decode_quantized_mesh_1 = __importStar(require("./decode-quantized-mesh"));
+const skirt_1 = require("./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
+    const { minHeight, maxHeight } = header;
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
+    const xScale = maxX - minX;
+    const yScale = maxY - minY;
+    const zScale = maxHeight - minHeight;
+    const nCoords = vertexData.length / 3;
+    // vec3. x, y defined by bounds, z in meters
+    const positions = new Float32Array(nCoords * 3);
+    // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
+    const texCoords = new Float32Array(nCoords * 2);
+    // Data is not interleaved; all u, then all v, then all heights
+    for (let i = 0; i < nCoords; i++) {
+        const x = vertexData[i] / 32767;
+        const y = vertexData[i + nCoords] / 32767;
+        const z = vertexData[i + nCoords * 2] / 32767;
+        positions[3 * i + 0] = x * xScale + minX;
+        positions[3 * i + 1] = y * yScale + minY;
+        positions[3 * i + 2] = z * zScale + minHeight;
+        texCoords[2 * i + 0] = x;
+        texCoords[2 * i + 1] = y;
     }
-  };
+    return {
+        POSITION: { value: positions, size: 3 },
+        TEXCOORD_0: { value: texCoords, size: 2 }
+        // TODO: Parse normals if they exist in the file
+        // NORMAL: {}, - optional, but creates the high poly look with lighting
+    };
 }
-
 function getTileMesh(arrayBuffer, options) {
-  if (!arrayBuffer) {
-    return null;
-  }
-
-  const {
-    bounds
-  } = options;
-  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
-  };
+    if (!arrayBuffer) {
+        return null;
+    }
+    const { bounds } = options;
+    // Don't parse edge indices or format extensions
+    const { header, vertexData, triangleIndices: originalTriangleIndices, westIndices, northIndices, eastIndices, southIndices } = (0, decode_quantized_mesh_1.default)(arrayBuffer, decode_quantized_mesh_1.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 = (0, schema_1.getMeshBoundingBox)(attributes);
+    if (options.skirtHeight) {
+        const { attributes: newAttributes, triangles: newTriangles } = (0, skirt_1.addSkirt)(attributes, triangleIndices, options.skirtHeight, {
+            westIndices,
+            northIndices,
+            eastIndices,
+            southIndices
+        });
+        attributes = newAttributes;
+        triangleIndices = newTriangles;
+    }
+    return {
+        // Data return by this loader implementation
+        loaderData: {
+            header: {}
+        },
+        header: {
+            // @ts-ignore
+            vertexCount: triangleIndices.length,
+            boundingBox
+        },
+        mode: 4,
+        indices: { value: triangleIndices, size: 1 },
+        attributes
+    };
 }
-
-export default function loadQuantizedMesh(arrayBuffer, options) {
-  return getTileMesh(arrayBuffer, options['quantized-mesh']);
+function loadQuantizedMesh(arrayBuffer, options) {
+    return getTileMesh(arrayBuffer, options['quantized-mesh']);
 }
-//# sourceMappingURL=parse-quantized-mesh.js.map
+exports.default = loadQuantizedMesh;

package/dist/lib/parse-terrain.d.ts

@@ -0,0 +1,25 @@
+export default function loadTerrain(arrayBuffer: any, options: any, context: any): 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;
+        };
+    };
+} | null>;
+//# sourceMappingURL=parse-terrain.d.ts.map

package/dist/lib/parse-terrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-terrain.d.ts","sourceRoot":"","sources":["../../src/lib/parse-terrain.ts"],"names":[],"mappings":"AA8MA,wBAA8B,WAAW,CAAC,WAAW,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;UAMtE"}