@loaders.gl/3d-tiles 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/esm/lib/parsers/helpers/parse-3d-implicit-tiles.js

@@ -0,0 +1,241 @@
+import { Tile3DSubtreeLoader } from '../../../tile-3d-subtree-loader';
+import { load } from '@loaders.gl/core';
+import { getS2CellIdFromToken, getS2ChildCellId, getS2TokenFromCellId } from '../../utils/s2/index';
+import { convertS2BoundingVolumetoOBB } from '../../utils/obb/s2-corners-to-obb';
+const QUADTREE_DEVISION_COUNT = 4;
+const OCTREE_DEVISION_COUNT = 8;
+const SUBDIVISION_COUNT_MAP = {
+  QUADTREE: QUADTREE_DEVISION_COUNT,
+  OCTREE: OCTREE_DEVISION_COUNT
+};
+function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
+  if (s2VolumeBox !== null && s2VolumeBox !== void 0 && s2VolumeBox.box) {
+    const cellId = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
+    const childCellId = getS2ChildCellId(cellId, index);
+    const childToken = getS2TokenFromCellId(childCellId);
+    const s2ChildVolumeInfo = {
+      ...s2VolumeBox.s2VolumeInfo
+    };
+    s2ChildVolumeInfo.token = childToken;
+    switch (subdivisionScheme) {
+      case 'OCTREE':
+        const s2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+        const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+        const sizeZ = delta / 2.0;
+        const midZ = s2VolumeInfo.minimumHeight + delta / 2.0;
+        s2VolumeInfo.minimumHeight = midZ - sizeZ;
+        s2VolumeInfo.maximumHeight = midZ + sizeZ;
+        break;
+      default:
+        break;
+    }
+    const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
+    const childS2VolumeBox = {
+      box,
+      s2VolumeInfo: s2ChildVolumeInfo
+    };
+    return childS2VolumeBox;
+  }
+  return undefined;
+}
+export async function parseImplicitTiles(params) {
+  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;
+  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 = "".concat(basePath, "/").concat(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 = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
+    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);
+      tile.children.push(formattedTile);
+    }
+  }
+  return tile;
+}
+function getAvailabilityResult(availabilityData, index) {
+  if ('constant' in availabilityData) {
+    return Boolean(availabilityData.constant);
+  }
+  if (availabilityData.explicitBitstream) {
+    return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
+  }
+  return false;
+}
+function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
+  const {
+    basePath,
+    refine,
+    getRefine,
+    lodMetricType,
+    getTileType,
+    rootLodMetricValue,
+    rootBoundingVolume
+  } = options;
+  const uri = tile.contentUrl && tile.contentUrl.replace("".concat(basePath, "/"), '');
+  const lodMetricValue = rootLodMetricValue / 2 ** level;
+  const boundingVolume = s2VolumeBox !== null && s2VolumeBox !== void 0 && 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
+  };
+}
+function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
+  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;
+    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 ".concat(rootBoundingVolume));
+}
+function concatBits(first, second) {
+  return parseInt(first.toString(2) + second.toString(2), 2);
+}
+export function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
+  const mapUrl = generateMapUrl({
+    level,
+    x,
+    y,
+    z
+  });
+  return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, matched => mapUrl[matched]);
+}
+function generateMapUrl(items) {
+  const mapUrl = {};
+  for (const key in items) {
+    mapUrl["{".concat(key, "}")] = items[key];
+  }
+  return mapUrl;
+}
+function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
+  const byteIndex = Math.floor(availabilityIndex / 8);
+  const bitIndex = availabilityIndex % 8;
+  const bitValue = availabilityBuffer[byteIndex] >> bitIndex & 1;
+  return bitValue === 1;
+}
+//# sourceMappingURL=parse-3d-implicit-tiles.js.map

package/dist/esm/lib/parsers/helpers/parse-3d-implicit-tiles.js.map

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

package/dist/esm/lib/parsers/helpers/parse-3d-tile-gltf-view.js

