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

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

@@ -0,0 +1,245 @@
+"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 loader_utils_1 = require("@loaders.gl/loader-utils");
+const tile_3d_accessor_utils_1 = require("./helpers/tile-3d-accessor-utils");
+const tile_3d_batch_table_hierarchy_1 = require("./tile-3d-batch-table-hierarchy");
+function defined(x) {
+    return x !== undefined && x !== null;
+}
+const clone = (x, y) => x;
+// These top level fields in the batch table json are not properties
+const IGNORED_PROPERTY_FIELDS = {
+    HIERARCHY: true,
+    extensions: true,
+    extras: true
+};
+// The size of this array equals the maximum instance count among all loaded tiles, which has the potential to be large.
+class Tile3DBatchTableParser {
+    constructor(json, binary, featureCount, options = {}) {
+        (0, loader_utils_1.assert)(featureCount >= 0);
+        this.json = json || {};
+        this.binary = binary;
+        this.featureCount = featureCount;
+        this._extensions = this.json?.extensions || {};
+        // Copy all top-level property fields from the json object, ignoring special fields
+        this._properties = {};
+        for (const propertyName in this.json) {
+            if (!IGNORED_PROPERTY_FIELDS[propertyName]) {
+                this._properties[propertyName] = this.json[propertyName];
+            }
+        }
+        this._binaryProperties = this._initializeBinaryProperties();
+        // TODO: hierarchy support is only partially implemented and not tested
+        if (options['3DTILES_batch_table_hierarchy']) {
+            this._hierarchy = (0, tile_3d_batch_table_hierarchy_1.initializeHierarchy)(this, this.json, this.binary);
+        }
+    }
+    getExtension(extensionName) {
+        return this.json && this.json.extensions && this.json.extensions[extensionName];
+    }
+    memorySizeInBytes() {
+        return 0;
+    }
+    isClass(batchId, className) {
+        this._checkBatchId(batchId);
+        (0, loader_utils_1.assert)(typeof className === 'string', className);
+        // extension: 3DTILES_batch_table_hierarchy
+        if (this._hierarchy) {
+            // PERFORMANCE_IDEA : cache results in the ancestor classes
+            //   to speed up this check if this area becomes a hotspot
+            // PERFORMANCE_IDEA : treat class names as integers for faster comparisons
+            const result = (0, tile_3d_batch_table_hierarchy_1.traverseHierarchy)(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
+                const classId = hierarchy.classIds[instanceIndex];
+                const instanceClass = hierarchy.classes[classId];
+                return instanceClass.name === className;
+            });
+            return defined(result);
+        }
+        return false;
+    }
+    isExactClass(batchId, className) {
+        (0, loader_utils_1.assert)(typeof className === 'string', className);
+        return this.getExactClassName(batchId) === className;
+    }
+    getExactClassName(batchId) {
+        this._checkBatchId(batchId);
+        // extension: 3DTILES_batch_table_hierarchy
+        if (this._hierarchy) {
+            const classId = this._hierarchy.classIds[batchId];
+            const instanceClass = this._hierarchy.classes[classId];
+            return instanceClass.name;
+        }
+        return undefined;
+    }
+    hasProperty(batchId, name) {
+        this._checkBatchId(batchId);
+        (0, loader_utils_1.assert)(typeof name === 'string', name);
+        return defined(this._properties[name]) || this._hasPropertyInHierarchy(batchId, name);
+    }
+    getPropertyNames(batchId, results) {
+        this._checkBatchId(batchId);
+        results = defined(results) ? results : [];
+        results.length = 0;
+        const propertyNames = Object.keys(this._properties);
+        results.push(...propertyNames);
+        if (this._hierarchy) {
+            this._getPropertyNamesInHierarchy(batchId, results);
+        }
+        return results;
+    }
+    getProperty(batchId, name) {
+        this._checkBatchId(batchId);
+        (0, loader_utils_1.assert)(typeof name === 'string', name);
+        if (this._binaryProperties) {
+            const binaryProperty = this._binaryProperties[name];
+            if (defined(binaryProperty)) {
+                return this._getBinaryProperty(binaryProperty, batchId);
+            }
+        }
+        const propertyValues = this._properties[name];
+        if (defined(propertyValues)) {
+            return clone(propertyValues[batchId], true);
+        }
+        // EXTENSION: 3DTILES_batch_table_hierarchy
+        if (this._hierarchy) {
+            const hierarchyProperty = this._getHierarchyProperty(batchId, name);
+            if (defined(hierarchyProperty)) {
+                return hierarchyProperty;
+            }
+        }
+        return undefined;
+    }
+    setProperty(batchId, name, value) {
+        const featureCount = this.featureCount;
+        this._checkBatchId(batchId);
+        (0, loader_utils_1.assert)(typeof name === 'string', name);
+        if (this._binaryProperties) {
+            const binaryProperty = this._binaryProperties[name];
+            if (binaryProperty) {
+                this._setBinaryProperty(binaryProperty, batchId, value);
+                return;
+            }
+        }
+        // EXTENSION: 3DTILES_batch_table_hierarchy
+        if (this._hierarchy) {
+            if (this._setHierarchyProperty(this, batchId, name, value)) {
+                return;
+            }
+        }
+        let propertyValues = this._properties[name];
+        if (!defined(propertyValues)) {
+            // Property does not exist. Create it.
+            this._properties[name] = new Array(featureCount);
+            propertyValues = this._properties[name];
+        }
+        propertyValues[batchId] = clone(value, true);
+    }
+    // PRIVATE METHODS
+    _checkBatchId(batchId) {
+        const valid = batchId >= 0 && batchId < this.featureCount;
+        if (!valid) {
+            throw new Error('batchId not in range [0, featureCount - 1].');
+        }
+    }
+    _getBinaryProperty(binaryProperty, index) {
+        return binaryProperty.unpack(binaryProperty.typedArray, index);
+    }
+    _setBinaryProperty(binaryProperty, index, value) {
+        binaryProperty.pack(value, binaryProperty.typedArray, index);
+    }
+    _initializeBinaryProperties() {
+        let binaryProperties = null;
+        for (const name in this._properties) {
+            const property = this._properties[name];
+            const binaryProperty = this._initializeBinaryProperty(name, property);
+            // Store any information needed to access the binary data, including the typed array,
+            // componentCount (e.g. a VEC4 would be 4), and the type used to pack and unpack (e.g. Cartesian4).
+            if (binaryProperty) {
+                binaryProperties = binaryProperties || {};
+                binaryProperties[name] = binaryProperty;
+            }
+        }
+        return binaryProperties;
+    }
+    _initializeBinaryProperty(name, property) {
+        if ('byteOffset' in property) {
+            // This is a binary property
+            const tile3DAccessor = property;
+            (0, loader_utils_1.assert)(this.binary, `Property ${name} requires a batch table binary.`);
+            (0, loader_utils_1.assert)(tile3DAccessor.type, `Property ${name} requires a type.`);
+            const accessor = (0, tile_3d_accessor_utils_1.createTypedArrayFromAccessor)(tile3DAccessor, this.binary.buffer, this.binary.byteOffset | 0, this.featureCount);
+            // Store any information needed to access the binary data, including the typed array,
+            // componentCount (e.g. a VEC4 would be 4), and the type used to pack and unpack (e.g. Cartesian4).
+            return {
+                typedArray: accessor.values,
+                componentCount: accessor.size,
+                unpack: accessor.unpacker,
+                pack: accessor.packer
+            };
+        }
+        return null;
+    }
+    //  EXTENSION SUPPORT: 3DTILES_batch_table_hierarchy
+    _hasPropertyInHierarchy(batchId, name) {
+        if (!this._hierarchy) {
+            return false;
+        }
+        const result = (0, tile_3d_batch_table_hierarchy_1.traverseHierarchy)(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
+            const classId = hierarchy.classIds[instanceIndex];
+            const instances = hierarchy.classes[classId].instances;
+            return defined(instances[name]);
+        });
+        return defined(result);
+    }
+    _getPropertyNamesInHierarchy(batchId, results) {
+        (0, tile_3d_batch_table_hierarchy_1.traverseHierarchy)(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
+            const classId = hierarchy.classIds[instanceIndex];
+            const instances = hierarchy.classes[classId].instances;
+            for (const name in instances) {
+                if (instances.hasOwnProperty(name)) {
+                    if (results.indexOf(name) === -1) {
+                        results.push(name);
+                    }
+                }
+            }
+        });
+    }
+    _getHierarchyProperty(batchId, name) {
+        return (0, tile_3d_batch_table_hierarchy_1.traverseHierarchy)(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
+            const classId = hierarchy.classIds[instanceIndex];
+            const instanceClass = hierarchy.classes[classId];
+            const indexInClass = hierarchy.classIndexes[instanceIndex];
+            const propertyValues = instanceClass.instances[name];
+            if (defined(propertyValues)) {
+                if (defined(propertyValues.typedArray)) {
+                    return this._getBinaryProperty(propertyValues, indexInClass);
+                }
+                return clone(propertyValues[indexInClass], true);
+            }
+            return null;
+        });
+    }
+    _setHierarchyProperty(batchTable, batchId, name, value) {
+        const result = (0, tile_3d_batch_table_hierarchy_1.traverseHierarchy)(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
+            const classId = hierarchy.classIds[instanceIndex];
+            const instanceClass = hierarchy.classes[classId];
+            const indexInClass = hierarchy.classIndexes[instanceIndex];
+            const propertyValues = instanceClass.instances[name];
+            if (defined(propertyValues)) {
+                (0, loader_utils_1.assert)(instanceIndex === batchId, `Inherited property "${name}" is read-only.`);
+                if (defined(propertyValues.typedArray)) {
+                    this._setBinaryProperty(propertyValues, indexInClass, value);
+                }
+                else {
+                    propertyValues[indexInClass] = clone(value, true);
+                }
+                return true;
+            }
+            return false;
+        });
+        return defined(result);
+    }
+}
+exports.default = Tile3DBatchTableParser;

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

