import { GLEnum } from '../core/type';
import GeometryBase from '../GeometryBase';
import InstancedMesh from '../InstancedMesh';
import { GeneralMaterialUniformObject } from '../Material';
import type { Matrix4 } from '../math';
import Mesh from '../Mesh';
import Skeleton from '../Skeleton';
import GLProgram from './GLProgram';
import type Texture from '../Texture';
import FrameBuffer from '../FrameBuffer';
import Shader, { ShaderDefineValue, ShaderPrecision } from '../Shader';
/**
 * A very basic material that is used in renderPass
 */
export interface GLMaterialObject {
    uid?: number;
    shader: Shader;
    uniforms?: Shader['uniformTpls'];
    depthTest?: boolean;
    depthMask?: boolean;
    transparent?: boolean;
    blend?: (gl: WebGL2RenderingContext) => void;
    precision?: ShaderPrecision;
    vertexDefines?: Record<string, ShaderDefineValue>;
    fragmentDefines?: Record<string, ShaderDefineValue>;
    getEnabledUniforms?(): string[];
    getTextureUniforms?(): string[];
    getEnabledTextures?(): string[];
    getProgramKey?(): string;
}
/**
 * A very basic renderable that is used in renderPass
 */
export interface GLRenderableObject<T extends GLMaterialObject = GLMaterialObject> {
    geometry: GeometryBase;
    material: T;
    mode?: GLEnum;
    lightGroup?: number;
    worldTransform?: Matrix4;
    cullFace?: GLEnum;
    frontFace?: GLEnum;
    culling?: boolean;
    ignorePreZ?: boolean;
    isSkinnedMesh?(): this is Mesh & {
        skeleton: Skeleton;
    };
    isInstancedMesh?(): this is InstancedMesh;
    beforeRender?(): void;
    afterRender?(): void;
}
export interface ExtendedRenderableObject<T extends GLMaterialObject = GLMaterialObject> extends GLRenderableObject<T> {
    __program: GLProgram;
    __depth: number;
    renderOrder: number;
}
export interface GLRenderHooks<T extends GLRenderableObject = GLRenderableObject> {
    /**
     * Filter the renderable
     */
    filter?(renderable: T): boolean;
    /**
     * Get material of renderable
     */
    getMaterial?(renderable: T): GLMaterialObject;
    /**
     * Get uniform from material
     */
    getMaterialUniform?(renderable: T, material: T['material'], symbol: string): any;
    /**
     * Get common uniforms to bind.
     * Renderable that trigger programs changed.
     */
    getCommonUniforms?(renderable: T): Record<string, GeneralMaterialUniformObject> | undefined | Record<string, GeneralMaterialUniformObject>[];
    /**
     * Get extra defines in shader for program.
     */
    getExtraDefines?(renderable: T, material: T['material']): Record<string, ShaderDefineValue>;
    /**
     * Get extra key for program
     */
    getProgramKey?(renderable: T, material: T['material']): string;
    /**
     * Set common uniforms once for each program
     */
    programChanged?(program: GLProgram): void;
    /**
     * Set uniforms for each program.
     * Uniform in material will be set automatically
     */
    renderableChanged?(renderable: T, material: T['material'], program: GLProgram): void;
    isMaterialChanged?(renderable: T, prevRenderable: T, material: GLMaterialObject, prevMaterial: GLMaterialObject): boolean;
    sortCompare?: (a: T & ExtendedRenderableObject, b: T & ExtendedRenderableObject) => number;
    beforeRender?: (renderable: T, material: GLMaterialObject, prevMaterial: GLMaterialObject | undefined) => void;
    afterRender?: (renderable: T) => void;
}
export type SupportedExtension = 'EXT_color_buffer_float' | 'EXT_color_buffer_half_float' | 'EXT_disjoint_timer_query_webgl2' | 'EXT_float_blend' | 'EXT_texture_compression_rgtc' | 'EXT_texture_filter_anisotropic' | 'EXT_texture_norm16' | 'KHR_parallel_shader_compile' | 'OES_draw_buffers_indexed' | 'OES_texture_float_linear' | 'WEBGL_compressed_texture_s3tc' | 'WEBGL_compressed_texture_s3tc_srgb' | 'WEBGL_debug_renderer_info' | 'WEBGL_debug_shaders' | 'WEBGL_lose_context' | 'WEBGL_multi_draw';
/**
 * Basic webgl renderer without scene management.
 */
declare class GLPipeline {
    readonly gl: WebGL2RenderingContext;
    readonly uid: number;
    private _programMgr;
    private _blankTexture?;
    private _glext;
    private _glTextureMap;
    private _glBuffersMap;
    private _glInstancedBufferMap;
    private _glFrameBufferMap;
    private _framebuffer?;
    private _viewport?;
    private _parallelShaderCompile?;
    throwError: boolean;
    maxJointNumber: number;
    constructor(gl: WebGL2RenderingContext, opts?: {
        throwError?: boolean;
        parallelShaderCompile?: boolean;
    });
    setViewport(x: number, y: number, width: number, height: number, dpr: number): void;
    getViewport(): {
        x: number;
        y: number;
        width: number;
        height: number;
        pixelRatio: number;
    };
    /**
     * Bind framebuffer before render
     *
     * Set null too unbind
     */
    bindFrameBuffer(frameBuffer?: FrameBuffer | null): void;
    /**
     * Render a single renderable list in camera in sequence
     * @param list List of all renderables.
     * @param renderHooks
     */
    render(list: GLRenderableObject[], renderHooks?: GLRenderHooks, opts?: {
        waitForAllShadersCompiled?: boolean;
    }): boolean;
    private _updatePrograms;
    isAllProgramCompiled(): boolean;
    getWebGLExtension(extName: string): any;
    private _getGLTexture;
    private _validateProgram;
    private _updateSkeleton;
    private _renderObject;
    private _getBlankTexture;
    private _setCommonUniforms;
    private _bindMaterial;
    /**
     * Dispose given geometry
     * @param geometry
     */
    disposeGeometry(geometry: GeometryBase): void;
    /**
     * Dispose given texture
     * @param texture
     */
    disposeTexture(texture: Texture): void;
    /**
     * Dispose given frame buffer
     * @param frameBuffer
     */
    disposeFrameBuffer(frameBuffer: FrameBuffer): void;
    /**
     * Dispose instanced mesh
     */
    disposeInstancedMesh(mesh: InstancedMesh): void;
    private _disposeResource;
}
export default GLPipeline;