@loaders.gl/terrain 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/lib/helpers/skirt.js

@@ -1,127 +0,0 @@
-"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 = 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;
-}
-/**
- * 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) {
-    // 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;
-}
-/**
- * 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;
-}

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

@@ -1,97 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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 });
-exports.parseQuantizedMesh = void 0;
-const schema_1 = require("@loaders.gl/schema");
-const decode_quantized_mesh_1 = __importStar(require("./decode-quantized-mesh"));
-const skirt_1 = require("./helpers/skirt");
-function parseQuantizedMesh(arrayBuffer, options = {}) {
-    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
-        },
-        // TODO
-        schema: undefined,
-        topology: 'triangle-list',
-        mode: 4,
-        indices: { value: triangleIndices, size: 1 },
-        attributes
-    };
-}
-exports.parseQuantizedMesh = parseQuantizedMesh;
-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;
-    // 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
-    };
-}

package/dist/lib/parse-terrain.js

@@ -1,154 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTerrainMeshFromImage = void 0;
-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");
-/**
- * Returns generated mesh object from image data
- *
- * @param terrainImage terrain image data
- * @param terrainOptions terrain options
- * @returns mesh object
- */
-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;
-        // 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
-    };
-}
-exports.makeTerrainMeshFromImage = makeTerrainMeshFromImage;
-/**
- * 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_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_1.default(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;
-    // 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
-    };
-}

package/dist/lib/utils/version.js

@@ -1,7 +0,0 @@
-"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.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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
-        }
-    }
-};

package/dist/terrain-loader.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TerrainLoader = void 0;
-const version_1 = require("./lib/utils/version");
-/**
- * Worker loader for image encoded terrain
- */
-exports.TerrainLoader = {
-    name: 'Terrain',
-    id: 'terrain',
-    module: 'terrain',
-    version: version_1.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
-        }
-    }
-};

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

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const index_1 = require("../index");
-(0, loader_utils_1.createLoaderWorker)(index_1.QuantizedMeshLoader);

package/dist/workers/terrain-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const index_1 = require("../index");
-(0, loader_utils_1.createLoaderWorker)(index_1.TerrainLoader);