"use strict";
/*---------------------------------------------------------------------------------------------
* 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
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.FeatureIndex = exports.FeatureIndexType = exports.ColorIndex = exports.NonUniformColor = void 0;
const ColorDef_1 = require("./ColorDef");
/** As part of a [[ColorIndex]], describes per-vertex colors for a [MeshArgs]($frontend) or [PolylineArgs]($frontend).
 * The [[colors]] array holds the set of unique colors. The [[indices]] array describes the color of each vertex as an index into [[colors]].
 * @note A `NonUniformColor` table cannot contain a mix of opaque and translucent colors. If any color in [[colors]] has a transparency greater
 * than zero, all of them must have a transparency greater than zero.
 * @public
 */
class NonUniformColor {
    /** An array of 32-bit [[ColorDef]] values in `tbgr` format, indexed by [[indices]]. */
    colors;
    /** For each vertex, an index into [[colors]] indicating the color of that vertex. */
    indices;
    /** If `true`, indicates none of the [[colors]] have a transparency greater than zero; otherwise, all of
     * the colors have a transparency greater than zero.
     */
    isOpaque;
    /** Constructor.
     * @param colors See [[colors]].
     * @param indices See [[indices]]
     * @param hasAlpha `true` if all `colors` have a transparency greater than zero, or `false` if they all have a transparency of zero.
     */
    constructor(colors, indices, hasAlpha) {
        this.colors = new Uint32Array(colors.buffer);
        this.indices = Uint16Array.from(indices);
        this.isOpaque = !hasAlpha;
    }
}
exports.NonUniformColor = NonUniformColor;
/** Describes the color(s) of the vertices of a [MeshArgs]($frontend) or [PolylineArgs]($frontend).
 * This may be a uniform color to be applied to every vertex, or a table specifying individual per-vertex colors.
 * @public
 */
class ColorIndex {
    _color;
    /** Whether the color(s) in this index have transparency. */
    get hasAlpha() { return !this._color.isOpaque; }
    /** Whether this index specifies a single uniform color for the entire mesh or polyline. */
    get isUniform() { return this._color instanceof ColorDef_1.ColorDef; }
    // Note: this.nonUniform will always return a value if this.isUniform is false.
    /** The number of colors in this index. */
    get numColors() { return this.isUniform ? 1 : this.nonUniform.colors.length; } // eslint-disable-line @typescript-eslint/no-non-null-assertion
    /** Construct a default index specifying a uniform white color. */
    constructor() { this._color = ColorDef_1.ColorDef.white; }
    /** Reset this index to specify a uniform white color. */
    reset() { this._color = ColorDef_1.ColorDef.white; }
    /** Returns the single color to be applied to all vertices, if [[isUniform]] is `true`; or `undefined` otherwise. */
    get uniform() {
        return this.isUniform ? this._color : undefined;
    }
    /** Set the specified color to be applied to all vertices. */
    initUniform(color) {
        this._color = typeof color === "number" ? ColorDef_1.ColorDef.fromJSON(color) : color;
    }
    /** Returns the per-vertex colors, if [[isUniform]] is `false`; or `undefined` otherwise. */
    get nonUniform() {
        return !this.isUniform ? this._color : undefined;
    }
    /** Set the per-vertex colors.
     * @param colors See [[NonUniformColor.colors]].
     * @param indices See [[NonUniformColor.indices]].
     * @param hasAlpha `true` if all `colors` have a transparency greater than zero, or `false` if they all have a transparency of zero.
     */
    initNonUniform(colors, indices, hasAlpha) {
        this._color = new NonUniformColor(colors, indices, hasAlpha);
    }
}
exports.ColorIndex = ColorIndex;
/** Describes the type of a [[FeatureIndex]].
 * @public
 */
var FeatureIndexType;
(function (FeatureIndexType) {
    /** Indicates that the index contains no features. */
    FeatureIndexType[FeatureIndexType["Empty"] = 0] = "Empty";
    /** Indicates that the index contains exactly one feature. */
    FeatureIndexType[FeatureIndexType["Uniform"] = 1] = "Uniform";
    /** Indicates that the index contains more than one feature. */
    FeatureIndexType[FeatureIndexType["NonUniform"] = 2] = "NonUniform";
})(FeatureIndexType || (exports.FeatureIndexType = FeatureIndexType = {}));
/** Describes the set of [[Feature]]s associated with a [MeshArgs]($frontend) or [PolylineArgs]($frontend).
 * The mesh or polyline may have zero or one features; or, individual vertices may be associated with different features.
 * The features are expressed as unsigned 32-bit integer Ids of [[Feature]]s within a [[FeatureTable]].
 * @public
 */
class FeatureIndex {
    /** Describes the quantity (zero, one, or more than one) of features in this index. */
    type = FeatureIndexType.Empty;
    /** If [[type]] is [[FeatureIndexType.Uniform]], the Id of the single feature. */
    featureID = 0;
    /** If [[type]] is [[FeatureIndexType.NonUniform]], the per-vertex feature Ids, indexed by the mesh or polyline's vertex indices. */
    featureIDs;
    /** True if [[type]] is [[FeatureIndexType.Uniform]]. */
    get isUniform() { return FeatureIndexType.Uniform === this.type; }
    /** True if [[type]] is [[FeatureIndexType.Empty]]. */
    get isEmpty() { return FeatureIndexType.Empty === this.type; }
    /** Reset to an empty index. */
    reset() {
        this.type = FeatureIndexType.Empty;
        this.featureID = 0;
        this.featureIDs = undefined;
    }
}
exports.FeatureIndex = FeatureIndex;
//# sourceMappingURL=FeatureIndex.js.map