@loaders.gl/3d-tiles 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-implicit-tiles.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAKhF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAYpE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,yFAAyF;IACzF,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,uGAAuG;IACvG,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AA6CF;;;;;;;;;;;GAWG;AAEH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC;IACb,UAAU,CAAC,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IACnF,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;;;;GAqIA;AA0HD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAGR"}

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceContentUrlTemplate = exports.parseImplicitTiles = void 0;
+const tile_3d_subtree_loader_1 = require("../../../tile-3d-subtree-loader");
+const core_1 = require("@loaders.gl/core");
+const index_1 = require("../../utils/s2/index");
+const s2_corners_to_obb_1 = require("../../utils/obb/s2-corners-to-obb");
+const QUADTREE_DEVISION_COUNT = 4;
+const OCTREE_DEVISION_COUNT = 8;
+const SUBDIVISION_COUNT_MAP = {
+    QUADTREE: QUADTREE_DEVISION_COUNT,
+    OCTREE: OCTREE_DEVISION_COUNT
+};
+function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
+    if (s2VolumeBox?.box) {
+        // Check if the BoundingVolume is of type "box"
+        const cellId = (0, index_1.getS2CellIdFromToken)(s2VolumeBox.s2VolumeInfo.token);
+        const childCellId = (0, index_1.getS2ChildCellId)(cellId, index);
+        const childToken = (0, index_1.getS2TokenFromCellId)(childCellId);
+        // Clone object. Note, s2VolumeInfo is a plain object that doesn't contain any nested object.
+        // So, we can use the Spread Operator to make a shallow copy of the object.
+        const s2ChildVolumeInfo = { ...s2VolumeBox.s2VolumeInfo };
+        s2ChildVolumeInfo.token = childToken; // replace the token with the child's one
+        // In case of QUADTREE the sizeZ should NOT be changed!
+        // https://portal.ogc.org/files/102132
+        // A quadtree divides space only on the x and y dimensions.
+        // It divides each tile into 4 smaller tiles where the x and y dimensions are halved.
+        // The quadtree z minimum and maximum remain unchanged.
+        switch (subdivisionScheme) {
+            case 'OCTREE':
+                const s2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+                const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+                const sizeZ = delta / 2.0; // It's a next level (a child)
+                const midZ = s2VolumeInfo.minimumHeight + delta / 2.0;
+                s2VolumeInfo.minimumHeight = midZ - sizeZ;
+                s2VolumeInfo.maximumHeight = midZ + sizeZ;
+                break;
+            default:
+                break;
+        }
+        const box = (0, s2_corners_to_obb_1.convertS2BoundingVolumetoOBB)(s2ChildVolumeInfo);
+        const childS2VolumeBox = {
+            box,
+            s2VolumeInfo: s2ChildVolumeInfo
+        };
+        return childS2VolumeBox;
+    }
+    return undefined;
+}
+/**
+ * Recursively parse implicit tiles tree
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * TODO Check out do we able to use Tile3D class as return type here.
+ * @param subtree
+ * @param lodMetricValue
+ * @param options
+ * @param parentData
+ * @param childIndex
+ * @param level
+ * @param globalData
+ */
+// eslint-disable-next-line max-statements
+async function parseImplicitTiles(params) {
+    const { options, parentData = {
+        mortonIndex: 0,
+        x: 0,
+        y: 0,
+        z: 0
+    }, childIndex = 0, globalData = {
+        level: 0,
+        mortonIndex: 0,
+        x: 0,
+        y: 0,
+        z: 0
+    }, s2VolumeBox } = params;
+    let { subtree, level = 0 } = params;
+    const { subdivisionScheme, subtreeLevels, maximumLevel, contentUrlTemplate, subtreesUriTemplate, basePath } = options;
+    const tile = { children: [], lodMetricValue: 0, contentUrl: '' };
+    const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+    const childX = childIndex & 0b01;
+    const childY = (childIndex >> 1) & 0b01;
+    const childZ = (childIndex >> 2) & 0b01;
+    const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
+    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+    let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+    // Local tile coordinates
+    let childTileX = concatBits(parentData.x, childX);
+    let childTileY = concatBits(parentData.y, childY);
+    let childTileZ = concatBits(parentData.z, childZ);
+    let isChildSubtreeAvailable = false;
+    if (level + 1 > subtreeLevels) {
+        isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
+    }
+    const x = concatBits(globalData.x, childTileX);
+    const y = concatBits(globalData.y, childTileY);
+    const z = concatBits(globalData.z, childTileZ);
+    const lev = level + globalData.level;
+    if (isChildSubtreeAvailable) {
+        const subtreePath = `${basePath}/${subtreesUriTemplate}`;
+        const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+        const childSubtree = await (0, core_1.load)(childSubtreeUrl, tile_3d_subtree_loader_1.Tile3DSubtreeLoader);
+        subtree = childSubtree;
+        globalData.mortonIndex = childTileMortonIndex;
+        globalData.x = childTileX;
+        globalData.y = childTileY;
+        globalData.z = childTileZ;
+        globalData.level = level;
+        childTileMortonIndex = 0;
+        tileAvailabilityIndex = 0;
+        childTileX = 0;
+        childTileY = 0;
+        childTileZ = 0;
+        level = 0;
+    }
+    const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+    if (!isTileAvailable || level > maximumLevel) {
+        return tile;
+    }
+    const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+    if (isContentAvailable) {
+        tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+    }
+    const childTileLevel = level + 1;
+    const pData = { mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ };
+    for (let index = 0; index < childrenPerTile; index++) {
+        const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
+        // Recursive calling...
+        const childTileParsed = await parseImplicitTiles({
+            subtree,
+            options,
+            parentData: pData,
+            childIndex: index,
+            level: childTileLevel,
+            globalData,
+            s2VolumeBox: childS2VolumeBox
+        });
+        if (childTileParsed.contentUrl || childTileParsed.children.length) {
+            const globalLevel = lev + 1;
+            const childCoordinates = { childTileX, childTileY, childTileZ };
+            const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, options, s2VolumeBox);
+            // @ts-ignore
+            tile.children.push(formattedTile);
+        }
+    }
+    return tile;
+}
+exports.parseImplicitTiles = parseImplicitTiles;
+function getAvailabilityResult(availabilityData, index) {
+    if ('constant' in availabilityData) {
+        return Boolean(availabilityData.constant);
+    }
+    if (availabilityData.explicitBitstream) {
+        return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
+    }
+    return false;
+}
+/**
+ * Do formatting of implicit tile data.
+ * TODO Check out do we able to use Tile3D class as type here.
+ * @param tile
+ * @param lodMetricValue
+ * @param options
+ * @returns
+ */
+function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
+    const { basePath, refine, getRefine, lodMetricType, getTileType, rootLodMetricValue, rootBoundingVolume } = options;
+    const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
+    const lodMetricValue = rootLodMetricValue / 2 ** level;
+    const boundingVolume = s2VolumeBox?.box
+        ? { box: s2VolumeBox.box }
+        : rootBoundingVolume;
+    const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
+    return {
+        children: tile.children,
+        contentUrl: tile.contentUrl,
+        content: { uri },
+        id: tile.contentUrl,
+        refine: getRefine(refine),
+        type: getTileType(tile),
+        lodMetricType,
+        lodMetricValue,
+        geometricError: lodMetricValue,
+        transform: tile.transform,
+        boundingVolume: boundingVolumeForChildTile
+    };
+}
+/**
+ * Calculate child bounding volume.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subdivision-rules
+ * @param level
+ * @param rootBoundingVolume
+ * @param childCoordinates
+ */
+function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
+    if (rootBoundingVolume.region) {
+        const { childTileX, childTileY, childTileZ } = childCoordinates;
+        const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
+        const boundingVolumesCount = 2 ** level;
+        const sizeX = (east - west) / boundingVolumesCount;
+        const sizeY = (north - south) / boundingVolumesCount;
+        // TODO : Why is the subdivisionScheme not being checked here?
+        // In case of QUADTREE the sizeZ should NOT be changed!
+        // https://portal.ogc.org/files/102132
+        // A quadtree divides space only on the x and y dimensions. It divides each tile into 4 smaller tiles where the x and y dimensions are halved. The quadtree z minimum and maximum remain unchanged.
+        const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
+        const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
+        const [childSouth, childNorth] = [south + sizeY * childTileY, south + sizeY * (childTileY + 1)];
+        const [childMinimumHeight, childMaximumHeight] = [
+            minimumHeight + sizeZ * childTileZ,
+            minimumHeight + sizeZ * (childTileZ + 1)
+        ];
+        return {
+            region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
+        };
+    }
+    if (rootBoundingVolume.box) {
+        return rootBoundingVolume;
+    }
+    throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
+}
+/**
+ * Do binary concatenation
+ * @param first
+ * @param second
+ */
+function concatBits(first, second) {
+    return parseInt(first.toString(2) + second.toString(2), 2);
+}
+/**
+ * Replace implicit tile content url with real coordinates.
+ * @param templateUrl
+ * @param level
+ * @param x
+ * @param y
+ * @param z
+ */
+function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
+    const mapUrl = generateMapUrl({ level, x, y, z });
+    return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, (matched) => mapUrl[matched]);
+}
+exports.replaceContentUrlTemplate = replaceContentUrlTemplate;
+/**
+ * Get Map object for content url generation
+ * @param items
+ */
+function generateMapUrl(items) {
+    const mapUrl = {};
+    for (const key in items) {
+        mapUrl[`{${key}}`] = items[key];
+    }
+    return mapUrl;
+}
+/**
+ * Get boolean value from bistream by index
+ * A boolean value is encoded as a single bit, either 0 (false) or 1 (true).
+ * Multiple boolean values are packed tightly in the same buffer.
+ * These buffers of tightly-packed bits are sometimes referred to as bitstreams.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/implicit-revisions/specification/Metadata#booleans
+ * @param availabilitiIndex
+ */
+function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
+    const byteIndex = Math.floor(availabilityIndex / 8);
+    const bitIndex = availabilityIndex % 8;
+    const bitValue = (availabilityBuffer[byteIndex] >> bitIndex) & 1;
+    return bitValue === 1;
+}

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

