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

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

@@ -1,72 +1,94 @@
-"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;
+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);
     }
-    getExtension(extensionName) {
-        return this.json.extensions && this.json.extensions[extensionName];
+
+    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);
     }
-    hasProperty(propertyName) {
-        return Boolean(this.json[propertyName]);
+
+    return this._getTypedArrayFromArray(propertyName, componentType, jsonValue);
+  }
+
+  getProperty(propertyName, componentType, componentLength, featureId, result) {
+    const jsonValue = this.json[propertyName];
+
+    if (!jsonValue) {
+      return jsonValue;
     }
-    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;
+
+    const typedArray = this.getPropertyArray(propertyName, componentType, componentLength);
+
+    if (componentLength === 1) {
+      return typedArray[featureId];
     }
-    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);
+
+    for (let i = 0; i < componentLength; ++i) {
+      result[i] = typedArray[componentLength * featureId + i];
     }
-    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 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;
     }
-    // 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;
+  }
+
+  _getTypedArrayFromArray(propertyName, componentType, array) {
+    const cachedTypedArrays = this._cachedTypedArrays;
+    let typedArray = cachedTypedArrays[propertyName];
+
+    if (!typedArray) {
+      typedArray = GLType.createTypedArray(componentType, array);
+      cachedTypedArrays[propertyName] = typedArray;
     }
+
+    return typedArray;
+  }
+
 }
-exports.default = Tile3DFeatureTable;
+//# sourceMappingURL=tile-3d-feature-table.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/classes/tile-3d-feature-table.ts"],"names":["GL","GLType","Tile3DFeatureTable","constructor","featureTableJson","featureTableBinary","json","buffer","getExtension","extensionName","extensions","hasProperty","propertyName","Boolean","getGlobalProperty","componentType","UNSIGNED_INT","componentLength","jsonValue","Number","isFinite","byteOffset","_getTypedArrayFromBinary","getPropertyArray","fromName","featuresLength","_getTypedArrayFromArray","getProperty","featureId","result","typedArray","i","count","cachedTypedArrays","_cachedTypedArrays","createTypedArray","array"],"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 {GL, GLType} from '@loaders.gl/math';\n\n// Reference:\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js\nexport default class Tile3DFeatureTable {\n  json;\n  buffer;\n  featuresLength = 0;\n  _cachedTypedArrays = {};\n\n  constructor(featureTableJson, featureTableBinary) {\n    this.json = featureTableJson;\n    this.buffer = featureTableBinary;\n  }\n\n  getExtension(extensionName) {\n    return this.json.extensions && this.json.extensions[extensionName];\n  }\n\n  hasProperty(propertyName) {\n    return Boolean(this.json[propertyName]);\n  }\n\n  getGlobalProperty(propertyName, componentType = GL.UNSIGNED_INT, componentLength = 1) {\n    const jsonValue = this.json[propertyName];\n\n    if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {\n      return this._getTypedArrayFromBinary(\n        propertyName,\n        componentType,\n        componentLength,\n        1,\n        jsonValue.byteOffset\n      );\n    }\n\n    return jsonValue;\n  }\n\n  getPropertyArray(propertyName, componentType, componentLength) {\n    const jsonValue = this.json[propertyName];\n\n    if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {\n      if ('componentType' in jsonValue) {\n        componentType = GLType.fromName(jsonValue.componentType);\n      }\n      return this._getTypedArrayFromBinary(\n        propertyName,\n        componentType,\n        componentLength,\n        this.featuresLength,\n        jsonValue.byteOffset\n      );\n    }\n\n    return this._getTypedArrayFromArray(propertyName, componentType, jsonValue);\n  }\n\n  getProperty(propertyName, componentType, componentLength, featureId, result) {\n    const jsonValue = this.json[propertyName];\n    if (!jsonValue) {\n      return jsonValue;\n    }\n\n    const typedArray = this.getPropertyArray(propertyName, componentType, componentLength);\n\n    if (componentLength === 1) {\n      return typedArray[featureId];\n    }\n\n    for (let i = 0; i < componentLength; ++i) {\n      result[i] = typedArray[componentLength * featureId + i];\n    }\n\n    return result;\n  }\n\n  // HELPERS\n\n  _getTypedArrayFromBinary(propertyName, componentType, componentLength, count, byteOffset) {\n    const cachedTypedArrays = this._cachedTypedArrays;\n    let typedArray = cachedTypedArrays[propertyName];\n    if (!typedArray) {\n      typedArray = GLType.createTypedArray(\n        componentType,\n        this.buffer.buffer,\n        this.buffer.byteOffset + byteOffset,\n        count * componentLength\n      );\n      cachedTypedArrays[propertyName] = typedArray;\n    }\n    return typedArray;\n  }\n\n  _getTypedArrayFromArray(propertyName, componentType, array) {\n    const cachedTypedArrays = this._cachedTypedArrays;\n    let typedArray = cachedTypedArrays[propertyName];\n    if (!typedArray) {\n      typedArray = GLType.createTypedArray(componentType, array);\n      cachedTypedArrays[propertyName] = typedArray;\n    }\n    return typedArray;\n  }\n}\n"],"file":"tile-3d-feature-table.js"}

package/dist/lib/constants.js

@@ -1,26 +1,22 @@
-"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_TYPE = {
+  COMPOSITE: 'cmpt',
+  POINT_CLOUD: 'pnts',
+  BATCHED_3D_MODEL: 'b3dm',
+  INSTANCED_3D_MODEL: 'i3dm',
+  GEOMETRY: 'geom',
+  VECTOR: 'vect',
+  GLTF: 'glTF'
 };
-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_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]
 };
-// TILE CONSTANTS
-exports.TILE3D_OPTIMIZATION_HINT = {
-    NOT_COMPUTED: -1,
-    USE_OPTIMIZATION: 1,
-    SKIP_OPTIMIZATION: 0
+export const TILE3D_OPTIMIZATION_HINT = {
+  NOT_COMPUTED: -1,
+  USE_OPTIMIZATION: 1,
+  SKIP_OPTIMIZATION: 0
 };
+//# sourceMappingURL=constants.js.map

package/dist/lib/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/constants.ts"],"names":["TILE3D_TYPE","COMPOSITE","POINT_CLOUD","BATCHED_3D_MODEL","INSTANCED_3D_MODEL","GEOMETRY","VECTOR","GLTF","TILE3D_TYPES","Object","keys","MAGIC_ARRAY","BATCHED_MODEL","INSTANCED_MODEL","TILE3D_OPTIMIZATION_HINT","NOT_COMPUTED","USE_OPTIMIZATION","SKIP_OPTIMIZATION"],"mappings":"AAEA,OAAO,MAAMA,WAAW,GAAG;AACzBC,EAAAA,SAAS,EAAE,MADc;AAEzBC,EAAAA,WAAW,EAAE,MAFY;AAGzBC,EAAAA,gBAAgB,EAAE,MAHO;AAIzBC,EAAAA,kBAAkB,EAAE,MAJK;AAKzBC,EAAAA,QAAQ,EAAE,MALe;AAMzBC,EAAAA,MAAM,EAAE,MANiB;AAOzBC,EAAAA,IAAI,EAAE;AAPmB,CAApB;AAUP,OAAO,MAAMC,YAAY,GAAGC,MAAM,CAACC,IAAP,CAAYV,WAAZ,CAArB;AAEP,OAAO,MAAMW,WAAW,GAAG;AACzBC,EAAAA,aAAa,EAAE,CAAC,EAAD,EAAK,EAAL,EAAS,GAAT,EAAc,GAAd,CADU;AAEzBC,EAAAA,eAAe,EAAE,CAAC,GAAD,EAAM,EAAN,EAAU,GAAV,EAAe,GAAf,CAFQ;AAGzBX,EAAAA,WAAW,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,CAHY;AAIzBD,EAAAA,SAAS,EAAE,CAAC,EAAD,EAAK,GAAL,EAAU,GAAV,EAAe,GAAf;AAJc,CAApB;AAQP,OAAO,MAAMa,wBAAwB,GAAG;AACtCC,EAAAA,YAAY,EAAE,CAAC,CADuB;AAEtCC,EAAAA,gBAAgB,EAAE,CAFoB;AAGtCC,EAAAA,iBAAiB,EAAE;AAHmB,CAAjC","sourcesContent":["// TILE TYPES\n\nexport const TILE3D_TYPE = {\n  COMPOSITE: 'cmpt',\n  POINT_CLOUD: 'pnts',\n  BATCHED_3D_MODEL: 'b3dm',\n  INSTANCED_3D_MODEL: 'i3dm',\n  GEOMETRY: 'geom',\n  VECTOR: 'vect',\n  GLTF: 'glTF'\n};\n\nexport const TILE3D_TYPES = Object.keys(TILE3D_TYPE);\n\nexport const MAGIC_ARRAY = {\n  BATCHED_MODEL: [98, 51, 100, 109],\n  INSTANCED_MODEL: [105, 51, 100, 109],\n  POINT_CLOUD: [112, 110, 116, 115],\n  COMPOSITE: [99, 109, 112, 116]\n};\n\n// TILE CONSTANTS\nexport const TILE3D_OPTIMIZATION_HINT = {\n  NOT_COMPUTED: -1,\n  USE_OPTIMIZATION: 1,\n  SKIP_OPTIMIZATION: 0\n};\n"],"file":"constants.js"}

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

@@ -1,46 +1,46 @@
-"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;
+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;
 }
