@loaders.gl/3d-tiles 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/lib/encoders/helpers/encode-3d-tile-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../../src/lib/encoders/helpers/encode-3d-tile-header.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,OAqB5D;AAGD,wBAAgB,sBAAsB,CAAC,QAAQ,KAAA,EAAE,mBAAmB,KAAA,EAAE,UAAU,KAAA,QAM/E"}

package/dist/lib/encoders/helpers/encode-3d-tile-header.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode3DTileByteLength = exports.encode3DTileHeader = void 0;
+// HELPER ENCODERS
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+function encode3DTileHeader(tile, dataView, byteOffset) {
+    const HEADER_SIZE = 12;
+    if (!dataView) {
+        return byteOffset + HEADER_SIZE;
+    }
+    const { magic, version = 1, byteLength = 12 } = tile;
+    (0, loader_utils_1.assert)(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
+    dataView.setUint8(byteOffset + 0, magic[0]);
+    dataView.setUint8(byteOffset + 1, magic[1]);
+    dataView.setUint8(byteOffset + 2, magic[2]);
+    dataView.setUint8(byteOffset + 3, magic[3]);
+    dataView.setUint32(byteOffset + 4, version, true); // version
+    dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength
+    byteOffset += HEADER_SIZE;
+    return byteOffset;
+}
+exports.encode3DTileHeader = encode3DTileHeader;
+// Bytelength is sometimes only known at the end of writing a tile
+function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
+    if (!dataView) {
+        return;
+    }
+    dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength
+}
+exports.encode3DTileByteLength = encode3DTileByteLength;

package/dist/lib/ion/ion.d.ts

@@ -1,3 +1,4 @@
 export function getIonTilesetMetadata(accessToken: any, assetId: any): Promise<any>;
 export function getIonAssets(accessToken: any): Promise<any>;
 export function getIonAssetMetadata(accessToken: any, assetId: any): Promise<any>;
+//# sourceMappingURL=ion.d.ts.map

package/dist/lib/ion/ion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ion.d.ts","sourceRoot":"","sources":["../../../src/lib/ion/ion.js"],"names":[],"mappings":"AAQA,oFAqBC;AAGD,6DASC;AAGD,kFA4BC"}

package/dist/lib/ion/ion.js

@@ -0,0 +1,68 @@
+"use strict";
+// Minimal support to load tilsets from the Cesium ION services
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIonAssetMetadata = exports.getIonAssets = exports.getIonTilesetMetadata = void 0;
+const core_1 = require("@loaders.gl/core");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';
+// Returns `{url, headers, type, attributions}` for an ion tileset
+async function getIonTilesetMetadata(accessToken, assetId) {
+    // Step 1, if no asset id, look for first 3DTILES asset associated with this token.
+    if (!assetId) {
+        const assets = await getIonAssets(accessToken);
+        for (const item of assets.items) {
+            if (item.type === '3DTILES') {
+                assetId = item.id;
+            }
+        }
+    }
+    // Step 2: Query metdatadata for this asset.
+    const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);
+    const { type, url } = ionAssetMetadata;
+    (0, loader_utils_1.assert)(type === '3DTILES' && url);
+    // Prepare a headers object for fetch
+    ionAssetMetadata.headers = {
+        Authorization: `Bearer ${ionAssetMetadata.accessToken}`
+    };
+    return ionAssetMetadata;
+}
+exports.getIonTilesetMetadata = getIonTilesetMetadata;
+// Return a list of all assets associated with accessToken
+async function getIonAssets(accessToken) {
+    (0, loader_utils_1.assert)(accessToken);
+    const url = CESIUM_ION_URL;
+    const headers = { Authorization: `Bearer ${accessToken}` };
+    const response = await (0, core_1.fetchFile)(url, { fetch: { headers } });
+    if (!response.ok) {
+        throw new Error(response.statusText);
+    }
+    return await response.json();
+}
+exports.getIonAssets = getIonAssets;
+// Return metadata for a specific asset associated with token
+async function getIonAssetMetadata(accessToken, assetId) {
+    (0, loader_utils_1.assert)(accessToken, assetId);
+    const headers = { Authorization: `Bearer ${accessToken}` };
+    const url = `${CESIUM_ION_URL}/${assetId}`;
+    // https://cesium.com/docs/rest-api/#operation/getAsset
+    // Retrieves metadata information about a specific asset.
+    let response = await (0, core_1.fetchFile)(`${url}`, { fetch: { headers } });
+    if (!response.ok) {
+        throw new Error(response.statusText);
+    }
+    let metadata = await response.json();
+    // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint
+    // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.
+    response = await (0, core_1.fetchFile)(`${url}/endpoint`, { fetch: { headers } });
+    if (!response.ok) {
+        throw new Error(response.statusText);
+    }
+    const tilesetInfo = await response.json();
+    // extract dataset description
+    metadata = {
+        ...metadata,
+        ...tilesetInfo
+    };
+    return metadata;
+}
+exports.getIonAssetMetadata = getIonAssetMetadata;