@@ -1,9 +1,9 @@
 export default class Tile3DFeatureTable {
-    constructor(featureTableJson: any, featureTableBinary: any);
     json: any;
     buffer: any;
     featuresLength: number;
     _cachedTypedArrays: {};
+    constructor(featureTableJson: any, featureTableBinary: any);
     getExtension(extensionName: any): any;
     hasProperty(propertyName: any): boolean;
     getGlobalProperty(propertyName: any, componentType?: number, componentLength?: number): any;
@@ -12,3 +12,4 @@ export default class Tile3DFeatureTable {
     _getTypedArrayFromBinary(propertyName: any, componentType: any, componentLength: any, count: any, byteOffset: any): any;
     _getTypedArrayFromArray(propertyName: any, componentType: any, array: any): any;
 }
+//# sourceMappingURL=tile-3d-feature-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-feature-table.d.ts","sourceRoot":"","sources":["../../../src/lib/classes/tile-3d-feature-table.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC,IAAI,MAAC;IACL,MAAM,MAAC;IACP,cAAc,SAAK;IACnB,kBAAkB,KAAM;gBAEZ,gBAAgB,KAAA,EAAE,kBAAkB,KAAA;IAKhD,YAAY,CAAC,aAAa,KAAA;IAI1B,WAAW,CAAC,YAAY,KAAA;IAIxB,iBAAiB,CAAC,YAAY,KAAA,EAAE,aAAa,SAAkB,EAAE,eAAe,SAAI;IAgBpF,gBAAgB,CAAC,YAAY,KAAA,EAAE,aAAa,KAAA,EAAE,eAAe,KAAA;IAmB7D,WAAW,CAAC,YAAY,KAAA,EAAE,aAAa,KAAA,EAAE,eAAe,KAAA,EAAE,SAAS,KAAA,EAAE,MAAM,KAAA;IAqB3E,wBAAwB,CAAC,YAAY,KAAA,EAAE,aAAa,KAAA,EAAE,eAAe,KAAA,EAAE,KAAK,KAAA,EAAE,UAAU,KAAA;IAexF,uBAAuB,CAAC,YAAY,KAAA,EAAE,aAAa,KAAA,EAAE,KAAK,KAAA;CAS3D"}

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

@@ -0,0 +1,72 @@
+"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;
+    }
+    getExtension(extensionName) {
+        return this.json.extensions && this.json.extensions[extensionName];
+    }
+    hasProperty(propertyName) {
+        return Boolean(this.json[propertyName]);
+    }
+    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;
+    }
+    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);
+    }
+    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;
+    }
+    // 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;
+    }
+}
+exports.default = Tile3DFeatureTable;