@@ -0,0 +1,10 @@
+import { LoaderContext } from '@loaders.gl/loader-utils';
+import { Tiles3DTileContent } from '../../../types';
+import { Tiles3DLoaderOptions } from '../../../tiles-3d-loader';
+export declare const GLTF_FORMAT: {
+    URI: number;
+    EMBEDDED: number;
+};
+export declare function parse3DTileGLTFViewSync(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions | undefined): number;
+export declare function extractGLTF(tile: Tiles3DTileContent, gltfFormat: number, options?: Tiles3DLoaderOptions, context?: LoaderContext): 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":"AAUA,OAAO,EAAC,aAAa,EAAmB,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAE9D,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAAG,SAAS,UAqC1C;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAyBf"}

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

@@ -1,69 +1,96 @@
-import { GLTFLoader } from '@loaders.gl/gltf';
-import { sliceArrayBuffer } from '@loaders.gl/loader-utils';
-export const GLTF_FORMAT = {
-  URI: 0,
-  EMBEDDED: 1
+"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
 };
-export function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
-  tile.rotateYtoZ = true;
-  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
-
-  if (gltfByteLength === 0) {
-    throw new Error('glTF byte length must be greater than 0.');
-  }
-
-  tile.gltfUpAxis = options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis ? options['3d-tiles'].assetGltfUpAxis : 'Y';
-  tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);
-  tile.gltfByteOffset = 0;
-  tile.gltfByteLength = gltfByteLength;
-
-  if (byteOffset % 4 === 0) {} else {
-    console.warn("".concat(tile.type, ": embedded glb is not aligned to a 4-byte boundary."));
-  }
-
-  return tile.byteOffset + tile.byteLength;
-}
-export 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;
+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 || 0) + (tile.byteLength || 0) - 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;
     }