package/dist/lib/parsers/helpers/normalize-3d-tile-colors.d.ts

@@ -1,6 +1,7 @@
-export function normalize3DTileColorAttribute(tile: any, colors: any, batchTable: any): {
+export declare function normalize3DTileColorAttribute(tile: any, colors: any, batchTable?: any): {
     type: number;
     value: any;
     size: number;
     normalized: boolean;
 } | null;
+//# sourceMappingURL=normalize-3d-tile-colors.d.ts.map

package/dist/lib/parsers/helpers/normalize-3d-tile-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-3d-tile-colors.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-colors.ts"],"names":[],"mappings":"AAGA,wBAAgB,6BAA6B,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,UAAU,CAAC,KAAA;;;;;SA6DtE"}

package/dist/lib/parsers/helpers/normalize-3d-tile-colors.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize3DTileColorAttribute = void 0;
+const math_1 = require("@loaders.gl/math");
+/* eslint-disable complexity*/
+function normalize3DTileColorAttribute(tile, colors, batchTable) {
+    // no colors defined
+    if (!colors && (!tile || !tile.batchIds || !batchTable)) {
+        return null;
+    }
+    const { batchIds, isRGB565, pointCount } = tile;
+    // Batch table, look up colors in table
+    if (batchIds && batchTable) {
+        const colorArray = new Uint8ClampedArray(pointCount * 3);
+        for (let i = 0; i < pointCount; i++) {
+            const batchId = batchIds[i];
+            // TODO figure out what is `dimensions` used for
+            const dimensions = batchTable.getProperty(batchId, 'dimensions');
+            const color = dimensions.map((d) => d * 255);
+            colorArray[i * 3] = color[0];
+            colorArray[i * 3 + 1] = color[1];
+            colorArray[i * 3 + 2] = color[2];
+        }
+        return {
+            type: math_1.GL.UNSIGNED_BYTE,
+            value: colorArray,
+            size: 3,
+            normalized: true
+        };
+    }
+    // RGB565 case, convert to RGB
+    if (isRGB565) {
+        const colorArray = new Uint8ClampedArray(pointCount * 3);
+        for (let i = 0; i < pointCount; i++) {
+            const color = (0, math_1.decodeRGB565)(colors[i]);
+            colorArray[i * 3] = color[0];
+            colorArray[i * 3 + 1] = color[1];
+            colorArray[i * 3 + 2] = color[2];
+        }
+        return {
+            type: math_1.GL.UNSIGNED_BYTE,
+            value: colorArray,
+            size: 3,
+            normalized: true
+        };
+    }
+    // RGB case (tile.isTranslucent)
+    if (colors && colors.length === pointCount * 3) {
+        return {
+            type: math_1.GL.UNSIGNED_BYTE,
+            value: colors,
+            size: 3,
+            normalized: true
+        };
+    }
+    // DEFAULT: RGBA case
+    return {
+        type: math_1.GL.UNSIGNED_BYTE,
+        value: colors,
+        size: 4,
+        normalized: true
+    };
+}
+exports.normalize3DTileColorAttribute = normalize3DTileColorAttribute;
+/* eslint-enable complexity*/

package/dist/lib/parsers/helpers/normalize-3d-tile-normals.d.ts

@@ -1,5 +1,6 @@
-export function normalize3DTileNormalAttribute(tile: any, normals: any): {
+export declare function normalize3DTileNormalAttribute(tile: any, normals: any): {
     type: number;
     size: number;
     value: any;
 } | null;
+//# sourceMappingURL=normalize-3d-tile-normals.d.ts.map

package/dist/lib/parsers/helpers/normalize-3d-tile-normals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-3d-tile-normals.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-normals.ts"],"names":[],"mappings":"AAKA,wBAAgB,8BAA8B,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA;;;;SAyB3D"}

package/dist/lib/parsers/helpers/normalize-3d-tile-normals.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize3DTileNormalAttribute = void 0;
+const core_1 = require("@math.gl/core");
+const math_1 = require("@loaders.gl/math");
+const scratchNormal = new core_1.Vector3();
+function normalize3DTileNormalAttribute(tile, normals) {
+    if (!normals) {
+        return null;
+    }
+    if (tile.isOctEncoded16P) {
+        const decodedArray = new Float32Array(tile.pointsLength * 3);
+        for (let i = 0; i < tile.pointsLength; i++) {
+            (0, math_1.octDecode)(normals[i * 2], normals[i * 2 + 1], scratchNormal);
+            // @ts-ignore
+            scratchNormal.toArray(decodedArray, i * 3);
+        }
+        return {
+            type: math_1.GL.FLOAT,
+            size: 2,
+            value: decodedArray
+        };
+    }
+    return {
+        type: math_1.GL.FLOAT,
+        size: 2,
+        value: normals
+    };
+}
+exports.normalize3DTileNormalAttribute = normalize3DTileNormalAttribute;

package/dist/lib/parsers/helpers/normalize-3d-tile-positions.d.ts

@@ -1 +1,2 @@
-export function normalize3DTilePositionAttribute(tile: any, positions: any, options: any): any;
+export declare function normalize3DTilePositionAttribute(tile: any, positions: any, options: any): any;
+//# sourceMappingURL=normalize-3d-tile-positions.d.ts.map

package/dist/lib/parsers/helpers/normalize-3d-tile-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-3d-tile-positions.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"names":[],"mappings":"AAIA,wBAAgB,gCAAgC,CAAC,IAAI,KAAA,EAAE,SAAS,KAAA,EAAE,OAAO,KAAA,OAsBxE"}

package/dist/lib/parsers/helpers/normalize-3d-tile-positions.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize3DTilePositionAttribute = void 0;
+const core_1 = require("@math.gl/core");
+const math_1 = require("@loaders.gl/math");
+// Prepare attribute for positions
+function normalize3DTilePositionAttribute(tile, positions, options) {
+    if (!tile.isQuantized) {
+        return positions;
+    }
+    // For quantized posititions, either expand to Float32Array or return custom accessor
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions
+    // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes
+    if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {
+        tile.isQuantized = false;
+        return decodeQuantizedPositions(tile, positions);
+    }
+    // Default: Use normalized shorts directly, no copying/processing.
+    // NOTE: The "missing" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`
+    return {
+        type: math_1.GL.UNSIGNED_SHORT,
+        value: positions,
+        size: 3,
+        normalized: true
+    };
+}
+exports.normalize3DTilePositionAttribute = normalize3DTilePositionAttribute;
+// Pre-scale quantized positions on CPU
+function decodeQuantizedPositions(tile, positions) {
+    const scratchPosition = new core_1.Vector3();
+    const decodedArray = new Float32Array(tile.pointCount * 3);
+    for (let i = 0; i < tile.pointCount; i++) {
+        // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET
+        scratchPosition
+            .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])
+            .scale(1 / tile.quantizedRange)
+            .multiply(tile.quantizedVolumeScale)
+            .add(tile.quantizedVolumeOffset)
+            .toArray(decodedArray, i * 3);
+    }
+    return decodedArray;
+}

