@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.7

package/src/lib/extensions/deprecated/EXT_feature_metadata.ts

@@ -0,0 +1,163 @@
+/* eslint-disable camelcase */
+import type {GLTF} from '../../types/gltf-json-schema';
+
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
+import {
+  ClassProperty,
+  EXT_feature_metadata_class_object,
+  EXT_feature_metadata_feature_table,
+  FeatureTableProperty,
+  GLTF_EXT_feature_metadata
+} from '../../types/gltf-json-schema';
+
+/** Extension name */
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+
+export const name = EXT_FEATURE_METADATA;
+
+export async function decode(gltfData: {json: GLTF}): Promise<void> {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  decodeExtFeatureMetadata(scenegraph);
+}
+
+/**
+ * Decodes feature metadata from extension
+ * @param scenegraph
+ */
+function decodeExtFeatureMetadata(scenegraph: GLTFScenegraph): void {
+  const extension: GLTF_EXT_feature_metadata | null = scenegraph.getExtension(EXT_FEATURE_METADATA);
+  const schemaClasses = extension?.schema?.classes;
+  const featureTables = extension?.featureTables;
+  const featureTextures = extension?.featureTextures;
+
+  if (featureTextures) {
+    /*
+     * TODO add support for featureTextures
+     * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-textures
+     */
+    // eslint-disable-next-line no-console
+    console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+  }
+
+  if (schemaClasses && featureTables) {
+    for (const schemaName in schemaClasses) {
+      const schemaClass = schemaClasses[schemaName];
+      const featureTable = findFeatureTableByName(featureTables, schemaName);
+
+      if (featureTable) {
+        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+      }
+    }
+  }
+}
+
+/**
+ * Navigate throw all properies in feature table and gets properties data.
+ * @param scenegraph
+ * @param featureTable
+ * @param schemaClass
+ */
+function handleFeatureTableProperties(
+  scenegraph: GLTFScenegraph,
+  featureTable: EXT_feature_metadata_feature_table,
+  schemaClass: EXT_feature_metadata_class_object
+): void {
+  for (const propertyName in schemaClass.properties) {
+    const schemaProperty = schemaClass.properties[propertyName];
+    const featureTableProperty = featureTable?.properties?.[propertyName];
+    const numberOfFeatures = featureTable.count;
+
+    if (featureTableProperty) {
+      const data = getPropertyDataFromBinarySource(
+        scenegraph,
+        schemaProperty,
+        numberOfFeatures,
+        featureTableProperty
+      );
+      featureTableProperty.data = data;
+    }
+  }
+}
+
+/**
+ * Decode properties from binary sourse based on property type.
+ * @param scenegraph
+ * @param schemaProperty
+ * @param numberOfFeatures
+ * @param featureTableProperty
+ */
+function getPropertyDataFromBinarySource(
+  scenegraph: GLTFScenegraph,
+  schemaProperty: ClassProperty,
+  numberOfFeatures: number,
+  featureTableProperty: FeatureTableProperty
+): Uint8Array | string[] {
+  const bufferView = featureTableProperty.bufferView;
+  // TODO think maybe we shouldn't get data only in Uint8Array format.
+  let data: Uint8Array | string[] = scenegraph.getTypedArrayForBufferView(bufferView);
+
+  switch (schemaProperty.type) {
+    case 'STRING': {
+      // stringOffsetBufferView should be available for string type.
+      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;
+      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+      data = getStringAttributes(data, offsetsData, numberOfFeatures);
+      break;
+    }
+    default:
+  }
+
+  return data;
+}
+
+/**
+ * Find the feature table by class name.
+ * @param featureTables
+ * @param schemaClassName
+ */
+function findFeatureTableByName(
+  featureTables: {[key: string]: EXT_feature_metadata_feature_table},
+  schemaClassName: string
+): EXT_feature_metadata_feature_table | null {
+  for (const featureTableName in featureTables) {
+    const featureTable = featureTables[featureTableName];
+
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Getting string attributes from binary data.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
+ * @param data
+ * @param offsetsData
+ * @param stringsCount
+ */
+function getStringAttributes(
+  data: Uint8Array,
+  offsetsData: Uint8Array,
+  stringsCount: number
+): string[] {
+  const stringsArray: string[] = [];
+  const textDecoder = new TextDecoder('utf8');
+
+  let stringOffset = 0;
+  const bytesPerStringSize = 4;
+
+  for (let index = 0; index < stringsCount; index++) {
+    // TODO check if it is multiplication on bytesPerStringSize is valid operation?
+    const stringByteSize =
+      offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringAttribute = textDecoder.decode(stringData);
+
+    stringsArray.push(stringAttribute);
+    stringOffset += stringByteSize;
+  }
+
+  return stringsArray;
+}

package/src/lib/extensions/deprecated/KHR_lights_punctual.ts

@@ -1,10 +1,10 @@
 // GLTF EXTENSION: KHR_lights_punctual
 // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
 
-import type {GLTF} from '../../types/gltf-types';
+import type {GLTF} from '../../types/gltf-json-schema';
 
 import {assert} from '../../utils/assert';
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 
 const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
 

package/src/lib/extensions/deprecated/KHR_materials_unlit.ts

@@ -1,9 +1,9 @@
 // GLTF EXTENSION: KHR_materials_unlit
 // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
 
-import type {GLTF} from '../../types/gltf-types';
+import type {GLTF} from '../../types/gltf-json-schema';
 
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 
 const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
 
@@ -13,9 +13,6 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
   const gltfScenegraph = new GLTFScenegraph(gltfData);
   const {json} = gltfScenegraph;
 
-  // Remove the top-level extension
-  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
-
   // Any nodes that have the extension, add lights field pointing to light object
   // and remove the extension
   for (const material of json.materials || []) {
@@ -26,6 +23,9 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
     }
     gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
   }
+
+  // Remove the top-level extension
+  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
 }
 
 export function encode(gltfData) {

package/src/lib/extensions/deprecated/KHR_techniques_webgl.ts

@@ -1,9 +1,9 @@
 // GLTF EXTENSION: KHR_techniques_webgl
 // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl
 
-import type {GLTF} from '../../types/gltf-types';
+import type {GLTF} from '../../types/gltf-json-schema';
 
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 
 const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
 
@@ -33,6 +33,7 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
       gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
     }
 
