@loaders.gl/3d-tiles 3.1.0-alpha.2 → 3.1.0-beta.1

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

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parse3DTilesSubtree;
+
+var _core = require("@loaders.gl/core");
+
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+
+async function parse3DTilesSubtree(data) {
+  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);
+  }
+
+  if ('bufferView' in subtree.contentAvailability) {
+    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'contentAvailability', internalBinaryBuffer);
+  }
+
+  if ('bufferView' in subtree.childSubtreeAvailability) {
+    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, 'childSubtreeAvailability', internalBinaryBuffer);
+  }
+
+  return subtree;
+}
+
+async function getExplicitBitstream(subtree, name, internalBinaryBuffer) {
+  const bufferViewIndex = subtree[name].bufferView;
+  const bufferView = subtree.bufferViews[bufferViewIndex];
+  const buffer = subtree.buffers[bufferView.buffer];
+
+  if (buffer.uri) {
+    const response = await (0, _core.fetchFile)(buffer.uri);
+    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/es5/lib/parsers/helpers/parse-3d-tile-subtree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-subtree.ts"],"names":["SUBTREE_FILE_MAGIC","SUBTREE_FILE_VERSION","parse3DTilesSubtree","data","magic","Uint32Array","slice","Error","version","jsonByteLength","parseUint64Value","stringAttribute","Uint8Array","textDecoder","TextDecoder","string","decode","subtree","JSON","parse","binaryByteLength","internalBinaryBuffer","ArrayBuffer","tileAvailability","explicitBitstream","getExplicitBitstream","contentAvailability","childSubtreeAvailability","name","bufferViewIndex","bufferView","bufferViews","buffer","buffers","uri","response","arrayBuffer","byteOffset","byteLength","dataView","DataView","left","getUint32","right"],"mappings":"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","sourcesContent":["import type {SubtreeAvailability, ExplicitBitstream} from '../../../types';\nimport {fetchFile} from '@loaders.gl/core';\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 */\nexport default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<SubtreeAvailability> {\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    );\n  }\n\n  if ('bufferView' in subtree.contentAvailability) {\n    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(\n      subtree,\n      'contentAvailability',\n      internalBinaryBuffer\n    );\n  }\n\n  if ('bufferView' in subtree.childSubtreeAvailability) {\n    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(\n      subtree,\n      'childSubtreeAvailability',\n      internalBinaryBuffer\n    );\n  }\n\n  return subtree;\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: SubtreeAvailability,\n  name: string,\n  internalBinaryBuffer: ArrayBuffer\n): Promise<ExplicitBitstream> {\n  const bufferViewIndex = subtree[name].bufferView;\n  const bufferView = subtree.bufferViews[bufferViewIndex];\n  const buffer = subtree.buffers[bufferView.buffer];\n\n  // External bitstream loading\n  if (buffer.uri) {\n    const response = await fetchFile(buffer.uri);\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"],"file":"parse-3d-tile-subtree.js"}

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

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parse3DTileTablesHeaderSync = parse3DTileTablesHeaderSync;
+exports.parse3DTileTablesSync = parse3DTileTablesSync;
+
+var _parseUtils = require("./parse-utils");
+
+const SIZEOF_UINT32 = 4;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
+
+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;
+}
+
+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 = (0, _parseUtils.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 = (0, _parseUtils.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/es5/lib/parsers/helpers/parse-3d-tile-tables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-3d-tile-tables.ts"],"names":["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"],"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\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"],"file":"parse-3d-tile-tables.js"}

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStringFromArrayBuffer = getStringFromArrayBuffer;
+exports.getStringFromTypedArray = getStringFromTypedArray;
+exports.getMagicString = getMagicString;
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+function getStringFromArrayBuffer(arrayBuffer, byteOffset, byteLength) {
+  (0, _loaderUtils.assert)(arrayBuffer instanceof ArrayBuffer);
+  const textDecoder = new TextDecoder('utf8');
+  const typedArray = new Uint8Array(arrayBuffer, byteOffset, byteLength);
+  const string = textDecoder.decode(typedArray);
+  return string;
+}
+
+function getStringFromTypedArray(typedArray) {
+  (0, _loaderUtils.assert)(ArrayBuffer.isView(typedArray));
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(typedArray);
+  return string;
+}
+
+function getMagicString(arrayBuffer, byteOffset = 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/es5/lib/parsers/helpers/parse-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/parsers/helpers/parse-utils.ts"],"names":["getStringFromArrayBuffer","arrayBuffer","byteOffset","byteLength","ArrayBuffer","textDecoder","TextDecoder","typedArray","Uint8Array","string","decode","getStringFromTypedArray","isView","getMagicString","dataView","DataView","String","fromCharCode","getUint8"],"mappings":";;;;;;;;;AAGA;;AAGO,SAASA,wBAAT,CAAkCC,WAAlC,EAA+CC,UAA/C,EAA2DC,UAA3D,EAAuE;AAC5E,2BAAOF,WAAW,YAAYG,WAA9B;AACA,QAAMC,WAAW,GAAG,IAAIC,WAAJ,CAAgB,MAAhB,CAApB;AACA,QAAMC,UAAU,GAAG,IAAIC,UAAJ,CAAeP,WAAf,EAA4BC,UAA5B,EAAwCC,UAAxC,CAAnB;AACA,QAAMM,MAAM,GAAGJ,WAAW,CAACK,MAAZ,CAAmBH,UAAnB,CAAf;AACA,SAAOE,MAAP;AACD;;AAGM,SAASE,uBAAT,CAAiCJ,UAAjC,EAA6C;AAClD,2BAAOH,WAAW,CAACQ,MAAZ,CAAmBL,UAAnB,CAAP;AACA,QAAMF,WAAW,GAAG,IAAIC,WAAJ,CAAgB,MAAhB,CAApB;AACA,QAAMG,MAAM,GAAGJ,WAAW,CAACK,MAAZ,CAAmBH,UAAnB,CAAf;AACA,SAAOE,MAAP;AACD;;AAEM,SAASI,cAAT,CAAwBZ,WAAxB,EAAqCC,UAAU,GAAG,CAAlD,EAAqD;AAC1D,QAAMY,QAAQ,GAAG,IAAIC,QAAJ,CAAad,WAAb,CAAjB;AACA,mBACAe,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBhB,UAAU,GAAG,CAA/B,CAApB,CADA,SAEAc,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBhB,UAAU,GAAG,CAA/B,CAApB,CAFA,SAGAc,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBhB,UAAU,GAAG,CAA/B,CAApB,CAHA,SAIAc,MAAM,CAACC,YAAP,CAAoBH,QAAQ,CAACI,QAAT,CAAkBhB,UAAU,GAAG,CAA/B,CAApB,CAJA;AAKD","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"],"file":"parse-utils.js"}

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

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseBatchedModel3DTile = parseBatchedModel3DTile;
+
+var _math = require("@loaders.gl/math");
+
+var _tile3dFeatureTable = _interopRequireDefault(require("../classes/tile-3d-feature-table"));
+
+var _parse3dTileHeader = require("./helpers/parse-3d-tile-header");
+
+var _parse3dTileTables = require("./helpers/parse-3d-tile-tables");
+
+var _parse3dTileGltfView = require("./helpers/parse-3d-tile-gltf-view");
+
+async function parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+  var _tile$gltf;
+
+  byteOffset = parseBatchedModel(tile, arrayBuffer, byteOffset, options, context);
+  await (0, _parse3dTileGltfView.extractGLTF)(tile, _parse3dTileGltfView.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 = (0, _parse3dTileHeader.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
+  byteOffset = (0, _parse3dTileTables.parse3DTileTablesHeaderSync)(tile, arrayBuffer, byteOffset);
+  byteOffset = (0, _parse3dTileTables.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
+  byteOffset = (0, _parse3dTileGltfView.parse3DTileGLTFViewSync)(tile, arrayBuffer, byteOffset, options);
+  const featureTable = new _tile3dFeatureTable.default(tile.featureTableJson, tile.featureTableBinary);
+  tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', _math.GL.FLOAT, 3);
+  return byteOffset;
+}
+//# sourceMappingURL=parse-3d-tile-batched-model.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/parse-3d-tile-batched-model.ts"],"names":["parseBatchedModel3DTile","tile","arrayBuffer","byteOffset","options","context","parseBatchedModel","GLTF_FORMAT","EMBEDDED","extensions","gltf","CESIUM_RTC","rtcCenter","center","featureTable","Tile3DFeatureTable","featureTableJson","featureTableBinary","getGlobalProperty","GL","FLOAT"],"mappings":";;;;;;;;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAEO,eAAeA,uBAAf,CAAuCC,IAAvC,EAA6CC,WAA7C,EAA0DC,UAA1D,EAAsEC,OAAtE,EAA+EC,OAA/E,EAAwF;AAAA;;AAC7FF,EAAAA,UAAU,GAAGG,iBAAiB,CAACL,IAAD,EAAOC,WAAP,EAAoBC,UAApB,EAAgCC,OAAhC,EAAyCC,OAAzC,CAA9B;AACA,QAAM,sCAAYJ,IAAZ,EAAkBM,iCAAYC,QAA9B,EAAwCJ,OAAxC,EAAiDC,OAAjD,CAAN;AAEA,QAAMI,UAAU,GAAGR,IAAH,aAAGA,IAAH,qCAAGA,IAAI,CAAES,IAAT,+CAAG,WAAYD,UAA/B;;AACA,MAAIA,UAAU,IAAIA,UAAU,CAACE,UAA7B,EAAyC;AACvCV,IAAAA,IAAI,CAACW,SAAL,GAAiBH,UAAU,CAACE,UAAX,CAAsBE,MAAvC;AACD;;AAED,SAAOV,UAAP;AACD;;AAED,SAASG,iBAAT,CAA2BL,IAA3B,EAAiCC,WAAjC,EAA8CC,UAA9C,EAA0DC,OAA1D,EAAmEC,OAAnE,EAA4E;AAC1EF,EAAAA,UAAU,GAAG,8CAAsBF,IAAtB,EAA4BC,WAA5B,EAAyCC,UAAzC,CAAb;AAEAA,EAAAA,UAAU,GAAG,oDAA4BF,IAA5B,EAAkCC,WAAlC,EAA+CC,UAA/C,CAAb;AACAA,EAAAA,UAAU,GAAG,8CAAsBF,IAAtB,EAA4BC,WAA5B,EAAyCC,UAAzC,EAAqDC,OAArD,CAAb;AAEAD,EAAAA,UAAU,GAAG,kDAAwBF,IAAxB,EAA8BC,WAA9B,EAA2CC,UAA3C,EAAuDC,OAAvD,CAAb;AAEA,QAAMU,YAAY,GAAG,IAAIC,2BAAJ,CAAuBd,IAAI,CAACe,gBAA5B,EAA8Cf,IAAI,CAACgB,kBAAnD,CAArB;AACAhB,EAAAA,IAAI,CAACW,SAAL,GAAiBE,YAAY,CAACI,iBAAb,CAA+B,YAA/B,EAA6CC,SAAGC,KAAhD,EAAuD,CAAvD,CAAjB;AAEA,SAAOjB,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\nimport {GL} from '@loaders.gl/math'; // math.gl/geometry;\nimport Tile3DFeatureTable from '../classes/tile-3d-feature-table';\n// import Tile3DBatchTable from '../classes/tile-3d-batch-table';\n\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\nimport {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';\nimport {parse3DTileGLTFViewSync, extractGLTF, GLTF_FORMAT} from './helpers/parse-3d-tile-gltf-view';\n\nexport async function parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {\n  byteOffset = parseBatchedModel(tile, arrayBuffer, byteOffset, options, context);\n  await extractGLTF(tile, GLTF_FORMAT.EMBEDDED, options, context);\n\n  const extensions = tile?.gltf?.extensions;\n  if (extensions && extensions.CESIUM_RTC) {\n    tile.rtcCenter = extensions.CESIUM_RTC.center;\n  }\n\n  return byteOffset;\n}\n\nfunction parseBatchedModel(tile, arrayBuffer, byteOffset, options, context) {\n  byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n\n  byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);\n  byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);\n\n  byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);\n\n  const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);\n  tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);\n\n  return byteOffset;\n}\n"],"file":"parse-3d-tile-batched-model.js"}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseComposite3DTile = parseComposite3DTile;
+
+var _parse3dTileHeader = require("./helpers/parse-3d-tile-header");
+
+async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, context, parse3DTile) {
+  byteOffset = (0, _parse3dTileHeader.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
+  const view = new DataView(arrayBuffer);
+  tile.tilesLength = view.getUint32(byteOffset, true);
+  byteOffset += 4;
+  tile.tiles = [];
+
+  while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {
+    const subtile = {};
+    tile.tiles.push(subtile);
+    byteOffset = await parse3DTile(arrayBuffer, byteOffset, options, context, subtile);
+  }
+
+  return byteOffset;
+}
+//# sourceMappingURL=parse-3d-tile-composite.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/parse-3d-tile-composite.ts"],"names":["parseComposite3DTile","tile","arrayBuffer","byteOffset","options","context","parse3DTile","view","DataView","tilesLength","getUint32","tiles","length","byteLength","subtile","push"],"mappings":";;;;;;;AAMA;;AAGO,eAAeA,oBAAf,CACLC,IADK,EAELC,WAFK,EAGLC,UAHK,EAILC,OAJK,EAKLC,OALK,EAMLC,WANK,EAOL;AACAH,EAAAA,UAAU,GAAG,8CAAsBF,IAAtB,EAA4BC,WAA5B,EAAyCC,UAAzC,CAAb;AAEA,QAAMI,IAAI,GAAG,IAAIC,QAAJ,CAAaN,WAAb,CAAb;AAGAD,EAAAA,IAAI,CAACQ,WAAL,GAAmBF,IAAI,CAACG,SAAL,CAAeP,UAAf,EAA2B,IAA3B,CAAnB;AACAA,EAAAA,UAAU,IAAI,CAAd;AAGAF,EAAAA,IAAI,CAACU,KAAL,GAAa,EAAb;;AACA,SAAOV,IAAI,CAACU,KAAL,CAAWC,MAAX,GAAoBX,IAAI,CAACQ,WAAzB,IAAwCR,IAAI,CAACY,UAAL,GAAkBV,UAAlB,GAA+B,EAA9E,EAAkF;AAChF,UAAMW,OAAO,GAAG,EAAhB;AACAb,IAAAA,IAAI,CAACU,KAAL,CAAWI,IAAX,CAAgBD,OAAhB;AACAX,IAAAA,UAAU,GAAG,MAAMG,WAAW,CAACJ,WAAD,EAAcC,UAAd,EAA0BC,OAA1B,EAAmCC,OAAnC,EAA4CS,OAA5C,CAA9B;AAED;;AAED,SAAOX,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\n// Reference code:\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Source/Scene/Composite3DTileContent.js#L182\n\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\n\n// eslint-disable-next-line max-params\nexport async function parseComposite3DTile(\n  tile,\n  arrayBuffer,\n  byteOffset,\n  options,\n  context,\n  parse3DTile\n) {\n  byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n\n  const view = new DataView(arrayBuffer);\n\n  // Extract number of tiles\n  tile.tilesLength = view.getUint32(byteOffset, true);\n  byteOffset += 4;\n\n  // extract each tile from the byte stream\n  tile.tiles = [];\n  while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {\n    const subtile = {};\n    tile.tiles.push(subtile);\n    byteOffset = await parse3DTile(arrayBuffer, byteOffset, options, context, subtile);\n    // TODO - do we need to add any padding in between tiles?\n  }\n\n  return byteOffset;\n}\n"],"file":"parse-3d-tile-composite.js"}

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

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeTileData = normalizeTileData;
+exports.normalizeTileHeaders = normalizeTileHeaders;
+
+var _tiles = require("@loaders.gl/tiles");
+
+function getTileType(tile) {
+  if (!tile.contentUrl) {
+    return _tiles.TILE_TYPE.EMPTY;
+  }
+
+  const contentUrl = tile.contentUrl;
+  const fileExtension = contentUrl.split('.').pop();
+
+  switch (fileExtension) {
+    case 'pnts':
+      return _tiles.TILE_TYPE.POINTCLOUD;
+
+    case 'i3dm':
+    case 'b3dm':
+      return _tiles.TILE_TYPE.SCENEGRAPH;
+
+    default:
+      return fileExtension;
+  }
+}
+
+function getRefine(refine) {
+  switch (refine) {
+    case 'REPLACE':
+    case 'replace':
+      return _tiles.TILE_REFINEMENT.REPLACE;
+
+    case 'ADD':
+    case 'add':
+      return _tiles.TILE_REFINEMENT.ADD;
+
+    default:
+      return refine;
+  }
+}
+
+function normalizeTileData(tile, options) {
+  if (!tile) {
+    return null;
+  }
+
+  if (tile.content) {
+    const contentUri = tile.content.uri || tile.content.url;
+    tile.contentUrl = "".concat(options.basePath, "/").concat(contentUri);
+  }
+
+  tile.id = tile.contentUrl;
+  tile.lodMetricType = _tiles.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+  tile.lodMetricValue = tile.geometricError;
+  tile.transformMatrix = tile.transform;
+  tile.type = getTileType(tile);
+  tile.refine = getRefine(tile.refine);
+  return tile;
+}
+
+function normalizeTileHeaders(tileset) {
+  const basePath = tileset.basePath;
+  const root = normalizeTileData(tileset.root, tileset);
+  const stack = [];
+  stack.push(root);
+
+  while (stack.length > 0) {
+    const tile = stack.pop() || {};
+    const children = tile.children || [];
+
+    for (const childHeader of children) {
+      normalizeTileData(childHeader, {
+        basePath
+      });
+      stack.push(childHeader);
+    }
+  }
+
+  return root;
+}
+//# sourceMappingURL=parse-3d-tile-header.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/parse-3d-tile-header.ts"],"names":["getTileType","tile","contentUrl","TILE_TYPE","EMPTY","fileExtension","split","pop","POINTCLOUD","SCENEGRAPH","getRefine","refine","TILE_REFINEMENT","REPLACE","ADD","normalizeTileData","options","content","contentUri","uri","url","basePath","id","lodMetricType","LOD_METRIC_TYPE","GEOMETRIC_ERROR","lodMetricValue","geometricError","transformMatrix","transform","type","normalizeTileHeaders","tileset","root","stack","push","length","children","childHeader"],"mappings":";;;;;;;;AAAA;;AAEA,SAASA,WAAT,CAAqBC,IAArB,EAA2B;AACzB,MAAI,CAACA,IAAI,CAACC,UAAV,EAAsB;AACpB,WAAOC,iBAAUC,KAAjB;AACD;;AAED,QAAMF,UAAU,GAAGD,IAAI,CAACC,UAAxB;AACA,QAAMG,aAAa,GAAGH,UAAU,CAACI,KAAX,CAAiB,GAAjB,EAAsBC,GAAtB,EAAtB;;AACA,UAAQF,aAAR;AACE,SAAK,MAAL;AACE,aAAOF,iBAAUK,UAAjB;;AACF,SAAK,MAAL;AACA,SAAK,MAAL;AACE,aAAOL,iBAAUM,UAAjB;;AACF;AACE,aAAOJ,aAAP;AAPJ;AASD;;AAED,SAASK,SAAT,CAAmBC,MAAnB,EAA2B;AACzB,UAAQA,MAAR;AACE,SAAK,SAAL;AACA,SAAK,SAAL;AACE,aAAOC,uBAAgBC,OAAvB;;AACF,SAAK,KAAL;AACA,SAAK,KAAL;AACE,aAAOD,uBAAgBE,GAAvB;;AACF;AACE,aAAOH,MAAP;AARJ;AAUD;;AAEM,SAASI,iBAAT,CAA2Bd,IAA3B,EAAiCe,OAAjC,EAA0C;AAC/C,MAAI,CAACf,IAAL,EAAW;AACT,WAAO,IAAP;AACD;;AACD,MAAIA,IAAI,CAACgB,OAAT,EAAkB;AAChB,UAAMC,UAAU,GAAGjB,IAAI,CAACgB,OAAL,CAAaE,GAAb,IAAoBlB,IAAI,CAACgB,OAAL,CAAaG,GAApD;AACAnB,IAAAA,IAAI,CAACC,UAAL,aAAqBc,OAAO,CAACK,QAA7B,cAAyCH,UAAzC;AACD;;AACDjB,EAAAA,IAAI,CAACqB,EAAL,GAAUrB,IAAI,CAACC,UAAf;AACAD,EAAAA,IAAI,CAACsB,aAAL,GAAqBC,uBAAgBC,eAArC;AACAxB,EAAAA,IAAI,CAACyB,cAAL,GAAsBzB,IAAI,CAAC0B,cAA3B;AACA1B,EAAAA,IAAI,CAAC2B,eAAL,GAAuB3B,IAAI,CAAC4B,SAA5B;AACA5B,EAAAA,IAAI,CAAC6B,IAAL,GAAY9B,WAAW,CAACC,IAAD,CAAvB;AACAA,EAAAA,IAAI,CAACU,MAAL,GAAcD,SAAS,CAACT,IAAI,CAACU,MAAN,CAAvB;AACA,SAAOV,IAAP;AACD;;AAGM,SAAS8B,oBAAT,CAA8BC,OAA9B,EAAuC;AAC5C,QAAMX,QAAQ,GAAGW,OAAO,CAACX,QAAzB;AACA,QAAMY,IAAI,GAAGlB,iBAAiB,CAACiB,OAAO,CAACC,IAAT,EAAeD,OAAf,CAA9B;AAEA,QAAME,KAAY,GAAG,EAArB;AACAA,EAAAA,KAAK,CAACC,IAAN,CAAWF,IAAX;;AAEA,SAAOC,KAAK,CAACE,MAAN,GAAe,CAAtB,EAAyB;AACvB,UAAMnC,IAAI,GAAGiC,KAAK,CAAC3B,GAAN,MAAe,EAA5B;AACA,UAAM8B,QAAQ,GAAGpC,IAAI,CAACoC,QAAL,IAAiB,EAAlC;;AACA,SAAK,MAAMC,WAAX,IAA0BD,QAA1B,EAAoC;AAClCtB,MAAAA,iBAAiB,CAACuB,WAAD,EAAc;AAACjB,QAAAA;AAAD,OAAd,CAAjB;AACAa,MAAAA,KAAK,CAACC,IAAN,CAAWG,WAAX;AACD;AACF;;AAED,SAAOL,IAAP;AACD","sourcesContent":["import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';\n\nfunction getTileType(tile) {\n  if (!tile.contentUrl) {\n    return TILE_TYPE.EMPTY;\n  }\n\n  const contentUrl = tile.contentUrl;\n  const fileExtension = contentUrl.split('.').pop();\n  switch (fileExtension) {\n    case 'pnts':\n      return TILE_TYPE.POINTCLOUD;\n    case 'i3dm':\n    case 'b3dm':\n      return TILE_TYPE.SCENEGRAPH;\n    default:\n      return fileExtension;\n  }\n}\n\nfunction getRefine(refine) {\n  switch (refine) {\n    case 'REPLACE':\n    case 'replace':\n      return TILE_REFINEMENT.REPLACE;\n    case 'ADD':\n    case 'add':\n      return TILE_REFINEMENT.ADD;\n    default:\n      return refine;\n  }\n}\n\nexport function normalizeTileData(tile, options) {\n  if (!tile) {\n    return null;\n  }\n  if (tile.content) {\n    const contentUri = tile.content.uri || tile.content.url;\n    tile.contentUrl = `${options.basePath}/${contentUri}`;\n  }\n  tile.id = tile.contentUrl;\n  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;\n  tile.lodMetricValue = tile.geometricError;\n  tile.transformMatrix = tile.transform;\n  tile.type = getTileType(tile);\n  tile.refine = getRefine(tile.refine);\n  return tile;\n}\n\n// normalize tile headers\nexport function normalizeTileHeaders(tileset) {\n  const basePath = tileset.basePath;\n  const root = normalizeTileData(tileset.root, tileset);\n\n  const stack: any[] = [];\n  stack.push(root);\n\n  while (stack.length > 0) {\n    const tile = stack.pop() || {};\n    const children = tile.children || [];\n    for (const childHeader of children) {\n      normalizeTileData(childHeader, {basePath});\n      stack.push(childHeader);\n    }\n  }\n\n  return root;\n}\n"],"file":"parse-3d-tile-header.js"}

package/dist/es5/lib/parsers/parse-3d-tile-instanced-model.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseInstancedModel3DTile = parseInstancedModel3DTile;
+
+var _core = require("@math.gl/core");
+
+var _geospatial = require("@math.gl/geospatial");
+
+var _math = require("@loaders.gl/math");
+
+var _tile3dFeatureTable = _interopRequireDefault(require("../classes/tile-3d-feature-table"));
+
+var _tile3dBatchTable = _interopRequireDefault(require("../classes/tile-3d-batch-table"));
+
+var _parse3dTileHeader = require("./helpers/parse-3d-tile-header");
+
+var _parse3dTileTables = require("./helpers/parse-3d-tile-tables");
+
+var _parse3dTileGltfView = require("./helpers/parse-3d-tile-gltf-view");
+
+async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+  byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
+  await (0, _parse3dTileGltfView.extractGLTF)(tile, tile.gltfFormat, options, context);
+  return byteOffset;
+}
+
+function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
+  byteOffset = (0, _parse3dTileHeader.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
+
+  if (tile.version !== 1) {
+    throw new Error("Instanced 3D Model version ".concat(tile.version, " is not supported"));
+  }
+
+  byteOffset = (0, _parse3dTileTables.parse3DTileTablesHeaderSync)(tile, arrayBuffer, byteOffset);
+  const view = new DataView(arrayBuffer);
+  tile.gltfFormat = view.getUint32(byteOffset, true);
+  byteOffset += 4;
+  byteOffset = (0, _parse3dTileTables.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
+  byteOffset = (0, _parse3dTileGltfView.parse3DTileGLTFViewSync)(tile, arrayBuffer, byteOffset, options);
+
+  if (tile.featureTableJsonByteLength === 0) {
+    throw new Error('i3dm parser: featureTableJsonByteLength is zero.');
+  }
+
+  const featureTable = new _tile3dFeatureTable.default(tile.featureTableJson, tile.featureTableBinary);
+  const instancesLength = featureTable.getGlobalProperty('INSTANCES_LENGTH');
+  featureTable.featuresLength = instancesLength;
+
+  if (!Number.isFinite(instancesLength)) {
+    throw new Error('i3dm parser: INSTANCES_LENGTH must be defined');
+  }
+
+  tile.eastNorthUp = featureTable.getGlobalProperty('EAST_NORTH_UP');
+  tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', _math.GL.FLOAT, 3);
+  const batchTable = new _tile3dBatchTable.default(tile.batchTableJson, tile.batchTableBinary, instancesLength);
+  extractInstancedAttributes(tile, featureTable, batchTable, instancesLength);
+  return byteOffset;
+}
+
+function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
+  const collectionOptions = {
+    instances: new Array(instancesLength),
+    batchTable: tile._batchTable,
+    cull: false,
+    url: undefined,
+    gltf: undefined,
+    basePath: undefined,
+    incrementallyLoadTextures: false,
+    forwardAxis: [1, 0, 0]
+  };
+  const instances = collectionOptions.instances;
+  const instancePosition = new _core.Vector3();
+  const instanceNormalRight = new _core.Vector3();
+  const instanceNormalUp = new _core.Vector3();
+  const instanceNormalForward = new _core.Vector3();
+  const instanceRotation = new _core.Matrix3();
+  const instanceQuaternion = new _core.Quaternion();
+  const instanceScale = new _core.Vector3();
+  const instanceTranslationRotationScale = {};
+  const instanceTransform = new _core.Matrix4();
+  const scratch1 = [];
+  const scratch2 = [];
+  const scratchVector1 = new _core.Vector3();
+  const scratchVector2 = new _core.Vector3();
+
+  for (let i = 0; i < instancesLength; i++) {
+    let position;
+
+    if (featureTable.hasProperty('POSITION')) {
+      position = featureTable.getProperty('POSITION', _math.GL.FLOAT, 3, i, instancePosition);
+    } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
+      position = featureTable.getProperty('POSITION_QUANTIZED', _math.GL.UNSIGNED_SHORT, 3, i, instancePosition);
+      const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', _math.GL.FLOAT, 3, scratchVector1);
+
+      if (!quantizedVolumeOffset) {
+        throw new Error('i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
+      }
+
+      const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', _math.GL.FLOAT, 3, scratchVector2);
+
+      if (!quantizedVolumeScale) {
+        throw new Error('i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
+      }
+
+      const MAX_UNSIGNED_SHORT = 65535.0;
+
+      for (let j = 0; j < 3; j++) {
+        position[j] = position[j] / MAX_UNSIGNED_SHORT * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
+      }
+    }
+
+    if (!position) {
+      throw new Error('i3dm: POSITION or POSITION_QUANTIZED must be defined for each instance.');
+    }
+
+    instancePosition.copy(position);
+    instanceTranslationRotationScale.translation = instancePosition;
+    tile.normalUp = featureTable.getProperty('NORMAL_UP', _math.GL.FLOAT, 3, i, scratch1);
+    tile.normalRight = featureTable.getProperty('NORMAL_RIGHT', _math.GL.FLOAT, 3, i, scratch2);
+    const hasCustomOrientation = false;
+
+    if (tile.normalUp) {
+      if (!tile.normalRight) {
+        throw new Error('i3dm: Custom orientation requires both NORMAL_UP and NORMAL_RIGHT.');
+      }
+
+      tile.hasCustomOrientation = true;
+    } else {
+      tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', _math.GL.UNSIGNED_SHORT, 2, scratch1);
+      tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', _math.GL.UNSIGNED_SHORT, 2, scratch2);
+
+      if (tile.octNormalUp) {
+        if (!tile.octNormalRight) {
+          throw new Error('i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P');
+        }
+
+        throw new Error('i3dm: oct-encoded orientation not implemented');
+      } else if (tile.eastNorthUp) {
+        _geospatial.Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
+
+        instanceTransform.getRotationMatrix3(instanceRotation);
+      } else {
+        instanceRotation.identity();
+      }
+    }
+
+    if (hasCustomOrientation) {
+      instanceNormalForward.copy(instanceNormalRight).cross(instanceNormalUp).normalize();
+      instanceRotation.setColumn(0, instanceNormalRight);
+      instanceRotation.setColumn(1, instanceNormalUp);
+      instanceRotation.setColumn(2, instanceNormalForward);
+    }
+
+    instanceQuaternion.fromMatrix3(instanceRotation);
+    instanceTranslationRotationScale.rotation = instanceQuaternion;
+    instanceScale.set(1.0, 1.0, 1.0);
+    const scale = featureTable.getProperty('SCALE', _math.GL.FLOAT, 1, i);
+
+    if (Number.isFinite(scale)) {
+      instanceScale.multiplyByScalar(scale);
+    }
+
+    const nonUniformScale = featureTable.getProperty('SCALE_NON_UNIFORM', _math.GL.FLOAT, 3, i, scratch1);
+
+    if (nonUniformScale) {
+      instanceScale.scale(nonUniformScale);
+    }
+
+    instanceTranslationRotationScale.scale = instanceScale;
+    let batchId = featureTable.getProperty('BATCH_ID', _math.GL.UNSIGNED_SHORT, 1, i);
+
+    if (batchId === undefined) {
+      batchId = i;
+    }
+
+    const rotationMatrix = new _core.Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
+    instanceTransform.identity();
+    instanceTransform.translate(instanceTranslationRotationScale.translation);
+    instanceTransform.multiplyRight(rotationMatrix);
+    instanceTransform.scale(instanceTranslationRotationScale.scale);
+    const modelMatrix = instanceTransform.clone();
+    instances[i] = {
+      modelMatrix,
+      batchId
+    };
+  }
+
+  tile.instances = instances;
+}
+//# sourceMappingURL=parse-3d-tile-instanced-model.js.map