package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.d.ts

@@ -1,6 +1,7 @@
-export function parse3DTileGLTFViewSync(tile: any, arrayBuffer: any, byteOffset: any, options: any): any;
-export function extractGLTF(tile: any, gltfFormat: any, options: any, context: any): Promise<void>;
-export namespace GLTF_FORMAT {
-    const URI: number;
-    const EMBEDDED: number;
-}
+export declare const GLTF_FORMAT: {
+    URI: number;
+    EMBEDDED: number;
+};
+export declare function parse3DTileGLTFViewSync(tile: any, arrayBuffer: any, byteOffset: any, options: any): any;
+export declare function extractGLTF(tile: any, gltfFormat: any, options: any, context: any): Promise<void>;
+//# sourceMappingURL=parse-3d-tile-gltf-view.d.ts.map

package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-gltf-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,OAoC7E;AAED,wBAAsB,WAAW,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAmBnE"}

package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.js

@@ -0,0 +1,88 @@
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGLTF = exports.parse3DTileGLTFViewSync = exports.GLTF_FORMAT = void 0;
+// TODO - should we automatically parse the embedded glTF or leave it to the app?
+// - I.e. some apps might work directly on a GLB, in that case no need for us to decode...
+// - And if we decode, do we still keep the GLB in case it is needed?
+// - Do we add an option to control this?
+// - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?
+const gltf_1 = require("@loaders.gl/gltf");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+exports.GLTF_FORMAT = {
+    URI: 0,
+    EMBEDDED: 1
+};
+function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
+    // Set flags
+    // glTF models need to be rotated from Y to Z up
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
+    tile.rotateYtoZ = true;
+    // Assume glTF consumes rest of tile
+    const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+    if (gltfByteLength === 0) {
+        throw new Error('glTF byte length must be greater than 0.');
+    }
+    // Save gltf up axis
+    tile.gltfUpAxis =
+        options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
+            ? options['3d-tiles'].assetGltfUpAxis
+            : 'Y';
+    // TODO - We can avoid copy if already 4-byte aligned...
+    // However the rest of the code may not be able to accept byteOffsets, so copy anyway
+    tile.gltfArrayBuffer = (0, loader_utils_1.sliceArrayBuffer)(arrayBuffer, byteOffset, gltfByteLength);
+    tile.gltfByteOffset = 0;
+    tile.gltfByteLength = gltfByteLength;
+    if (byteOffset % 4 === 0) {
+        // tile.gltfArrayBuffer = arrayBuffer;
+        // tile.gltfByteOffset = byteOffset;
+        // tile.gltfByteLength = gltfByteLength;
+    }
+    else {
+        // Create a copy of the glb so that it is 4-byte aligned
+        // eslint-disable-next-line
+        console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);
+    }
+    // Entire tile is consumed
+    return tile.byteOffset + tile.byteLength;
+}
+exports.parse3DTileGLTFViewSync = parse3DTileGLTFViewSync;
+async function extractGLTF(tile, gltfFormat, options, context) {
+    const tile3DOptions = options['3d-tiles'] || {};
+    extractGLTFBufferOrURL(tile, gltfFormat, options);
+    if (tile3DOptions.loadGLTF) {
+        const { parse, fetch } = context;
+        if (tile.gltfUrl) {
+            tile.gltfArrayBuffer = await fetch(tile.gltfUrl, options);
+            tile.gltfByteOffset = 0;
+        }
+        if (tile.gltfArrayBuffer) {
+            // TODO - Should handle byteOffset... However, not used now...
+            tile.gltf = await parse(tile.gltfArrayBuffer, gltf_1.GLTFLoader, options, context);
+            delete tile.gltfArrayBuffer;
+            delete tile.gltfByteOffset;
+            delete tile.gltfByteLength;
+        }
+    }
+}
+exports.extractGLTF = extractGLTF;
+function extractGLTFBufferOrURL(tile, gltfFormat, options) {
+    switch (gltfFormat) {
+        case exports.GLTF_FORMAT.URI:
+            // We need to remove padding from the end of the model URL in case this tile was part of a composite tile.
+            // This removes all white space and null characters from the end of the string.
+            const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+            const textDecoder = new TextDecoder();
+            const gltfUrl = textDecoder.decode(gltfUrlBytes);
+            tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, '');
+            delete tile.gltfArrayBuffer;
+            delete tile.gltfByteOffset;
+            delete tile.gltfByteLength;
+            break;
+        case exports.GLTF_FORMAT.EMBEDDED:
+            break;
+        default:
+            throw new Error('b3dm: Illegal glTF format field');
+    }
+}

