import { WorkPromise } from "../managers/promiseManager";
import { StringKeyList } from "../longan/gs.collections";
import { KtxInfo } from "./ktxReader";
import { Viewer } from "../viewer";
import { VertexData } from "../longan/gs.types";
export type Texture2d = WebGLTexture;
export type VertexBuffer = WebGLBuffer;
export type IndexBuffer = WebGLBuffer;
export type RenderTarget = WebGLFramebuffer;
export type Sync = WebGLSync;
export type Cubemap = WebGLTexture;
export type mat2 = [number, number, number, number] | Float32Array;
export type mat3 = [number, number, number, number, number, number, number, number, number] | Float32Array;
export type mat4 = [
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number
] | Float32Array;
export type quat = [number, number, number, number] | Float32Array;
export type vec2 = [number, number] | Float32Array;
export type vec3 = [number, number, number] | Float32Array;
export type vec4 = [number, number, number, number] | Float32Array;
export type ivec2 = [number, number] | Int32Array;
export type ivec3 = [number, number, number] | Int32Array;
export type ivec4 = [number, number, number, number] | Int32Array;
export type FloatArray = number[] | Float32Array;
export type IntArray = number[] | Int32Array;
export interface VertexAttribute {
    name: string;
    slot: number;
    size: number;
    type: GLenum;
    offset: number;
    stride: number;
    divisor?: number;
}
export interface VboInfo {
    vbo: VertexBuffer;
    length: number;
    names: string[];
}
export interface Geometry {
    vao: WebGLVertexArrayObject;
    vbos: VboInfo | VboInfo[];
    ebo?: IndexBuffer;
    length: number;
    type: GLenum;
    vbosOwned: boolean;
}
export interface TransformFeedback {
    tfo: WebGLTransformFeedback;
    buffers: VertexBuffer[];
    vbosOwned: boolean;
}
export interface ShaderProgram {
    no: number;
    program: WebGLProgram;
    shaders: WebGLShader[];
    uniformBlocks: UniformBlock[];
}
export interface Mesh {
    formats: VertexAttribute[];
    vertexes: VertexData | VertexData[];
    indexes?: Int32Array;
}
export declare enum BitField {
    ColorBufferBit,
    DepthBufferBit
}
export declare enum TextureFiltering {
    Nearest,
    Linear,
    Linear_MipMap_Linear
}
export declare enum TextureMode {
    Repeat,
    Edge,
    Mirror
}
export declare enum CompareFunction {
    Never,
    Less,
    Equal,
    LessEqual,
    Greater,
    NotEqual,
    GreaterEqual,
    Always
}
export declare enum FaceMode {
    CW,
    CCW
}
export declare enum CullFaceType {
    Back = 1,
    Front = 2,
    On = 3,
    Off = 4
}
export declare enum BlendType {
    SrcFactor = 1,
    DstFactor = 2,
    On = 3,
    Off = 4,
    Custom = 5
}
export declare enum StencilOperation {
    Keep,
    Zero,
    Replace,
    Increase,
    Decrease,
    Invert
}
export interface IRenderContext {
    readonly width: number;
    readonly height: number;
    resize(width: number, height: number): any;
}
export declare class UniformBlock {
    renderContext: IRenderContext;
    name: string;
    uniforms: StringKeyList<{
        offset: number;
        initValue: Float32Array | Int32Array | null;
    }>;
    bindingIndex: number;
    size: number;
    ubo: WebGLBuffer;
    static bindingIndexCounter: number;
    set(uniformName: string, value: Float32Array | Int32Array | null): void;
}
export declare class UniformBlockCollection {
    private owner;
    _items: StringKeyList<UniformBlock>;
    constructor(owner: WebGL2RenderContext);
    add(block: UniformBlock): void;
    remove(block: UniformBlock | string): void;
    find(name: string): UniformBlock;
    has(name: string): boolean;
}
export declare class WebGL2RenderContext implements IRenderContext {
    get width(): number;
    get height(): number;
    get defaultRenderTarget(): RenderTarget;
    set defaultRenderTarget(value: RenderTarget);
    private _width;
    private _height;
    _gl: WebGL2RenderingContext;
    private _defaultRenderTarget;
    private currentProgram;
    private currentVariableTable;
    private variableTables;
    private static programCounter;
    uniformBlocks: UniformBlockCollection;
    systemBlock: UniformBlock;
    transformBlock: UniformBlock;
    cameraBlock: UniformBlock;
    lightBlock: UniformBlock;
    materialBlock: UniformBlock;
    cuttingBlock: UniformBlock;
    constructor(gl: WebGL2RenderingContext);
    resize(width: number, height: number): void;
    setViewport(x: number, y: number, width: number, height: number): void;
    createGeometry(mesh: Mesh, type?: GLenum, inVbos?: WebGLBuffer | WebGLBuffer[]): Geometry;
    createGeometryPartable(mesh: Mesh, blockSize: number, viewer: Viewer, type?: GLenum): WorkPromise<Geometry>;
    drawGeometry(geometry: Geometry, offset?: number, count?: number, instanceCount?: number): void;
    drawSubGeometry(geometry: Geometry, start: number, count: number): void;
    createUniformBlock(block: UniformBlock): void;
    createRenderTarget(): RenderTarget;
    createTransformFeedback(capacities: number[] | WebGLBuffer[]): TransformFeedback;
    beginTransformFeedback(transformFeedback: TransformFeedback, primitive?: GLenum): void;
    endTransformFeedback(): void;
    createShaderProgram(vs: string, fs: string, feedbackVars?: string[]): ShaderProgram;
    flush(): void;
    createFloatTexture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createFloat2Texture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createFloat3Texture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createFloat4Texture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createByte4Texture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createByte3Texture(width: number, height: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createByte4TextureArray(width: number, height: number, depth: number, filter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createByte4TextureArray1(width: number, height: number, depth: number, minfilter?: TextureFiltering, magfilter?: TextureFiltering, mode?: TextureMode): WebGLTexture;
    createByte4TextureArray2(width: number, height: number, depth: number, data: any, minfilter?: TextureFiltering, magfilter?: TextureFiltering, modeS?: TextureMode, modeT?: TextureMode): WebGLTexture;
    createDepthTexture(width: number, height: number): WebGLTexture;
    createShadowTexture(width: number, height: number): WebGLTexture;
    createDepthStencilTexture(width: number, height: number): WebGLTexture;
    attachTextures(target: RenderTarget, textures: Texture2d[]): void;
    attachDepthTexture(target: RenderTarget, texture: Texture2d): void;
    attachDepthStencilTexture(target: RenderTarget, texture: Texture2d): void;
    copyToTextureArray(target: RenderTarget, textures: WebGLTexture[], textureArray: Texture2d): void;
    setRenderTarget(target: RenderTarget): void;
    clearRenderTarget(): void;
    clearColor(r: any, g: any, b: any, a: any): void;
    copyRenderTarget(from: RenderTarget, to: RenderTarget, width: number, height: number, mask?: BitField, filter?: TextureFiltering): void;
    updateTexture(texture: WebGLTexture, width: number, height: number, format: GLenum, type: GLenum, data: ArrayBufferView): void;
    createCubeMap(ktx: KtxInfo): Cubemap;
    updateGeometry(geometry: Geometry, vertexData: VertexData | VertexData[]): void;
    destroyProgram(program: ShaderProgram): void;
    destroyGeometry(geometry: Geometry): void;
    destroyRenderTarget(target: RenderTarget): void;
    destroyTexture(texture: Texture2d): void;
    destroyUniformBlock(block: UniformBlock): void;
    destroyTransformFeedback(feedback: TransformFeedback): void;
    resetProgram(): void;
    setProgram(program: ShaderProgram): boolean;
    setProgramVariableUInt(program: ShaderProgram, name: string, value: number): void;
    setProgramVariableInt(program: ShaderProgram, name: string, value: number): void;
    setProgramVariableFloat(program: ShaderProgram, name: string, value: number): void;
    setProgramVariableVec2(program: ShaderProgram, name: string, value: vec2): void;
    setProgramVariableVec3(program: ShaderProgram, name: string, value: vec3): void;
    setProgramVariableVec4(program: ShaderProgram, name: string, value: vec4): void;
    setProgramVariableMat2(program: ShaderProgram, name: string, value: mat2): void;
    setProgramVariableMat3(program: ShaderProgram, name: string, value: mat3): void;
    setProgramVariableMat4(program: ShaderProgram, name: string, value: mat4): void;
    setProgramVariableIVec2(program: ShaderProgram, name: string, value: ivec2): void;
    setProgramVariableIVec3(program: ShaderProgram, name: string, value: ivec3): void;
    setProgramVariableIVec4(program: ShaderProgram, name: string, value: ivec4): void;
    setProgramVariableFloatArray(program: ShaderProgram, name: string, value: FloatArray): void;
    setProgramVariableIntArray(program: ShaderProgram, name: string, value: IntArray): void;
    setProgramVariableVec3Array(program: ShaderProgram, name: string, value: FloatArray): void;
    setProgramVariableVec4Array(program: ShaderProgram, name: string, value: FloatArray): void;
    setProgramTexture(program: ShaderProgram, name: string, texture: Texture2d, slot: number): void;
    setProgramCubemap(program: ShaderProgram, name: string, texture: Cubemap, slot: number): void;
    setProgramTextureArray(program: ShaderProgram, name: string, texture: Texture2d, slot: number): void;
    setBlockUniform(blockName: string, uniformName: string, value: Float32Array | Int32Array | null): void;
    setDepthFunction(func: CompareFunction): void;
    setFrontFace(mode: FaceMode): void;
    setDepthTest(flag: boolean): void;
    setScissorTest(flag: boolean): void;
    setStencilTest(flag: boolean): void;
    clearStencilBuffer(): void;
    setStencil(func: CompareFunction, value: number, mask: number, fail: StencilOperation, zFail: StencilOperation, zPass: StencilOperation): void;
    setDepthWrite(flag: boolean): void;
    setCullFace(type: CullFaceType): void;
    setBlend(type: BlendType, sfactor?: number, dfactor?: number): void;
    setBlendSeparate(type: BlendType, srcRGB?: number, dstRGB?: number, srcAlpha?: number, dstAlpha?: number): void;
    setDepthRange(zNear: number, zFar: number): void;
    getImageFormat(image: {
        width: number;
        height: number;
        channels: number;
        isHdr: number;
        data: ArrayBuffer;
    }): number;
    getImageType(image: {
        width: number;
        height: number;
        channels: number;
        isHdr: number;
        data: ArrayBuffer;
    }): number;
    isRegularImageSize(width: number, height: number): boolean;
    readPixels(target: RenderTarget, values: ArrayBufferView, x: number, y: number, width: number, height: number, format: GLenum, type: GLenum, slot: number): void;
    getGeometry(geometry: Geometry, mesh: Mesh, names?: string[]): void;
    createVertexBuffer(data: any, usage: GLenum): VertexBuffer;
    bindVertexBuffer(vbo: WebGLBuffer, data: any, usage: GLenum): void;
    private createVertexBufferPartable;
    private createIndexBuffer;
    private createUniformBuffer;
    private initUniformBlock;
    private bindUniformBlocks;
}