-exports.encodeBatchedModel3DTile = encodeBatchedModel3DTile;
+//# sourceMappingURL=encode-3d-tile-batched-model.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/encoders/encode-3d-tile-batched-model.ts"],"names":["padToNBytes","copyBinaryToDataView","copyPaddedStringToDataView","MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeBatchedModel3DTile","tile","dataView","byteOffset","options","featuresLength","batchTable","featureTableJson","BATCH_LENGTH","featureTableJsonString","JSON","stringify","batchTableJsonString","featureTableJsonByteLength","length","batchTableJsonByteLength","magic","BATCHED_MODEL","byteOffsetStart","setUint32","gltfEncoded","byteLength"],"mappings":"AAGA,SACEA,WADF,EAEEC,oBAFF,EAGEC,0BAHF,QAIO,0BAJP;AAKA,SAAQC,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AAGA,OAAO,SAASC,wBAAT,CAAkCC,IAAlC,EAAwCC,QAAxC,EAAkDC,UAAlD,EAA8DC,OAA9D,EAAuE;AAC5E,QAAM;AAACC,IAAAA,cAAc,GAAG,CAAlB;AAAqBC,IAAAA;AAArB,MAAmCL,IAAzC;AAEA,QAAMM,gBAAgB,GAAG;AACvBC,IAAAA,YAAY,EAAEH;AADS,GAAzB;AAGA,QAAMI,sBAAsB,GAAGC,IAAI,CAACC,SAAL,CAAeJ,gBAAf,CAA/B;AACA,QAAMK,oBAAoB,GAAGN,UAAU,GAAGI,IAAI,CAACC,SAAL,CAAeL,UAAf,CAAH,GAAgC,EAAvE;AACA,QAAMO,0BAA0B,GAAGnB,WAAW,CAACe,sBAAsB,CAACK,MAAxB,EAAgC,CAAhC,CAA9C;AACA,QAAMC,wBAAwB,GAAGH,oBAAoB,GACjDlB,WAAW,CAACkB,oBAAoB,CAACE,MAAtB,EAA8B,CAA9B,CADsC,GAEjD,CAFJ;AAKAb,EAAAA,IAAI,GAAG;AAACe,IAAAA,KAAK,EAAEnB,WAAW,CAACoB,aAApB;AAAmC,OAAGhB;AAAtC,GAAP;AAEA,QAAMiB,eAAe,GAAGf,UAAxB;AAEAA,EAAAA,UAAU,GAAGL,kBAAkB,CAACG,IAAD,EAAOC,QAAP,EAAiBC,UAAjB,CAA/B;;AAEA,MAAID,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACiB,SAAT,CAAmB,EAAnB,EAAuBN,0BAAvB,EAAmD,IAAnD;AACAX,IAAAA,QAAQ,CAACiB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACAjB,IAAAA,QAAQ,CAACiB,SAAT,CAAmB,EAAnB,EAAuBJ,wBAAvB,EAAiD,IAAjD;AACAb,IAAAA,QAAQ,CAACiB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACD;;AACDhB,EAAAA,UAAU,IAAI,EAAd;AAGAA,EAAAA,UAAU,GAAGP,0BAA0B,CAACM,QAAD,EAAWC,UAAX,EAAuBM,sBAAvB,EAA+C,CAA/C,CAAvC;;AAEA,MAAIH,UAAJ,EAAgB;AACdH,IAAAA,UAAU,GAAGP,0BAA0B,CAACM,QAAD,EAAWC,UAAX,EAAuBS,oBAAvB,EAA6C,CAA7C,CAAvC;AACD;;AAGD,QAAMQ,WAAW,GAAGnB,IAAI,CAACmB,WAAzB;;AACA,MAAIA,WAAJ,EAAiB;AACfjB,IAAAA,UAAU,GAAGR,oBAAoB,CAACO,QAAD,EAAWC,UAAX,EAAuBiB,WAAvB,EAAoCA,WAAW,CAACC,UAAhD,CAAjC;AACD;;AAGDtB,EAAAA,sBAAsB,CAACG,QAAD,EAAWgB,eAAX,EAA4Bf,UAAU,GAAGe,eAAzC,CAAtB;AAEA,SAAOf,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 {\n  padToNBytes,\n  copyBinaryToDataView,\n  copyPaddedStringToDataView\n} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array dataView for testing purposes\nexport function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {\n  const {featuresLength = 0, batchTable} = tile;\n\n  const featureTableJson = {\n    BATCH_LENGTH: featuresLength\n  };\n  const featureTableJsonString = JSON.stringify(featureTableJson);\n  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';\n  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);\n  const batchTableJsonByteLength = batchTableJsonString\n    ? padToNBytes(batchTableJsonString.length, 8)\n    : 0;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);\n\n  if (dataView) {\n    dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n    dataView.setUint32(20, batchTableJsonByteLength, true); // batchTableJsonByteLength\n    dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n  }\n  byteOffset += 16;\n\n  // TODO feature table binary\n  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);\n\n  if (batchTable) {\n    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);\n  }\n\n  // Add encoded GLTF to the end of data\n  const gltfEncoded = tile.gltfEncoded;\n  if (gltfEncoded) {\n    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);\n  }\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-batched-model.js"}

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

