@loaders.gl/3d-tiles 4.0.0-alpha.7 → 4.0.0-alpha.9

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

@@ -1,7 +1,8 @@
 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, context: LoaderContext, subtile: any) => Promise<number>;
-export declare function parseComposite3DTile(tile: any, arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions, context: LoaderContext, parse3DTile: Parse3DTile): Promise<number>;
+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":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAGhE,8EAA8E;AAC9E,KAAK,WAAW,GAAG,CACjB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,EACtB,OAAO,KAAA,KACJ,OAAO,CAAC,MAAM,CAAC,CAAC;AAGrB,wBAAsB,oBAAoB,CACxC,IAAI,KAAA,EACJ,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,MAAM,CAAC,CAmBjB"}
+{"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

@@ -13,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,4 +1,5 @@
 import type { LoaderContext } from '@loaders.gl/loader-utils';
 import type { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
-export declare function parseGltf3DTile(tile: any, arrayBuffer: ArrayBuffer, options: Tiles3DLoaderOptions, context: LoaderContext): Promise<void>;
+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":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAGhE,wBAAsB,eAAe,CACnC,IAAI,KAAA,EACJ,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAef"}
+{"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,12 +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;
-    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);
+    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,15 +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: Tiles3DLoaderOptions): 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
@@ -17,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,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAChE,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,oBAAoB,gBA2C9B;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.split('?')[0]; // Discard query string
+    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,4 +1,5 @@
 import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
 import { LoaderContext } from '@loaders.gl/loader-utils';
-export declare function parseInstancedModel3DTile(tile: any, arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions, context: LoaderContext): Promise<number>;
+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":"AAYA,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD,wBAAsB,yBAAyB,CAC7C,IAAI,KAAA,EACJ,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,CAAC,CAIjB"}
+{"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,5 +1,6 @@
 import { Tiles3DLoaderOptions } from '../../tiles-3d-loader';
 import { LoaderContext } from '@loaders.gl/loader-utils';
-export declare function parsePointCloud3DTile(tile: any, arrayBuffer: ArrayBuffer, byteOffset: number, options: Tiles3DLoaderOptions, context: LoaderContext): Promise<number>;
-export declare function loadDraco(tile: any, dracoData: any, options: Tiles3DLoaderOptions, context: LoaderContext): Promise<void>;
+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":"AAcA,OAAO,EAAC,oBAAoB,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD,wBAAsB,qBAAqB,CACzC,IAAI,KAAA,EACJ,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AA2LD,wBAAsB,SAAS,CAC7B,IAAI,KAAA,EACJ,SAAS,KAAA,EACT,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,aAAa,iBAsDvB"}
+{"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

@@ -58,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);
@@ -82,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')) {
@@ -102,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')) {
@@ -148,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) ||
@@ -171,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.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,EAAE,aAAa,EAAgB,MAAM,0BAA0B,CAAC;AAE7F,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAQ3D,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"}
+{"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"}

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

@@ -38,25 +38,26 @@ async function parse(data, options = {}, context) {
     else {
         isTileset = loaderOptions.isTileset;
     }
-    return (await isTileset)
-        ? parseTileset(data, options, context)
-        : parseTile(data, options, context);
+    return isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
 }
 /** Parse a tileset */
 async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
-    // eslint-disable-next-line no-use-before-define
-    tilesetJson.loader = options?.loader || exports.Tiles3DLoader;
-    tilesetJson.url = context?.url || '';
-    tilesetJson.queryString = context?.queryString || '';
-    // base path that non-absolute paths in tileset are relative to.
-    tilesetJson.basePath = getBaseUri(tilesetJson);
-    // TODO - check option types in normalizeTileHeaders
-    tilesetJson.root = await (0, parse_3d_tile_header_1.normalizeTileHeaders)(tilesetJson, options || {});
-    tilesetJson.type = tiles_1.TILESET_TYPE.TILES3D;
-    tilesetJson.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
-    return tilesetJson;
+    const tilesetUrl = context?.url || '';
+    const basePath = getBaseUri(tilesetUrl);
+    const normalizedRoot = await (0, parse_3d_tile_header_1.normalizeTileHeaders)(tilesetJson, basePath, options || {});
+    const tilesetJsonPostprocessed = {
+        ...tilesetJson,
+        loader: exports.Tiles3DLoader,
+        url: tilesetUrl,
+        queryString: context?.queryString || '',
+        basePath,
+        root: normalizedRoot || tilesetJson.root,
+        type: tiles_1.TILESET_TYPE.TILES3D,
+        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+        lodMetricValue: tilesetJson.root?.geometricError || 0
+    };
+    return tilesetJsonPostprocessed;
 }
 /** Parse a tile */
 async function parseTile(arrayBuffer, options, context) {
@@ -70,6 +71,6 @@ async function parseTile(arrayBuffer, options, context) {
     return tile.content;
 }
 /** Get base name */
-function getBaseUri(tileset) {
-    return loader_utils_1.path.dirname(tileset.url);
+function getBaseUri(tilesetUrl) {
+    return loader_utils_1.path.dirname(tilesetUrl);
 }