+    // Remove the top-level extension
     gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
   }
 }

package/src/lib/gltf-utils/gltf-attribute-utils.ts

@@ -1,5 +1,5 @@
 // import type {TypedArray} from '../types/loader-utils';
-import type {GLTFAccessor} from '../types/gltf-types';
+import type {GLTFAccessor} from '../types/gltf-json-schema';
 // TODO - remove
 import {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';
 

package/src/lib/gltf-utils/gltf-constants.ts

@@ -1,4 +1,4 @@
-const COMPONENTS = {
+export const COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
   VEC3: 3,
@@ -8,7 +8,7 @@ const COMPONENTS = {
   MAT4: 16
 };
 
-const BYTES = {
+export const BYTES = {
   5120: 1, // BYTE
   5121: 1, // UNSIGNED_BYTE
   5122: 2, // SHORT

package/src/lib/gltf-utils/gltf-utils.ts

@@ -1,4 +1,11 @@
 import {assert} from '../utils/assert';
+import type {GLTFPostprocessed} from '../types/gltf-postprocessed-schema';
+
+/**
+ * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...
+ * Minimum 1.33, but due to GPU layout may be 1.5
+ */
+const MIPMAP_FACTOR = 1.33;
 
 const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
 
@@ -77,3 +84,27 @@ export function getAccessorArrayTypeAndLength(accessor, bufferView) {
   assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
   return {ArrayType, length, byteLength};
 }
+
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+export function getMemoryUsageGLTF(gltf: GLTFPostprocessed): number {
+  let {images, bufferViews} = gltf;
+  images = images || [];
+  bufferViews = bufferViews || [];
+  const imageBufferViews = images.map((i) => i.bufferView);
+  bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view as any));
+
+  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+
+  // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)
+  // TODO correctly handle compressed textures
+  const pixelCount = images.reduce((acc, image) => {
+    // @ts-ignore
+    const {width, height} = (image as any).image;
+    return acc + width * height;
+  }, 0);
+  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+}

package/src/lib/parsers/parse-glb.ts

@@ -4,24 +4,29 @@
 import type {GLB} from '../types/glb-types';
 import {padToNBytes, assert} from '@loaders.gl/loader-utils';
 
-export type GLBParseOptions = {
+/** Options for parsing a GLB */
+export type ParseGLBOptions = {
+  /** @deprecated This option was used by XVIZ protocol to define a non-standard magic number */
   magic?: number;
+  /** @deprecated This option was used by XVIZ protocol to embed non-standard chunks */
   strict?: boolean;
 };
 
-const MAGIC_glTF = 0x676c5446; // glTF in Big-Endian ASCII
+/** Binary GLTF is little endian. */
+const LITTLE_ENDIAN = true;
 
+/** 'glTF' in Big-Endian ASCII */
+const MAGIC_glTF = 0x676c5446;
 const GLB_FILE_HEADER_SIZE = 12;
 const GLB_CHUNK_HEADER_SIZE = 8;
-
 const GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
 const GLB_CHUNK_TYPE_BIN = 0x004e4942;
-const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0; // DEPRECATED - Backward compatibility for old xviz files
-const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1; // DEPRECATED - Backward compatibility for old xviz files
-
 const GLB_V1_CONTENT_FORMAT_JSON = 0x0;
 
-const LE = true; // Binary GLTF is little endian.
+/** @deprecated - Backward compatibility for old xviz files */
+const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+/** @deprecated - Backward compatibility for old xviz files */
+const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
 
 function getMagicString(dataView, byteOffset = 0) {
   return `\
@@ -31,11 +36,11 @@ ${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\
 ${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
 }
 
-// Check if a data view is a GLB
+/** Check if the contents of an array buffer contains GLB byte markers */
 export function isGLB(
   arrayBuffer: ArrayBuffer,
   byteOffset: number = 0,
-  options: GLBParseOptions = {}
+  options: ParseGLBOptions = {}
 ): boolean {
   const dataView = new DataView(arrayBuffer);
   // Check that GLB Header starts with the magic number
@@ -44,19 +49,27 @@ export function isGLB(
   return magic1 === magic || magic1 === MAGIC_glTF;
 }
 
-export default function parseGLBSync(
+/**
+ * Synchronously parse a GLB
+ * @param glb - Target, Output is stored there
+ * @param arrayBuffer - Input data
+ * @param byteOffset - Offset into arrayBuffer to start parsing from (for "embedded" GLBs, e.g. in 3D tiles)
+ * @param options
+ * @returns
+ */
+export function parseGLBSync(
   glb: GLB,
   arrayBuffer: ArrayBuffer,
   byteOffset: number = 0,
-  options: GLBParseOptions = {}
+  options: ParseGLBOptions = {}
 ) {
   // Check that GLB Header starts with the magic number
   const dataView = new DataView(arrayBuffer);
 
   // Compare format with GLBLoader documentation
   const type = getMagicString(dataView, byteOffset + 0);
-  const version = dataView.getUint32(byteOffset + 4, LE); // Version 2 of binary glTF container format
-  const byteLength = dataView.getUint32(byteOffset + 8, LE); // Total byte length of binary file
+  const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Version 2 of binary glTF container format
+  const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN); // Total byte length of binary file
 
   Object.assign(glb, {
     // Put less important stuff in a header, to avoid clutter
@@ -77,24 +90,29 @@ export default function parseGLBSync(
 
   switch (glb.version) {
     case 1:
-      // eslint-disable-next-line
       return parseGLBV1(glb, dataView, byteOffset);
     case 2:
-      // eslint-disable-next-line
       return parseGLBV2(glb, dataView, byteOffset, (options = {}));
     default:
-      throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);
+      throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
   }
 }
 
+/**
+ * Parse a V1 GLB
+ * @param glb - target, output is stored in this object
+ * @param dataView - Input, memory to be parsed
+ * @param byteOffset - Offset of first byte of GLB data in the data view
+ * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)
+ */
 function parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {
   // Sanity: ensure file is big enough to hold at least the headers
   assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
 
   // Explanation of GLB structure:
   // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png
-  const contentLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
-  const contentFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+  const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk
+  const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32
   byteOffset += GLB_CHUNK_HEADER_SIZE;
 
   // GLB v1 only supports a single chunk type
@@ -108,11 +126,18 @@ function parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {
   return byteOffset;
 }
 
+/**
+ * Parse a V2 GLB
+ * @param glb - target, output is stored in this object
+ * @param dataView - Input, memory to be parsed
+ * @param byteOffset - Offset of first byte of GLB data in the data view
+ * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)
+ */
 function parseGLBV2(
   glb: GLB,
   dataView: DataView,
   byteOffset: number,
-  options: GLBParseOptions
+  options: ParseGLBOptions
 ): number {
   // Sanity: ensure file is big enough to hold at least the first chunk header
   assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
@@ -122,17 +147,18 @@ function parseGLBV2(
   return byteOffset + glb.header.byteLength;
 }
 
+/** Iterate over GLB chunks and parse them */
 function parseGLBChunksSync(
   glb: GLB,
   dataView: DataView,
   byteOffset: number,
-  options: GLBParseOptions
+  options: ParseGLBOptions
 ) {
   // Per spec we must iterate over chunks, ignoring all except JSON and BIN
   // Iterate as long as there is space left for another chunk header
   while (byteOffset + 8 <= glb.header.byteLength) {
-    const chunkLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk
-    const chunkFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32
+    const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk
+    const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32
     byteOffset += GLB_CHUNK_HEADER_SIZE;
 
     // Per spec we must iterate over chunks, ignoring all except JSON and BIN
@@ -168,7 +194,7 @@ function parseGLBChunksSync(
   return byteOffset;
 }
 
-// Parse a GLB JSON chunk
+/* Parse a GLB JSON chunk */
 function parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkLength: number) {
   // 1. Create a "view" of the binary encoded JSON data inside the GLB
   const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
@@ -183,7 +209,7 @@ function parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkL
   return padToNBytes(chunkLength, 4);
 }
 
-// Parse a GLB BIN chunk
+/** Parse a GLB BIN chunk */
 function parseBINChunk(glb: GLB, dataView, byteOffset, chunkLength) {
   // Note: BIN chunk can be optional
   glb.header.hasBinChunk = true;

package/src/lib/parsers/parse-gltf.ts

@@ -1,34 +1,35 @@
 /* eslint-disable camelcase, max-statements, no-restricted-globals */
 import type {LoaderContext} from '@loaders.gl/loader-utils';
-import {BasisLoader, selectSupportedBasisFormat} from '@loaders.gl/textures';
 import type {GLTFLoaderOptions} from '../../gltf-loader';
-import type {GLB} from '../types/glb-types';
 import type {GLTFWithBuffers} from '../types/gltf-types';
+import type {GLB} from '../types/glb-types';
+import type {ParseGLBOptions} from './parse-glb';
 
-import {ImageLoader} from '@loaders.gl/images';
 import {parseJSON, sliceArrayBuffer} from '@loaders.gl/loader-utils';
+import {ImageLoader} from '@loaders.gl/images';
+import {BasisLoader, selectSupportedBasisFormat} from '@loaders.gl/textures';
+
 import {assert} from '../utils/assert';
+import {isGLB, parseGLBSync} from './parse-glb';
 import {resolveUrl} from '../gltf-utils/resolve-url';
 import {getTypedArrayForBufferView} from '../gltf-utils/get-typed-array';
 import {preprocessExtensions, decodeExtensions} from '../api/gltf-extensions';
 import {normalizeGLTFV1} from '../api/normalize-gltf-v1';
-import {postProcessGLTF} from '../api/post-process-gltf';
-import parseGLBSync, {isGLB} from './parse-glb';
 
-export type GLTFParseOptions = {
+/**  */
+export type ParseGLTFOptions = ParseGLBOptions & {
   normalize?: boolean;
   loadImages?: boolean;
   loadBuffers?: boolean;
   decompressMeshes?: boolean;
-  postProcess?: boolean;
   excludeExtensions?: string[];
-};
 
-// export type GLTFOptions = {
-//   gltf?: GLTFParseOptions;
-// };
+  /** @deprecated not supported in v4. `postProcessGLTF()` must be called by the application */
+  postProcess?: false;
+};
 
-export function isGLTF(arrayBuffer, options?): boolean {
+/** Check if an array buffer appears to contain GLTF data */
+export function isGLTF(arrayBuffer: ArrayBuffer, options?: ParseGLTFOptions): boolean {
   const byteOffset = 0;
   return isGLB(arrayBuffer, byteOffset, options);
 }
@@ -39,7 +40,7 @@ export async function parseGLTF(
   byteOffset = 0,
   options: GLTFLoaderOptions,
   context: LoaderContext
-) {
+): Promise<GLTFWithBuffers> {
   parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
 
   normalizeGLTFV1(gltf, {normalize: options?.gltf?.normalize});
@@ -64,11 +65,16 @@ export async function parseGLTF(
   // Parallelize image loading and buffer loading/extension decoding
   await Promise.all(promises);
 
-  // Post processing resolves indices to objects, buffers
-  return options?.gltf?.postProcess ? postProcessGLTF(gltf, options) : gltf;
+  return gltf;
 }
 
-// `data` - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)
+/**
+ *
+ * @param gltf
+ * @param data - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)
+ * @param byteOffset
+ * @param options
+ */
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
   // Initialize gltf container
   if (options.uri) {
@@ -144,6 +150,12 @@ async function loadBuffers(gltf: GLTFWithBuffers, options, context: LoaderContex
       };
 
       delete buffer.uri;
+    } else if (gltf.buffers[i] === null) {
+      gltf.buffers[i] = {
+        arrayBuffer: new ArrayBuffer(buffer.byteLength),
+        byteOffset: 0,
+        byteLength: buffer.byteLength
+      };
     }
   }
 }
@@ -195,10 +207,13 @@ async function loadImage(
 
   let arrayBuffer;
 
-  if (image.uri) {
+  if (image.uri && !image.hasOwnProperty('bufferView')) {
     const uri = resolveUrl(image.uri, options);
     const response = await fetch(uri);
     arrayBuffer = await response.arrayBuffer();
+    image.bufferView = {
+      data: arrayBuffer
+    };
   }
 
   if (Number.isFinite(image.bufferView)) {

package/src/lib/types/glb-types.ts

@@ -16,6 +16,6 @@ export type GLB = {
   };
 
   // Per spec we must iterate over chunks, ignoring all except JSON and BIN
-  json: {};
+  json: Record<string, any>;
   binChunks: GLBBinChunk[];
 };