@@ -0,0 +1,59 @@
+import { GLTFLoader } from '@loaders.gl/gltf';
+import { sliceArrayBuffer } from '@loaders.gl/loader-utils';
+export const GLTF_FORMAT = {
+  URI: 0,
+  EMBEDDED: 1
+};
+export function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
+  tile.rotateYtoZ = true;
+  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+  if (gltfByteLength === 0) {
+    throw new Error('glTF byte length must be greater than 0.');
+  }
+  tile.gltfUpAxis = options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis ? options['3d-tiles'].assetGltfUpAxis : 'Y';
+  tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);
+  tile.gltfByteOffset = 0;
+  tile.gltfByteLength = gltfByteLength;
+  if (byteOffset % 4 === 0) {} else {
+    console.warn("".concat(tile.type, ": embedded glb is not aligned to a 4-byte boundary."));
+  }
+  return tile.byteOffset + tile.byteLength;
+}
+export async function extractGLTF(tile, gltfFormat, options, context) {
+  const tile3DOptions = options['3d-tiles'] || {};
+  extractGLTFBufferOrURL(tile, gltfFormat, options);
+  if (tile3DOptions.loadGLTF) {
+    const {
+      parse,
+      fetch
+    } = context;
+    if (tile.gltfUrl) {
+      tile.gltfArrayBuffer = await fetch(tile.gltfUrl, options);
+      tile.gltfByteOffset = 0;
+    }
+    if (tile.gltfArrayBuffer) {
+      tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      delete tile.gltfArrayBuffer;
+      delete tile.gltfByteOffset;
+      delete tile.gltfByteLength;
+    }
+  }
+}
+function extractGLTFBufferOrURL(tile, gltfFormat, options) {
+  switch (gltfFormat) {
+    case GLTF_FORMAT.URI:
+      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;
+      break;
+    case GLTF_FORMAT.EMBEDDED:
+      break;
+    default:
+      throw new Error('b3dm: Illegal glTF format field');
+  }
+}
+//# sourceMappingURL=parse-3d-tile-gltf-view.js.map

package/dist/esm/lib/parsers/helpers/parse-3d-tile-gltf-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-gltf-view.js","names":["GLTFLoader","sliceArrayBuffer","GLTF_FORMAT","URI","EMBEDDED","parse3DTileGLTFViewSync","tile","arrayBuffer","byteOffset","options","rotateYtoZ","gltfByteLength","byteLength","Error","gltfUpAxis","assetGltfUpAxis","gltfArrayBuffer","gltfByteOffset","console","warn","concat","type","extractGLTF","gltfFormat","context","tile3DOptions","extractGLTFBufferOrURL","loadGLTF","parse","fetch","gltfUrl","gltf","gltfUrlBytes","Uint8Array","textDecoder","TextDecoder","decode","replace"],"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n// TODO - should we automatically parse the embedded glTF or leave it to the app?\n// - I.e. some apps might work directly on a GLB, in that case no need for us to decode...\n// - And if we decode, do we still keep the GLB in case it is needed?\n// - Do we add an option to control this?\n// - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?\n\nimport {GLTFLoader} from '@loaders.gl/gltf';\nimport {sliceArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport const GLTF_FORMAT = {\n  URI: 0,\n  EMBEDDED: 1\n};\n\nexport function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {\n  // Set flags\n  // glTF models need to be rotated from Y to Z up\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up\n  tile.rotateYtoZ = true;\n\n  // Assume glTF consumes rest of tile\n  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;\n  if (gltfByteLength === 0) {\n    throw new Error('glTF byte length must be greater than 0.');\n  }\n\n  // Save gltf up axis\n  tile.gltfUpAxis =\n    options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis\n      ? options['3d-tiles'].assetGltfUpAxis\n      : 'Y';\n\n  // TODO - We can avoid copy if already 4-byte aligned...\n  // However the rest of the code may not be able to accept byteOffsets, so copy anyway\n  tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);\n  tile.gltfByteOffset = 0;\n  tile.gltfByteLength = gltfByteLength;\n\n  if (byteOffset % 4 === 0) {\n    // tile.gltfArrayBuffer = arrayBuffer;\n    // tile.gltfByteOffset = byteOffset;\n    // tile.gltfByteLength = gltfByteLength;\n  } else {\n    // Create a copy of the glb so that it is 4-byte aligned\n    // eslint-disable-next-line\n    console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);\n  }\n\n  // Entire tile is consumed\n  return tile.byteOffset + tile.byteLength;\n}\n\nexport async function extractGLTF(tile, gltfFormat, options, context) {\n  const tile3DOptions = options['3d-tiles'] || {};\n\n  extractGLTFBufferOrURL(tile, gltfFormat, options);\n\n  if (tile3DOptions.loadGLTF) {\n    const {parse, fetch} = context;\n    if (tile.gltfUrl) {\n      tile.gltfArrayBuffer = await fetch(tile.gltfUrl, options);\n      tile.gltfByteOffset = 0;\n    }\n    if (tile.gltfArrayBuffer) {\n      // TODO - Should handle byteOffset... However, not used now...\n      tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);\n      delete tile.gltfArrayBuffer;\n      delete tile.gltfByteOffset;\n      delete tile.gltfByteLength;\n    }\n  }\n}\n\nfunction extractGLTFBufferOrURL(tile, gltfFormat, options) {\n  switch (gltfFormat) {\n    case GLTF_FORMAT.URI:\n      // We need to remove padding from the end of the model URL in case this tile was part of a composite tile.\n      // This removes all white space and null characters from the end of the string.\n      const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);\n      const textDecoder = new TextDecoder();\n      const gltfUrl = textDecoder.decode(gltfUrlBytes);\n      tile.gltfUrl = gltfUrl.replace(/[\\s\\0]+$/, '');\n      delete tile.gltfArrayBuffer;\n      delete tile.gltfByteOffset;\n      delete tile.gltfByteLength;\n      break;\n    case GLTF_FORMAT.EMBEDDED:\n      break;\n    default:\n      throw new Error('b3dm: Illegal glTF format field');\n  }\n}\n"],"mappings":"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"}

