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

package/src/lib/parsers/helpers/parse-3d-implicit-tiles.ts

@@ -0,0 +1,396 @@
+import type {Availability, Tile3DBoundingVolume, Subtree} from '../../../types';
+import {Tile3DSubtreeLoader} from '../../../tile-3d-subtree-loader';
+import {load} from '@loaders.gl/core';
+
+import {getS2CellIdFromToken, getS2ChildCellId, getS2TokenFromCellId} from '../../utils/s2/index';
+import type {S2VolumeInfo} from '../../utils/obb/s2-corners-to-obb';
+import {convertS2BoundingVolumetoOBB} from '../../utils/obb/s2-corners-to-obb';
+import Long from 'long';
+
+const QUADTREE_DEVISION_COUNT = 4;
+const OCTREE_DEVISION_COUNT = 8;
+
+const SUBDIVISION_COUNT_MAP = {
+  QUADTREE: QUADTREE_DEVISION_COUNT,
+  OCTREE: OCTREE_DEVISION_COUNT
+};
+
+/**
+ *  S2VolumeBox is an extention of BoundingVolume of type "box"
+ */
+export type S2VolumeBox = {
+  /** BoundingVolume of type "box" has the "box" field. S2VolumeBox contains it as well. */
+  box: number[];
+  /** s2VolumeInfo provides additional info about the box - specifically the token, min and max height */
+  s2VolumeInfo: S2VolumeInfo;
+};
+
+function getChildS2VolumeBox(
+  s2VolumeBox: S2VolumeBox | undefined,
+  index: number,
+  subdivisionScheme: string
+): S2VolumeBox | undefined {
+  if (s2VolumeBox?.box) {
+    // Check if the BoundingVolume is of type "box"
+    const cellId: Long = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
+    const childCellId = getS2ChildCellId(cellId, index);
+    const childToken = getS2TokenFromCellId(childCellId);
+
+    // Clone object. Note, s2VolumeInfo is a plain object that doesn't contain any nested object.
+    // So, we can use the Spread Operator to make a shallow copy of the object.
+    const s2ChildVolumeInfo: S2VolumeInfo = {...s2VolumeBox.s2VolumeInfo};
+    s2ChildVolumeInfo.token = childToken; // replace the token with the child's one
+
+    // In case of QUADTREE the sizeZ should NOT be changed!
+    // https://portal.ogc.org/files/102132
+    // A quadtree divides space only on the x and y dimensions.
+    // It divides each tile into 4 smaller tiles where the x and y dimensions are halved.
+    // The quadtree z minimum and maximum remain unchanged.
+    switch (subdivisionScheme) {
+      case 'OCTREE':
+        const s2VolumeInfo: S2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+        const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+        const sizeZ: number = delta / 2.0; // It's a next level (a child)
+        const midZ: number = s2VolumeInfo.minimumHeight + delta / 2.0;
+        s2VolumeInfo.minimumHeight = midZ - sizeZ;
+        s2VolumeInfo.maximumHeight = midZ + sizeZ;
+        break;
+      default:
+        break;
+    }
+    const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
+    const childS2VolumeBox: S2VolumeBox = {
+      box,
+      s2VolumeInfo: s2ChildVolumeInfo
+    };
+    return childS2VolumeBox;
+  }
+  return undefined;
+}
+
+/**
+ * Recursively parse implicit tiles tree
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * TODO Check out do we able to use Tile3D class as return type here.
+ * @param subtree
+ * @param lodMetricValue
+ * @param options
+ * @param parentData
+ * @param childIndex
+ * @param level
+ * @param globalData
+ */
+// eslint-disable-next-line max-statements
+export async function parseImplicitTiles(params: {
+  subtree: Subtree;
+  options: any;
+  parentData?: {mortonIndex: number; x: number; y: number; z: number};
+  childIndex?: number;
+  level?: number;
+  globalData?: {level: number; mortonIndex: number; x: number; y: number; z: number};
+  s2VolumeBox?: S2VolumeBox;
+}) {
+  const {
+    options,
+    parentData = {
+      mortonIndex: 0,
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    childIndex = 0,
+    globalData = {
+      level: 0,
+      mortonIndex: 0,
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    s2VolumeBox
+  } = params;
+  let {subtree, level = 0} = params;
+  const {
+    subdivisionScheme,
+    subtreeLevels,
+    maximumLevel,
+    contentUrlTemplate,
+    subtreesUriTemplate,
+    basePath
+  } = options;
+
+  const tile = {children: [], lodMetricValue: 0, contentUrl: ''};
+
+  const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+
+  const childX = childIndex & 0b01;
+  const childY = (childIndex >> 1) & 0b01;
+  const childZ = (childIndex >> 2) & 0b01;
+
+  const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
+  let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+  let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+
+  // Local tile coordinates
+  let childTileX = concatBits(parentData.x, childX);
+  let childTileY = concatBits(parentData.y, childY);
+  let childTileZ = concatBits(parentData.z, childZ);
+
+  let isChildSubtreeAvailable = false;
+
+  if (level + 1 > subtreeLevels) {
+    isChildSubtreeAvailable = getAvailabilityResult(
+      subtree.childSubtreeAvailability,
+      childTileMortonIndex
+    );
+  }
+
+  const x = concatBits(globalData.x, childTileX);
+  const y = concatBits(globalData.y, childTileY);
+  const z = concatBits(globalData.z, childTileZ);
+  const lev = level + globalData.level;
+
+  if (isChildSubtreeAvailable) {
+    const subtreePath = `${basePath}/${subtreesUriTemplate}`;
+    const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+    const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader);
+
+    subtree = childSubtree;
+
+    globalData.mortonIndex = childTileMortonIndex;
+    globalData.x = childTileX;
+    globalData.y = childTileY;
+    globalData.z = childTileZ;
+    globalData.level = level;
+
+    childTileMortonIndex = 0;
+    tileAvailabilityIndex = 0;
+    childTileX = 0;
+    childTileY = 0;
+    childTileZ = 0;
+    level = 0;
+  }
+
+  const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+
+  if (!isTileAvailable || level > maximumLevel) {
+    return tile;
+  }
+
+  const isContentAvailable = getAvailabilityResult(
+    subtree.contentAvailability,
+    tileAvailabilityIndex
+  );
+
+  if (isContentAvailable) {
+    tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+  }
+
+  const childTileLevel = level + 1;
+  const pData = {mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ};
+
+  for (let index = 0; index < childrenPerTile; index++) {
+    const childS2VolumeBox: S2VolumeBox | undefined = getChildS2VolumeBox(
+      s2VolumeBox,
+      index,
+      subdivisionScheme
+    );
+
+    // Recursive calling...
+    const childTileParsed = await parseImplicitTiles({
+      subtree,
+      options,
+      parentData: pData,
+      childIndex: index,
+      level: childTileLevel,
+      globalData,
+      s2VolumeBox: childS2VolumeBox
+    });
+
+    if (childTileParsed.contentUrl || childTileParsed.children.length) {
+      const globalLevel = lev + 1;
+      const childCoordinates = {childTileX, childTileY, childTileZ};
+      const formattedTile = formatTileData(
+        childTileParsed,
+        globalLevel,
+        childCoordinates,
+        options,
+        s2VolumeBox
+      );
+      // @ts-ignore
+      tile.children.push(formattedTile);
+    }
+  }
+
+  return tile;
+}
+
+function getAvailabilityResult(availabilityData: Availability, index: number): boolean {
+  if ('constant' in availabilityData) {
+    return Boolean(availabilityData.constant);
+  }
+
+  if (availabilityData.explicitBitstream) {
+    return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
+  }
+
+  return false;
+}
+
+/**
+ * Do formatting of implicit tile data.
+ * TODO Check out do we able to use Tile3D class as type here.
+ * @param tile
+ * @param lodMetricValue
+ * @param options
+ * @returns
+ */
+function formatTileData(
+  tile,
+  level: number,
+  childCoordinates: {childTileX: number; childTileY: number; childTileZ: number},
+  options: any,
+  s2VolumeBox?: S2VolumeBox
+) {
+  const {
+    basePath,
+    refine,
+    getRefine,
+    lodMetricType,
+    getTileType,
+    rootLodMetricValue,
+    rootBoundingVolume
+  } = options;
+  const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
+  const lodMetricValue = rootLodMetricValue / 2 ** level;
+
+  const boundingVolume: Tile3DBoundingVolume = s2VolumeBox?.box
+    ? {box: s2VolumeBox.box}
+    : rootBoundingVolume;
+
+  const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(
+    level,
+    boundingVolume,
+    childCoordinates
+  );
+
+  return {
+    children: tile.children,
+    contentUrl: tile.contentUrl,
+    content: {uri},
+    id: tile.contentUrl,
+    refine: getRefine(refine),
+    type: getTileType(tile),
+    lodMetricType,
+    lodMetricValue,
+    geometricError: lodMetricValue,
+    transform: tile.transform,
+    boundingVolume: boundingVolumeForChildTile
+  };
+}
+
+/**
+ * Calculate child bounding volume.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subdivision-rules
+ * @param level
+ * @param rootBoundingVolume
+ * @param childCoordinates
+ */
+function calculateBoundingVolumeForChildTile(
+  level: number,
+  rootBoundingVolume: Tile3DBoundingVolume,
+  childCoordinates: {childTileX: number; childTileY: number; childTileZ: number}
+): Tile3DBoundingVolume {
+  if (rootBoundingVolume.region) {
+    const {childTileX, childTileY, childTileZ} = childCoordinates;
+    const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
+    const boundingVolumesCount = 2 ** level;
+
+    const sizeX = (east - west) / boundingVolumesCount;
+    const sizeY = (north - south) / boundingVolumesCount;
+
+    // TODO : Why is the subdivisionScheme not being checked here?
+
+    // In case of QUADTREE the sizeZ should NOT be changed!
+    // https://portal.ogc.org/files/102132
+    // A quadtree divides space only on the x and y dimensions. It divides each tile into 4 smaller tiles where the x and y dimensions are halved. The quadtree z minimum and maximum remain unchanged.
+
+    const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
+
+    const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
+    const [childSouth, childNorth] = [south + sizeY * childTileY, south + sizeY * (childTileY + 1)];
+    const [childMinimumHeight, childMaximumHeight] = [
+      minimumHeight + sizeZ * childTileZ,
+      minimumHeight + sizeZ * (childTileZ + 1)
+    ];
+
+    return {
+      region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
+    };
+  }
+
+  if (rootBoundingVolume.box) {
+    return rootBoundingVolume;
+  }
+
+  throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
+}
+
+/**
+ * Do binary concatenation
+ * @param first
+ * @param second
+ */
+function concatBits(first: number, second: number): number {
+  return parseInt(first.toString(2) + second.toString(2), 2);
+}
+
+/**
+ * Replace implicit tile content url with real coordinates.
+ * @param templateUrl
+ * @param level
+ * @param x
+ * @param y
+ * @param z
+ */
+export function replaceContentUrlTemplate(
+  templateUrl: string,
+  level: number,
+  x: number,
+  y: number,
+  z: number
+): string {
+  const mapUrl = generateMapUrl({level, x, y, z});
+  return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, (matched) => mapUrl[matched]);
+}
+
+/**
+ * Get Map object for content url generation
+ * @param items
+ */
+function generateMapUrl(items: {[key: string]: number}): {[key: string]: string} {
+  const mapUrl = {};
+
+  for (const key in items) {
+    mapUrl[`{${key}}`] = items[key];
+  }
+  return mapUrl;
+}
+
+/**
+ * Get boolean value from bistream by index
+ * A boolean value is encoded as a single bit, either 0 (false) or 1 (true).
+ * Multiple boolean values are packed tightly in the same buffer.
+ * These buffers of tightly-packed bits are sometimes referred to as bitstreams.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/implicit-revisions/specification/Metadata#booleans
+ * @param availabilitiIndex
+ */
+function getBooleanValueFromBitstream(
+  availabilityIndex: number,
+  availabilityBuffer: Uint8Array
+): boolean {
+  const byteIndex = Math.floor(availabilityIndex / 8);
+  const bitIndex = availabilityIndex % 8;
+  const bitValue = (availabilityBuffer[byteIndex] >> bitIndex) & 1;
+
+  return bitValue === 1;
+}

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

