@loaders.gl/3d-tiles 3.1.0-beta.7 → 3.1.3

package/dist/es5/lib/parsers/helpers/normalize-3d-tile-positions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"names":["normalize3DTilePositionAttribute","tile","positions","options","isQuantized","decodeQuantizedPositions","type","GL","UNSIGNED_SHORT","value","size","normalized","scratchPosition","Vector3","decodedArray","Float32Array","pointCount","i","set","scale","quantizedRange","multiply","quantizedVolumeScale","add","quantizedVolumeOffset","toArray"],"mappings":";;;;;;;AAAA;;AACA;;AAGO,SAASA,gCAAT,CAA0CC,IAA1C,EAAgDC,SAAhD,EAA2DC,OAA3D,EAAoE;AACzE,MAAI,CAACF,IAAI,CAACG,WAAV,EAAuB;AACrB,WAAOF,SAAP;AACD;;AAMD,MAAIC,OAAO,CAAC,UAAD,CAAP,IAAuBA,OAAO,CAAC,UAAD,CAAP,CAAoBE,wBAA/C,EAAyE;AACvEJ,IAAAA,IAAI,CAACG,WAAL,GAAmB,KAAnB;AACA,WAAOC,wBAAwB,CAACJ,IAAD,EAAOC,SAAP,CAA/B;AACD;;AAID,SAAO;AACLI,IAAAA,IAAI,EAAEC,SAAGC,cADJ;AAELC,IAAAA,KAAK,EAAEP,SAFF;AAGLQ,IAAAA,IAAI,EAAE,CAHD;AAILC,IAAAA,UAAU,EAAE;AAJP,GAAP;AAMD;;AAGD,SAASN,wBAAT,CAAkCJ,IAAlC,EAAwCC,SAAxC,EAAmD;AACjD,QAAMU,eAAe,GAAG,IAAIC,aAAJ,EAAxB;AACA,QAAMC,YAAY,GAAG,IAAIC,YAAJ,CAAiBd,IAAI,CAACe,UAAL,GAAkB,CAAnC,CAArB;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGhB,IAAI,CAACe,UAAzB,EAAqCC,CAAC,EAAtC,EAA0C;AAExCL,IAAAA,eAAe,CACZM,GADH,CACOhB,SAAS,CAACe,CAAC,GAAG,CAAL,CADhB,EACyBf,SAAS,CAACe,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADlC,EAC+Cf,SAAS,CAACe,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADxD,EAEGE,KAFH,CAES,IAAIlB,IAAI,CAACmB,cAFlB,EAGGC,QAHH,CAGYpB,IAAI,CAACqB,oBAHjB,EAIGC,GAJH,CAIOtB,IAAI,CAACuB,qBAJZ,EAKGC,OALH,CAKWX,YALX,EAKyBG,CAAC,GAAG,CAL7B;AAMD;;AAED,SAAOH,YAAP;AACD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n  if (!tile.isQuantized) {\n    return positions;\n  }\n\n  // For quantized posititions, either expand to Float32Array or return custom accessor\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n  // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n    tile.isQuantized = false;\n    return decodeQuantizedPositions(tile, positions);\n  }\n\n  // Default: Use normalized shorts directly, no copying/processing.\n  // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n  return {\n    type: GL.UNSIGNED_SHORT,\n    value: positions,\n    size: 3,\n    normalized: true\n  };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n  const scratchPosition = new Vector3();\n  const decodedArray = new Float32Array(tile.pointCount * 3);\n\n  for (let i = 0; i < tile.pointCount; i++) {\n    // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n    scratchPosition\n      .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n      .scale(1 / tile.quantizedRange)\n      .multiply(tile.quantizedVolumeScale)\n      .add(tile.quantizedVolumeOffset)\n      .toArray(decodedArray, i * 3);\n  }\n\n  return decodedArray;\n}\n"],"file":"normalize-3d-tile-positions.js"}
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"names":["normalize3DTilePositionAttribute","tile","positions","options","isQuantized","decodeQuantizedPositions","type","GL","UNSIGNED_SHORT","value","size","normalized","scratchPosition","Vector3","decodedArray","Float32Array","pointCount","i","set","scale","quantizedRange","multiply","quantizedVolumeScale","add","quantizedVolumeOffset","toArray"],"mappings":";;;;;;;AAAA;;AACA;;AAGO,SAASA,gCAAT,CAA0CC,IAA1C,EAAgDC,SAAhD,EAA2DC,OAA3D,EAAoE;AACzE,MAAI,CAACF,IAAI,CAACG,WAAV,EAAuB;AACrB,WAAOF,SAAP;AACD;;AAMD,MAAIC,OAAO,CAAC,UAAD,CAAP,IAAuBA,OAAO,CAAC,UAAD,CAAP,CAAoBE,wBAA/C,EAAyE;AACvEJ,IAAAA,IAAI,CAACG,WAAL,GAAmB,KAAnB;AACA,WAAOC,wBAAwB,CAACJ,IAAD,EAAOC,SAAP,CAA/B;AACD;;AAID,SAAO;AACLI,IAAAA,IAAI,EAAEC,SAAGC,cADJ;AAELC,IAAAA,KAAK,EAAEP,SAFF;AAGLQ,IAAAA,IAAI,EAAE,CAHD;AAILC,IAAAA,UAAU,EAAE;AAJP,GAAP;AAMD;;AAGD,SAASN,wBAAT,CAAkCJ,IAAlC,EAAwCC,SAAxC,EAAmD;AACjD,MAAMU,eAAe,GAAG,IAAIC,aAAJ,EAAxB;AACA,MAAMC,YAAY,GAAG,IAAIC,YAAJ,CAAiBd,IAAI,CAACe,UAAL,GAAkB,CAAnC,CAArB;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGhB,IAAI,CAACe,UAAzB,EAAqCC,CAAC,EAAtC,EAA0C;AAExCL,IAAAA,eAAe,CACZM,GADH,CACOhB,SAAS,CAACe,CAAC,GAAG,CAAL,CADhB,EACyBf,SAAS,CAACe,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADlC,EAC+Cf,SAAS,CAACe,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADxD,EAEGE,KAFH,CAES,IAAIlB,IAAI,CAACmB,cAFlB,EAGGC,QAHH,CAGYpB,IAAI,CAACqB,oBAHjB,EAIGC,GAJH,CAIOtB,IAAI,CAACuB,qBAJZ,EAKGC,OALH,CAKWX,YALX,EAKyBG,CAAC,GAAG,CAL7B;AAMD;;AAED,SAAOH,YAAP;AACD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n  if (!tile.isQuantized) {\n    return positions;\n  }\n\n  // For quantized posititions, either expand to Float32Array or return custom accessor\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n  // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n    tile.isQuantized = false;\n    return decodeQuantizedPositions(tile, positions);\n  }\n\n  // Default: Use normalized shorts directly, no copying/processing.\n  // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n  return {\n    type: GL.UNSIGNED_SHORT,\n    value: positions,\n    size: 3,\n    normalized: true\n  };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n  const scratchPosition = new Vector3();\n  const decodedArray = new Float32Array(tile.pointCount * 3);\n\n  for (let i = 0; i < tile.pointCount; i++) {\n    // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n    scratchPosition\n      .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n      .scale(1 / tile.quantizedRange)\n      .multiply(tile.quantizedVolumeScale)\n      .add(tile.quantizedVolumeOffset)\n      .toArray(decodedArray, i * 3);\n  }\n\n  return decodedArray;\n}\n"],"file":"normalize-3d-tile-positions.js"}

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