@@ -1,24 +1,25 @@
-"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;
+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;
 }
-exports.encodeComposite3DTile = encodeComposite3DTile;
+//# sourceMappingURL=encode-3d-tile-composite.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/encoders/encode-3d-tile-composite.ts"],"names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeComposite3DTile","tile","dataView","byteOffset","options","encode3DTile","magic","COMPOSITE","tiles","byteOffsetStart","setUint32","length","i"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AAEA,OAAO,SAASC,qBAAT,CAA+BC,IAA/B,EAAqCC,QAArC,EAA+CC,UAA/C,EAA2DC,OAA3D,EAAoEC,YAApE,EAAkF;AAEvFJ,EAAAA,IAAI,GAAG;AAACK,IAAAA,KAAK,EAAET,WAAW,CAACU,SAApB;AAA+BC,IAAAA,KAAK,EAAE,EAAtC;AAA0C,OAAGP;AAA7C,GAAP;AAEA,QAAMQ,eAAe,GAAGN,UAAxB;AAEAA,EAAAA,UAAU,IAAIL,kBAAkB,CAACG,IAAD,EAAOC,QAAP,EAAiBC,UAAjB,CAAhC;;AAEA,MAAID,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACQ,SAAT,CAAmBP,UAAnB,EAA+BF,IAAI,CAACO,KAAL,CAAWG,MAA1C,EAAkD,IAAlD;AACD;;AACDR,EAAAA,UAAU,IAAI,CAAd;;AAEA,OAAK,IAAIS,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGX,IAAI,CAACO,KAAL,CAAWG,MAA/B,EAAuC,EAAEC,CAAzC,EAA4C;AAC1CT,IAAAA,UAAU,IAAIE,YAAY,CAACJ,IAAI,CAACO,KAAL,CAAWI,CAAX,CAAD,EAAgBV,QAAhB,EAA0BC,UAA1B,EAAsCC,OAAtC,CAA1B;AACD;;AAGDL,EAAAA,sBAAsB,CAACG,QAAD,EAAWO,eAAX,EAA4BN,UAAU,GAAGM,eAAzC,CAAtB;AAEA,SAAON,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 {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\nexport function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset, tile.tiles.length, true); // tilesLength\n  }\n  byteOffset += 4;\n\n  for (let i = 0; i < tile.tiles.length; ++i) {\n    byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);\n  }\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-composite.js"}

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

@@ -1,38 +1,38 @@
-"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;
+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;
 }