@@ -7,29 +7,36 @@
 // - Do we add an option to control this?
 // - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?
 
-import {GLTFLoader} from '@loaders.gl/gltf';
-import {sliceArrayBuffer} from '@loaders.gl/loader-utils';
+import {GLTFLoader, postProcessGLTF, _getMemoryUsageGLTF} from '@loaders.gl/gltf';
+import {LoaderContext, sliceArrayBuffer} from '@loaders.gl/loader-utils';
+import {Tiles3DTileContent} from '../../../types';
+import {Tiles3DLoaderOptions} from '../../../tiles-3d-loader';
 
 export const GLTF_FORMAT = {
   URI: 0,
   EMBEDDED: 1
 };
 
-export function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
+export function parse3DTileGLTFViewSync(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions | undefined
+) {
   // 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;
 
   // Assume glTF consumes rest of tile
-  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+  const gltfByteLength = (tile.byteOffset || 0) + (tile.byteLength || 0) - byteOffset;
   if (gltfByteLength === 0) {
     throw new Error('glTF byte length must be greater than 0.');
   }
 
   // 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';
 
@@ -50,23 +57,34 @@ export function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options)
   }
 
   // Entire tile is consumed
-  return tile.byteOffset + tile.byteLength;
+  return (tile.byteOffset || 0) + (tile.byteLength || 0);
 }
 