@@ -0,0 +1,270 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseImplicitTiles = parseImplicitTiles;
+exports.replaceContentUrlTemplate = replaceContentUrlTemplate;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _tile3dSubtreeLoader = require("../../../tile-3d-subtree-loader");
+
+var _core = require("@loaders.gl/core");
+
+var QUADTREE_DEVISION_COUNT = 4;
+var OCTREE_DEVISION_COUNT = 8;
+var SUBDIVISION_COUNT_MAP = {
+  QUADTREE: QUADTREE_DEVISION_COUNT,
+  OCTREE: OCTREE_DEVISION_COUNT
+};
+
+function parseImplicitTiles(_x, _x2) {
+  return _parseImplicitTiles.apply(this, arguments);
+}
+
+function _parseImplicitTiles() {
+  _parseImplicitTiles = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(subtree, options) {
+    var parentData,
+        childIndex,
+        level,
+        globalData,
+        subdivisionScheme,
+        subtreeLevels,
+        maximumLevel,
+        contentUrlTemplate,
+        subtreesUriTemplate,
+        basePath,
+        tile,
+        childrenPerTile,
+        childX,
+        childY,
+        childZ,
+        levelOffset,
+        childTileMortonIndex,
+        tileAvailabilityIndex,
+        childTileX,
+        childTileY,
+        childTileZ,
+        isChildSubtreeAvailable,
+        x,
+        y,
+        z,
+        lev,
+        subtreePath,
+        childSubtreeUrl,
+        childSubtree,
+        isTileAvailable,
+        isContentAvailable,
+        childTileLevel,
+        pData,
+        index,
+        currentTile,
+        globalLevel,
+        formattedTile,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            parentData = _args.length > 2 && _args[2] !== undefined ? _args[2] : {
+              mortonIndex: 0,
+              x: 0,
+              y: 0,
+              z: 0
+            };
+            childIndex = _args.length > 3 && _args[3] !== undefined ? _args[3] : 0;
+            level = _args.length > 4 && _args[4] !== undefined ? _args[4] : 0;
+            globalData = _args.length > 5 && _args[5] !== undefined ? _args[5] : {
+              level: 0,
+              mortonIndex: 0,
+              x: 0,
+              y: 0,
+              z: 0
+            };
+            subdivisionScheme = options.subdivisionScheme, subtreeLevels = options.subtreeLevels, maximumLevel = options.maximumLevel, contentUrlTemplate = options.contentUrlTemplate, subtreesUriTemplate = options.subtreesUriTemplate, basePath = options.basePath;
+            tile = {
+              children: [],
+              lodMetricValue: 0,
+              contentUrl: ''
+            };
+            childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+            childX = childIndex & 1;
+            childY = childIndex >> 1 & 1;
+            childZ = childIndex >> 2 & 1;
+            levelOffset = (Math.pow(childrenPerTile, level) - 1) / (childrenPerTile - 1);
+            childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+            tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+            childTileX = concatBits(parentData.x, childX);
+            childTileY = concatBits(parentData.y, childY);
+            childTileZ = concatBits(parentData.z, childZ);
+            isChildSubtreeAvailable = false;
+
+            if (level + 1 > subtreeLevels) {
+              isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
+            }
+
+            x = concatBits(globalData.x, childTileX);
+            y = concatBits(globalData.y, childTileY);
+            z = concatBits(globalData.z, childTileZ);
+            lev = level + globalData.level;
+
+            if (!isChildSubtreeAvailable) {
+              _context.next = 40;
+              break;
+            }
+
+            subtreePath = "".concat(basePath, "/").concat(subtreesUriTemplate);
+            childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+            _context.next = 27;
+            return (0, _core.load)(childSubtreeUrl, _tile3dSubtreeLoader.Tile3DSubtreeLoader);
+
+          case 27:
+            childSubtree = _context.sent;
+            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;
+
+          case 40:
+            isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+
+            if (!(!isTileAvailable || level > maximumLevel)) {
+              _context.next = 43;
+              break;
+            }
+
+            return _context.abrupt("return", tile);
+
+          case 43:
+            isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+
+            if (isContentAvailable) {
+              tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+            }
+
+            childTileLevel = level + 1;
+            pData = {
+              mortonIndex: childTileMortonIndex,
+              x: childTileX,
+              y: childTileY,
+              z: childTileZ
+            };
+            index = 0;
+
+          case 48:
+            if (!(index < childrenPerTile)) {
+              _context.next = 56;
+              break;
+            }
+
+            _context.next = 51;
+            return parseImplicitTiles(subtree, options, pData, index, childTileLevel, globalData);
+
+          case 51:
+            currentTile = _context.sent;
+
+            if (currentTile.contentUrl || currentTile.children.length) {
+              globalLevel = lev + 1;
+              formattedTile = formatTileData(currentTile, globalLevel, options);
+              tile.children.push(formattedTile);
+            }
+
+          case 53:
+            index++;
+            _context.next = 48;
+            break;
+
+          case 56:
+            return _context.abrupt("return", tile);
+
+          case 57:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _parseImplicitTiles.apply(this, arguments);
+}
+
+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, options) {
+  var basePath = options.basePath,
+      refine = options.refine,
+      getRefine = options.getRefine,
+      lodMetricType = options.lodMetricType,
+      getTileType = options.getTileType,
+      rootLodMetricValue = options.rootLodMetricValue;
+  var uri = tile.contentUrl && tile.contentUrl.replace("".concat(basePath, "/"), '');
+  var lodMetricValue = rootLodMetricValue / Math.pow(2, level);
+  return {
+    children: tile.children,
+    contentUrl: tile.contentUrl,
+    content: {
+      uri: uri
+    },
+    id: tile.contentUrl,
+    refine: getRefine(refine),
+    type: getTileType(tile),
+    lodMetricType: lodMetricType,
+    lodMetricValue: lodMetricValue
+  };
+}
+
+function concatBits(first, second) {
+  return parseInt(first.toString(2) + second.toString(2), 2);
+}
+
+function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
+  var mapUrl = generateMapUrl({
+    level: level,
+    x: x,
+    y: y,
+    z: z
+  });
+  return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, function (matched) {
+    return mapUrl[matched];
+  });
+}
+
+function generateMapUrl(items) {
+  var mapUrl = {};
+
+  for (var _key in items) {
+    mapUrl["{".concat(_key, "}")] = items[_key];
+  }
+
+  return mapUrl;
+}
+
+function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
+  var byteIndex = Math.floor(availabilityIndex / 8);
+  var bitIndex = availabilityIndex % 8;
+  var bitValue = availabilityBuffer[byteIndex] >> bitIndex & 1;
+  return bitValue === 1;
+}
+//# sourceMappingURL=parse-3d-implicit-tiles.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"],"names":["QUADTREE_DEVISION_COUNT","OCTREE_DEVISION_COUNT","SUBDIVISION_COUNT_MAP","QUADTREE","OCTREE","parseImplicitTiles","subtree","options","parentData","mortonIndex","x","y","z","childIndex","level","globalData","subdivisionScheme","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","childSubtreeUrl","replaceContentUrlTemplate","Tile3DSubtreeLoader","childSubtree","isTileAvailable","tileAvailability","isContentAvailable","contentAvailability","childTileLevel","pData","index","currentTile","length","globalLevel","formattedTile","formatTileData","push","availabilityData","Boolean","constant","explicitBitstream","getBooleanValueFromBitstream","refine","getRefine","lodMetricType","getTileType","rootLodMetricValue","uri","replace","content","id","type","first","second","parseInt","toString","templateUrl","mapUrl","generateMapUrl","matched","items","key","availabilityIndex","availabilityBuffer","byteIndex","Math","floor","bitIndex","bitValue"],"mappings":"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","sourcesContent":["import type {Availability, Subtree} from '../../../types';\nimport {Tile3DSubtreeLoader} from '../../../tile-3d-subtree-loader';\nimport {load} from '@loaders.gl/core';\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 * 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-params\n// eslint-disable-next-line max-statements\nexport async function parseImplicitTiles(\n  subtree: Subtree,\n  options: any,\n  parentData: {mortonIndex: number; x: number; y: number; z: number} = {\n    mortonIndex: 0,\n    x: 0,\n    y: 0,\n    z: 0\n  },\n  childIndex: number = 0,\n  level: number = 0,\n  globalData: {level: number; mortonIndex: number; x: number; y: number; z: number} = {\n    level: 0,\n    mortonIndex: 0,\n    x: 0,\n    y: 0,\n    z: 0\n  }\n) {\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  // TODO Remove after real implicit tileset will be tested.\n  // Degug data\n  // tile.level = level + globalData.level;\n  // tile.x = concatBits(globalData.x, childTileX);\n  // tile.y = concatBits(globalData.y, childTileY);\n  // tile.z = concatBits(globalData.z, childTileZ);\n  // tile.mortonIndex = childTileMortonIndex;\n  // End of debug data\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 currentTile = await parseImplicitTiles(\n      subtree,\n      options,\n      pData,\n      index,\n      childTileLevel,\n      globalData\n    );\n\n    if (currentTile.contentUrl || currentTile.children.length) {\n      const globalLevel = lev + 1;\n      const formattedTile = formatTileData(currentTile, globalLevel, options);\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(tile, level: number, options: any) {\n  const {basePath, refine, getRefine, lodMetricType, getTileType, rootLodMetricValue} = options;\n  const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');\n  const lodMetricValue = rootLodMetricValue / 2 ** level;\n  // TODO handle bounding volume\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    // Temp debug values. Remove when real implicit tileset will be tested.\n    // x: tile.x,\n    // y: tile.y,\n    // z: tile.z,\n    // level: tile.level\n  };\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"],"file":"parse-3d-implicit-tiles.js"}

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

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,11 +9,15 @@ exports.parse3DTileGLTFViewSync = parse3DTileGLTFViewSync;
 exports.extractGLTF = extractGLTF;
 exports.GLTF_FORMAT = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _gltf = require("@loaders.gl/gltf");
 
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
-const GLTF_FORMAT = {
+var GLTF_FORMAT = {
   URI: 0,
   EMBEDDED: 1
 };
@@ -19,7 +25,7 @@ exports.GLTF_FORMAT = GLTF_FORMAT;
 
 function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
   tile.rotateYtoZ = true;
-  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+  var gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
 
   if (gltfByteLength === 0) {
     throw new Error('glTF byte length must be greater than 0.');
@@ -37,36 +43,70 @@ function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
   return tile.byteOffset + tile.byteLength;
 }
 
-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;
-    }
+function extractGLTF(_x, _x2, _x3, _x4) {
+  return _extractGLTF.apply(this, arguments);
+}
 
