@loaders.gl/3d-tiles 4.0.0-alpha.6 → 4.0.0-alpha.8

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

@@ -56,17 +56,17 @@ function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {
 }
 exports.parse3DTileTablesSync = parse3DTileTablesSync;
 function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
-    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header;
+    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header || {};
     tile.featureTableJson = {
         BATCH_LENGTH: batchLength || 0
     };
-    if (featureTableJsonByteLength > 0) {
+    if (featureTableJsonByteLength && featureTableJsonByteLength > 0) {
         const featureTableString = (0, parse_utils_1.getStringFromArrayBuffer)(arrayBuffer, byteOffset, featureTableJsonByteLength);
         tile.featureTableJson = JSON.parse(featureTableString);
     }
-    byteOffset += featureTableJsonByteLength;
+    byteOffset += featureTableJsonByteLength || 0;
     tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
-    byteOffset += featureTableBinaryByteLength;
+    byteOffset += featureTableBinaryByteLength || 0;
     /*
     const featureTable = parseFeatureTable(featureTableJson, featureTableBinary);
   
@@ -76,12 +76,12 @@ function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
     return byteOffset;
 }
 function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
-    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header;
-    if (batchTableJsonByteLength > 0) {
+    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header || {};
+    if (batchTableJsonByteLength && batchTableJsonByteLength > 0) {
         const batchTableString = (0, parse_utils_1.getStringFromArrayBuffer)(arrayBuffer, byteOffset, batchTableJsonByteLength);
         tile.batchTableJson = JSON.parse(batchTableString);
         byteOffset += batchTableJsonByteLength;
-        if (batchTableBinaryByteLength > 0) {
+        if (batchTableBinaryByteLength && 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

package/dist/lib/parsers/parse-3d-tile-batched-model.d.ts

@@ -1,2 +1,5 @@
-export declare function parseBatchedModel3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any): Promise<any>;
+import { Tiles3DTileContent } from '../../types';
+import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { LoaderContext } from '@loaders.gl/loader-utils';
+export declare function parseBatchedModel3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<number>;
 //# sourceMappingURL=parse-3d-tile-batched-model.d.ts.map

package/dist/lib/parsers/parse-3d-tile-batched-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-batched-model.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-batched-model.ts"],"names":[],"mappings":"AAWA,wBAAsB,uBAAuB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,gBAU5F"}
+{"version":3,"file":"parse-3d-tile-batched-model.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-batched-model.ts"],"names":[],"mappings":"AAUA,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,mBAWxB"}

package/dist/lib/parsers/parse-3d-tile-batched-model.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBatchedModel3DTile = void 0;
 const math_1 = require("@loaders.gl/math"); // math.gl/geometry;
 const tile_3d_feature_table_1 = __importDefault(require("../classes/tile-3d-feature-table"));
-// import Tile3DBatchTable from '../classes/tile-3d-batch-table.js';
+// import Tile3DBatchTable from '../classes/tile-3d-batch-table';
 const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
 const parse_3d_tile_tables_1 = require("./helpers/parse-3d-tile-tables");
 const parse_3d_tile_gltf_view_1 = require("./helpers/parse-3d-tile-gltf-view");

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

@@ -1,2 +1,8 @@
-export declare function parseComposite3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any, parse3DTile: any): Promise<any>;
+import type { LoaderContext } from '@loaders.gl/loader-utils';
+import type { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { Tiles3DTileContent } from '../../types';
+/** Resolve circulate dependency by passing in parsing function as argument */
+type Parse3DTile = (arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions | undefined, context: LoaderContext | undefined, subtile: any) => Promise<number>;
+export declare function parseComposite3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions | undefined, context: LoaderContext | undefined, parse3DTile: Parse3DTile): Promise<number>;
+export {};
 //# sourceMappingURL=parse-3d-tile-composite.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-composite.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-composite.ts"],"names":[],"mappings":"AASA,wBAAsB,oBAAoB,CACxC,IAAI,KAAA,EACJ,WAAW,KAAA,EACX,UAAU,KAAA,EACV,OAAO,KAAA,EACP,OAAO,KAAA,EACP,WAAW,KAAA,gBAoBZ"}
