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

package/src/lib/parsers/helpers/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.';
 
 // 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.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.ts

@@ -7,23 +7,24 @@
 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,
-  context: LoaderContext,
+  options: Tiles3DLoaderOptions | undefined,
+  context: LoaderContext | undefined,
   subtile
 ) => Promise<number>;
 
 // eslint-disable-next-line max-params
 export async function parseComposite3DTile(
-  tile,
+  tile: Tiles3DTileContent,
   arrayBuffer: ArrayBuffer,
   byteOffset: number,
-  options: Tiles3DLoaderOptions,
-  context: LoaderContext,
+  options: Tiles3DLoaderOptions | undefined,
+  context: LoaderContext | undefined,
   parse3DTile: Parse3DTile
 ): Promise<number> {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
@@ -36,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

@@ -1,12 +1,13 @@
 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,
+  tile: Tiles3DTileContent,
   arrayBuffer: ArrayBuffer,
-  options: Tiles3DLoaderOptions,
-  context: LoaderContext
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
 ): Promise<void> {
   // Set flags
   // glTF models need to be rotated from Y to Z up
@@ -14,12 +15,19 @@ export async function parseGltf3DTile(
   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, GLTFLoader, options, context);
-  tile.gltf = postProcessGLTF(gltfWithBuffers);
-  tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
+  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

@@ -2,19 +2,26 @@ 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 {Tileset3D, LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE, Tile3D} from '@loaders.gl/tiles';
-import {ImplicitTilingExtension, Subtree} from '../../types';
+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) {
-  if (!tile.contentUrl) {
+function getTileType(tile: Tiles3DTileJSON, tileContentUrl: string = ''): TILE_TYPE | string {
+  if (!tileContentUrl) {
     return 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':
@@ -25,11 +32,11 @@ function getTileType(tile) {
     case 'gltf':
       return TILE_TYPE.SCENEGRAPH;
     default:
-      return fileExtension;
+      return fileExtension || TILE_TYPE.EMPTY;
   }
 }
 
-function getRefine(refine) {
+function getRefine(refine?: string): TILE_REFINEMENT | string | undefined {
   switch (refine) {
     case 'REPLACE':
     case 'replace':
@@ -42,7 +49,7 @@ function getRefine(refine) {
   }
 }
 
-function resolveUri(uri, basePath) {
+function resolveUri(uri: string = '', basePath: string): string {
   // url scheme per RFC3986
   const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
 
@@ -56,42 +63,51 @@ function resolveUri(uri, basePath) {
   return `${basePath}/${uri}`;
 }
 
-export function normalizeTileData(tile, options) {
+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;
-    tile.contentUrl = resolveUri(contentUri, options.basePath);
+    const contentUri = tile.content.uri || tile.content?.url;
+    tileContentUrl = resolveUri(contentUri, basePath);
   }
-  tile.id = tile.contentUrl;
-  tile.lodMetricType = 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: 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: Tileset3D,
+  tileset: Tiles3DTilesetJSON,
+  basePath: string,
   options: LoaderOptions
-): Promise<Tileset3D> {
-  const basePath = tileset.basePath;
-  let root: Tileset3D;
+): Promise<Tiles3DTileJSONPostprocessed | null> {
+  let root: Tiles3DTileJSONPostprocessed | null = null;
 
-  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
   if (rootImplicitTilingExtension && tileset.root) {
     root = await normalizeImplicitTileHeaders(
       tileset.root,
       tileset,
+      basePath,
       rootImplicitTilingExtension,
       options
     );
   } else {
-    root = normalizeTileData(tileset.root, tileset);
+    root = normalizeTileData(tileset.root, basePath);
   }
 
   const stack: any[] = [];
@@ -100,21 +116,28 @@ export async function normalizeTileHeaders(
   while (stack.length > 0) {
     const tile = stack.pop() || {};
     const children = tile.children || [];
-    for (let childHeader of children) {
+    const childrenPostprocessed: Tiles3DTileJSONPostprocessed[] = [];
+    for (const childHeader of children) {
       const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+      let childHeaderPostprocessed: Tiles3DTileJSONPostprocessed | null;
       if (childImplicitTilingExtension) {
-        childHeader = await normalizeImplicitTileHeaders(
+        childHeaderPostprocessed = await normalizeImplicitTileHeaders(
           childHeader,
           tileset,
+          basePath,
           childImplicitTilingExtension,
           options
         );
       } else {
-        normalizeTileData(childHeader, {basePath});
+        childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
       }
 
-      stack.push(childHeader);
+      if (childHeaderPostprocessed) {
+        childrenPostprocessed.push(childHeaderPostprocessed);
+        stack.push(childHeaderPostprocessed);
+      }
     }
+    tile.children = childrenPostprocessed;
   }
 
   return root;
@@ -126,12 +149,12 @@ export async function normalizeTileHeaders(
  * @param tileset
  */
 export async function normalizeImplicitTileHeaders(
-  tile: Tile3D,
-  tileset: Tileset3D,
-  implicitTilingExtension: ImplicitTilingExtension,
+  tile: Tiles3DTileJSON,
+  tileset: Tiles3DTilesetJSON,
+  basePath: string,
+  implicitTilingExtension: ImplicitTilingExensionData,
   options: Tiles3DLoaderOptions
-) {
-  const basePath = tileset.basePath;
+): Promise<Tiles3DTileJSONPostprocessed | null> {
   const {
     subdivisionScheme,
     maximumLevel,
@@ -141,7 +164,7 @@ export async function normalizeImplicitTileHeaders(
   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 contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
   const refine = tileset?.root?.refine;
   // @ts-ignore
   const rootLodMetricValue = tile.geometricError;
@@ -171,7 +194,7 @@ export async function normalizeImplicitTileHeaders(
     getRefine
   };
 
-  return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+  return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
 }
 
 /**
@@ -181,32 +204,41 @@ export async function normalizeImplicitTileHeaders(
  * @param options
  * @returns
  */
-export async function normalizeImplicitTileData(tile, rootSubtree: Subtree, options: any) {
+export async function normalizeImplicitTileData(
+  tile: Tiles3DTileJSON,
+  basePath: string,
+  rootSubtree: Subtree,
+  options: any
+): Promise<Tiles3DTileJSONPostprocessed | null> {
   if (!tile) {
     return null;
   }
 
-  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tile.lodMetricValue = tile.geometricError;
-  tile.transformMatrix = tile.transform;
-
   const {children, contentUrl} = await parseImplicitTiles({
     subtree: rootSubtree,
-    options,
-    s2VolumeBox: tile
+    options
   });
 
+  let tileContentUrl: string | undefined;
+  let tileContent: Tiles3DTileContentJSON | null = null;
   if (contentUrl) {
-    tile.contentUrl = contentUrl;
-    tile.content = {uri: contentUrl.replace(`${options.basePath}/`, '')};
+    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
+  };
 
-  tile.refine = getRefine(tile.refine);
-  tile.type = getTileType(tile);
-  tile.children = children;
-  tile.id = tile.contentUrl;
-
-  return tile;
+  return tilePostprocessed;
 }
 
 /**
@@ -216,6 +248,6 @@ export async function normalizeImplicitTileData(tile, rootSubtree: Subtree, opti
  * @param tile
  * @returns
  */
-function getImplicitTilingExtensionData(tile: Tile3D | null): ImplicitTilingExtension {
+function getImplicitTilingExtensionData(tile: Tiles3DTileJSON | null): ImplicitTilingExensionData {
   return tile?.extensions?.['3DTILES_implicit_tiling'] || tile?.implicitTiling;
 }

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

@@ -12,25 +12,26 @@ import {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/pars
 import {parse3DTileGLTFViewSync, extractGLTF} from './helpers/parse-3d-tile-gltf-view';
 import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import {LoaderContext} from '@loaders.gl/loader-utils';
+import {Tiles3DTileContent} from '../../types';
 
 export async function parseInstancedModel3DTile(
-  tile,
+  tile: Tiles3DTileContent,
   arrayBuffer: ArrayBuffer,
   byteOffset: number,
-  options: Tiles3DLoaderOptions,
-  context: LoaderContext
+  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,
+  tile: Tiles3DTileContent,
   arrayBuffer: ArrayBuffer,
   byteOffset: number,
-  options: Tiles3DLoaderOptions,
-  context: LoaderContext
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
 ): number {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
   if (tile.version !== 1) {
@@ -50,7 +51,7 @@ function parseInstancedModel(
   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.');
   }
 
@@ -78,23 +79,13 @@ function parseInstancedModel(
 }
 
 // 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();
@@ -106,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;
@@ -127,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(
@@ -139,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(
@@ -180,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
       );
 
@@ -223,7 +214,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
 
     // 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);
     }
@@ -236,7 +227,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     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;