-    if (tile.gltfArrayBuffer) {
-      tile.gltf = await parse(tile.gltfArrayBuffer, _gltf.GLTFLoader, options, context);
-      delete tile.gltfArrayBuffer;
-      delete tile.gltfByteOffset;
-      delete tile.gltfByteLength;
-    }
-  }
+function _extractGLTF() {
+  _extractGLTF = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tile, gltfFormat, options, context) {
+    var tile3DOptions, parse, fetch;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            tile3DOptions = options['3d-tiles'] || {};
+            extractGLTFBufferOrURL(tile, gltfFormat, options);
+
+            if (!tile3DOptions.loadGLTF) {
+              _context.next = 16;
+              break;
+            }
+
+            parse = context.parse, fetch = context.fetch;
+
+            if (!tile.gltfUrl) {
+              _context.next = 9;
+              break;
+            }
+
+            _context.next = 7;
+            return fetch(tile.gltfUrl, options);
+
+          case 7:
+            tile.gltfArrayBuffer = _context.sent;
+            tile.gltfByteOffset = 0;
+
+          case 9:
+            if (!tile.gltfArrayBuffer) {
+              _context.next = 16;
+              break;
+            }
+
+            _context.next = 12;
+            return parse(tile.gltfArrayBuffer, _gltf.GLTFLoader, options, context);
+
+          case 12:
+            tile.gltf = _context.sent;
+            delete tile.gltfArrayBuffer;
+            delete tile.gltfByteOffset;
+            delete tile.gltfByteLength;
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _extractGLTF.apply(this, arguments);
 }
 
 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);