-exports.encodeInstancedModel3DTile = encodeInstancedModel3DTile;
+//# sourceMappingURL=encode-3d-tile-instanced-model.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/encoders/encode-3d-tile-instanced-model.ts"],"names":["copyStringToDataView","MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeInstancedModel3DTile","tile","dataView","byteOffset","options","featuresLength","gltfFormat","gltfUri","gltfUriByteLength","length","featureTableJson","INSTANCES_LENGTH","POSITION","Array","fill","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","magic","INSTANCED_MODEL","byteOffsetStart","setUint32"],"mappings":"AAGA,SAAQA,oBAAR,QAAmC,0BAAnC;AACA,SAAQC,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AAIA,OAAO,SAASC,0BAAT,CAAoCC,IAApC,EAA0CC,QAA1C,EAAoDC,UAApD,EAAgEC,OAAhE,EAAyE;AAC9E,QAAM;AAACC,IAAAA,cAAc,GAAG,CAAlB;AAAqBC,IAAAA,UAAU,GAAG,CAAlC;AAAqCC,IAAAA,OAAO,GAAG;AAA/C,MAAqDN,IAA3D;AAEA,QAAMO,iBAAiB,GAAGD,OAAO,CAACE,MAAlC;AAEA,QAAMC,gBAAgB,GAAG;AACvBC,IAAAA,gBAAgB,EAAEN,cADK;AAEvBO,IAAAA,QAAQ,EAAE,IAAIC,KAAJ,CAAUR,cAAc,GAAG,CAA3B,EAA8BS,IAA9B,CAAmC,CAAnC;AAFa,GAAzB;AAIA,QAAMC,sBAAsB,GAAGC,IAAI,CAACC,SAAL,CAAeP,gBAAf,CAA/B;AACA,QAAMQ,0BAA0B,GAAGH,sBAAsB,CAACN,MAA1D;AAGAR,EAAAA,IAAI,GAAG;AAACkB,IAAAA,KAAK,EAAEtB,WAAW,CAACuB,eAApB;AAAqC,OAAGnB;AAAxC,GAAP;AAEA,QAAMoB,eAAe,GAAGlB,UAAxB;AAEAA,EAAAA,UAAU,GAAGL,kBAAkB,CAACG,IAAD,EAAOC,QAAP,EAAiB,CAAjB,CAA/B;;AAEA,MAAIA,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuBJ,0BAAvB,EAAmD,IAAnD;AACAhB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuBhB,UAAvB,EAAmC,IAAnC;AACD;;AAEDH,EAAAA,UAAU,IAAI,EAAd;AAEAA,EAAAA,UAAU,IAAIP,oBAAoB,CAChCM,QADgC,EAEhCC,UAFgC,EAGhCY,sBAHgC,EAIhCG,0BAJgC,CAAlC;AAMAf,EAAAA,UAAU,IAAIP,oBAAoB,CAACM,QAAD,EAAWC,UAAX,EAAuBI,OAAvB,EAAgCC,iBAAhC,CAAlC;AAGAT,EAAAA,sBAAsB,CAACG,QAAD,EAAWmB,eAAX,EAA4BlB,UAAU,GAAGkB,eAAzC,CAAtB;AAEA,SAAOlB,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 {copyStringToDataView} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array buffer for testing purposes\n// eslint-disable-next-line max-statements\nexport function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {\n  const {featuresLength = 1, gltfFormat = 1, gltfUri = ''} = tile;\n\n  const gltfUriByteLength = gltfUri.length;\n\n  const featureTableJson = {\n    INSTANCES_LENGTH: featuresLength,\n    POSITION: new Array(featuresLength * 3).fill(0)\n  };\n  const featureTableJsonString = JSON.stringify(featureTableJson);\n  const featureTableJsonByteLength = featureTableJsonString.length;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset = encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n    dataView.setUint32(20, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n    dataView.setUint32(28, gltfFormat, true); // gltfFormat\n  }\n\n  byteOffset += 20;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-instanced-model.js"}

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

@@ -1,39 +1,41 @@
-"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");
+import { MAGIC_ARRAY } from '../constants';
+import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
+import { padStringToByteAlignment, copyStringToDataView, copyBinaryToDataView } from '@loaders.gl/loader-utils';
 const DEFAULT_FEATURE_TABLE_JSON = {
-    POINTS_LENGTH: 1,
-    POSITIONS: {
-        byteOffset: 0
-    }
+  POINTS_LENGTH: 1,
+  POSITIONS: {
+    byteOffset: 0
+  }
 };
-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;
+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;
 }
