@loaders.gl/terrain 3.1.0-alpha.5 → 3.1.0-beta.5

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

@@ -1,12 +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 {number} skirtHeight - height of the skirt geometry
- * @param {object} outsideIndices - edge indices from quantized mesh data
+ * @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: object, triangles: any, skirtHeight: number, outsideIndices?: object): {
+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

@@ -0,0 +1,127 @@
+"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++;
+        }
+    }
+    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] = 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];
+}

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

@@ -3,12 +3,12 @@ export default function loadQuantizedMesh(arrayBuffer: any, options: any): {
         header: {};
     };
     header: {
-        vertexCount: number;
+        vertexCount: any;
         boundingBox: [[number, number, number], [number, number, number]];
     };
     mode: number;
     indices: {
-        value: Uint16Array | Uint32Array | undefined;
+        value: any;
         size: number;
     };
     attributes: {
@@ -22,3 +22,4 @@ export default function loadQuantizedMesh(arrayBuffer: any, options: any): {
         };
     };
 } | 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

@@ -0,0 +1,95 @@
+"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;
+    // 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;
+    // 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
+    };
+}
+function loadQuantizedMesh(arrayBuffer, options) {
+    return getTileMesh(arrayBuffer, options['quantized-mesh']);
+}
+exports.default = loadQuantizedMesh;

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

@@ -3,7 +3,7 @@ export default function loadTerrain(arrayBuffer: any, options: any, context: any
         header: {};
     };
     header: {
-        vertexCount: number;
+        vertexCount: any;
         boundingBox: [[number, number, number], [number, number, number]];
     };
     mode: number;
@@ -22,3 +22,4 @@ export default function loadTerrain(arrayBuffer: any, options: any, context: any
         };
     };
 } | 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"}

package/dist/lib/parse-terrain.js

@@ -0,0 +1,162 @@
+"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;
+    // 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;
+    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_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 };
+}
+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);
+}
+exports.default = loadTerrain;

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

@@ -1 +1,2 @@
-export const VERSION: any;
+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

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

@@ -18,3 +18,4 @@ export declare const QuantizedMeshLoader: {
     };
 };
 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

@@ -0,0 +1,23 @@
+"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
+        }
+    }
+};
+exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader;