/** @packageDocumentation
 * @module WebGL
 */
import { IDisposable } from "@itwin/core-bentley";
import { ColorDef, RenderTexture } from "@itwin/core-common";
import { Matrix4d, Range2d, Range3d, Transform } from "@itwin/core-geometry";
import { RealityMeshGraphicParams } from "../RealityMeshGraphicParams";
import { RealityMeshParams } from "../RealityMeshParams";
import { RenderGraphic } from "../RenderGraphic";
import { RenderMemory } from "../RenderMemory";
import { RenderPlanarClassifier } from "../RenderPlanarClassifier";
import { RenderSystem, TerrainTexture } from "../RenderSystem";
import { BufferHandle, QBufferHandle2d, QBufferHandle3d } from "./AttributeBuffers";
import { IndexedGeometry, IndexedGeometryParams } from "./CachedGeometry";
import { Matrix4 } from "./Matrix";
import { PlanarClassifier } from "./PlanarClassifier";
import { RenderOrder } from "./RenderFlags";
import { Target } from "./Target";
import { TechniqueId } from "./TechniqueId";
declare class ProjectedTexture {
    meshParams: RealityMeshGraphicParams;
    targetRectangle: Range2d;
    classifier: PlanarClassifier;
    constructor(classifier: RenderPlanarClassifier, meshParams: RealityMeshGraphicParams, targetRectangle: Range2d);
    clone(targetRectangle: Range2d): ProjectedTexture;
}
type TerrainOrProjectedTexture = TerrainTexture | ProjectedTexture;
declare class RealityTextureParam implements IDisposable {
    texture: RenderTexture | undefined;
    private _projectedTextureOrMatrix;
    constructor(texture: RenderTexture | undefined, _projectedTextureOrMatrix: ProjectedTexture | Matrix4);
    get isProjected(): boolean;
    dispose(): void;
    getProjectionMatrix(): Matrix4d | undefined;
    getTerrainMatrix(): Matrix4 | undefined;
    getParams(result: Matrix4): Matrix4;
}
/** @internal */
export declare class RealityTextureParams implements IDisposable {
    params: RealityTextureParam[];
    constructor(params: RealityTextureParam[]);
    static create(textures: TerrainOrProjectedTexture[]): RealityTextureParams;
    dispose(): void;
}
/** @internal */
export declare class RealityMeshGeometryParams extends IndexedGeometryParams {
    readonly uvParams: QBufferHandle2d;
    readonly featureID?: number;
    readonly normals?: BufferHandle;
    readonly numBytesPerIndex: 1 | 2 | 4;
    protected constructor(positions: QBufferHandle3d, normals: BufferHandle | undefined, uvParams: QBufferHandle2d, indices: BufferHandle, numIndices: number, numBytesPerIndex: 1 | 2 | 4, featureID?: number);
    private static createFromBuffers;
    static fromRealityMesh(params: RealityMeshParams): RealityMeshGeometryParams | undefined;
    get isDisposed(): boolean;
    get bytesUsed(): number;
    dispose(): void;
}
/** @internal */
export declare class RealityMeshGeometry extends IndexedGeometry implements IDisposable, RenderMemory.Consumer {
    readonly hasTextures: boolean;
    get asRealityMesh(): RealityMeshGeometry | undefined;
    get isDisposed(): boolean;
    get uvQParams(): Float32Array;
    get hasFeatures(): boolean;
    get supportsThematicDisplay(): boolean;
    get overrideColorMix(): number;
    get transform(): Transform | undefined;
    private _realityMeshParams;
    private readonly _indexType;
    textureParams: RealityTextureParams | undefined;
    private readonly _transform;
    readonly baseColor: ColorDef | undefined;
    private _baseIsTransparent;
    private _isTerrain;
    private _disableTextureDisposal;
    private constructor();
    dispose(): void;
    static createForTerrain(mesh: RealityMeshParams, transform: Transform | undefined, disableTextureDisposal?: boolean): RealityMeshGeometry | undefined;
    static createFromRealityMesh(realityMesh: RealityMeshParams, disableTextureDisposal?: boolean): RealityMeshGeometry | undefined;
    getRange(): Range3d;
    static createGraphic(system: RenderSystem, params: RealityMeshGraphicParams, disableTextureDisposal?: boolean): RenderGraphic | undefined;
    collectStatistics(stats: RenderMemory.Statistics): void;
    get techniqueId(): TechniqueId;
    getPass(target: Target): "opaque" | "translucent";
    get renderOrder(): RenderOrder;
    draw(): void;
}
export {};
//# sourceMappingURL=RealityMesh.d.ts.map