+      var gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+      var textDecoder = new TextDecoder();
+      var gltfUrl = textDecoder.decode(gltfUrlBytes);
       tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, '');
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"names":["GLTF_FORMAT","URI","EMBEDDED","parse3DTileGLTFViewSync","tile","arrayBuffer","byteOffset","options","rotateYtoZ","gltfByteLength","byteLength","Error","gltfUpAxis","assetGltfUpAxis","gltfArrayBuffer","gltfByteOffset","console","warn","type","extractGLTF","gltfFormat","context","tile3DOptions","extractGLTFBufferOrURL","loadGLTF","parse","fetch","gltfUrl","gltf","GLTFLoader","gltfUrlBytes","Uint8Array","textDecoder","TextDecoder","decode","replace"],"mappings":"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","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"],"file":"parse-3d-tile-gltf-view.js"}
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"names":["GLTF_FORMAT","URI","EMBEDDED","parse3DTileGLTFViewSync","tile","arrayBuffer","byteOffset","options","rotateYtoZ","gltfByteLength","byteLength","Error","gltfUpAxis","assetGltfUpAxis","gltfArrayBuffer","gltfByteOffset","console","warn","type","extractGLTF","gltfFormat","context","tile3DOptions","extractGLTFBufferOrURL","loadGLTF","parse","fetch","gltfUrl","GLTFLoader","gltf","gltfUrlBytes","Uint8Array","textDecoder","TextDecoder","decode","replace"],"mappings":"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","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"],"file":"parse-3d-tile-gltf-view.js"}

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