package/dist/esm/lib/parsers/helpers/parse-3d-tile-header.js

@@ -0,0 +1,16 @@
+const SIZEOF_UINT32 = 4;
+export function parse3DTileHeaderSync(tile, arrayBuffer) {
+  let byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  const view = new DataView(arrayBuffer);
+  tile.magic = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  tile.version = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  tile.byteLength = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  if (tile.version !== 1) {
+    throw new Error("3D Tile Version ".concat(tile.version, " not supported"));
+  }
+  return byteOffset;
+}
+//# sourceMappingURL=parse-3d-tile-header.js.map

package/dist/esm/lib/parsers/helpers/parse-3d-tile-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-header.js","names":["SIZEOF_UINT32","parse3DTileHeaderSync","tile","arrayBuffer","byteOffset","arguments","length","undefined","view","DataView","magic","getUint32","version","byteLength","Error","concat"],"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-header.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nconst SIZEOF_UINT32 = 4;\n\n/* PARSE FIXED HEADER:\nPopulates\n  magic, // identifies type of tile\n  type, // String version of magic\n  version,\n  byteLength\n */\nexport function parse3DTileHeaderSync(tile, arrayBuffer, byteOffset = 0) {\n  const view = new DataView(arrayBuffer);\n\n  tile.magic = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  tile.version = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  tile.byteLength = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  // TODO - move version check into each tile parser?\n  if (tile.version !== 1) {\n    throw new Error(`3D Tile Version ${tile.version} not supported`);\n  }\n\n  return byteOffset; // Indicates where the parsing ended\n}\n"],"mappings":"AAGA,MAAMA,aAAa,GAAG,CAAC;AASvB,OAAO,SAASC,qBAAqBA,CAACC,IAAI,EAAEC,WAAW,EAAkB;EAAA,IAAhBC,UAAU,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EACrE,MAAMG,IAAI,GAAG,IAAIC,QAAQ,CAACN,WAAW,CAAC;EAEtCD,IAAI,CAACQ,KAAK,GAAGF,IAAI,CAACG,SAAS,CAACP,UAAU,EAAE,IAAI,CAAC;EAC7CA,UAAU,IAAIJ,aAAa;EAE3BE,IAAI,CAACU,OAAO,GAAGJ,IAAI,CAACG,SAAS,CAACP,UAAU,EAAE,IAAI,CAAC;EAC/CA,UAAU,IAAIJ,aAAa;EAE3BE,IAAI,CAACW,UAAU,GAAGL,IAAI,CAACG,SAAS,CAACP,UAAU,EAAE,IAAI,CAAC;EAClDA,UAAU,IAAIJ,aAAa;EAG3B,IAAIE,IAAI,CAACU,OAAO,KAAK,CAAC,EAAE;IACtB,MAAM,IAAIE,KAAK,oBAAAC,MAAA,CAAoBb,IAAI,CAACU,OAAO,mBAAgB,CAAC;EAClE;EAEA,OAAOR,UAAU;AACnB"}

package/dist/esm/lib/parsers/helpers/parse-3d-tile-subtree.js

@@ -0,0 +1,67 @@
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+export default async function parse3DTilesSubtree(data, options, context) {
+  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;
+}
+function resolveBufferUri(bitstreamRelativeUri, basePath) {
+  const hasProtocol = basePath.startsWith('http');
+  if (hasProtocol) {
+    const resolvedUri = new URL(bitstreamRelativeUri, basePath);
+    return decodeURI(resolvedUri.toString());
+  }
+  const basePathWithProtocol = "http://".concat(basePath);
+  const resolvedUri = new URL(bitstreamRelativeUri, basePathWithProtocol);
+  return "/".concat(resolvedUri.host).concat(resolvedUri.pathname);
+}
+async function getExplicitBitstream(subtree, name, internalBinaryBuffer, context) {
+  const bufferViewIndex = subtree[name].bufferView;
+  const bufferView = subtree.bufferViews[bufferViewIndex];
+  const buffer = subtree.buffers[bufferView.buffer];
+  if (!(context !== null && context !== void 0 && context.url) || !context.fetch) {
+    throw new Error('Url is not provided');
+  }
+  if (!context.fetch) {
+    throw new Error('fetch is not provided');
+  }
+  if (buffer.uri) {
+    const bufferUri = resolveBufferUri(buffer.uri, context === null || context === void 0 ? void 0 : context.url);
+    const response = await context.fetch(bufferUri);
+    const data = await response.arrayBuffer();
+    return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+  }
+  return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+function parseUint64Value(buffer) {
+  const dataView = new DataView(buffer);
+  const left = dataView.getUint32(0, true);
+  const right = dataView.getUint32(4, true);
+  return left + 2 ** 32 * right;
+}
+//# sourceMappingURL=parse-3d-tile-subtree.js.map

package/dist/esm/lib/parsers/helpers/parse-3d-tile-subtree.js.map

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

package/dist/esm/lib/parsers/helpers/parse-3d-tile-tables.js

@@ -0,0 +1,80 @@
+import { getStringFromArrayBuffer } from './parse-utils';
+const SIZEOF_UINT32 = 4;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
+export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {
+  const view = new DataView(arrayBuffer);
+  let batchLength;
+  tile.header = tile.header || {};
+  let featureTableJsonByteLength = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  let featureTableBinaryByteLength = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  let batchTableJsonByteLength = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  let batchTableBinaryByteLength = view.getUint32(byteOffset, true);
+  byteOffset += SIZEOF_UINT32;
+  if (batchTableJsonByteLength >= 570425344) {
+    byteOffset -= SIZEOF_UINT32 * 2;
+    batchLength = featureTableJsonByteLength;
+    batchTableJsonByteLength = featureTableBinaryByteLength;
+    batchTableBinaryByteLength = 0;
+    featureTableJsonByteLength = 0;
+    featureTableBinaryByteLength = 0;
+    console.warn(DEPRECATION_WARNING);
+  } else if (batchTableBinaryByteLength >= 570425344) {
+    byteOffset -= SIZEOF_UINT32;
+    batchLength = batchTableJsonByteLength;
+    batchTableJsonByteLength = featureTableJsonByteLength;
+    batchTableBinaryByteLength = featureTableBinaryByteLength;
+    featureTableJsonByteLength = 0;
+    featureTableBinaryByteLength = 0;
+    console.warn(DEPRECATION_WARNING);
+  }
+  tile.header.featureTableJsonByteLength = featureTableJsonByteLength;
+  tile.header.featureTableBinaryByteLength = featureTableBinaryByteLength;
+  tile.header.batchTableJsonByteLength = batchTableJsonByteLength;
+  tile.header.batchTableBinaryByteLength = batchTableBinaryByteLength;
+  tile.header.batchLength = batchLength;
+  return byteOffset;
+}
+export function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {
+  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;
+  tile.featureTableJson = {
+    BATCH_LENGTH: batchLength || 0
+  };
+  if (featureTableJsonByteLength > 0) {
+    const featureTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, featureTableJsonByteLength);
+    tile.featureTableJson = JSON.parse(featureTableString);
+  }
+  byteOffset += featureTableJsonByteLength;
+  tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
+  byteOffset += featureTableBinaryByteLength;
+  return byteOffset;
+}
+function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
+  const {
+    batchTableJsonByteLength,
+    batchTableBinaryByteLength
+  } = tile.header;
+  if (batchTableJsonByteLength > 0) {
+    const batchTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, batchTableJsonByteLength);
+    tile.batchTableJson = JSON.parse(batchTableString);
+    byteOffset += batchTableJsonByteLength;
+    if (batchTableBinaryByteLength > 0) {
+      tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);
+      tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);
+      byteOffset += batchTableBinaryByteLength;
+    }
+  }
+  return byteOffset;
+}
+//# sourceMappingURL=parse-3d-tile-tables.js.map