-exports.encodePointCloud3DTile = encodePointCloud3DTile;
+//# sourceMappingURL=encode-3d-tile-point-cloud.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/encoders/encode-3d-tile-point-cloud.ts"],"names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","padStringToByteAlignment","copyStringToDataView","copyBinaryToDataView","DEFAULT_FEATURE_TABLE_JSON","POINTS_LENGTH","POSITIONS","byteOffset","encodePointCloud3DTile","tile","dataView","options","featureTableJson","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","length","featureTableBinary","ArrayBuffer","featureTableBinaryByteLength","byteLength","magic","POINT_CLOUD","byteOffsetStart","setUint32"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AACA,SACEC,wBADF,EAEEC,oBAFF,EAGEC,oBAHF,QAIO,0BAJP;AAMA,MAAMC,0BAA0B,GAAG;AACjCC,EAAAA,aAAa,EAAE,CADkB;AAEjCC,EAAAA,SAAS,EAAE;AACTC,IAAAA,UAAU,EAAE;AADH;AAFsB,CAAnC;AAOA,OAAO,SAASC,sBAAT,CAAgCC,IAAhC,EAAsCC,QAAtC,EAAgDH,UAAhD,EAA4DI,OAA5D,EAAqE;AAC1E,QAAM;AAACC,IAAAA,gBAAgB,GAAGR;AAApB,MAAkDK,IAAxD;AAEA,MAAII,sBAAsB,GAAGC,IAAI,CAACC,SAAL,CAAeH,gBAAf,CAA7B;AACAC,EAAAA,sBAAsB,GAAGZ,wBAAwB,CAACY,sBAAD,EAAyB,CAAzB,CAAjD;AAEA,QAAM;AAACG,IAAAA,0BAA0B,GAAGH,sBAAsB,CAACI;AAArD,MAA+DR,IAArE;AAEA,QAAMS,kBAAkB,GAAG,IAAIC,WAAJ,CAAgB,EAAhB,CAA3B;AACA,QAAMC,4BAA4B,GAAGF,kBAAkB,CAACG,UAAxD;AAGAZ,EAAAA,IAAI,GAAG;AAACa,IAAAA,KAAK,EAAExB,WAAW,CAACyB,WAApB;AAAiC,OAAGd;AAApC,GAAP;AAEA,QAAMe,eAAe,GAAGjB,UAAxB;AAEAA,EAAAA,UAAU,IAAIR,kBAAkB,CAACU,IAAD,EAAOC,QAAP,EAAiB,CAAjB,CAAhC;;AAEA,MAAIA,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmCS,0BAAnC,EAA+D,IAA/D;AACAN,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmCa,4BAAnC,EAAiE,IAAjE;AACAV,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmC,CAAnC,EAAsC,IAAtC;AACAG,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,EAAhC,EAAoC,CAApC,EAAuC,IAAvC;AACD;;AACDA,EAAAA,UAAU,IAAI,EAAd;AAEAA,EAAAA,UAAU,IAAIL,oBAAoB,CAChCQ,QADgC,EAEhCH,UAFgC,EAGhCM,sBAHgC,EAIhCG,0BAJgC,CAAlC;AAMAT,EAAAA,UAAU,IAAIJ,oBAAoB,CAChCO,QADgC,EAEhCH,UAFgC,EAGhCW,kBAHgC,EAIhCE,4BAJgC,CAAlC;AAQApB,EAAAA,sBAAsB,CAACU,QAAD,EAAWc,eAAX,EAA4BjB,UAAU,GAAGiB,eAAzC,CAAtB;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 {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\nimport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from '@loaders.gl/loader-utils';\n\nconst DEFAULT_FEATURE_TABLE_JSON = {\n  POINTS_LENGTH: 1,\n  POSITIONS: {\n    byteOffset: 0\n  }\n};\n\nexport function encodePointCloud3DTile(tile, dataView, byteOffset, options) {\n  const {featureTableJson = DEFAULT_FEATURE_TABLE_JSON} = tile;\n\n  let featureTableJsonString = JSON.stringify(featureTableJson);\n  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);\n\n  const {featureTableJsonByteLength = featureTableJsonString.length} = tile;\n\n  const featureTableBinary = new ArrayBuffer(12); // Enough space to hold 3 floats\n  const featureTableBinaryByteLength = featureTableBinary.byteLength;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.POINT_CLOUD, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true); // featureTableBinaryByteLength\n    dataView.setUint32(byteOffset + 8, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(byteOffset + 12, 0, true); // batchTableBinaryByteLength\n  }\n  byteOffset += 16;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyBinaryToDataView(\n    dataView,\n    byteOffset,\n    featureTableBinary,\n    featureTableBinaryByteLength\n  );\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-point-cloud.js"}