package/dist/lib/parsers/helpers/parse-3d-tile-header.d.ts

@@ -1 +1,2 @@
-export function parse3DTileHeaderSync(tile: any, arrayBuffer: any, byteOffset?: number): number;
+export declare function parse3DTileHeaderSync(tile: any, arrayBuffer: any, byteOffset?: number): number;
+//# sourceMappingURL=parse-3d-tile-header.d.ts.map

package/dist/lib/parsers/helpers/parse-3d-tile-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-header.ts"],"names":[],"mappings":"AAYA,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,SAAI,UAkBtE"}

package/dist/lib/parsers/helpers/parse-3d-tile-header.js

@@ -0,0 +1,28 @@
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse3DTileHeaderSync = void 0;
+const SIZEOF_UINT32 = 4;
+/* PARSE FIXED HEADER:
+Populates
+  magic, // identifies type of tile
+  type, // String version of magic
+  version,
+  byteLength
+ */
+function parse3DTileHeaderSync(tile, arrayBuffer, byteOffset = 0) {
+    const view = new DataView(arrayBuffer);
+    tile.magic = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    tile.version = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    tile.byteLength = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    // TODO - move version check into each tile parser?
+    if (tile.version !== 1) {
+        throw new Error(`3D Tile Version ${tile.version} not supported`);
+    }
+    return byteOffset; // Indicates where the parsing ended
+}
+exports.parse3DTileHeaderSync = parse3DTileHeaderSync;