package/dist/esm/lib/parsers/helpers/parse-3d-tile-tables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-tables.js","names":["getStringFromArrayBuffer","SIZEOF_UINT32","DEPRECATION_WARNING","parse3DTileTablesHeaderSync","tile","arrayBuffer","byteOffset","view","DataView","batchLength","header","featureTableJsonByteLength","getUint32","featureTableBinaryByteLength","batchTableJsonByteLength","batchTableBinaryByteLength","console","warn","parse3DTileTablesSync","options","parse3DTileFeatureTable","parse3DTileBatchTable","featureTableJson","BATCH_LENGTH","featureTableString","JSON","parse","featureTableBinary","Uint8Array","batchTableString","batchTableJson","batchTableBinary"],"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-tables.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {getStringFromArrayBuffer} from './parse-utils';\n\nconst SIZEOF_UINT32 = 4;\nconst DEPRECATION_WARNING = 'b3dm tile in legacy format.';\n\n// eslint-disable-next-line max-statements\nexport function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {\n  const view = new DataView(arrayBuffer);\n  let batchLength;\n\n  tile.header = tile.header || {};\n\n  let featureTableJsonByteLength = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  let featureTableBinaryByteLength = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  let batchTableJsonByteLength = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  let batchTableBinaryByteLength = view.getUint32(byteOffset, true);\n  byteOffset += SIZEOF_UINT32;\n\n  // First legacy header format - [batchLength] [batchTableByteLength] ('batchTableJsonByteLength': JSON starts with a quotation mark or the glTF magic)\n  // Second legacy format - [batchTableJsonByteLength] [batchTableBinaryByteLength] [batchLength] (Second legacy format is similar as first but here we check 'batchTableBinaryByteLength' instead)\n  // Current header format - [featureTableJsonByteLength] [featureTableBinaryByteLength] [batchTableJsonByteLength] [batchTableBinaryByteLength]\n  // First byte will be 0x22 or 0x67. The minimum uint32 expected is 0x22000000 = 570425344 = 570MB.\n  if (batchTableJsonByteLength >= 570425344) {\n    byteOffset -= SIZEOF_UINT32 * 2;\n    batchLength = featureTableJsonByteLength;\n    batchTableJsonByteLength = featureTableBinaryByteLength;\n    batchTableBinaryByteLength = 0;\n    featureTableJsonByteLength = 0;\n    featureTableBinaryByteLength = 0;\n\n    console.warn(DEPRECATION_WARNING); // eslint-disable-line\n  } else if (batchTableBinaryByteLength >= 570425344) {\n    byteOffset -= SIZEOF_UINT32;\n    batchLength = batchTableJsonByteLength;\n    batchTableJsonByteLength = featureTableJsonByteLength;\n    batchTableBinaryByteLength = featureTableBinaryByteLength;\n    featureTableJsonByteLength = 0;\n    featureTableBinaryByteLength = 0;\n\n    console.warn(DEPRECATION_WARNING); // eslint-disable-line\n  }\n\n  tile.header.featureTableJsonByteLength = featureTableJsonByteLength;\n  tile.header.featureTableBinaryByteLength = featureTableBinaryByteLength;\n  tile.header.batchTableJsonByteLength = batchTableJsonByteLength;\n  tile.header.batchTableBinaryByteLength = batchTableBinaryByteLength;\n  tile.header.batchLength = batchLength;\n\n  return byteOffset;\n}\n\nexport function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {\n  byteOffset = parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options);\n  byteOffset = parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options);\n  return byteOffset;\n}\n\nfunction parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {\n  const {featureTableJsonByteLength, featureTableBinaryByteLength, batchLength} = tile.header;\n\n  tile.featureTableJson = {\n    BATCH_LENGTH: batchLength || 0\n  };\n\n  if (featureTableJsonByteLength > 0) {\n    const featureTableString = getStringFromArrayBuffer(\n      arrayBuffer,\n      byteOffset,\n      featureTableJsonByteLength\n    );\n    tile.featureTableJson = JSON.parse(featureTableString);\n  }\n  byteOffset += featureTableJsonByteLength;\n\n  tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);\n  byteOffset += featureTableBinaryByteLength;\n\n  /*\n  const featureTable = parseFeatureTable(featureTableJson, featureTableBinary);\n\n  const batchLength = featureTable.getGlobalProperty('BATCH_LENGTH');\n  featureTable.featuresLength = batchLength;\n  */\n\n  return byteOffset;\n}\n\nfunction parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {\n  const {batchTableJsonByteLength, batchTableBinaryByteLength} = tile.header;\n\n  if (batchTableJsonByteLength > 0) {\n    const batchTableString = getStringFromArrayBuffer(\n      arrayBuffer,\n      byteOffset,\n      batchTableJsonByteLength\n    );\n    tile.batchTableJson = JSON.parse(batchTableString);\n    byteOffset += batchTableJsonByteLength;\n\n    if (batchTableBinaryByteLength > 0) {\n      // Has a batch table binary\n      tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);\n      // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed\n      tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);\n\n      byteOffset += batchTableBinaryByteLength;\n    }\n  }\n\n  return byteOffset;\n}\n"],"mappings":"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"}