@@ -4,10 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parse3DTileHeaderSync = parse3DTileHeaderSync;
-const SIZEOF_UINT32 = 4;
+var SIZEOF_UINT32 = 4;
 
-function parse3DTileHeaderSync(tile, arrayBuffer, byteOffset = 0) {
-  const view = new DataView(arrayBuffer);
+function parse3DTileHeaderSync(tile, arrayBuffer) {
+  var byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var view = new DataView(arrayBuffer);
   tile.magic = view.getUint32(byteOffset, true);
   byteOffset += SIZEOF_UINT32;
   tile.version = view.getUint32(byteOffset, true);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-header.ts"],"names":["SIZEOF_UINT32","parse3DTileHeaderSync","tile","arrayBuffer","byteOffset","view","DataView","magic","getUint32","version","byteLength","Error"],"mappings":";;;;;;AAGA,MAAMA,aAAa,GAAG,CAAtB;;AASO,SAASC,qBAAT,CAA+BC,IAA/B,EAAqCC,WAArC,EAAkDC,UAAU,GAAG,CAA/D,EAAkE;AACvE,QAAMC,IAAI,GAAG,IAAIC,QAAJ,CAAaH,WAAb,CAAb;AAEAD,EAAAA,IAAI,CAACK,KAAL,GAAaF,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAb;AACAA,EAAAA,UAAU,IAAIJ,aAAd;AAEAE,EAAAA,IAAI,CAACO,OAAL,GAAeJ,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAf;AACAA,EAAAA,UAAU,IAAIJ,aAAd;AAEAE,EAAAA,IAAI,CAACQ,UAAL,GAAkBL,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAlB;AACAA,EAAAA,UAAU,IAAIJ,aAAd;;AAGA,MAAIE,IAAI,CAACO,OAAL,KAAiB,CAArB,EAAwB;AACtB,UAAM,IAAIE,KAAJ,2BAA6BT,IAAI,CAACO,OAAlC,oBAAN;AACD;;AAED,SAAOL,UAAP;AACD","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"],"file":"parse-3d-tile-header.js"}
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-header.ts"],"names":["SIZEOF_UINT32","parse3DTileHeaderSync","tile","arrayBuffer","byteOffset","view","DataView","magic","getUint32","version","byteLength","Error"],"mappings":";;;;;;AAGA,IAAMA,aAAa,GAAG,CAAtB;;AASO,SAASC,qBAAT,CAA+BC,IAA/B,EAAqCC,WAArC,EAAkE;AAAA,MAAhBC,UAAgB,uEAAH,CAAG;AACvE,MAAMC,IAAI,GAAG,IAAIC,QAAJ,CAAaH,WAAb,CAAb;AAEAD,EAAAA,IAAI,CAACK,KAAL,GAAaF,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAb;AACAA,EAAAA,UAAU,IAAIJ,aAAd;AAEAE,EAAAA,IAAI,CAACO,OAAL,GAAeJ,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAf;AACAA,EAAAA,UAAU,IAAIJ,aAAd;AAEAE,EAAAA,IAAI,CAACQ,UAAL,GAAkBL,IAAI,CAACG,SAAL,CAAeJ,UAAf,EAA2B,IAA3B,CAAlB;AACAA,EAAAA,UAAU,IAAIJ,aAAd;;AAGA,MAAIE,IAAI,CAACO,OAAL,KAAiB,CAArB,EAAwB;AACtB,UAAM,IAAIE,KAAJ,2BAA6BT,IAAI,CAACO,OAAlC,oBAAN;AACD;;AAED,SAAOL,UAAP;AACD","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"],"file":"parse-3d-tile-header.js"}