package/dist/lib/parsers/helpers/parse-3d-tile-subtree.d.ts

@@ -0,0 +1,9 @@
+import type { SubtreeAvailability } from '../../../types';
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+export default function parse3DTilesSubtree(data: ArrayBuffer): Promise<SubtreeAvailability>;
+//# sourceMappingURL=parse-3d-tile-subtree.d.ts.map

package/dist/lib/parsers/helpers/parse-3d-tile-subtree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-subtree.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-subtree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,mBAAmB,EAAoB,MAAM,gBAAgB,CAAC;AAM3E;;;;;GAKG;AACH,wBAA8B,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAoDjG"}

package/dist/lib/parsers/helpers/parse-3d-tile-subtree.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+async function parse3DTilesSubtree(data) {
+    const magic = new Uint32Array(data.slice(0, 4));
+    if (magic[0] !== SUBTREE_FILE_MAGIC) {
+        throw new Error('Wrong subtree file magic number');
+    }
+    const version = new Uint32Array(data.slice(4, 8));
+    if (version[0] !== SUBTREE_FILE_VERSION) {
+        throw new Error('Wrong subtree file verson, must be 1');
+    }
+    const jsonByteLength = parseUint64Value(data.slice(8, 16));
+    const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+    const textDecoder = new TextDecoder('utf8');
+    const string = textDecoder.decode(stringAttribute);
+    const subtree = JSON.parse(string);
+    const binaryByteLength = parseUint64Value(data.slice(16, 24));
+    let internalBinaryBuffer = new ArrayBuffer(0);
+    if (binaryByteLength) {
+        internalBinaryBuffer = data.slice(24 + jsonByteLength);
+    }
+    if ('bufferView' in subtree.tileAvailability) {
+        subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'tileAvailability', internalBinaryBuffer);
+    }
+    if ('bufferView' in subtree.contentAvailability) {
+        subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'contentAvailability', internalBinaryBuffer);
+    }
+    if ('bufferView' in subtree.childSubtreeAvailability) {
+        subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'childSubtreeAvailability', internalBinaryBuffer);
+    }
+    return subtree;
+}
+exports.default = parse3DTilesSubtree;
+/**
+ * Get explicit bitstream for subtree availability data.
+ * @param subtree
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(subtree, name, internalBinaryBuffer) {
+    const bufferViewIndex = subtree[name].bufferView;
+    const bufferView = subtree.bufferViews[bufferViewIndex];
+    const buffer = subtree.buffers[bufferView.buffer];
+    // External bitstream loading
+    if (buffer.uri) {
+        const response = await (0, core_1.fetchFile)(buffer.uri);
+        const data = await response.arrayBuffer();
+        // Return view of bitstream.
+        return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+    }
+    // Return view of bitstream.
+    return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+/**
+ * Parse buffer to return uint64 value
+ * @param buffer
+ * @returns 64-bit value until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Value(buffer) {
+    const dataView = new DataView(buffer);
+    const left = dataView.getUint32(0, true);
+    const right = dataView.getUint32(4, true);
+    // combine the two 32-bit values
+    return left + 2 ** 32 * right;
+}

package/dist/lib/parsers/helpers/parse-3d-tile-tables.d.ts

@@ -1,2 +1,3 @@
-export function parse3DTileTablesHeaderSync(tile: any, arrayBuffer: any, byteOffset: any): any;
-export function parse3DTileTablesSync(tile: any, arrayBuffer: any, byteOffset: any, options: any): any;
+export declare function parse3DTileTablesHeaderSync(tile: any, arrayBuffer: any, byteOffset: any): any;
+export declare function parse3DTileTablesSync(tile: any, arrayBuffer: any, byteOffset: any, options: any): any;
+//# sourceMappingURL=parse-3d-tile-tables.d.ts.map

package/dist/lib/parsers/helpers/parse-3d-tile-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-tables.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-tables.ts"],"names":[],"mappings":"AASA,wBAAgB,2BAA2B,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,OAiDxE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,OAI3E"}

package/dist/lib/parsers/helpers/parse-3d-tile-tables.js

@@ -0,0 +1,93 @@
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse3DTileTablesSync = exports.parse3DTileTablesHeaderSync = void 0;
+const parse_utils_1 = require("./parse-utils");
+const SIZEOF_UINT32 = 4;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
+// eslint-disable-next-line max-statements
+function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {
+    const view = new DataView(arrayBuffer);
+    let batchLength;
+    tile.header = tile.header || {};
+    let featureTableJsonByteLength = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    let featureTableBinaryByteLength = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    let batchTableJsonByteLength = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    let batchTableBinaryByteLength = view.getUint32(byteOffset, true);
+    byteOffset += SIZEOF_UINT32;
+    // First legacy header format - [batchLength] [batchTableByteLength] ('batchTableJsonByteLength': JSON starts with a quotation mark or the glTF magic)
+    // Second legacy format - [batchTableJsonByteLength] [batchTableBinaryByteLength] [batchLength] (Second legacy format is similar as first but here we check 'batchTableBinaryByteLength' instead)
+    // Current header format - [featureTableJsonByteLength] [featureTableBinaryByteLength] [batchTableJsonByteLength] [batchTableBinaryByteLength]
+    // First byte will be 0x22 or 0x67. The minimum uint32 expected is 0x22000000 = 570425344 = 570MB.
+    if (batchTableJsonByteLength >= 570425344) {
+        byteOffset -= SIZEOF_UINT32 * 2;
+        batchLength = featureTableJsonByteLength;
+        batchTableJsonByteLength = featureTableBinaryByteLength;
+        batchTableBinaryByteLength = 0;
+        featureTableJsonByteLength = 0;
+        featureTableBinaryByteLength = 0;
+        console.warn(DEPRECATION_WARNING); // eslint-disable-line
+    }
+    else if (batchTableBinaryByteLength >= 570425344) {
+        byteOffset -= SIZEOF_UINT32;
+        batchLength = batchTableJsonByteLength;
+        batchTableJsonByteLength = featureTableJsonByteLength;
+        batchTableBinaryByteLength = featureTableBinaryByteLength;
+        featureTableJsonByteLength = 0;
+        featureTableBinaryByteLength = 0;
+        console.warn(DEPRECATION_WARNING); // eslint-disable-line
+    }
+    tile.header.featureTableJsonByteLength = featureTableJsonByteLength;
+    tile.header.featureTableBinaryByteLength = featureTableBinaryByteLength;
+    tile.header.batchTableJsonByteLength = batchTableJsonByteLength;
+    tile.header.batchTableBinaryByteLength = batchTableBinaryByteLength;
+    tile.header.batchLength = batchLength;
+    return byteOffset;
+}
+exports.parse3DTileTablesHeaderSync = parse3DTileTablesHeaderSync;
+function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {
+    byteOffset = parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options);
+    byteOffset = parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options);
+    return byteOffset;
+}
+exports.parse3DTileTablesSync = parse3DTileTablesSync;
+function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
+    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header;
+    tile.featureTableJson = {
+        BATCH_LENGTH: batchLength || 0
+    };
+    if (featureTableJsonByteLength > 0) {
+        const featureTableString = (0, parse_utils_1.getStringFromArrayBuffer)(arrayBuffer, byteOffset, featureTableJsonByteLength);
+        tile.featureTableJson = JSON.parse(featureTableString);
+    }
+    byteOffset += featureTableJsonByteLength;
+    tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
+    byteOffset += featureTableBinaryByteLength;
+    /*
+    const featureTable = parseFeatureTable(featureTableJson, featureTableBinary);
+  
+    const batchLength = featureTable.getGlobalProperty('BATCH_LENGTH');
+    featureTable.featuresLength = batchLength;
+    */
+    return byteOffset;
+}
+function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
+    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header;
+    if (batchTableJsonByteLength > 0) {
+        const batchTableString = (0, parse_utils_1.getStringFromArrayBuffer)(arrayBuffer, byteOffset, batchTableJsonByteLength);
+        tile.batchTableJson = JSON.parse(batchTableString);
+        byteOffset += batchTableJsonByteLength;
+        if (batchTableBinaryByteLength > 0) {
+            // Has a batch table binary
+            tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);
+            // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed
+            tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);
+            byteOffset += batchTableBinaryByteLength;
+        }
+    }
+    return byteOffset;
+}

package/dist/lib/parsers/helpers/parse-utils.d.ts

@@ -1,3 +1,4 @@
-export function getStringFromArrayBuffer(arrayBuffer: any, byteOffset: any, byteLength: any): string;
-export function getStringFromTypedArray(typedArray: any): string;
-export function getMagicString(arrayBuffer: any, byteOffset?: number): string;
+export declare function getStringFromArrayBuffer(arrayBuffer: any, byteOffset: any, byteLength: any): string;
+export declare function getStringFromTypedArray(typedArray: any): string;
+export declare function getMagicString(arrayBuffer: any, byteOffset?: number): string;
+//# sourceMappingURL=parse-utils.d.ts.map

package/dist/lib/parsers/helpers/parse-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,wBAAwB,CAAC,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,UAAU,KAAA,UAM3E;AAGD,wBAAgB,uBAAuB,CAAC,UAAU,KAAA,UAKjD;AAED,wBAAgB,cAAc,CAAC,WAAW,KAAA,EAAE,UAAU,SAAI,UAOzD"}