@itwin/core-common 3.5.0-dev.4 → 3.5.0-dev.7

package/lib/esm/FeatureTable.js

@@ -1,273 +1,273 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Rendering
- */
-import { assert, compareNumbers, compareStrings, Id64, IndexedValue, IndexMap } from "@itwin/core-bentley";
-import { GeometryClass } from "./GeometryParams";
-/** Describes a discrete entity within a batched [RenderGraphic]($frontend) that can be
- * grouped with other such entities in a [[FeatureTable]].
- * Features roughly correlate to elements: a [Tile]($frontend)'s graphics combines geometry from every
- * [GeometricElement]($backend) that intersects the tile's volume, so each element produces at least one feature.
- * However, an element's geometry stream can contain geometry belonging to multiple different combinations of [SubCategory]($backend) and
- * [[GeometryClass]], so an individual element may produce more than one feature.
- * @see [[FeatureOverrides]] for customizing the appearance of individual features.
- * @public
- */
-export class Feature {
-    constructor(elementId = Id64.invalid, subCategoryId = Id64.invalid, geometryClass = GeometryClass.Primary) {
-        this.elementId = elementId;
-        this.subCategoryId = subCategoryId;
-        this.geometryClass = geometryClass;
-    }
-    get isDefined() { return !Id64.isInvalid(this.elementId) || !Id64.isInvalid(this.subCategoryId) || this.geometryClass !== GeometryClass.Primary; }
-    get isUndefined() { return !this.isDefined; }
-    /** Returns true if this feature is equivalent to the supplied feature. */
-    equals(other) { return 0 === this.compare(other); }
-    /** Performs ordinal comparison of this feature with another.
-     * @param rhs The feature to compare with.
-     * @returns zero if the features are equivalent, a negative value if this feature compares as "less than" `rhs`, or a positive value if this feature compares "greater than" `rhs`.
-     */
-    compare(rhs) {
-        if (this === rhs)
-            return 0;
-        let cmp = compareNumbers(this.geometryClass, rhs.geometryClass);
-        if (0 === cmp) {
-            cmp = compareStrings(this.elementId, rhs.elementId);
-            if (0 === cmp) {
-                cmp = compareStrings(this.subCategoryId, rhs.subCategoryId);
-            }
-        }
-        return cmp;
-    }
-}
-/** Describes the type of a 'batch' of graphics representing multiple [[Feature]]s.
- * The most commonly-encountered batches are Tiles, which can be of either Primary or
- * Classifier type.
- * @public
- * @extensions
- */
-export var BatchType;
-(function (BatchType) {
-    /** This batch contains graphics derived from a model's visible geometry. */
-    BatchType[BatchType["Primary"] = 0] = "Primary";
-    /**
-     * This batch contains color volumes which are used to classify a model's visible geometry.
-     * The graphics themselves are not rendered to the screen; instead they are rendered to the stencil buffer
-     * to resymbolize the primary geometry.
-     */
-    BatchType[BatchType["VolumeClassifier"] = 1] = "VolumeClassifier";
-    /**
-     * This batch contains planar graphics which are used to classify a model's visible geometry.
-     * The graphics themselves are not rendered to the screen; instead they are rendered to a texture buffer
-     * to resymbolize the primary geometry.
-     */
-    BatchType[BatchType["PlanarClassifier"] = 2] = "PlanarClassifier";
-})(BatchType || (BatchType = {}));
-/** Defines a look-up table for [[Feature]]s within a batched [RenderGraphic]($frontend). Consecutive 32-bit
- * indices are assigned to each unique Feature. Primitives within the RenderGraphic can
- * use per-vertex indices to specify the distribution of Features within the primitive. The appearance of individual
- * features can be customized using [[FeatureOverrides]]. Typically a [Tile]($frontend) will contain a feature table
- * identifying the elements whose geometry appears within that tile.
- * @see [[FeatureOverrides]] for customizing the appearance of individual features.
- * @public
- */
-export class FeatureTable extends IndexMap {
-    /** Construct an empty FeatureTable. */
-    constructor(maxFeatures, modelId = Id64.invalid, type = BatchType.Primary) {
-        super((lhs, rhs) => lhs.compare(rhs), maxFeatures);
-        this.modelId = modelId;
-        this.type = type;
-    }
-    /** Returns the maximum number of [[Feature]]s this FeatureTable can contain. */
-    get maxFeatures() { return this._maximumSize; }
-    /** @internal */
-    get anyDefined() { return this.length > 1 || (1 === this.length && this._array[0].value.isDefined); }
-    /** Returns true if this FeatureTable contains exactly one [[Feature]]. */
-    get isUniform() { return 1 === this.length; }
-    /** If this FeatureTable contains exactly one [[Feature]], returns that Feature; otherwise returns undefined. */
-    get uniform() { return 1 === this.length ? this._array[0].value : undefined; }
-    /** Returns true if this FeatureTable is associated with [[BatchType.VolumeClassifier]] geometry. */
-    get isVolumeClassifier() { return BatchType.VolumeClassifier === this.type; }
-    /** Returns true if this FeatureTable is associated with [[BatchType.PlanarClassifier]] geometry. */
-    get isPlanarClassifier() { return BatchType.PlanarClassifier === this.type; }
-    /** Returns the Feature corresponding to the specified index, or undefined if the index is not present. */
-    findFeature(index) {
-        for (const entry of this._array)
-            if (entry.index === index)
-                return entry.value;
-        return undefined;
-    }
-    /** @internal */
-    insertWithIndex(feature, index) {
-        const bound = this.lowerBound(feature);
-        assert(!bound.equal);
-        assert(!this.isFull);
-        const entry = new IndexedValue(feature, index);
-        this._array.splice(bound.index, 0, entry);
-    }
-    /** @internal */
-    getArray() { return this._array; }
-}
-/**
- * An immutable, packed representation of a [[FeatureTable]]. The features are packed into a single array of 32-bit integer values,
- * wherein each feature occupies 3 32-bit integers.
- * @internal
- */
-export class PackedFeatureTable {
-    /** Construct a PackedFeatureTable from the packed binary data.
-     * This is used internally when deserializing Tiles in iMdl format.
-     * @internal
-     */
-    constructor(data, modelId, numFeatures, maxFeatures, type, animationNodeIds) {
-        this._data = data;
-        this.modelId = modelId;
-        this.maxFeatures = maxFeatures;
-        this.numFeatures = numFeatures;
-        this.type = type;
-        this._animationNodeIds = animationNodeIds;
-        switch (this.numFeatures) {
-            case 0:
-                this.anyDefined = false;
-                break;
-            case 1:
-                this.anyDefined = this.getFeature(0).isDefined;
-                break;
-            default:
-                this.anyDefined = true;
-                break;
-        }
-        assert(this._data.length >= this._subCategoriesOffset);
-        assert(this.maxFeatures >= this.numFeatures);
-        assert(undefined === this._animationNodeIds || this._animationNodeIds.length === this.numFeatures);
-    }
-    get byteLength() { return this._data.byteLength; }
-    get animationNodeIds() { return this._animationNodeIds; }
-    /** Create a packed feature table from a [[FeatureTable]]. */
-    static pack(featureTable) {
-        // We must determine how many subcategories we have ahead of time to compute the size of the Uint32Array, as
-        // the array cannot be resized after it is created.
-        // We are not too worried about this as FeatureTables created on the front-end will contain few if any features; those obtained from the
-        // back-end arrive within tiles already in the packed format.
-        const subcategories = new Map();
-        for (const iv of featureTable.getArray()) {
-            const found = subcategories.get(iv.value.subCategoryId.toString());
-            if (undefined === found)
-                subcategories.set(iv.value.subCategoryId, subcategories.size);
-        }
-        // We need 3 32-bit integers per feature, plus 2 32-bit integers per subcategory.
-        const subCategoriesOffset = 3 * featureTable.length;
-        const nUint32s = subCategoriesOffset + 2 * subcategories.size;
-        const uint32s = new Uint32Array(nUint32s);
-        for (const iv of featureTable.getArray()) {
-            const feature = iv.value;
-            const index = iv.index * 3;
-            let subCategoryIndex = subcategories.get(feature.subCategoryId);
-            assert(undefined !== subCategoryIndex); // we inserted it above...
-            subCategoryIndex |= (feature.geometryClass << 24);
-            uint32s[index + 0] = Id64.getLowerUint32(feature.elementId);
-            uint32s[index + 1] = Id64.getUpperUint32(feature.elementId);
-            uint32s[index + 2] = subCategoryIndex;
-        }
-        subcategories.forEach((index, id, _map) => {
-            const index32 = subCategoriesOffset + 2 * index;
-            uint32s[index32 + 0] = Id64.getLowerUint32(id);
-            uint32s[index32 + 1] = Id64.getUpperUint32(id);
-        });
-        return new PackedFeatureTable(uint32s, featureTable.modelId, featureTable.length, featureTable.maxFeatures, featureTable.type);
-    }
-    /** Retrieve the Feature associated with the specified index. */
-    getFeature(featureIndex) {
-        const packed = this.getPackedFeature(featureIndex);
-        const elemId = Id64.fromUint32Pair(packed.elementId.lower, packed.elementId.upper);
-        const subcatId = Id64.fromUint32Pair(packed.subCategoryId.lower, packed.subCategoryId.upper);
-        return new Feature(elemId, subcatId, packed.geometryClass);
-    }
-    /** Returns the Feature associated with the specified index, or undefined if the index is out of range. */
-    findFeature(featureIndex) {
-        return featureIndex < this.numFeatures ? this.getFeature(featureIndex) : undefined;
-    }
-    /** @internal */
-    getElementIdPair(featureIndex, out) {
-        out = out !== null && out !== void 0 ? out : { lower: 0, upper: 0 };
-        assert(featureIndex < this.numFeatures);
-        const offset = 3 * featureIndex;
-        out.lower = this._data[offset];
-        out.upper = this._data[offset + 1];
-        return out;
-    }
-    /** @internal */
-    getSubCategoryIdPair(featureIndex) {
-        const index = 3 * featureIndex;
-        let subCatIndex = this._data[index + 2];
-        subCatIndex = (subCatIndex & 0x00ffffff) >>> 0;
-        subCatIndex = subCatIndex * 2 + this._subCategoriesOffset;
-        return { lower: this._data[subCatIndex], upper: this._data[subCatIndex + 1] };
-    }
-    /** @internal */
-    getAnimationNodeId(featureIndex) {
-        return undefined !== this._animationNodeIds && featureIndex < this.numFeatures ? this._animationNodeIds[featureIndex] : 0;
-    }
-    /** @internal */
-    getPackedFeature(featureIndex) {
-        assert(featureIndex < this.numFeatures);
-        const index32 = 3 * featureIndex;
-        const elementId = { lower: this._data[index32], upper: this._data[index32 + 1] };
-        const subCatIndexAndClass = this._data[index32 + 2];
-        const geometryClass = (subCatIndexAndClass >>> 24) & 0xff;
-        let subCatIndex = (subCatIndexAndClass & 0x00ffffff) >>> 0;
-        subCatIndex = subCatIndex * 2 + this._subCategoriesOffset;
-        const subCategoryId = { lower: this._data[subCatIndex], upper: this._data[subCatIndex + 1] };
-        const animationNodeId = this.getAnimationNodeId(featureIndex);
-        return { elementId, subCategoryId, geometryClass, animationNodeId };
-    }
-    /** Returns the element ID of the Feature associated with the specified index, or undefined if the index is out of range. */
-    findElementId(featureIndex) {
-        if (featureIndex >= this.numFeatures)
-            return undefined;
-        else
-            return this.readId(3 * featureIndex);
-    }
-    /** Return true if this table contains exactly 1 feature. */
-    get isUniform() { return 1 === this.numFeatures; }
-    /** If this table contains exactly 1 feature, return it. */
-    get uniform() { return this.isUniform ? this.getFeature(0) : undefined; }
-    get isVolumeClassifier() { return BatchType.VolumeClassifier === this.type; }
-    get isPlanarClassifier() { return BatchType.VolumeClassifier === this.type; }
-    get isClassifier() { return this.isVolumeClassifier || this.isPlanarClassifier; }
-    /** Unpack the features into a [[FeatureTable]]. */
-    unpack() {
-        const table = new FeatureTable(this.maxFeatures, this.modelId);
-        for (let i = 0; i < this.numFeatures; i++) {
-            const feature = this.getFeature(i);
-            table.insertWithIndex(feature, i);
-        }
-        return table;
-    }
-    populateAnimationNodeIds(computeNodeId, maxNodeId) {
-        assert(undefined === this._animationNodeIds);
-        assert(maxNodeId > 0);
-        const pair = { lower: 0, upper: 0 };
-        let haveNodes = false;
-        const size = this.numFeatures;
-        const nodeIds = maxNodeId < 0x100 ? new Uint8Array(size) : (maxNodeId < 0x10000 ? new Uint16Array(size) : new Uint32Array(size));
-        for (let i = 0; i < this.numFeatures; i++) {
-            this.getElementIdPair(i, pair);
-            const nodeId = computeNodeId(pair, i);
-            assert(nodeId <= maxNodeId);
-            if (0 !== nodeId) {
-                nodeIds[i] = nodeId;
-                haveNodes = true;
-            }
-        }
-        if (haveNodes)
-            this._animationNodeIds = nodeIds;
-    }
-    get _subCategoriesOffset() { return this.numFeatures * 3; }
-    readId(offset32) {
-        return Id64.fromUint32Pair(this._data[offset32], this._data[offset32 + 1]);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { assert, compareNumbers, compareStrings, Id64, IndexedValue, IndexMap } from "@itwin/core-bentley";
+import { GeometryClass } from "./GeometryParams";
+/** Describes a discrete entity within a batched [RenderGraphic]($frontend) that can be
+ * grouped with other such entities in a [[FeatureTable]].
+ * Features roughly correlate to elements: a [Tile]($frontend)'s graphics combines geometry from every
+ * [GeometricElement]($backend) that intersects the tile's volume, so each element produces at least one feature.
+ * However, an element's geometry stream can contain geometry belonging to multiple different combinations of [SubCategory]($backend) and
+ * [[GeometryClass]], so an individual element may produce more than one feature.
+ * @see [[FeatureOverrides]] for customizing the appearance of individual features.
+ * @public
+ */
+export class Feature {
+    constructor(elementId = Id64.invalid, subCategoryId = Id64.invalid, geometryClass = GeometryClass.Primary) {
+        this.elementId = elementId;
+        this.subCategoryId = subCategoryId;
+        this.geometryClass = geometryClass;
+    }
+    get isDefined() { return !Id64.isInvalid(this.elementId) || !Id64.isInvalid(this.subCategoryId) || this.geometryClass !== GeometryClass.Primary; }
+    get isUndefined() { return !this.isDefined; }
+    /** Returns true if this feature is equivalent to the supplied feature. */
+    equals(other) { return 0 === this.compare(other); }
+    /** Performs ordinal comparison of this feature with another.
+     * @param rhs The feature to compare with.
+     * @returns zero if the features are equivalent, a negative value if this feature compares as "less than" `rhs`, or a positive value if this feature compares "greater than" `rhs`.
+     */
+    compare(rhs) {
+        if (this === rhs)
+            return 0;
+        let cmp = compareNumbers(this.geometryClass, rhs.geometryClass);
+        if (0 === cmp) {
+            cmp = compareStrings(this.elementId, rhs.elementId);
+            if (0 === cmp) {
+                cmp = compareStrings(this.subCategoryId, rhs.subCategoryId);
+            }
+        }
+        return cmp;
+    }
+}
+/** Describes the type of a 'batch' of graphics representing multiple [[Feature]]s.
+ * The most commonly-encountered batches are Tiles, which can be of either Primary or
+ * Classifier type.
+ * @public
+ * @extensions
+ */
+export var BatchType;
+(function (BatchType) {
+    /** This batch contains graphics derived from a model's visible geometry. */
+    BatchType[BatchType["Primary"] = 0] = "Primary";
+    /**
+     * This batch contains color volumes which are used to classify a model's visible geometry.
+     * The graphics themselves are not rendered to the screen; instead they are rendered to the stencil buffer
+     * to resymbolize the primary geometry.
+     */
+    BatchType[BatchType["VolumeClassifier"] = 1] = "VolumeClassifier";
+    /**
+     * This batch contains planar graphics which are used to classify a model's visible geometry.
+     * The graphics themselves are not rendered to the screen; instead they are rendered to a texture buffer
+     * to resymbolize the primary geometry.
+     */
+    BatchType[BatchType["PlanarClassifier"] = 2] = "PlanarClassifier";
+})(BatchType || (BatchType = {}));
+/** Defines a look-up table for [[Feature]]s within a batched [RenderGraphic]($frontend). Consecutive 32-bit
+ * indices are assigned to each unique Feature. Primitives within the RenderGraphic can
+ * use per-vertex indices to specify the distribution of Features within the primitive. The appearance of individual
+ * features can be customized using [[FeatureOverrides]]. Typically a [Tile]($frontend) will contain a feature table
+ * identifying the elements whose geometry appears within that tile.
+ * @see [[FeatureOverrides]] for customizing the appearance of individual features.
+ * @public
+ */
+export class FeatureTable extends IndexMap {
+    /** Construct an empty FeatureTable. */
+    constructor(maxFeatures, modelId = Id64.invalid, type = BatchType.Primary) {
+        super((lhs, rhs) => lhs.compare(rhs), maxFeatures);
+        this.modelId = modelId;
+        this.type = type;
+    }
+    /** Returns the maximum number of [[Feature]]s this FeatureTable can contain. */
+    get maxFeatures() { return this._maximumSize; }
+    /** @internal */
+    get anyDefined() { return this.length > 1 || (1 === this.length && this._array[0].value.isDefined); }
+    /** Returns true if this FeatureTable contains exactly one [[Feature]]. */
+    get isUniform() { return 1 === this.length; }
+    /** If this FeatureTable contains exactly one [[Feature]], returns that Feature; otherwise returns undefined. */
+    get uniform() { return 1 === this.length ? this._array[0].value : undefined; }
+    /** Returns true if this FeatureTable is associated with [[BatchType.VolumeClassifier]] geometry. */
+    get isVolumeClassifier() { return BatchType.VolumeClassifier === this.type; }
+    /** Returns true if this FeatureTable is associated with [[BatchType.PlanarClassifier]] geometry. */
+    get isPlanarClassifier() { return BatchType.PlanarClassifier === this.type; }
+    /** Returns the Feature corresponding to the specified index, or undefined if the index is not present. */
+    findFeature(index) {
+        for (const entry of this._array)
+            if (entry.index === index)
+                return entry.value;
+        return undefined;
+    }
+    /** @internal */
+    insertWithIndex(feature, index) {
+        const bound = this.lowerBound(feature);
+        assert(!bound.equal);
+        assert(!this.isFull);
+        const entry = new IndexedValue(feature, index);
+        this._array.splice(bound.index, 0, entry);
+    }
+    /** @internal */
+    getArray() { return this._array; }
+}
+/**
+ * An immutable, packed representation of a [[FeatureTable]]. The features are packed into a single array of 32-bit integer values,
+ * wherein each feature occupies 3 32-bit integers.
+ * @internal
+ */
+export class PackedFeatureTable {
+    /** Construct a PackedFeatureTable from the packed binary data.
+     * This is used internally when deserializing Tiles in iMdl format.
+     * @internal
+     */
+    constructor(data, modelId, numFeatures, maxFeatures, type, animationNodeIds) {
+        this._data = data;
+        this.modelId = modelId;
+        this.maxFeatures = maxFeatures;
+        this.numFeatures = numFeatures;
+        this.type = type;
+        this._animationNodeIds = animationNodeIds;
+        switch (this.numFeatures) {
+            case 0:
+                this.anyDefined = false;
+                break;
+            case 1:
+                this.anyDefined = this.getFeature(0).isDefined;
+                break;
+            default:
+                this.anyDefined = true;
+                break;
+        }
+        assert(this._data.length >= this._subCategoriesOffset);
+        assert(this.maxFeatures >= this.numFeatures);
+        assert(undefined === this._animationNodeIds || this._animationNodeIds.length === this.numFeatures);
+    }
+    get byteLength() { return this._data.byteLength; }
+    get animationNodeIds() { return this._animationNodeIds; }
+    /** Create a packed feature table from a [[FeatureTable]]. */
+    static pack(featureTable) {
+        // We must determine how many subcategories we have ahead of time to compute the size of the Uint32Array, as
+        // the array cannot be resized after it is created.
+        // We are not too worried about this as FeatureTables created on the front-end will contain few if any features; those obtained from the
+        // back-end arrive within tiles already in the packed format.
+        const subcategories = new Map();
+        for (const iv of featureTable.getArray()) {
+            const found = subcategories.get(iv.value.subCategoryId.toString());
+            if (undefined === found)
+                subcategories.set(iv.value.subCategoryId, subcategories.size);
+        }
+        // We need 3 32-bit integers per feature, plus 2 32-bit integers per subcategory.
+        const subCategoriesOffset = 3 * featureTable.length;
+        const nUint32s = subCategoriesOffset + 2 * subcategories.size;
+        const uint32s = new Uint32Array(nUint32s);
+        for (const iv of featureTable.getArray()) {
+            const feature = iv.value;
+            const index = iv.index * 3;
+            let subCategoryIndex = subcategories.get(feature.subCategoryId);
+            assert(undefined !== subCategoryIndex); // we inserted it above...
+            subCategoryIndex |= (feature.geometryClass << 24);
+            uint32s[index + 0] = Id64.getLowerUint32(feature.elementId);
+            uint32s[index + 1] = Id64.getUpperUint32(feature.elementId);
+            uint32s[index + 2] = subCategoryIndex;
+        }
+        subcategories.forEach((index, id, _map) => {
+            const index32 = subCategoriesOffset + 2 * index;
+            uint32s[index32 + 0] = Id64.getLowerUint32(id);
+            uint32s[index32 + 1] = Id64.getUpperUint32(id);
+        });
+        return new PackedFeatureTable(uint32s, featureTable.modelId, featureTable.length, featureTable.maxFeatures, featureTable.type);
+    }
+    /** Retrieve the Feature associated with the specified index. */
+    getFeature(featureIndex) {
+        const packed = this.getPackedFeature(featureIndex);
+        const elemId = Id64.fromUint32Pair(packed.elementId.lower, packed.elementId.upper);
+        const subcatId = Id64.fromUint32Pair(packed.subCategoryId.lower, packed.subCategoryId.upper);
+        return new Feature(elemId, subcatId, packed.geometryClass);
+    }
+    /** Returns the Feature associated with the specified index, or undefined if the index is out of range. */
+    findFeature(featureIndex) {
+        return featureIndex < this.numFeatures ? this.getFeature(featureIndex) : undefined;
+    }
+    /** @internal */
+    getElementIdPair(featureIndex, out) {
+        out = out !== null && out !== void 0 ? out : { lower: 0, upper: 0 };
+        assert(featureIndex < this.numFeatures);
+        const offset = 3 * featureIndex;
+        out.lower = this._data[offset];
+        out.upper = this._data[offset + 1];
+        return out;
+    }
+    /** @internal */
+    getSubCategoryIdPair(featureIndex) {
+        const index = 3 * featureIndex;
+        let subCatIndex = this._data[index + 2];
+        subCatIndex = (subCatIndex & 0x00ffffff) >>> 0;
+        subCatIndex = subCatIndex * 2 + this._subCategoriesOffset;
+        return { lower: this._data[subCatIndex], upper: this._data[subCatIndex + 1] };
+    }
+    /** @internal */
+    getAnimationNodeId(featureIndex) {
+        return undefined !== this._animationNodeIds && featureIndex < this.numFeatures ? this._animationNodeIds[featureIndex] : 0;
+    }
+    /** @internal */
+    getPackedFeature(featureIndex) {
+        assert(featureIndex < this.numFeatures);
+        const index32 = 3 * featureIndex;
+        const elementId = { lower: this._data[index32], upper: this._data[index32 + 1] };
+        const subCatIndexAndClass = this._data[index32 + 2];
+        const geometryClass = (subCatIndexAndClass >>> 24) & 0xff;
+        let subCatIndex = (subCatIndexAndClass & 0x00ffffff) >>> 0;
+        subCatIndex = subCatIndex * 2 + this._subCategoriesOffset;
+        const subCategoryId = { lower: this._data[subCatIndex], upper: this._data[subCatIndex + 1] };
+        const animationNodeId = this.getAnimationNodeId(featureIndex);
+        return { elementId, subCategoryId, geometryClass, animationNodeId };
+    }
+    /** Returns the element ID of the Feature associated with the specified index, or undefined if the index is out of range. */
+    findElementId(featureIndex) {
+        if (featureIndex >= this.numFeatures)
+            return undefined;
+        else
+            return this.readId(3 * featureIndex);
+    }
+    /** Return true if this table contains exactly 1 feature. */
+    get isUniform() { return 1 === this.numFeatures; }
+    /** If this table contains exactly 1 feature, return it. */
+    get uniform() { return this.isUniform ? this.getFeature(0) : undefined; }
+    get isVolumeClassifier() { return BatchType.VolumeClassifier === this.type; }
+    get isPlanarClassifier() { return BatchType.VolumeClassifier === this.type; }
+    get isClassifier() { return this.isVolumeClassifier || this.isPlanarClassifier; }
+    /** Unpack the features into a [[FeatureTable]]. */
+    unpack() {
+        const table = new FeatureTable(this.maxFeatures, this.modelId);
+        for (let i = 0; i < this.numFeatures; i++) {
+            const feature = this.getFeature(i);
+            table.insertWithIndex(feature, i);
+        }
+        return table;
+    }
+    populateAnimationNodeIds(computeNodeId, maxNodeId) {
+        assert(undefined === this._animationNodeIds);
+        assert(maxNodeId > 0);
+        const pair = { lower: 0, upper: 0 };
+        let haveNodes = false;
+        const size = this.numFeatures;
+        const nodeIds = maxNodeId < 0x100 ? new Uint8Array(size) : (maxNodeId < 0x10000 ? new Uint16Array(size) : new Uint32Array(size));
+        for (let i = 0; i < this.numFeatures; i++) {
+            this.getElementIdPair(i, pair);
+            const nodeId = computeNodeId(pair, i);
+            assert(nodeId <= maxNodeId);
+            if (0 !== nodeId) {
+                nodeIds[i] = nodeId;
+                haveNodes = true;
+            }
+        }
+        if (haveNodes)
+            this._animationNodeIds = nodeIds;
+    }
+    get _subCategoriesOffset() { return this.numFeatures * 3; }
+    readId(offset32) {
+        return Id64.fromUint32Pair(this._data[offset32], this._data[offset32 + 1]);
+    }
+}
 //# sourceMappingURL=FeatureTable.js.map