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

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

@@ -1,230 +1,245 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// Copyright vis.gl contributors
+// 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
 import { assert } from '@loaders.gl/loader-utils';
 import { createTypedArrayFromAccessor } from "./helpers/tile-3d-accessor-utils.js";
 import { initializeHierarchy, traverseHierarchy } from "./tile-3d-batch-table-hierarchy.js";
 function defined(x) {
-  return x !== undefined && x !== null;
+    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
+    HIERARCHY: true, // Deprecated HIERARCHY property
+    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.
 export default class Tile3DBatchTableParser {
-  constructor(json, binary, featureCount) {
-    var _this$json;
-    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    this.json = void 0;
-    this.binary = void 0;
-    this.featureCount = void 0;
-    this._extensions = void 0;
-    this._properties = void 0;
-    this._binaryProperties = void 0;
-    this._hierarchy = void 0;
-    assert(featureCount >= 0);
-    this.json = json || {};
-    this.binary = binary;
-    this.featureCount = featureCount;
-    this._extensions = ((_this$json = this.json) === null || _this$json === void 0 ? void 0 : _this$json.extensions) || {};
-    this._properties = {};
-    for (const propertyName in this.json) {
-      if (!IGNORED_PROPERTY_FIELDS[propertyName]) {
-        this._properties[propertyName] = this.json[propertyName];
-      }
-    }
-    this._binaryProperties = this._initializeBinaryProperties();
-    if (options['3DTILES_batch_table_hierarchy']) {
-      this._hierarchy = 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);
-    assert(typeof className === 'string', className);
-    if (this._hierarchy) {
-      const result = 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) {
-    assert(typeof className === 'string', className);
-    return this.getExactClassName(batchId) === className;
-  }
-  getExactClassName(batchId) {
-    this._checkBatchId(batchId);
-    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);
-    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);
-    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);
-    }
-    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);
-    assert(typeof name === 'string', name);
-    if (this._binaryProperties) {
-      const binaryProperty = this._binaryProperties[name];
-      if (binaryProperty) {
-        this._setBinaryProperty(binaryProperty, batchId, value);
-        return;
-      }
-    }
-    if (this._hierarchy) {
-      if (this._setHierarchyProperty(this, batchId, name, value)) {
-        return;
-      }
-    }
-    let propertyValues = this._properties[name];
-    if (!defined(propertyValues)) {
-      this._properties[name] = new Array(featureCount);
-      propertyValues = this._properties[name];
-    }
-    propertyValues[batchId] = clone(value, true);
-  }
-  _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);
-      if (binaryProperty) {
-        binaryProperties = binaryProperties || {};
-        binaryProperties[name] = binaryProperty;
-      }
-    }
-    return binaryProperties;
-  }
-  _initializeBinaryProperty(name, property) {
-    if ('byteOffset' in property) {
-      const tile3DAccessor = property;
-      assert(this.binary, `Property ${name} requires a batch table binary.`);
-      assert(tile3DAccessor.type, `Property ${name} requires a type.`);
-      const accessor = createTypedArrayFromAccessor(tile3DAccessor, this.binary.buffer, this.binary.byteOffset | 0, this.featureCount);
-      return {
-        typedArray: accessor.values,
-        componentCount: accessor.size,
-        unpack: accessor.unpacker,
-        pack: accessor.packer
-      };
-    }
-    return null;
-  }
-  _hasPropertyInHierarchy(batchId, name) {
-    if (!this._hierarchy) {
-      return false;
-    }
-    const result = 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) {
-    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);
-          }
+    constructor(json, binary, featureCount, options = {}) {
+        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];
+            }
         }
-      }
-    });
-  }
-  _getHierarchyProperty(batchId, name) {
-    return 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);
+        this._binaryProperties = this._initializeBinaryProperties();
+        // TODO: hierarchy support is only partially implemented and not tested
+        if (options['3DTILES_batch_table_hierarchy']) {
+            this._hierarchy = initializeHierarchy(this, this.json, this.binary);
         }
-        return clone(propertyValues[indexInClass], true);
-      }
-      return null;
-    });
-  }
-  _setHierarchyProperty(batchTable, batchId, name, value) {
-    const result = 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)) {
-        assert(instanceIndex === batchId, `Inherited property "${name}" is read-only.`);
-        if (defined(propertyValues.typedArray)) {
-          this._setBinaryProperty(propertyValues, indexInClass, value);
-        } else {
-          propertyValues[indexInClass] = clone(value, true);
+    }
+    getExtension(extensionName) {
+        return this.json && this.json.extensions && this.json.extensions[extensionName];
+    }
+    memorySizeInBytes() {
+        return 0;
+    }
+    isClass(batchId, className) {
+        this._checkBatchId(batchId);
+        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 = 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) {
+        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);
+        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);
+        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);
+        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;
+            }
         }
-        return true;
-      }
-      return false;
-    });
-    return defined(result);
-  }
+        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;
+            assert(this.binary, `Property ${name} requires a batch table binary.`);
+            assert(tile3DAccessor.type, `Property ${name} requires a type.`);
+            const accessor = 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 = 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) {
+        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 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 = 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)) {
+                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);
+    }
 }
-//# sourceMappingURL=tile-3d-batch-table.js.map

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

@@ -1,69 +1,72 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// Copyright vis.gl contributors
+// 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
 import { GL, GLType } from '@loaders.gl/math';
+// Reference:
+// https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js
 export default class Tile3DFeatureTable {
-  constructor(featureTableJson, featureTableBinary) {
-    this.json = void 0;
-    this.buffer = void 0;
-    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) {
-    let componentType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GL.UNSIGNED_INT;
-    let componentLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-    const jsonValue = this.json[propertyName];
-    if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {
-      return this._getTypedArrayFromBinary(propertyName, componentType, componentLength, 1, jsonValue.byteOffset);
+    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 = 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 = 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 = 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 = GLType.createTypedArray(componentType, array);
+            cachedTypedArrays[propertyName] = typedArray;
+        }
+        return typedArray;
     }
-    return typedArray;
-  }
 }
-//# sourceMappingURL=tile-3d-feature-table.js.map

package/dist/lib/constants.js

@@ -1,22 +1,26 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+// TILE TYPES
 export const TILE3D_TYPE = {
-  COMPOSITE: 'cmpt',
-  POINT_CLOUD: 'pnts',
-  BATCHED_3D_MODEL: 'b3dm',
-  INSTANCED_3D_MODEL: 'i3dm',
-  GEOMETRY: 'geom',
-  VECTOR: 'vect',
-  GLTF: 'glTF'
+    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]
+    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
 export const TILE3D_OPTIMIZATION_HINT = {
-  NOT_COMPUTED: -1,
-  USE_OPTIMIZATION: 1,
-  SKIP_OPTIMIZATION: 0
+    NOT_COMPUTED: -1,
+    USE_OPTIMIZATION: 1,
+    SKIP_OPTIMIZATION: 0
 };
-//# sourceMappingURL=constants.js.map