package/dist/lib/constants.d.ts

@@ -1,22 +1,21 @@
-export namespace TILE3D_TYPE {
-    const COMPOSITE: string;
-    const POINT_CLOUD: string;
-    const BATCHED_3D_MODEL: string;
-    const INSTANCED_3D_MODEL: string;
-    const GEOMETRY: string;
-    const VECTOR: string;
-}
-export const TILE3D_TYPES: string[];
-export namespace MAGIC_ARRAY {
-    export const BATCHED_MODEL: number[];
-    export const INSTANCED_MODEL: number[];
-    const POINT_CLOUD_1: number[];
-    export { POINT_CLOUD_1 as POINT_CLOUD };
-    const COMPOSITE_1: number[];
-    export { COMPOSITE_1 as COMPOSITE };
-}
-export namespace TILE3D_OPTIMIZATION_HINT {
-    const NOT_COMPUTED: number;
-    const USE_OPTIMIZATION: number;
-    const SKIP_OPTIMIZATION: number;
-}
+export declare const TILE3D_TYPE: {
+    COMPOSITE: string;
+    POINT_CLOUD: string;
+    BATCHED_3D_MODEL: string;
+    INSTANCED_3D_MODEL: string;
+    GEOMETRY: string;
+    VECTOR: string;
+};
+export declare const TILE3D_TYPES: string[];
+export declare const MAGIC_ARRAY: {
+    BATCHED_MODEL: number[];
+    INSTANCED_MODEL: number[];
+    POINT_CLOUD: number[];
+    COMPOSITE: number[];
+};
+export declare const TILE3D_OPTIMIZATION_HINT: {
+    NOT_COMPUTED: number;
+    USE_OPTIMIZATION: number;
+    SKIP_OPTIMIZATION: number;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/lib/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;CAOvB,CAAC;AAEF,eAAO,MAAM,YAAY,UAA2B,CAAC;AAErD,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAGF,eAAO,MAAM,wBAAwB;;;;CAIpC,CAAC"}

package/dist/lib/constants.js

@@ -0,0 +1,25 @@
+"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'
+};
+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]
+};
+// TILE CONSTANTS
+exports.TILE3D_OPTIMIZATION_HINT = {
+    NOT_COMPUTED: -1,
+    USE_OPTIMIZATION: 1,
+    SKIP_OPTIMIZATION: 0
+};

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