+{"version":3,"file":"parse-3d-tile-composite.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-composite.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,8EAA8E;AAC9E,KAAK,WAAW,GAAG,CACjB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,OAAO,KAAA,KACJ,OAAO,CAAC,MAAM,CAAC,CAAC;AAGrB,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,CAmBjB"}

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

@@ -3,8 +3,6 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseComposite3DTile = void 0;
-// Reference code:
-// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Source/Scene/Composite3DTileContent.js#L182
 const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
 // eslint-disable-next-line max-params
 async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, context, parse3DTile) {
@@ -15,7 +13,7 @@ async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, cont
     byteOffset += 4;
     // extract each tile from the byte stream
     tile.tiles = [];
-    while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {
+    while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
         const subtile = {};
         tile.tiles.push(subtile);
         byteOffset = await parse3DTile(arrayBuffer, byteOffset, options, context, subtile);

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

@@ -1,2 +1,5 @@
-export declare function parseGltf3DTile(tile: any, arrayBuffer: any, options: any, context: any): Promise<void>;
+import type { LoaderContext } from '@loaders.gl/loader-utils';
+import type { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { Tiles3DTileContent } from '../../types';
+export declare function parseGltf3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<void>;
 //# sourceMappingURL=parse-3d-tile-gltf.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-gltf.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAaxE"}
+{"version":3,"file":"parse-3d-tile-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-gltf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,eAAe,CACnC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAsBf"}

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

@@ -9,10 +9,20 @@ async function parseGltf3DTile(tile, arrayBuffer, options, context) {
     tile.rotateYtoZ = true;
     // Save gltf up axis
     tile.gltfUpAxis =
-        options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
+        options?.['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
             ? options['3d-tiles'].assetGltfUpAxis
             : 'Y';
-    const { parse } = context;
-    tile.gltf = await parse(arrayBuffer, gltf_1.GLTFLoader, options, context);
+    if (options?.['3d-tiles']?.loadGLTF) {
+        if (!context) {
+            return;
+        }
+        const { parse } = context;
+        const gltfWithBuffers = await parse(arrayBuffer, gltf_1.GLTFLoader, options, context);
+        tile.gltf = (0, gltf_1.postProcessGLTF)(gltfWithBuffers);
+        tile.gpuMemoryUsageInBytes = (0, gltf_1._getMemoryUsageGLTF)(tile.gltf);
+    }
+    else {
+        tile.gltfArrayBuffer = arrayBuffer;
+    }
 }
 exports.parseGltf3DTile = parseGltf3DTile;

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

@@ -1,14 +1,14 @@
+import type { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
-import { Tileset3D, Tile3D } from '@loaders.gl/tiles';
-import { ImplicitTilingExtension, Subtree } from '../../types';
-export declare function normalizeTileData(tile: any, options: any): any;
-export declare function normalizeTileHeaders(tileset: Tileset3D, options: LoaderOptions): Promise<Tileset3D>;
+import { ImplicitTilingExensionData, Subtree, Tiles3DTileJSON, Tiles3DTileJSONPostprocessed, Tiles3DTilesetJSON } from '../../types';
+export declare function normalizeTileData(tile: Tiles3DTileJSON | null, basePath: string): Tiles3DTileJSONPostprocessed | null;
+export declare function normalizeTileHeaders(tileset: Tiles3DTilesetJSON, basePath: string, options: LoaderOptions): Promise<Tiles3DTileJSONPostprocessed | null>;
 /**
  * Do normalisation of implicit tile headers
  * TODO Check if Tile3D class can be a return type here.
  * @param tileset
  */
-export declare function normalizeImplicitTileHeaders(tile: Tile3D, tileset: Tileset3D, implicitTilingExtension: ImplicitTilingExtension, options: LoaderOptions): Promise<any>;
+export declare function normalizeImplicitTileHeaders(tile: Tiles3DTileJSON, tileset: Tiles3DTilesetJSON, basePath: string, implicitTilingExtension: ImplicitTilingExensionData, options: Tiles3DLoaderOptions): Promise<Tiles3DTileJSONPostprocessed | null>;
 /**
  * Do implicit data normalisation to create hierarchical tile structure
  * @param tile
@@ -16,5 +16,5 @@ export declare function normalizeImplicitTileHeaders(tile: Tile3D, tileset: Tile
  * @param options
  * @returns
  */
-export declare function normalizeImplicitTileData(tile: any, rootSubtree: Subtree, options: any): Promise<any>;
+export declare function normalizeImplicitTileData(tile: Tiles3DTileJSON, basePath: string, rootSubtree: Subtree, options: any): Promise<Tiles3DTileJSONPostprocessed | null>;
 //# sourceMappingURL=parse-3d-tile-header.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAC,SAAS,EAA+C,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAC,uBAAuB,EAAE,OAAO,EAAC,MAAM,aAAa,CAAC;AAqD7D,wBAAgB,iBAAiB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,OAgB9C;AAGD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,SAAS,CAAC,CAwCpB;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,EAClB,uBAAuB,EAAE,uBAAuB,EAChD,OAAO,EAAE,aAAa,gBA2CvB;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,KAAA,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,gBA0BvF"}
+{"version":3,"file":"parse-3d-tile-header.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAI5D,OAAO,EACL,0BAA0B,EAC1B,OAAO,EAEP,eAAe,EACf,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAqDrB,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACf,4BAA4B,GAAG,IAAI,CAqBrC;AAGD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA+C9C;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,0BAA0B,EACnD,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAyC9C;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,OAAO,EACpB,OAAO,EAAE,GAAG,GACX,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA8B9C"}

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

@@ -6,11 +6,11 @@ const core_1 = require("@loaders.gl/core");
 const tiles_1 = require("@loaders.gl/tiles");
 const parse_3d_implicit_tiles_1 = require("./helpers/parse-3d-implicit-tiles");
 const s2_corners_to_obb_1 = require("../utils/obb/s2-corners-to-obb");
-function getTileType(tile) {
-    if (!tile.contentUrl) {
+function getTileType(tile, tileContentUrl = '') {
+    if (!tileContentUrl) {
         return tiles_1.TILE_TYPE.EMPTY;
     }
-    const contentUrl = tile.contentUrl;
+    const contentUrl = tileContentUrl.split('?')[0]; // Discard query string
     const fileExtension = contentUrl.split('.').pop();
     switch (fileExtension) {
         case 'pnts':
@@ -21,7 +21,7 @@ function getTileType(tile) {
         case 'gltf':
             return tiles_1.TILE_TYPE.SCENEGRAPH;
         default:
-            return fileExtension;
+            return fileExtension || tiles_1.TILE_TYPE.EMPTY;
     }
 }
 function getRefine(refine) {
@@ -36,7 +36,7 @@ function getRefine(refine) {
             return refine;
     }
 }
-function resolveUri(uri, basePath) {
+function resolveUri(uri = '', basePath) {
     // url scheme per RFC3986
     const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
     if (urlSchemeRegex.test(basePath)) {
@@ -48,49 +48,59 @@ function resolveUri(uri, basePath) {
     }
     return `${basePath}/${uri}`;
 }
-function normalizeTileData(tile, options) {
+function normalizeTileData(tile, basePath) {
     if (!tile) {
         return null;
     }
+    let tileContentUrl;
     if (tile.content) {
-        const contentUri = tile.content.uri || tile.content.url;
-        tile.contentUrl = resolveUri(contentUri, options.basePath);
+        const contentUri = tile.content.uri || tile.content?.url;
+        tileContentUrl = resolveUri(contentUri, basePath);
     }
-    tile.id = tile.contentUrl;
-    tile.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
-    tile.type = getTileType(tile);
-    tile.refine = getRefine(tile.refine);
-    return tile;
+    const tilePostprocessed = {
+        ...tile,
+        id: tileContentUrl,
+        contentUrl: tileContentUrl,
+        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+        lodMetricValue: tile.geometricError,
+        transformMatrix: tile.transform,
+        type: getTileType(tile, tileContentUrl),
+        refine: getRefine(tile.refine)
+    };
+    return tilePostprocessed;
 }
 exports.normalizeTileData = normalizeTileData;
 // normalize tile headers
-async function normalizeTileHeaders(tileset, options) {
-    const basePath = tileset.basePath;
-    let root;
-    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+async function normalizeTileHeaders(tileset, basePath, options) {
+    let root = null;
+    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
     if (rootImplicitTilingExtension && tileset.root) {
-        root = await normalizeImplicitTileHeaders(tileset.root, tileset, rootImplicitTilingExtension, options);
+        root = await normalizeImplicitTileHeaders(tileset.root, tileset, basePath, rootImplicitTilingExtension, options);
     }
     else {
-        root = normalizeTileData(tileset.root, tileset);
+        root = normalizeTileData(tileset.root, basePath);
     }
     const stack = [];
     stack.push(root);
     while (stack.length > 0) {
         const tile = stack.pop() || {};
         const children = tile.children || [];
-        for (let childHeader of children) {
+        const childrenPostprocessed = [];
+        for (const childHeader of children) {
             const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+            let childHeaderPostprocessed;
             if (childImplicitTilingExtension) {
-                childHeader = await normalizeImplicitTileHeaders(childHeader, tileset, childImplicitTilingExtension, options);
+                childHeaderPostprocessed = await normalizeImplicitTileHeaders(childHeader, tileset, basePath, childImplicitTilingExtension, options);
             }
             else {
-                normalizeTileData(childHeader, { basePath });
+                childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
+            }
+            if (childHeaderPostprocessed) {
+                childrenPostprocessed.push(childHeaderPostprocessed);
+                stack.push(childHeaderPostprocessed);
             }
-            stack.push(childHeader);
         }
+        tile.children = childrenPostprocessed;
     }
     return root;
 }
@@ -100,13 +110,12 @@ exports.normalizeTileHeaders = normalizeTileHeaders;
  * TODO Check if Tile3D class can be a return type here.
  * @param tileset
  */
-async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtension, options) {
-    const basePath = tileset.basePath;
+async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTilingExtension, options) {
     const { subdivisionScheme, maximumLevel, subtreeLevels, subtrees: { uri: subtreesUriTemplate } } = implicitTilingExtension;
     const replacedUrlTemplate = (0, parse_3d_implicit_tiles_1.replaceContentUrlTemplate)(subtreesUriTemplate, 0, 0, 0, 0);
     const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
     const subtree = await (0, core_1.load)(subtreeUrl, tile_3d_subtree_loader_1.Tile3DSubtreeLoader, options);
-    const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+    const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
     const refine = tileset?.root?.refine;
     // @ts-ignore
     const rootLodMetricValue = tile.geometricError;
@@ -132,7 +141,7 @@ async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtensi
         getTileType,
         getRefine
     };
-    return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
 }
 exports.normalizeImplicitTileHeaders = normalizeImplicitTileHeaders;
 /**
@@ -142,27 +151,33 @@ exports.normalizeImplicitTileHeaders = normalizeImplicitTileHeaders;
  * @param options
  * @returns
  */
-async function normalizeImplicitTileData(tile, rootSubtree, options) {
+async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
     if (!tile) {
         return null;
     }
-    tile.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
     const { children, contentUrl } = await (0, parse_3d_implicit_tiles_1.parseImplicitTiles)({
         subtree: rootSubtree,
-        options,
-        s2VolumeBox: tile
+        options
     });
+    let tileContentUrl;
+    let tileContent = null;
     if (contentUrl) {
-        tile.contentUrl = contentUrl;
-        tile.content = { uri: contentUrl.replace(`${options.basePath}/`, '') };
+        tileContentUrl = contentUrl;
+        tileContent = { uri: contentUrl.replace(`${basePath}/`, '') };
     }
-    tile.refine = getRefine(tile.refine);
-    tile.type = getTileType(tile);
-    tile.children = children;
-    tile.id = tile.contentUrl;
-    return tile;
+    const tilePostprocessed = {
+        ...tile,
+        id: tileContentUrl,
+        contentUrl: tileContentUrl,
+        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+        lodMetricValue: tile.geometricError,
+        transformMatrix: tile.transform,
+        type: getTileType(tile, tileContentUrl),
+        refine: getRefine(tile.refine),
+        content: tileContent || tile.content,
+        children
+    };
+    return tilePostprocessed;
 }
 exports.normalizeImplicitTileData = normalizeImplicitTileData;
 /**

package/dist/lib/parsers/parse-3d-tile-instanced-model.d.ts

@@ -1,2 +1,5 @@
-export declare function parseInstancedModel3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any): Promise<any>;
+import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { LoaderContext } from '@loaders.gl/loader-utils';
+import { Tiles3DTileContent } from '../../types';
+export declare function parseInstancedModel3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<number>;
 //# sourceMappingURL=parse-3d-tile-instanced-model.d.ts.map

package/dist/lib/parsers/parse-3d-tile-instanced-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-instanced-model.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-instanced-model.ts"],"names":[],"mappings":"AAaA,wBAAsB,yBAAyB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,gBAI9F"}
+{"version":3,"file":"parse-3d-tile-instanced-model.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-instanced-model.ts"],"names":[],"mappings":"AAYA,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAIjB"}

package/dist/lib/parsers/parse-3d-tile-instanced-model.js

@@ -16,7 +16,7 @@ const parse_3d_tile_tables_1 = require("./helpers/parse-3d-tile-tables");
 const parse_3d_tile_gltf_view_1 = require("./helpers/parse-3d-tile-gltf-view");
 async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
     byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-    await (0, parse_3d_tile_gltf_view_1.extractGLTF)(tile, tile.gltfFormat, options, context);
+    await (0, parse_3d_tile_gltf_view_1.extractGLTF)(tile, tile.gltfFormat || 0, options, context);
     return byteOffset;
 }
 exports.parseInstancedModel3DTile = parseInstancedModel3DTile;
@@ -33,7 +33,7 @@ function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
     byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
     byteOffset = (0, parse_3d_tile_gltf_view_1.parse3DTileGLTFViewSync)(tile, arrayBuffer, byteOffset, options);
     // TODO - Is the feature table sometimes optional or can check be moved into table header parser?
-    if (tile.featureTableJsonByteLength === 0) {
+    if (!tile?.header?.featureTableJsonByteLength || tile.header.featureTableJsonByteLength === 0) {
         throw new Error('i3dm parser: featureTableJsonByteLength is zero.');
     }
     const featureTable = new tile_3d_feature_table_1.default(tile.featureTableJson, tile.featureTableBinary);
@@ -50,21 +50,7 @@ function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
 }
 // eslint-disable-next-line max-statements, complexity
 function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-    // Create model instance collection
-    const collectionOptions = {
-        instances: new Array(instancesLength),
-        batchTable: tile._batchTable,
-        cull: false,
-        url: undefined,
-        // requestType: RequestType.TILES3D,
-        gltf: undefined,
-        basePath: undefined,
-        incrementallyLoadTextures: false,
-        // TODO - tileset is not available at this stage, tile is parsed independently
-        // upAxis: (tileset && tileset._gltfUpAxis) || [0, 1, 0],
-        forwardAxis: [1, 0, 0]
-    };
-    const instances = collectionOptions.instances;
+    const instances = new Array(instancesLength);
     const instancePosition = new core_1.Vector3();
     const instanceNormalRight = new core_1.Vector3();
     const instanceNormalUp = new core_1.Vector3();
@@ -76,8 +62,8 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     const instanceTransform = new core_1.Matrix4();
     const scratch1 = [];
     const scratch2 = [];
-    const scratchVector1 = new core_1.Vector3();
-    const scratchVector2 = new core_1.Vector3();
+    const scratch3 = [];
+    const scratch4 = [];
     for (let i = 0; i < instancesLength; i++) {
         let position;
         // Get the instance position
@@ -86,11 +72,11 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         }
         else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
             position = featureTable.getProperty('POSITION_QUANTIZED', math_1.GL.UNSIGNED_SHORT, 3, i, instancePosition);
-            const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', math_1.GL.FLOAT, 3, scratchVector1);
+            const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', math_1.GL.FLOAT, 3);
             if (!quantizedVolumeOffset) {
                 throw new Error('i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
             }
-            const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', math_1.GL.FLOAT, 3, scratchVector2);
+            const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', math_1.GL.FLOAT, 3);
             if (!quantizedVolumeScale) {
                 throw new Error('i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
             }
@@ -119,8 +105,8 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
             tile.hasCustomOrientation = true;
         }
         else {
-            tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, scratch1);
-            tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, scratch2);
+            tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, i, scratch1);
+            tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, i, scratch2);
             if (tile.octNormalUp) {
                 if (!tile.octNormalRight) {
                     throw new Error('i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P');
@@ -151,7 +137,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         instanceTranslationRotationScale.rotation = instanceQuaternion;
         // Get the instance scale
         instanceScale.set(1.0, 1.0, 1.0);
-        const scale = featureTable.getProperty('SCALE', math_1.GL.FLOAT, 1, i);
+        const scale = featureTable.getProperty('SCALE', math_1.GL.FLOAT, 1, i, scratch3);
         if (Number.isFinite(scale)) {
             instanceScale.multiplyByScalar(scale);
         }
@@ -162,7 +148,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         // @ts-expect-error
         instanceTranslationRotationScale.scale = instanceScale;
         // Get the batchId
-        let batchId = featureTable.getProperty('BATCH_ID', math_1.GL.UNSIGNED_SHORT, 1, i);
+        let batchId = featureTable.getProperty('BATCH_ID', math_1.GL.UNSIGNED_SHORT, 1, i, scratch4);
         if (batchId === undefined) {
             // If BATCH_ID semantic is undefined, batchId is just the instance number
             batchId = i;

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts

@@ -1,3 +1,6 @@
-export declare function parsePointCloud3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any): Promise<any>;
-export declare function loadDraco(tile: any, dracoData: any, options: any, context: any): Promise<void>;
+import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { LoaderContext } from '@loaders.gl/loader-utils';
+import { Tiles3DTileContent } from '../../types';
+export declare function parsePointCloud3DTile(tile: Tiles3DTileContent, arrayBuffer: ArrayBuffer, byteOffset: number, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<number>;
+export declare function loadDraco(tile: Tiles3DTileContent, dracoData: any, options?: Tiles3DLoaderOptions, context?: LoaderContext): Promise<void>;
 //# sourceMappingURL=parse-3d-tile-point-cloud.d.ts.map

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAeA,wBAAsB,qBAAqB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,gBAe1F;AA8KD,wBAAsB,SAAS,CAAC,IAAI,KAAA,EAAE,SAAS,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAqDhE"}
+{"version":3,"file":"parse-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAcA,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAE/C,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AAuND,wBAAsB,SAAS,CAC7B,IAAI,EAAE,kBAAkB,EACxB,SAAS,KAAA,EACT,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAwDf"}

package/dist/lib/parsers/parse-3d-tile-point-cloud.js

@@ -24,6 +24,7 @@ async function parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, con
     const { featureTable, batchTable } = parsePointCloudTables(tile);
     await parseDraco(tile, featureTable, batchTable, options, context);
     parsePositions(tile, featureTable, options);
+    // @ts-expect-error TODO - do we need to assert on the batch table?
     parseColors(tile, featureTable, batchTable);
     parseNormals(tile, featureTable);
     return byteOffset;
@@ -57,6 +58,12 @@ function parsePointCloudTables(tile) {
     return { featureTable, batchTable };
 }
 function parsePositions(tile, featureTable, options) {
+    tile.attributes = tile.attributes || {
+        positions: null,
+        colors: null,
+        normals: null,
+        batchIds: null
+    };
     if (!tile.attributes.positions) {
         if (featureTable.hasProperty('POSITION')) {
             tile.attributes.positions = featureTable.getPropertyArray('POSITION', math_1.GL.FLOAT, 3);
@@ -81,6 +88,12 @@ function parsePositions(tile, featureTable, options) {
     }
 }
 function parseColors(tile, featureTable, batchTable) {
+    tile.attributes = tile.attributes || {
+        positions: null,
+        colors: null,
+        normals: null,
+        batchIds: null
+    };
     if (!tile.attributes.colors) {
         let colors = null;
         if (featureTable.hasProperty('RGBA')) {
@@ -101,6 +114,12 @@ function parseColors(tile, featureTable, batchTable) {
     }
 }
 function parseNormals(tile, featureTable) {
+    tile.attributes = tile.attributes || {
+        positions: null,
+        colors: null,
+        normals: null,
+        batchIds: null
+    };
     if (!tile.attributes.normals) {
         let normals = null;
         if (featureTable.hasProperty('NORMAL')) {
@@ -147,7 +166,7 @@ async function parseDraco(tile, featureTable, batchTable, options, context) {
         if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {
             throw new Error('Draco properties, byteOffset, and byteLength must be defined');
         }
-        dracoBuffer = tile.featureTableBinary.slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
+        dracoBuffer = (tile.featureTableBinary || []).slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
         tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);
         tile.hasColors =
             Number.isFinite(dracoFeatureTableProperties.RGB) ||
@@ -170,11 +189,14 @@ async function parseDraco(tile, featureTable, batchTable, options, context) {
 }
 // eslint-disable-next-line complexity, max-statements
 async function loadDraco(tile, dracoData, options, context) {
+    if (!context) {
+        return;
+    }
     const { parse } = context;
     const dracoOptions = {
         ...options,
         draco: {
-            ...options.draco,
+            ...options?.draco,
             extraAttributes: dracoData.batchTableProperties || {}
         }
     };

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

@@ -1,2 +1,5 @@
-export declare function parse3DTile(arrayBuffer: any, byteOffset: number | undefined, options: any, context: any, tile?: {}): Promise<any>;
+import { LoaderContext } from '@loaders.gl/loader-utils';
+import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
+import { Tiles3DTileContent } from '../../types';
+export declare function parse3DTile(arrayBuffer: ArrayBuffer, byteOffset: number | undefined, options: Tiles3DLoaderOptions | undefined, context: LoaderContext | undefined, tile?: Tiles3DTileContent): Promise<number | void>;
 //# sourceMappingURL=parse-3d-tile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile.ts"],"names":[],"mappings":"AAaA,wBAAsB,WAAW,CAAC,WAAW,KAAA,EAAE,UAAU,oBAAI,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,EAAE,IAAI,KAAK,gBAmCzF"}
+{"version":3,"file":"parse-3d-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile.ts"],"names":[],"mappings":"AAWA,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAG/C,wBAAsB,WAAW,CAC/B,WAAW,EAAE,WAAW,EACxB,UAAU,oBAAI,EACd,OAAO,EAAE,oBAAoB,GAAG,SAAS,EACzC,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,IAAI,GAAE,kBAAuB,0BAgC9B"}

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

@@ -12,11 +12,8 @@ const parse_3d_tile_composite_1 = require("./parse-3d-tile-composite");
 const parse_3d_tile_gltf_1 = require("./parse-3d-tile-gltf");
 // Extracts
 async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
-    // @ts-expect-error
     tile.byteOffset = byteOffset;
-    // @ts-expect-error
     tile.type = (0, parse_utils_1.getMagicString)(arrayBuffer, byteOffset);
-    // @ts-expect-error
     switch (tile.type) {
         case constants_1.TILE3D_TYPE.COMPOSITE:
             // Note: We pass this function as argument so that embedded tiles can be parsed recursively
@@ -30,7 +27,6 @@ async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile =
         case constants_1.TILE3D_TYPE.POINT_CLOUD:
             return await (0, parse_3d_tile_point_cloud_1.parsePointCloud3DTile)(tile, arrayBuffer, byteOffset, options, context);
         default:
-            // @ts-expect-error
             throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line
     }
 }

package/dist/tiles-3d-loader.d.ts

@@ -1,4 +1,18 @@
-import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { DracoLoaderOptions } from '@loaders.gl/draco';
+import type { ImageLoaderOptions } from '@loaders.gl/images';
+export type Tiles3DLoaderOptions = LoaderOptions & DracoLoaderOptions & ImageLoaderOptions & {
+    '3d-tiles'?: {
+        /** Whether to parse any embedded glTF binaries (or extract memory for independent glTF parsing) */
+        loadGLTF?: boolean;
+        /** If renderer doesn't support quantized positions, loader can decode them on CPU */
+        decodeQuantizedPositions?: boolean;
+        /** Whether this is a tileset or a tile */
+        isTileset?: boolean | 'auto';
+        /** Controls which axis is "up" in glTF files */
+        assetGltfUpAxis?: 'x' | 'y' | 'z' | null;
+    };
+};
 /**
  * Loader for 3D Tiles
  */

package/dist/tiles-3d-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiles-3d-loader.d.ts","sourceRoot":"","sources":["../src/tiles-3d-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAO/D;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC"}
+{"version":3,"file":"tiles-3d-loader.d.ts","sourceRoot":"","sources":["../src/tiles-3d-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAgB,MAAM,0BAA0B,CAAC;AAE7F,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAS3D,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAE9C,kBAAkB,GAClB,kBAAkB,GAAG;IACnB,UAAU,CAAC,EAAE;QACX,mGAAmG;QACnG,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,qFAAqF;QACrF,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,0CAA0C;QAC1C,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;QAC7B,gDAAgD;QAChD,eAAe,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;KAC1C,CAAC;CACH,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC"}