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

package/src/lib/parsers/helpers/{parse-3d-tile-tables.js → parse-3d-tile-tables.ts}

@@ -2,12 +2,18 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 import {getStringFromArrayBuffer} from './parse-utils';
+import {Tiles3DLoaderOptions} from '../../../tiles-3d-loader';
+import {Tiles3DTileContent} from '../../../types';
 
 const SIZEOF_UINT32 = 4;
-const DEPRECATION_WARNING = `b3dm tile in legacy format.`;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
 
 // eslint-disable-next-line max-statements
-export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {
+export function parse3DTileTablesHeaderSync(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number
+) {
   const view = new DataView(arrayBuffer);
   let batchLength;
 
@@ -58,20 +64,30 @@ export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {
   return byteOffset;
 }
 
-export function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {
+export function parse3DTileTablesSync(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions
+) {
   byteOffset = parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options);
   byteOffset = parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options);
   return byteOffset;
 }
 
-function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
-  const {featureTableJsonByteLength, featureTableBinaryByteLength, batchLength} = tile.header;
+function parse3DTileFeatureTable(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions
+) {
+  const {featureTableJsonByteLength, featureTableBinaryByteLength, batchLength} = tile.header || {};
 
   tile.featureTableJson = {
     BATCH_LENGTH: batchLength || 0
   };
 
-  if (featureTableJsonByteLength > 0) {
+  if (featureTableJsonByteLength && featureTableJsonByteLength > 0) {
     const featureTableString = getStringFromArrayBuffer(
       arrayBuffer,
       byteOffset,
@@ -79,10 +95,10 @@ function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
     );
     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);
@@ -94,10 +110,15 @@ function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
   return byteOffset;
 }
 
-function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
-  const {batchTableJsonByteLength, batchTableBinaryByteLength} = tile.header;
+function parse3DTileBatchTable(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions
+) {
+  const {batchTableJsonByteLength, batchTableBinaryByteLength} = tile.header || {};
 
-  if (batchTableJsonByteLength > 0) {
+  if (batchTableJsonByteLength && batchTableJsonByteLength > 0) {
     const batchTableString = getStringFromArrayBuffer(
       arrayBuffer,
       byteOffset,
@@ -106,7 +127,7 @@ function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
     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/src/lib/parsers/{parse-3d-tile-batched-model.js → parse-3d-tile-batched-model.ts}

@@ -8,8 +8,17 @@ import Tile3DFeatureTable from '../classes/tile-3d-feature-table';
 import {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';
 import {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';
 import {parse3DTileGLTFViewSync, extractGLTF, GLTF_FORMAT} from './helpers/parse-3d-tile-gltf-view';
-
-export async function parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+import {Tiles3DTileContent} from '../../types';
+import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {LoaderContext} from '@loaders.gl/loader-utils';
+
+export async function parseBatchedModel3DTile(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+) {
   byteOffset = parseBatchedModel(tile, arrayBuffer, byteOffset, options, context);
   await extractGLTF(tile, GLTF_FORMAT.EMBEDDED, options, context);
 
@@ -21,7 +30,13 @@ export async function parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, opt
   return byteOffset;
 }
 
-function parseBatchedModel(tile, arrayBuffer, byteOffset, options, context) {
+function parseBatchedModel(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+) {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
 
   byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);

package/src/lib/parsers/{parse-3d-tile-composite.js → parse-3d-tile-composite.ts}

@@ -4,17 +4,29 @@
 // Reference code:
 // https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Source/Scene/Composite3DTileContent.js#L182
 
+import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';
+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
+) => Promise<number>;
 
 // eslint-disable-next-line max-params
 export async function parseComposite3DTile(
-  tile,
-  arrayBuffer,
-  byteOffset,
-  options,
-  context,
-  parse3DTile
-) {
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions | undefined,
+  context: LoaderContext | undefined,
+  parse3DTile: Parse3DTile
+): Promise<number> {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
 
   const view = new DataView(arrayBuffer);
@@ -25,7 +37,7 @@ export async function parseComposite3DTile(
 
   // 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/src/lib/parsers/parse-3d-tile-gltf.ts

@@ -0,0 +1,33 @@
+import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {_getMemoryUsageGLTF, GLTFLoader, postProcessGLTF} from '@loaders.gl/gltf';
+import {Tiles3DTileContent} from '../../types';
+
+export async function parseGltf3DTile(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+): Promise<void> {
+  // 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;
+  // Save gltf up axis
+  tile.gltfUpAxis =
+    options?.['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
+      ? options['3d-tiles'].assetGltfUpAxis
+      : 'Y';
+
+  if (options?.['3d-tiles']?.loadGLTF) {
+    if (!context) {
+      return;
+    }
+    const {parse} = context;
+    const gltfWithBuffers = await parse(arrayBuffer, GLTFLoader, options, context);
+    tile.gltf = postProcessGLTF(gltfWithBuffers);
+    tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
+  } else {
+    tile.gltfArrayBuffer = arrayBuffer;
+  }
+}

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

@@ -0,0 +1,253 @@
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
+import {Tile3DSubtreeLoader} from '../../tile-3d-subtree-loader';
+import {load} from '@loaders.gl/core';
+import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';
+import {
+  ImplicitTilingExensionData,
+  Subtree,
+  Tiles3DTileContentJSON,
+  Tiles3DTileJSON,
+  Tiles3DTileJSONPostprocessed,
+  Tiles3DTilesetJSON
+} from '../../types';
+import type {S2VolumeBox} from './helpers/parse-3d-implicit-tiles';
+import {parseImplicitTiles, replaceContentUrlTemplate} from './helpers/parse-3d-implicit-tiles';
+import type {S2VolumeInfo} from '../utils/obb/s2-corners-to-obb';
+import {convertS2BoundingVolumetoOBB} from '../utils/obb/s2-corners-to-obb';
+
+function getTileType(tile: Tiles3DTileJSON, tileContentUrl: string = ''): TILE_TYPE | string {
+  if (!tileContentUrl) {
+    return TILE_TYPE.EMPTY;
+  }
+
+  const contentUrl = tileContentUrl.split('?')[0]; // Discard query string
+  const fileExtension = contentUrl.split('.').pop();
+  switch (fileExtension) {
+    case 'pnts':
+      return TILE_TYPE.POINTCLOUD;
+    case 'i3dm':
+    case 'b3dm':
+    case 'glb':
+    case 'gltf':
+      return TILE_TYPE.SCENEGRAPH;
+    default:
+      return fileExtension || TILE_TYPE.EMPTY;
+  }
+}
+
+function getRefine(refine?: string): TILE_REFINEMENT | string | undefined {
+  switch (refine) {
+    case 'REPLACE':
+    case 'replace':
+      return TILE_REFINEMENT.REPLACE;
+    case 'ADD':
+    case 'add':
+      return TILE_REFINEMENT.ADD;
+    default:
+      return refine;
+  }
+}
+
+function resolveUri(uri: string = '', basePath: string): string {
+  // url scheme per RFC3986
+  const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
+
+  if (urlSchemeRegex.test(basePath)) {
+    const url = new URL(uri, `${basePath}/`);
+    return decodeURI(url.toString());
+  } else if (uri.startsWith('/')) {
+    return uri;
+  }
+
+  return `${basePath}/${uri}`;
+}
+
+export function normalizeTileData(
+  tile: Tiles3DTileJSON | null,
+  basePath: string
+): Tiles3DTileJSONPostprocessed | null {
+  if (!tile) {
+    return null;
+  }
+  let tileContentUrl: string | undefined;
+  if (tile.content) {
+    const contentUri = tile.content.uri || tile.content?.url;
+    tileContentUrl = resolveUri(contentUri, basePath);
+  }
+  const tilePostprocessed: Tiles3DTileJSONPostprocessed = {
+    ...tile,
+    id: tileContentUrl,
+    contentUrl: tileContentUrl,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    lodMetricValue: tile.geometricError,
+    transformMatrix: tile.transform,
+    type: getTileType(tile, tileContentUrl),
+    refine: getRefine(tile.refine)
+  };
+
+  return tilePostprocessed;
+}
+
+// normalize tile headers
+export async function normalizeTileHeaders(
+  tileset: Tiles3DTilesetJSON,
+  basePath: string,
+  options: LoaderOptions
+): Promise<Tiles3DTileJSONPostprocessed | null> {
+  let root: Tiles3DTileJSONPostprocessed | null = null;
+
+  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
+  if (rootImplicitTilingExtension && tileset.root) {
+    root = await normalizeImplicitTileHeaders(
+      tileset.root,
+      tileset,
+      basePath,
+      rootImplicitTilingExtension,
+      options
+    );
+  } else {
+    root = normalizeTileData(tileset.root, basePath);
+  }
+
+  const stack: any[] = [];
+  stack.push(root);
+
+  while (stack.length > 0) {
+    const tile = stack.pop() || {};
+    const children = tile.children || [];
+    const childrenPostprocessed: Tiles3DTileJSONPostprocessed[] = [];
+    for (const childHeader of children) {
+      const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+      let childHeaderPostprocessed: Tiles3DTileJSONPostprocessed | null;
+      if (childImplicitTilingExtension) {
+        childHeaderPostprocessed = await normalizeImplicitTileHeaders(
+          childHeader,
+          tileset,
+          basePath,
+          childImplicitTilingExtension,
+          options
+        );
+      } else {
+        childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
+      }
+
+      if (childHeaderPostprocessed) {
+        childrenPostprocessed.push(childHeaderPostprocessed);
+        stack.push(childHeaderPostprocessed);
+      }
+    }
+    tile.children = childrenPostprocessed;
+  }
+
+  return root;
+}
+
+/**
+ * Do normalisation of implicit tile headers
+ * TODO Check if Tile3D class can be a return type here.
+ * @param tileset
+ */
+export async function normalizeImplicitTileHeaders(
+  tile: Tiles3DTileJSON,
+  tileset: Tiles3DTilesetJSON,
+  basePath: string,
+  implicitTilingExtension: ImplicitTilingExensionData,
+  options: Tiles3DLoaderOptions
+): Promise<Tiles3DTileJSONPostprocessed | null> {
+  const {
+    subdivisionScheme,
+    maximumLevel,
+    subtreeLevels,
+    subtrees: {uri: subtreesUriTemplate}
+  } = implicitTilingExtension;
+  const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
+  const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
+  const subtree = await load(subtreeUrl, Tile3DSubtreeLoader, options);
+  const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
+  const refine = tileset?.root?.refine;
+  // @ts-ignore
+  const rootLodMetricValue = tile.geometricError;
+
+  // Replace tile.boundingVolume with the the bounding volume specified by the extensions['3DTILES_bounding_volume_S2']
+  const s2VolumeInfo: S2VolumeInfo = tile.boundingVolume.extensions?.['3DTILES_bounding_volume_S2'];
+  if (s2VolumeInfo) {
+    const box = convertS2BoundingVolumetoOBB(s2VolumeInfo);
+    const s2VolumeBox: S2VolumeBox = {box, s2VolumeInfo};
+    tile.boundingVolume = s2VolumeBox;
+  }
+
+  const rootBoundingVolume = tile.boundingVolume;
+
+  const implicitOptions = {
+    contentUrlTemplate,
+    subtreesUriTemplate,
+    subdivisionScheme,
+    subtreeLevels,
+    maximumLevel,
+    refine,
+    basePath,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    rootLodMetricValue,
+    rootBoundingVolume,
+    getTileType,
+    getRefine
+  };
+
+  return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
+}
+
+/**
+ * Do implicit data normalisation to create hierarchical tile structure
+ * @param tile
+ * @param rootSubtree
+ * @param options
+ * @returns
+ */
+export async function normalizeImplicitTileData(
+  tile: Tiles3DTileJSON,
+  basePath: string,
+  rootSubtree: Subtree,
+  options: any
+): Promise<Tiles3DTileJSONPostprocessed | null> {
+  if (!tile) {
+    return null;
+  }
+
+  const {children, contentUrl} = await parseImplicitTiles({
+    subtree: rootSubtree,
+    options
+  });
+
+  let tileContentUrl: string | undefined;
+  let tileContent: Tiles3DTileContentJSON | null = null;
+  if (contentUrl) {
+    tileContentUrl = contentUrl;
+    tileContent = {uri: contentUrl.replace(`${basePath}/`, '')};
+  }
+  const tilePostprocessed: Tiles3DTileJSONPostprocessed = {
+    ...tile,
+    id: tileContentUrl,
+    contentUrl: tileContentUrl,
+    lodMetricType: 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;
+}
+
+/**
+ * Implicit Tiling data can be in 3DTILES_implicit_tiling for 3DTiles v.Next or directly in implicitTiling object for 3DTiles v1.1.
+ * Spec 3DTiles v.Next - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * Spec 3DTiles v.1.1 - https://github.com/CesiumGS/3d-tiles/tree/draft-1.1/specification/ImplicitTiling
+ * @param tile
+ * @returns
+ */
+function getImplicitTilingExtensionData(tile: Tiles3DTileJSON | null): ImplicitTilingExensionData {
+  return tile?.extensions?.['3DTILES_implicit_tiling'] || tile?.implicitTiling;
+}

package/src/lib/parsers/{parse-3d-tile-instanced-model.js → parse-3d-tile-instanced-model.ts}

@@ -10,14 +10,29 @@ import Tile3DBatchTable from '../classes/tile-3d-batch-table';
 import {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';
 import {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';
 import {parse3DTileGLTFViewSync, extractGLTF} from './helpers/parse-3d-tile-gltf-view';
-
-export async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {LoaderContext} from '@loaders.gl/loader-utils';
+import {Tiles3DTileContent} from '../../types';
+
+export async function parseInstancedModel3DTile(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+): Promise<number> {
   byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-  await extractGLTF(tile, tile.gltfFormat, options, context);
+  await extractGLTF(tile, tile.gltfFormat || 0, options, context);
   return byteOffset;
 }
 
-function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
+function parseInstancedModel(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+): number {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
   if (tile.version !== 1) {
     throw new Error(`Instanced 3D Model version ${tile.version} is not supported`);
@@ -36,7 +51,7 @@ function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
   byteOffset = 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.');
   }
 
@@ -64,23 +79,13 @@ 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, // Already culled by 3D Tiles
-    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;
+function extractInstancedAttributes(
+  tile: Tiles3DTileContent,
+  featureTable: Tile3DFeatureTable,
+  batchTable: Tile3DBatchTable,
+  instancesLength: number
+) {
+  const instances = new Array(instancesLength);
   const instancePosition = new Vector3();
   const instanceNormalRight = new Vector3();
   const instanceNormalUp = new Vector3();
@@ -92,8 +97,8 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
   const instanceTransform = new Matrix4();
   const scratch1 = [];
   const scratch2 = [];
-  const scratchVector1 = new Vector3();
-  const scratchVector2 = new Vector3();
+  const scratch3 = [];
+  const scratch4 = [];
 
   for (let i = 0; i < instancesLength; i++) {
     let position;
@@ -113,8 +118,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       const quantizedVolumeOffset = featureTable.getGlobalProperty(
         'QUANTIZED_VOLUME_OFFSET',
         GL.FLOAT,
-        3,
-        scratchVector1
+        3
       );
       if (!quantizedVolumeOffset) {
         throw new Error(
@@ -125,8 +129,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       const quantizedVolumeScale = featureTable.getGlobalProperty(
         'QUANTIZED_VOLUME_SCALE',
         GL.FLOAT,
-        3,
-        scratchVector2
+        3
       );
       if (!quantizedVolumeScale) {
         throw new Error(
@@ -146,6 +149,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instancePosition.copy(position);
+    // @ts-expect-error
     instanceTranslationRotationScale.translation = instancePosition;
 
     // Get the instance rotation
@@ -165,12 +169,14 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
         'NORMAL_UP_OCT32P',
         GL.UNSIGNED_SHORT,
         2,
+        i,
         scratch1
       );
       tile.octNormalRight = featureTable.getProperty(
         'NORMAL_RIGHT_OCT32P',
         GL.UNSIGNED_SHORT,
         2,
+        i,
         scratch2
       );
 
@@ -203,11 +209,12 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instanceQuaternion.fromMatrix3(instanceRotation);
+    // @ts-expect-error
     instanceTranslationRotationScale.rotation = instanceQuaternion;
 
     // Get the instance scale
     instanceScale.set(1.0, 1.0, 1.0);
-    const scale = featureTable.getProperty('SCALE', GL.FLOAT, 1, i);
+    const scale = featureTable.getProperty('SCALE', GL.FLOAT, 1, i, scratch3);
     if (Number.isFinite(scale)) {
       instanceScale.multiplyByScalar(scale);
     }
@@ -216,21 +223,25 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       instanceScale.scale(nonUniformScale);
     }
 
+    // @ts-expect-error
     instanceTranslationRotationScale.scale = instanceScale;
 
     // Get the batchId
-    let batchId = featureTable.getProperty('BATCH_ID', GL.UNSIGNED_SHORT, 1, i);
+    let batchId = featureTable.getProperty('BATCH_ID', GL.UNSIGNED_SHORT, 1, i, scratch4);
     if (batchId === undefined) {
       // If BATCH_ID semantic is undefined, batchId is just the instance number
       batchId = i;
     }
 
+    // @ts-expect-error
     const rotationMatrix = new Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
 
     // Create the model matrix and the instance
     instanceTransform.identity();
+    // @ts-expect-error
     instanceTransform.translate(instanceTranslationRotationScale.translation);
     instanceTransform.multiplyRight(rotationMatrix);
+    // @ts-expect-error
     instanceTransform.scale(instanceTranslationRotationScale.scale);
 
     const modelMatrix = instanceTransform.clone();