@@ -1 +1,2 @@
-export function encodeBatchedModel3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+export declare function encodeBatchedModel3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+//# sourceMappingURL=encode-3d-tile-batched-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-batched-model.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-3d-tile-batched-model.ts"],"names":[],"mappings":"AAYA,wBAAgB,wBAAwB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,OA6C3E"}

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

@@ -0,0 +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;
+}
+exports.encodeBatchedModel3DTile = encodeBatchedModel3DTile;

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

@@ -1 +1,2 @@
-export function encodeComposite3DTile(tile: any, dataView: any, byteOffset: any, options: any, encode3DTile: any): any;
+export declare function encodeComposite3DTile(tile: any, dataView: any, byteOffset: any, options: any, encode3DTile: any): any;
+//# sourceMappingURL=encode-3d-tile-composite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-composite.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-3d-tile-composite.ts"],"names":[],"mappings":"AAMA,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,YAAY,KAAA,OAqBtF"}

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

@@ -0,0 +1,24 @@
+"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;
+}
+exports.encodeComposite3DTile = encodeComposite3DTile;

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

@@ -1 +1,2 @@
-export function encodeInstancedModel3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+export declare function encodeInstancedModel3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+//# sourceMappingURL=encode-3d-tile-instanced-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-instanced-model.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-3d-tile-instanced-model.ts"],"names":[],"mappings":"AASA,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,OAyC7E"}

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

@@ -0,0 +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;
+}
+exports.encodeInstancedModel3DTile = encodeInstancedModel3DTile;

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

@@ -1 +1,2 @@
-export function encodePointCloud3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+export declare function encodePointCloud3DTile(tile: any, dataView: any, byteOffset: any, options: any): any;
+//# sourceMappingURL=encode-3d-tile-point-cloud.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAkBA,wBAAgB,sBAAsB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,OA2CzE"}

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

@@ -0,0 +1,39 @@
+"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
+    }
+};
+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;
+}
+exports.encodePointCloud3DTile = encodePointCloud3DTile;

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

@@ -1 +1,2 @@
 export default function encode3DTile(tile: any, options: any): ArrayBuffer;
+//# sourceMappingURL=encode-3d-tile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-3d-tile.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,eAMjD"}

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

@@ -0,0 +1,33 @@
+"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) {
+    (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');
+    }
+}

package/dist/lib/encoders/helpers/encode-3d-tile-header.d.ts

@@ -1,2 +1,3 @@
-export function encode3DTileHeader(tile: any, dataView: any, byteOffset: any): any;
-export function encode3DTileByteLength(dataView: any, byteOffsetTileStart: any, byteLength: any): void;
+export declare function encode3DTileHeader(tile: any, dataView: any, byteOffset: any): any;
+export declare function encode3DTileByteLength(dataView: any, byteOffsetTileStart: any, byteLength: any): void;
+//# sourceMappingURL=encode-3d-tile-header.d.ts.map