package/dist/esm/lib/parsers/helpers/parse-utils.js

@@ -0,0 +1,20 @@
+import { assert } from '@loaders.gl/loader-utils';
+export function getStringFromArrayBuffer(arrayBuffer, byteOffset, byteLength) {
+  assert(arrayBuffer instanceof ArrayBuffer);
+  const textDecoder = new TextDecoder('utf8');
+  const typedArray = new Uint8Array(arrayBuffer, byteOffset, byteLength);
+  const string = textDecoder.decode(typedArray);
+  return string;
+}
+export function getStringFromTypedArray(typedArray) {
+  assert(ArrayBuffer.isView(typedArray));
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(typedArray);
+  return string;
+}
+export function getMagicString(arrayBuffer) {
+  let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  const dataView = new DataView(arrayBuffer);
+  return "".concat(String.fromCharCode(dataView.getUint8(byteOffset + 0))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 1))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 2))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 3)));
+}
+//# sourceMappingURL=parse-utils.js.map

package/dist/esm/lib/parsers/helpers/parse-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-utils.js","names":["assert","getStringFromArrayBuffer","arrayBuffer","byteOffset","byteLength","ArrayBuffer","textDecoder","TextDecoder","typedArray","Uint8Array","string","decode","getStringFromTypedArray","isView","getMagicString","arguments","length","undefined","dataView","DataView","concat","String","fromCharCode","getUint8"],"sources":["../../../../../src/lib/parsers/helpers/parse-utils.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {assert} from '@loaders.gl/loader-utils';\n\n// Decode the JSON binary array into clear text\nexport function getStringFromArrayBuffer(arrayBuffer, byteOffset, byteLength) {\n  assert(arrayBuffer instanceof ArrayBuffer);\n  const textDecoder = new TextDecoder('utf8');\n  const typedArray = new Uint8Array(arrayBuffer, byteOffset, byteLength);\n  const string = textDecoder.decode(typedArray);\n  return string;\n}\n\n// Decode the JSON binary array into clear text\nexport function getStringFromTypedArray(typedArray) {\n  assert(ArrayBuffer.isView(typedArray));\n  const textDecoder = new TextDecoder('utf8');\n  const string = textDecoder.decode(typedArray);\n  return string;\n}\n\nexport function getMagicString(arrayBuffer, byteOffset = 0) {\n  const dataView = new DataView(arrayBuffer);\n  return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n"],"mappings":"AAGA,SAAQA,MAAM,QAAO,0BAA0B;AAG/C,OAAO,SAASC,wBAAwBA,CAACC,WAAW,EAAEC,UAAU,EAAEC,UAAU,EAAE;EAC5EJ,MAAM,CAACE,WAAW,YAAYG,WAAW,CAAC;EAC1C,MAAMC,WAAW,GAAG,IAAIC,WAAW,CAAC,MAAM,CAAC;EAC3C,MAAMC,UAAU,GAAG,IAAIC,UAAU,CAACP,WAAW,EAAEC,UAAU,EAAEC,UAAU,CAAC;EACtE,MAAMM,MAAM,GAAGJ,WAAW,CAACK,MAAM,CAACH,UAAU,CAAC;EAC7C,OAAOE,MAAM;AACf;AAGA,OAAO,SAASE,uBAAuBA,CAACJ,UAAU,EAAE;EAClDR,MAAM,CAACK,WAAW,CAACQ,MAAM,CAACL,UAAU,CAAC,CAAC;EACtC,MAAMF,WAAW,GAAG,IAAIC,WAAW,CAAC,MAAM,CAAC;EAC3C,MAAMG,MAAM,GAAGJ,WAAW,CAACK,MAAM,CAACH,UAAU,CAAC;EAC7C,OAAOE,MAAM;AACf;AAEA,OAAO,SAASI,cAAcA,CAACZ,WAAW,EAAkB;EAAA,IAAhBC,UAAU,GAAAY,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EACxD,MAAMG,QAAQ,GAAG,IAAIC,QAAQ,CAACjB,WAAW,CAAC;EAC1C,UAAAkB,MAAA,CACAC,MAAM,CAACC,YAAY,CAACJ,QAAQ,CAACK,QAAQ,CAACpB,UAAU,GAAG,CAAC,CAAC,CAAC,EAAAiB,MAAA,CACtDC,MAAM,CAACC,YAAY,CAACJ,QAAQ,CAACK,QAAQ,CAACpB,UAAU,GAAG,CAAC,CAAC,CAAC,EAAAiB,MAAA,CACtDC,MAAM,CAACC,YAAY,CAACJ,QAAQ,CAACK,QAAQ,CAACpB,UAAU,GAAG,CAAC,CAAC,CAAC,EAAAiB,MAAA,CACtDC,MAAM,CAACC,YAAY,CAACJ,QAAQ,CAACK,QAAQ,CAACpB,UAAU,GAAG,CAAC,CAAC,CAAC;AACxD"}

package/dist/esm/lib/parsers/parse-3d-tile-batched-model.js

@@ -0,0 +1,25 @@
+import { GL } from '@loaders.gl/math';
+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) {
+  var _tile$gltf;
+  byteOffset = parseBatchedModel(tile, arrayBuffer, byteOffset, options, context);
+  await extractGLTF(tile, GLTF_FORMAT.EMBEDDED, options, context);
+  const extensions = tile === null || tile === void 0 ? void 0 : (_tile$gltf = tile.gltf) === null || _tile$gltf === void 0 ? void 0 : _tile$gltf.extensions;
+  if (extensions && extensions.CESIUM_RTC) {
+    tile.rtcCenter = extensions.CESIUM_RTC.center;
+  }
+  return byteOffset;
+}
+function parseBatchedModel(tile, arrayBuffer, byteOffset, options, context) {
+  byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
+  byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);
+  byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
+  byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);
+  const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
+  tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);
+  return byteOffset;
+}
+//# sourceMappingURL=parse-3d-tile-batched-model.js.map