/** @packageDocumentation
 * @module WebGL
 */
import { Id64String } from "@itwin/core-bentley";
import { ElementAlignedBox3d, FeatureAppearanceProvider, RenderFeatureTable, ViewFlags } from "@itwin/core-common";
import { Range3d, Transform } from "@itwin/core-geometry";
import { IModelConnection } from "../../IModelConnection";
import { FeatureSymbology } from "../FeatureSymbology";
import { GraphicBranch, GraphicBranchFrustum, GraphicBranchOptions } from "../GraphicBranch";
import { GraphicList, RenderGraphic } from "../RenderGraphic";
import { RenderMemory } from "../RenderMemory";
import { ClipVolume } from "./ClipVolume";
import { WebGLDisposable } from "./Disposable";
import { EdgeSettings } from "./EdgeSettings";
import { FeatureOverrides } from "./FeatureOverrides";
import { PlanarClassifier } from "./PlanarClassifier";
import { Primitive } from "./Primitive";
import { RenderCommands } from "./RenderCommands";
import { RenderPass } from "./RenderFlags";
import { Target } from "./Target";
import { TextureDrape } from "./TextureDrape";
import { ThematicSensors } from "./ThematicSensors";
import { BranchState } from "./BranchState";
import { BatchOptions } from "../../common/render/BatchOptions";
/** @internal */
export declare abstract class Graphic extends RenderGraphic implements WebGLDisposable {
    abstract addCommands(_commands: RenderCommands): void;
    abstract get isDisposed(): boolean;
    abstract get isPickable(): boolean;
    addHiliteCommands(_commands: RenderCommands, _pass: RenderPass): void;
    toPrimitive(): Primitive | undefined;
}
export declare class GraphicOwner extends Graphic {
    private readonly _graphic;
    constructor(graphic: Graphic);
    get graphic(): RenderGraphic;
    private _isDisposed;
    get isDisposed(): boolean;
    dispose(): void;
    disposeGraphic(): void;
    collectStatistics(stats: RenderMemory.Statistics): void;
    unionRange(range: Range3d): void;
    addCommands(commands: RenderCommands): void;
    get isPickable(): boolean;
    addHiliteCommands(commands: RenderCommands, pass: RenderPass): void;
    toPrimitive(): Primitive | undefined;
}
/** Transiently assigned to a Batch while rendering a frame, reset afterward. Used to provide context for pick IDs.
 * @internal
 */
export interface BatchContext {
    batchId: number;
    iModel?: IModelConnection;
    viewAttachmentId?: Id64String;
}
/** @internal exported strictly for tests. */
export declare class PerTargetBatchData {
    readonly target: Target;
    protected readonly _featureOverrides: Map<FeatureSymbology.Source | undefined, FeatureOverrides>;
    protected _thematicSensors?: ThematicSensors;
    constructor(target: Target);
    dispose(): void;
    getThematicSensors(batch: Batch): ThematicSensors;
    getFeatureOverrides(batch: Batch): FeatureOverrides;
    collectStatistics(stats: RenderMemory.Statistics): void;
    /** Exposed strictly for tests. */
    get featureOverrides(): Map<FeatureSymbology.Source | undefined, FeatureOverrides>;
    private onSourceDisposed;
}
/** @internal exported strictly for tests. */
export declare class PerTargetData {
    private readonly _batch;
    private readonly _data;
    constructor(batch: Batch);
    dispose(): void;
    get isDisposed(): boolean;
    /** Exposed strictly for tests. */
    get data(): PerTargetBatchData[];
    onTargetDisposed(target: Target): void;
    collectStatistics(stats: RenderMemory.Statistics): void;
    getThematicSensors(target: Target): ThematicSensors;
    getFeatureOverrides(target: Target): FeatureOverrides;
    private getBatchData;
}
/** @internal */
export declare class Batch extends Graphic {
    readonly graphic: RenderGraphic;
    readonly featureTable: RenderFeatureTable;
    readonly range: ElementAlignedBox3d;
    private readonly _context;
    /** Public strictly for tests. */
    readonly perTargetData: PerTargetData;
    readonly options: BatchOptions;
    get tileId(): string | undefined;
    get locateOnly(): boolean;
    /** The following are valid only during a draw and reset afterward. */
    get batchId(): number;
    get batchIModel(): IModelConnection | undefined;
    get viewAttachmentId(): string | undefined;
    setContext(batchId: number, branch: BranchState): void;
    resetContext(): void;
    constructor(graphic: RenderGraphic, features: RenderFeatureTable, range: ElementAlignedBox3d, options?: BatchOptions);
    private _isDisposed;
    get isDisposed(): boolean;
    dispose(): void;
    collectStatistics(stats: RenderMemory.Statistics): void;
    unionRange(range: Range3d): void;
    addCommands(commands: RenderCommands): void;
    get isPickable(): boolean;
    getThematicSensors(target: Target): ThematicSensors;
    getOverrides(target: Target): FeatureOverrides;
    onTargetDisposed(target: Target): void;
}
/** @internal */
export declare class Branch extends Graphic {
    readonly branch: GraphicBranch;
    localToWorldTransform: Transform;
    readonly clips?: ClipVolume;
    readonly planarClassifier?: PlanarClassifier;
    readonly textureDrape?: TextureDrape;
    readonly layerClassifiers?: Map<number, PlanarClassifier>;
    readonly edgeSettings?: EdgeSettings;
    readonly iModel?: IModelConnection;
    readonly frustum?: GraphicBranchFrustum;
    readonly appearanceProvider?: FeatureAppearanceProvider;
    readonly secondaryClassifiers?: PlanarClassifier[];
    readonly viewAttachmentId?: Id64String;
    constructor(branch: GraphicBranch, localToWorld: Transform, viewFlags?: ViewFlags, opts?: GraphicBranchOptions);
    get isDisposed(): boolean;
    dispose(): void;
    get isPickable(): boolean;
    collectStatistics(stats: RenderMemory.Statistics): void;
    unionRange(range: Range3d): void;
    private shouldAddCommands;
    addCommands(commands: RenderCommands): void;
    addHiliteCommands(commands: RenderCommands, pass: RenderPass): void;
}
/** @internal */
export declare class AnimationTransformBranch extends Graphic {
    readonly nodeId: number;
    readonly graphic: Graphic;
    constructor(graphic: RenderGraphic, nodeId: number);
    dispose(): void;
    get isDisposed(): boolean;
    get isPickable(): boolean;
    collectStatistics(stats: RenderMemory.Statistics): void;
    unionRange(range: Range3d): void;
    addCommands(commands: RenderCommands): void;
    addHiliteCommands(commands: RenderCommands, pass: RenderPass): void;
}
/** @internal */
export declare class WorldDecorations extends Branch {
    constructor(viewFlags: ViewFlags);
    init(decs: GraphicList): void;
}
/** @internal */
export declare class GraphicsArray extends Graphic {
    graphics: RenderGraphic[];
    constructor(graphics: RenderGraphic[]);
    get isDisposed(): boolean;
    get isPickable(): boolean;
    dispose(): void;
    addCommands(commands: RenderCommands): void;
    addHiliteCommands(commands: RenderCommands, pass: RenderPass): void;
    collectStatistics(stats: RenderMemory.Statistics): void;
    unionRange(range: Range3d): void;
}
//# sourceMappingURL=Graphic.d.ts.map