-
-    if (tile.gltfArrayBuffer) {
-      tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
-      delete tile.gltfArrayBuffer;
-      delete tile.gltfByteOffset;
-      delete tile.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 || 0) + (tile.byteLength || 0);
 }
-
+exports.parse3DTileGLTFViewSync = parse3DTileGLTFViewSync;
+async function extractGLTF(tile, gltfFormat, options, context) {
+    const tile3DOptions = options?.['3d-tiles'] || {};
+    extractGLTFBufferOrURL(tile, gltfFormat, options);
+    if (tile3DOptions.loadGLTF) {
+        if (!context) {
+            return;
+        }
+        const { parse, fetch } = context;
+        if (tile.gltfUrl) {
+            const response = await fetch(tile.gltfUrl, options);
+            tile.gltfArrayBuffer = await response.arrayBuffer();
+            tile.gltfByteOffset = 0;
+        }
+        if (tile.gltfArrayBuffer) {
+            // TODO - Should handle byteOffset... However, not used now...
+            const gltfWithBuffers = await parse(tile.gltfArrayBuffer, gltf_1.GLTFLoader, options, context);
+            tile.gltf = (0, gltf_1.postProcessGLTF)(gltfWithBuffers);
+            tile.gpuMemoryUsageInBytes = (0, gltf_1._getMemoryUsageGLTF)(tile.gltf);
+            delete tile.gltfArrayBuffer;
+            delete tile.gltfByteOffset;
+            delete tile.gltfByteLength;
+        }
+    }
+}
+exports.extractGLTF = extractGLTF;
 function extractGLTFBufferOrURL(tile, gltfFormat, options) {
-  switch (gltfFormat) {
-    case GLTF_FORMAT.URI:
-      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 GLTF_FORMAT.EMBEDDED:
-      break;
-
-    default:
-      throw new Error("b3dm: Illegal glTF format field");
-  }
+    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.
+            if (tile.gltfArrayBuffer) {
+                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');
+    }
 }