-export async function extractGLTF(tile, gltfFormat, options, context) {
-  const tile3DOptions = options['3d-tiles'] || {};
+export async function extractGLTF(
+  tile: Tiles3DTileContent,
+  gltfFormat: number,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+): Promise<void> {
+  const tile3DOptions = options?.['3d-tiles'] || {};
 
   extractGLTFBufferOrURL(tile, gltfFormat, options);
 
   if (tile3DOptions.loadGLTF) {
+    if (!context) {
+      return;
+    }
     const {parse, fetch} = context;
     if (tile.gltfUrl) {
-      tile.gltfArrayBuffer = await fetch(tile.gltfUrl, options);
+      const response = await fetch(tile.gltfUrl, options);
+      tile.gltfArrayBuffer = await response.arrayBuffer();
       tile.gltfByteOffset = 0;
     }
     if (tile.gltfArrayBuffer) {
       // TODO - Should handle byteOffset... However, not used now...
-      tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      tile.gltf = postProcessGLTF(gltfWithBuffers);
+      tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;
@@ -74,15 +92,21 @@ export async function extractGLTF(tile, gltfFormat, options, context) {
   }
 }
 
-function extractGLTFBufferOrURL(tile, gltfFormat, options) {
+function extractGLTFBufferOrURL(
+  tile: Tiles3DTileContent,
+  gltfFormat: number,
+  options: Tiles3DLoaderOptions | undefined
+) {
   switch (gltfFormat) {
     case GLTF_FORMAT.URI:
       // We need to remove padding from the end of the model URL in case this tile was part of a composite tile.
       // This removes all white space and null characters from the end of the string.
-      const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
-      const textDecoder = new TextDecoder();
-      const gltfUrl = textDecoder.decode(gltfUrlBytes);
-      tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, '');
+      if (tile.gltfArrayBuffer) {
+        const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+        const textDecoder = new TextDecoder();
+        const gltfUrl = textDecoder.decode(gltfUrlBytes);
+        tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, '');
+      }
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;
@@ -90,6 +114,6 @@ function extractGLTFBufferOrURL(tile, gltfFormat, options) {
     case GLTF_FORMAT.EMBEDDED:
       break;
     default:
-      throw new Error(`b3dm: Illegal glTF format field`);
+      throw new Error('b3dm: Illegal glTF format field');
   }
 }

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

@@ -1,6 +1,8 @@
 // This file is derived from the Cesium code base under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
+import {Tiles3DTileContent} from '../../../types';
+
 const SIZEOF_UINT32 = 4;
 
 /* PARSE FIXED HEADER:
@@ -10,7 +12,11 @@ Populates
   version,
   byteLength
  */
-export function parse3DTileHeaderSync(tile, arrayBuffer, byteOffset = 0) {
+export function parse3DTileHeaderSync(
+  tile: Tiles3DTileContent,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number = 0
+) {
   const view = new DataView(arrayBuffer);
 
   tile.magic = view.getUint32(byteOffset, true);

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

@@ -0,0 +1,148 @@
+import type {Subtree, ExplicitBitstream} from '../../../types';
+import type {LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+// eslint-disable-next-line max-statements
+export default async function parse3DTilesSubtree(
+  data: ArrayBuffer,
+  options: LoaderOptions | undefined,
+  context: LoaderContext | undefined
+): Promise<Subtree> {
+  const magic = new Uint32Array(data.slice(0, 4));
+
+  if (magic[0] !== SUBTREE_FILE_MAGIC) {
+    throw new Error('Wrong subtree file magic number');
+  }
+
+  const version = new Uint32Array(data.slice(4, 8));
+
+  if (version[0] !== SUBTREE_FILE_VERSION) {
+    throw new Error('Wrong subtree file verson, must be 1');
+  }
+
+  const jsonByteLength = parseUint64Value(data.slice(8, 16));
+  const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(stringAttribute);
+  const subtree = JSON.parse(string);
+
+  const binaryByteLength = parseUint64Value(data.slice(16, 24));
+  let internalBinaryBuffer = new ArrayBuffer(0);
+
+  if (binaryByteLength) {
+    internalBinaryBuffer = data.slice(24 + jsonByteLength);
+  }
+
+  if ('bufferView' in subtree.tileAvailability) {
+    subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'tileAvailability',
+      internalBinaryBuffer,
+      context
+    );
+  }
+
+  if ('bufferView' in subtree.contentAvailability) {
+    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'contentAvailability',
+      internalBinaryBuffer,
+      context
+    );
+  }
+
+  if ('bufferView' in subtree.childSubtreeAvailability) {
+    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'childSubtreeAvailability',
+      internalBinaryBuffer,
+      context
+    );
+  }
+
+  return subtree;
+}
+
+/**
+ * Get url for bitstream downloading
+ * @param bitstreamRelativeUri
+ * @param basePath
+ * @returns
+ */
+function resolveBufferUri(bitstreamRelativeUri: string, basePath: string): string {
+  const hasProtocol = basePath.startsWith('http');
+
+  if (hasProtocol) {
+    const resolvedUri = new URL(bitstreamRelativeUri, basePath);
+    return decodeURI(resolvedUri.toString());
+  }
+
+  /**
+   * Adding http protocol only for new URL constructor usage.
+   * It allows to resolve relative paths like ../../example with basePath.
+   */
+  const basePathWithProtocol = `http://${basePath}`;
+  const resolvedUri = new URL(bitstreamRelativeUri, basePathWithProtocol);
+  /**
+   * Drop protocol and use just relative path.
+   */
+  return `/${resolvedUri.host}${resolvedUri.pathname}`;
+}
+
+/**
+ * Get explicit bitstream for subtree availability data.
+ * @param subtree
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(
+  subtree: Subtree,
+  name: string,
+  internalBinaryBuffer: ArrayBuffer,
+  context: LoaderContext | undefined
+): Promise<ExplicitBitstream> {
+  const bufferViewIndex = subtree[name].bufferView;
+  const bufferView = subtree.bufferViews[bufferViewIndex];
+  const buffer = subtree.buffers[bufferView.buffer];
+
+  if (!context?.url || !context.fetch) {
+    throw new Error('Url is not provided');
+  }
+
+  if (!context.fetch) {
+    throw new Error('fetch is not provided');
+  }
+
+  // External bitstream loading
+  if (buffer.uri) {
+    const bufferUri = resolveBufferUri(buffer.uri, context?.url);
+    const response = await context.fetch(bufferUri);
+    const data = await response.arrayBuffer();
+    // Return view of bitstream.
+    return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+  }
+  // Return view of bitstream.
+  return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+
+/**
+ * Parse buffer to return uint64 value
+ * @param buffer
+ * @returns 64-bit value until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Value(buffer: ArrayBuffer): number {
+  const dataView = new DataView(buffer);
+  const left = dataView.getUint32(0, true);
+  const right = dataView.getUint32(4, true);
+  // combine the two 32-bit values
+  return left + 2 ** 32 * right;
+}