@loaders.gl/3d-tiles 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/classes/tile-3d-feature-table.js

@@ -1,94 +1,72 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { GL, GLType } from '@loaders.gl/math';
-export default class Tile3DFeatureTable {
-  constructor(featureTableJson, featureTableBinary) {
-    _defineProperty(this, "json", void 0);
-
-    _defineProperty(this, "buffer", void 0);
-
-    _defineProperty(this, "featuresLength", 0);
-
-    _defineProperty(this, "_cachedTypedArrays", {});
-
-    this.json = featureTableJson;
-    this.buffer = featureTableBinary;
-  }
-
-  getExtension(extensionName) {
-    return this.json.extensions && this.json.extensions[extensionName];
-  }
-
-  hasProperty(propertyName) {
-    return Boolean(this.json[propertyName]);
-  }
-
-  getGlobalProperty(propertyName, componentType = GL.UNSIGNED_INT, componentLength = 1) {
-    const jsonValue = this.json[propertyName];
-
-    if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {
-      return this._getTypedArrayFromBinary(propertyName, componentType, componentLength, 1, jsonValue.byteOffset);
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+const math_1 = require("@loaders.gl/math");
+// Reference:
+// https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js
+class Tile3DFeatureTable {
+    constructor(featureTableJson, featureTableBinary) {
+        this.featuresLength = 0;
+        this._cachedTypedArrays = {};
+        this.json = featureTableJson;
+        this.buffer = featureTableBinary;
     }
-
-    return jsonValue;
-  }
-
-  getPropertyArray(propertyName, componentType, componentLength) {
-    const jsonValue = this.json[propertyName];
-
-    if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {
-      if ('componentType' in jsonValue) {
-        componentType = GLType.fromName(jsonValue.componentType);
-      }
-
-      return this._getTypedArrayFromBinary(propertyName, componentType, componentLength, this.featuresLength, jsonValue.byteOffset);
+    getExtension(extensionName) {
+        return this.json.extensions && this.json.extensions[extensionName];
     }
-
-    return this._getTypedArrayFromArray(propertyName, componentType, jsonValue);
-  }
-
-  getProperty(propertyName, componentType, componentLength, featureId, result) {
-    const jsonValue = this.json[propertyName];
-
-    if (!jsonValue) {
-      return jsonValue;
+    hasProperty(propertyName) {
+        return Boolean(this.json[propertyName]);
     }
-
-    const typedArray = this.getPropertyArray(propertyName, componentType, componentLength);
-
-    if (componentLength === 1) {
-      return typedArray[featureId];
+    getGlobalProperty(propertyName, componentType = math_1.GL.UNSIGNED_INT, componentLength = 1) {
+        const jsonValue = this.json[propertyName];
+        if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {
+            return this._getTypedArrayFromBinary(propertyName, componentType, componentLength, 1, jsonValue.byteOffset);
+        }
+        return jsonValue;
     }
-
-    for (let i = 0; i < componentLength; ++i) {
-      result[i] = typedArray[componentLength * featureId + i];
+    getPropertyArray(propertyName, componentType, componentLength) {
+        const jsonValue = this.json[propertyName];
+        if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {
+            if ('componentType' in jsonValue) {
+                componentType = math_1.GLType.fromName(jsonValue.componentType);
+            }
+            return this._getTypedArrayFromBinary(propertyName, componentType, componentLength, this.featuresLength, jsonValue.byteOffset);
+        }
+        return this._getTypedArrayFromArray(propertyName, componentType, jsonValue);
     }
-
-    return result;
-  }
-
-  _getTypedArrayFromBinary(propertyName, componentType, componentLength, count, byteOffset) {
-    const cachedTypedArrays = this._cachedTypedArrays;
-    let typedArray = cachedTypedArrays[propertyName];
-
-    if (!typedArray) {
-      typedArray = GLType.createTypedArray(componentType, this.buffer.buffer, this.buffer.byteOffset + byteOffset, count * componentLength);
-      cachedTypedArrays[propertyName] = typedArray;
+    getProperty(propertyName, componentType, componentLength, featureId, result) {
+        const jsonValue = this.json[propertyName];
+        if (!jsonValue) {
+            return jsonValue;
+        }
+        const typedArray = this.getPropertyArray(propertyName, componentType, componentLength);
+        if (componentLength === 1) {
+            return typedArray[featureId];
+        }
+        for (let i = 0; i < componentLength; ++i) {
+            result[i] = typedArray[componentLength * featureId + i];
+        }
+        return result;
     }
-
-    return typedArray;
-  }
-
-  _getTypedArrayFromArray(propertyName, componentType, array) {
-    const cachedTypedArrays = this._cachedTypedArrays;
-    let typedArray = cachedTypedArrays[propertyName];
-
-    if (!typedArray) {
-      typedArray = GLType.createTypedArray(componentType, array);
-      cachedTypedArrays[propertyName] = typedArray;
+    // HELPERS
+    _getTypedArrayFromBinary(propertyName, componentType, componentLength, count, byteOffset) {
+        const cachedTypedArrays = this._cachedTypedArrays;
+        let typedArray = cachedTypedArrays[propertyName];
+        if (!typedArray) {
+            typedArray = math_1.GLType.createTypedArray(componentType, this.buffer.buffer, this.buffer.byteOffset + byteOffset, count * componentLength);
+            cachedTypedArrays[propertyName] = typedArray;
+        }
+        return typedArray;
+    }
+    _getTypedArrayFromArray(propertyName, componentType, array) {
+        const cachedTypedArrays = this._cachedTypedArrays;
+        let typedArray = cachedTypedArrays[propertyName];
+        if (!typedArray) {
+            typedArray = math_1.GLType.createTypedArray(componentType, array);
+            cachedTypedArrays[propertyName] = typedArray;
+        }
+        return typedArray;
     }
-
-    return typedArray;
-  }
-
 }
-//# sourceMappingURL=tile-3d-feature-table.js.map
+exports.default = Tile3DFeatureTable;

package/dist/lib/constants.js

@@ -1,22 +1,26 @@
-export const TILE3D_TYPE = {
-  COMPOSITE: 'cmpt',
-  POINT_CLOUD: 'pnts',
-  BATCHED_3D_MODEL: 'b3dm',
-  INSTANCED_3D_MODEL: 'i3dm',
-  GEOMETRY: 'geom',
-  VECTOR: 'vect',
-  GLTF: 'glTF'
+"use strict";
+// TILE TYPES
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TILE3D_OPTIMIZATION_HINT = exports.MAGIC_ARRAY = exports.TILE3D_TYPES = exports.TILE3D_TYPE = void 0;
+exports.TILE3D_TYPE = {
+    COMPOSITE: 'cmpt',
+    POINT_CLOUD: 'pnts',
+    BATCHED_3D_MODEL: 'b3dm',
+    INSTANCED_3D_MODEL: 'i3dm',
+    GEOMETRY: 'geom',
+    VECTOR: 'vect',
+    GLTF: 'glTF'
 };
-export const TILE3D_TYPES = Object.keys(TILE3D_TYPE);
-export const MAGIC_ARRAY = {
-  BATCHED_MODEL: [98, 51, 100, 109],
-  INSTANCED_MODEL: [105, 51, 100, 109],
-  POINT_CLOUD: [112, 110, 116, 115],
-  COMPOSITE: [99, 109, 112, 116]
+exports.TILE3D_TYPES = Object.keys(exports.TILE3D_TYPE);
+exports.MAGIC_ARRAY = {
+    BATCHED_MODEL: [98, 51, 100, 109],
+    INSTANCED_MODEL: [105, 51, 100, 109],
+    POINT_CLOUD: [112, 110, 116, 115],
+    COMPOSITE: [99, 109, 112, 116]
 };
-export const TILE3D_OPTIMIZATION_HINT = {
-  NOT_COMPUTED: -1,
-  USE_OPTIMIZATION: 1,
-  SKIP_OPTIMIZATION: 0
+// TILE CONSTANTS
+exports.TILE3D_OPTIMIZATION_HINT = {
+    NOT_COMPUTED: -1,
+    USE_OPTIMIZATION: 1,
+    SKIP_OPTIMIZATION: 0
 };
-//# sourceMappingURL=constants.js.map

package/dist/lib/encoders/encode-3d-tile-batched-model.js

@@ -1,46 +1,46 @@
-import { padToNBytes, copyBinaryToDataView, copyPaddedStringToDataView } from '@loaders.gl/loader-utils';
-import { MAGIC_ARRAY } from '../constants';
-import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
-export function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
-  const {
-    featuresLength = 0,
-    batchTable
-  } = tile;
-  const featureTableJson = {
-    BATCH_LENGTH: featuresLength
-  };
-  const featureTableJsonString = JSON.stringify(featureTableJson);
-  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';
-  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);
-  const batchTableJsonByteLength = batchTableJsonString ? padToNBytes(batchTableJsonString.length, 8) : 0;
-  tile = {
-    magic: MAGIC_ARRAY.BATCHED_MODEL,
-    ...tile
-  };
-  const byteOffsetStart = byteOffset;
-  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
-
-  if (dataView) {
-    dataView.setUint32(12, featureTableJsonByteLength, true);
-    dataView.setUint32(16, 0, true);
-    dataView.setUint32(20, batchTableJsonByteLength, true);
-    dataView.setUint32(24, 0, true);
-  }
-
-  byteOffset += 16;
-  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);
-
-  if (batchTable) {
-    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);
-  }
-
-  const gltfEncoded = tile.gltfEncoded;
-
-  if (gltfEncoded) {
-    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
-  }
-
-  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
-  return byteOffset;
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBatchedModel3DTile = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const constants_1 = require("../constants");
+const encode_3d_tile_header_1 = require("./helpers/encode-3d-tile-header");
+// Procedurally encode the tile array dataView for testing purposes
+function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
+    const { featuresLength = 0, batchTable } = tile;
+    const featureTableJson = {
+        BATCH_LENGTH: featuresLength
+    };
+    const featureTableJsonString = JSON.stringify(featureTableJson);
+    const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';
+    const featureTableJsonByteLength = (0, loader_utils_1.padToNBytes)(featureTableJsonString.length, 8);
+    const batchTableJsonByteLength = batchTableJsonString
+        ? (0, loader_utils_1.padToNBytes)(batchTableJsonString.length, 8)
+        : 0;
+    // Add default magic for this tile type
+    tile = { magic: constants_1.MAGIC_ARRAY.BATCHED_MODEL, ...tile };
+    const byteOffsetStart = byteOffset;
+    byteOffset = (0, encode_3d_tile_header_1.encode3DTileHeader)(tile, dataView, byteOffset);
+    if (dataView) {
+        dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength
+        dataView.setUint32(16, 0, true); // featureTableBinaryByteLength
+        dataView.setUint32(20, batchTableJsonByteLength, true); // batchTableJsonByteLength
+        dataView.setUint32(24, 0, true); // batchTableBinaryByteLength
+    }
+    byteOffset += 16;
+    // TODO feature table binary
+    byteOffset = (0, loader_utils_1.copyPaddedStringToDataView)(dataView, byteOffset, featureTableJsonString, 8);
+    if (batchTable) {
+        byteOffset = (0, loader_utils_1.copyPaddedStringToDataView)(dataView, byteOffset, batchTableJsonString, 8);
+    }
+    // Add encoded GLTF to the end of data
+    const gltfEncoded = tile.gltfEncoded;
+    if (gltfEncoded) {
+        byteOffset = (0, loader_utils_1.copyBinaryToDataView)(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
+    }
+    // Go "back" and rewrite the tile's `byteLength` now that we know the value
+    (0, encode_3d_tile_header_1.encode3DTileByteLength)(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+    return byteOffset;
 }
-//# sourceMappingURL=encode-3d-tile-batched-model.js.map
+exports.encodeBatchedModel3DTile = encodeBatchedModel3DTile;

package/dist/lib/encoders/encode-3d-tile-composite.js

@@ -1,25 +1,24 @@
-import { MAGIC_ARRAY } from '../constants';
-import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
-export function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {
-  tile = {
-    magic: MAGIC_ARRAY.COMPOSITE,
-    tiles: [],
-    ...tile
-  };
-  const byteOffsetStart = byteOffset;
-  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);
-
-  if (dataView) {
-    dataView.setUint32(byteOffset, tile.tiles.length, true);
-  }
-
-  byteOffset += 4;
-
-  for (let i = 0; i < tile.tiles.length; ++i) {
-    byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);
-  }
-
-  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
-  return byteOffset;
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeComposite3DTile = void 0;
+const constants_1 = require("../constants");
+const encode_3d_tile_header_1 = require("./helpers/encode-3d-tile-header");
+function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {
+    // Add default magic for this tile type
+    tile = { magic: constants_1.MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile };
+    const byteOffsetStart = byteOffset;
+    byteOffset += (0, encode_3d_tile_header_1.encode3DTileHeader)(tile, dataView, byteOffset);
+    if (dataView) {
+        dataView.setUint32(byteOffset, tile.tiles.length, true); // tilesLength
+    }
+    byteOffset += 4;
+    for (let i = 0; i < tile.tiles.length; ++i) {
+        byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);
+    }
+    // Go "back" and rewrite the tile's `byteLength` now that we know the value
+    (0, encode_3d_tile_header_1.encode3DTileByteLength)(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+    return byteOffset;
 }
-//# sourceMappingURL=encode-3d-tile-composite.js.map
+exports.encodeComposite3DTile = encodeComposite3DTile;

package/dist/lib/encoders/encode-3d-tile-instanced-model.js

@@ -1,38 +1,38 @@
-import { copyStringToDataView } from '@loaders.gl/loader-utils';
-import { MAGIC_ARRAY } from '../constants';
-import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
-export function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
-  const {
-    featuresLength = 1,
-    gltfFormat = 1,
-    gltfUri = ''
-  } = tile;
-  const gltfUriByteLength = gltfUri.length;
-  const featureTableJson = {
-    INSTANCES_LENGTH: featuresLength,
-    POSITION: new Array(featuresLength * 3).fill(0)
-  };
-  const featureTableJsonString = JSON.stringify(featureTableJson);
-  const featureTableJsonByteLength = featureTableJsonString.length;
-  tile = {
-    magic: MAGIC_ARRAY.INSTANCED_MODEL,
-    ...tile
-  };
-  const byteOffsetStart = byteOffset;
-  byteOffset = encode3DTileHeader(tile, dataView, 0);
-
-  if (dataView) {
-    dataView.setUint32(12, featureTableJsonByteLength, true);
-    dataView.setUint32(16, 0, true);
-    dataView.setUint32(20, 0, true);
-    dataView.setUint32(24, 0, true);
-    dataView.setUint32(28, gltfFormat, true);
-  }
-
-  byteOffset += 20;
-  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
-  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
-  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
-  return byteOffset;
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeInstancedModel3DTile = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const constants_1 = require("../constants");
+const encode_3d_tile_header_1 = require("./helpers/encode-3d-tile-header");
+// Procedurally encode the tile array buffer for testing purposes
+// eslint-disable-next-line max-statements
+function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
+    const { featuresLength = 1, gltfFormat = 1, gltfUri = '' } = tile;
+    const gltfUriByteLength = gltfUri.length;
+    const featureTableJson = {
+        INSTANCES_LENGTH: featuresLength,
+        POSITION: new Array(featuresLength * 3).fill(0)
+    };
+    const featureTableJsonString = JSON.stringify(featureTableJson);
+    const featureTableJsonByteLength = featureTableJsonString.length;
+    // Add default magic for this tile type
+    tile = { magic: constants_1.MAGIC_ARRAY.INSTANCED_MODEL, ...tile };
+    const byteOffsetStart = byteOffset;
+    byteOffset = (0, encode_3d_tile_header_1.encode3DTileHeader)(tile, dataView, 0);
+    if (dataView) {
+        dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength
+        dataView.setUint32(16, 0, true); // featureTableBinaryByteLength
+        dataView.setUint32(20, 0, true); // batchTableJsonByteLength
+        dataView.setUint32(24, 0, true); // batchTableBinaryByteLength
+        dataView.setUint32(28, gltfFormat, true); // gltfFormat
+    }
+    byteOffset += 20;
+    byteOffset += (0, loader_utils_1.copyStringToDataView)(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+    byteOffset += (0, loader_utils_1.copyStringToDataView)(dataView, byteOffset, gltfUri, gltfUriByteLength);
+    // Go "back" and rewrite the tile's `byteLength` now that we know the value
+    (0, encode_3d_tile_header_1.encode3DTileByteLength)(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+    return byteOffset;
 }
-//# sourceMappingURL=encode-3d-tile-instanced-model.js.map
+exports.encodeInstancedModel3DTile = encodeInstancedModel3DTile;

package/dist/lib/encoders/encode-3d-tile-point-cloud.js

@@ -1,41 +1,39 @@
-import { MAGIC_ARRAY } from '../constants';
-import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
-import { padStringToByteAlignment, copyStringToDataView, copyBinaryToDataView } from '@loaders.gl/loader-utils';
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePointCloud3DTile = void 0;
+const constants_1 = require("../constants");
+const encode_3d_tile_header_1 = require("./helpers/encode-3d-tile-header");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
 const DEFAULT_FEATURE_TABLE_JSON = {
-  POINTS_LENGTH: 1,
-  POSITIONS: {
-    byteOffset: 0
-  }
+    POINTS_LENGTH: 1,
+    POSITIONS: {
+        byteOffset: 0
+    }
 };
-export function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
-  const {
-    featureTableJson = DEFAULT_FEATURE_TABLE_JSON
-  } = tile;
-  let featureTableJsonString = JSON.stringify(featureTableJson);
-  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);
-  const {
-    featureTableJsonByteLength = featureTableJsonString.length
-  } = tile;
-  const featureTableBinary = new ArrayBuffer(12);
-  const featureTableBinaryByteLength = featureTableBinary.byteLength;
-  tile = {
-    magic: MAGIC_ARRAY.POINT_CLOUD,
-    ...tile
-  };
-  const byteOffsetStart = byteOffset;
-  byteOffset += encode3DTileHeader(tile, dataView, 0);
-
-  if (dataView) {
-    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true);
-    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true);
-    dataView.setUint32(byteOffset + 8, 0, true);
-    dataView.setUint32(byteOffset + 12, 0, true);
-  }
-
-  byteOffset += 16;
-  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
-  byteOffset += copyBinaryToDataView(dataView, byteOffset, featureTableBinary, featureTableBinaryByteLength);
-  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
-  return byteOffset;
+function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
+    const { featureTableJson = DEFAULT_FEATURE_TABLE_JSON } = tile;
+    let featureTableJsonString = JSON.stringify(featureTableJson);
+    featureTableJsonString = (0, loader_utils_1.padStringToByteAlignment)(featureTableJsonString, 4);
+    const { featureTableJsonByteLength = featureTableJsonString.length } = tile;
+    const featureTableBinary = new ArrayBuffer(12); // Enough space to hold 3 floats
+    const featureTableBinaryByteLength = featureTableBinary.byteLength;
+    // Add default magic for this tile type
+    tile = { magic: constants_1.MAGIC_ARRAY.POINT_CLOUD, ...tile };
+    const byteOffsetStart = byteOffset;
+    byteOffset += (0, encode_3d_tile_header_1.encode3DTileHeader)(tile, dataView, 0);
+    if (dataView) {
+        dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true); // featureTableJsonByteLength
+        dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true); // featureTableBinaryByteLength
+        dataView.setUint32(byteOffset + 8, 0, true); // batchTableJsonByteLength
+        dataView.setUint32(byteOffset + 12, 0, true); // batchTableBinaryByteLength
+    }
+    byteOffset += 16;
+    byteOffset += (0, loader_utils_1.copyStringToDataView)(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+    byteOffset += (0, loader_utils_1.copyBinaryToDataView)(dataView, byteOffset, featureTableBinary, featureTableBinaryByteLength);
+    // Go "back" and rewrite the tile's `byteLength` now that we know the value
+    (0, encode_3d_tile_header_1.encode3DTileByteLength)(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+    return byteOffset;
 }
-//# sourceMappingURL=encode-3d-tile-point-cloud.js.map
+exports.encodePointCloud3DTile = encodePointCloud3DTile;

package/dist/lib/encoders/encode-3d-tile.js

@@ -1,35 +1,33 @@
-import { TILE3D_TYPE } from '../constants';
-import { assert } from '@loaders.gl/loader-utils';
-import { encodeComposite3DTile } from './encode-3d-tile-composite';
-import { encodeBatchedModel3DTile } from './encode-3d-tile-batched-model';
-import { encodeInstancedModel3DTile } from './encode-3d-tile-instanced-model';
-import { encodePointCloud3DTile } from './encode-3d-tile-point-cloud';
-export default function encode3DTile(tile, options) {
-  const byteLength = encode3DTileToDataView(tile, null, 0, options);
-  const arrayBuffer = new ArrayBuffer(byteLength);
-  const dataView = new DataView(arrayBuffer);
-  encode3DTileToDataView(tile, dataView, 0, options);
-  return arrayBuffer;
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const encode_3d_tile_composite_1 = require("./encode-3d-tile-composite");
+const encode_3d_tile_batched_model_1 = require("./encode-3d-tile-batched-model");
+const encode_3d_tile_instanced_model_1 = require("./encode-3d-tile-instanced-model");
+const encode_3d_tile_point_cloud_1 = require("./encode-3d-tile-point-cloud");
+function encode3DTile(tile, options) {
+    const byteLength = encode3DTileToDataView(tile, null, 0, options);
+    const arrayBuffer = new ArrayBuffer(byteLength);
+    const dataView = new DataView(arrayBuffer);
+    encode3DTileToDataView(tile, dataView, 0, options);
+    return arrayBuffer;
 }
-
+exports.default = encode3DTile;
 function encode3DTileToDataView(tile, dataView, byteOffset, options) {
-  assert(typeof tile.type === 'string');
-
-  switch (tile.type) {
-    case TILE3D_TYPE.COMPOSITE:
-      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
-
-    case TILE3D_TYPE.POINT_CLOUD:
-      return encodePointCloud3DTile(tile, dataView, byteOffset, options);
-
-    case TILE3D_TYPE.BATCHED_3D_MODEL:
-      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
-
-    case TILE3D_TYPE.INSTANCED_3D_MODEL:
-      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
-
-    default:
-      throw new Error('3D Tiles: unknown tile type');
-  }
+    (0, loader_utils_1.assert)(typeof tile.type === 'string');
+    switch (tile.type) {
+        case constants_1.TILE3D_TYPE.COMPOSITE:
+            return (0, encode_3d_tile_composite_1.encodeComposite3DTile)(tile, dataView, byteOffset, options, encode3DTileToDataView);
+        case constants_1.TILE3D_TYPE.POINT_CLOUD:
+            return (0, encode_3d_tile_point_cloud_1.encodePointCloud3DTile)(tile, dataView, byteOffset, options);
+        case constants_1.TILE3D_TYPE.BATCHED_3D_MODEL:
+            return (0, encode_3d_tile_batched_model_1.encodeBatchedModel3DTile)(tile, dataView, byteOffset, options);
+        case constants_1.TILE3D_TYPE.INSTANCED_3D_MODEL:
+            return (0, encode_3d_tile_instanced_model_1.encodeInstancedModel3DTile)(tile, dataView, byteOffset, options);
+        default:
+            throw new Error('3D Tiles: unknown tile type');
+    }
 }
-//# sourceMappingURL=encode-3d-tile.js.map