-//# sourceMappingURL=parse-3d-tile-gltf-view.js.map

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

@@ -0,0 +1,3 @@
+import { Tiles3DTileContent } from '../../../types';
+export declare function parse3DTileHeaderSync(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, 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":"AAGA,OAAO,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAWlD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,UAmBvB"}

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

@@ -1,17 +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;
-export 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;
-
-  if (tile.version !== 1) {
-    throw new Error("3D Tile Version ".concat(tile.version, " not supported"));
-  }
-
-  return byteOffset;
+/* 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
 }
-//# sourceMappingURL=parse-3d-tile-header.js.map
+exports.parse3DTileHeaderSync = parse3DTileHeaderSync;

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

@@ -0,0 +1,10 @@
+import type { Subtree } from '../../../types';
+import type { LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * 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, options: LoaderOptions | undefined, context: LoaderContext | undefined): Promise<Subtree>;
+//# 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,OAAO,EAAoB,MAAM,gBAAgB,CAAC;AAC/D,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E;;;;;GAKG;AAEH,wBAA8B,mBAAmB,CAC/C,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,OAAO,EAAE,aAAa,GAAG,SAAS,GACjC,OAAO,CAAC,OAAO,CAAC,CAuDlB"}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ */
+// eslint-disable-next-line max-statements
+async function parse3DTilesSubtree(data, options, context) {
+    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, context);
+    }
+    if ('bufferView' in subtree.contentAvailability) {
+        subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'contentAvailability', internalBinaryBuffer, context);
+    }
+    if ('bufferView' in subtree.childSubtreeAvailability) {
+        subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'childSubtreeAvailability', internalBinaryBuffer, context);
+    }
+    return subtree;
+}
+exports.default = parse3DTilesSubtree;
+/**
+ * Get url for bitstream downloading
+ * @param bitstreamRelativeUri
+ * @param basePath
+ * @returns
+ */
+function resolveBufferUri(bitstreamRelativeUri, basePath) {
+    const hasProtocol = basePath.startsWith('http');
+    if (hasProtocol) {
+        const resolvedUri = new URL(bitstreamRelativeUri, basePath);
+        return decodeURI(resolvedUri.toString());
+    }
+    /**
+     * Adding http protocol only for new URL constructor usage.
+     * It allows to resolve relative paths like ../../example with basePath.
+     */
+    const basePathWithProtocol = `http://${basePath}`;
+    const resolvedUri = new URL(bitstreamRelativeUri, basePathWithProtocol);
+    /**
+     * Drop protocol and use just relative path.
+     */
+    return `/${resolvedUri.host}${resolvedUri.pathname}`;
+}
+/**
+ * Get explicit bitstream for subtree availability data.
+ * @param subtree
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(subtree, name, internalBinaryBuffer, context) {
+    const bufferViewIndex = subtree[name].bufferView;
+    const bufferView = subtree.bufferViews[bufferViewIndex];
+    const buffer = subtree.buffers[bufferView.buffer];
+    if (!context?.url || !context.fetch) {
+        throw new Error('Url is not provided');
+    }
+    if (!context.fetch) {
+        throw new Error('fetch is not provided');
+    }
+    // External bitstream loading
+    if (buffer.uri) {
+        const bufferUri = resolveBufferUri(buffer.uri, context?.url);
+        const response = await context.fetch(bufferUri);
+        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

@@ -0,0 +1,5 @@
+import { Tiles3DLoaderOptions } from '../../../tiles-3d-loader';
+import { Tiles3DTileContent } from '../../../types';
+export declare function parse3DTileTablesHeaderSync(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number): number;
+export declare function parse3DTileTablesSync(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options?: Tiles3DLoaderOptions): number;
+//# 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":"AAIA,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAMlD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,UAkDnB;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,UAK/B"}