export declare enum UpdateType {
    Enter = "Enter",
    Exit = "Exit",
    Update = "Update"
}
export declare class PersistentArray<T> {
    maxLength: number;
    data: T[];
    length: number;
    constructor(maxLength: number, initialItem: T);
    getMeaningfulData(): T[];
}
export declare class PersistentFloat32Array {
    maxLength: number;
    buffer: Float32Array;
    length: number;
    constructor(maxLength: number);
    getMeaningfulData(): Float32Array;
    copyFrom(they: PersistentFloat32Array): void;
}
export interface WebGLTimerQueryEXT {
    __dummyWebGLTimerQueryEXT: number;
}
export interface EXTDisjointTimerQuery {
    readonly TIME_ELAPSED_EXT: number;
    readonly QUERY_COUNTER_BITS_EXT: number;
    readonly CURRENT_QUERY_EXT: number;
    readonly QUERY_RESULT_EXT: number;
    readonly QUERY_RESULT_AVAILABLE_EXT: number;
    readonly TIMESTAMP_EXT: number;
    readonly GPU_DISJOINT_EXT: number;
    createQueryEXT(): WebGLTimerQueryEXT;
    beginQueryEXT(num: EXTDisjointTimerQuery['TIME_ELAPSED_EXT'], query: WebGLTimerQueryEXT): void;
    endQueryEXT(target: number): void;
    getQueryObjectEXT(query: WebGLTimerQueryEXT, pname: number): any;
}
export interface OESElementIndexUint {
    __dummyOESElementIndexUint: number;
}
export interface ANGLEInstancedArrays {
    readonly VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE: number;
    drawArraysInstancedANGLE(mode: number, first: number, count: number, primcount: number): void;
    drawElementsInstancedANGLE(mode: number, count: number, type: number, offset: number, primcount: number): void;
    vertexAttribDivisorANGLE(index: number, divisor: number): void;
}
interface WebGLQuery {
    __dummyWebGLQuery: number;
}
export interface EXT_disjoint_timer_query_webgl2 {
    readonly QUERY_COUNTER_BITS_EXT: number;
    readonly TIME_ELAPSED_EXT: number;
    readonly TIMESTAMP_EXT: number;
    readonly GPU_DISJOINT_EXT: number;
    queryCounterEXT(query: WebGLQuery, target: number): void;
    beginQuery(target: number, query?: WebGLQuery): void;
    endQuery(target: number): void;
}
declare global {
    interface WebGLRenderingContextBase {
        getExtension(name: 'EXT_disjoint_timer_query'): EXTDisjointTimerQuery | null;
    }
    interface WebGL2RenderingContext extends WebGLRenderingContext {
        createVertexArray: OES_vertex_array_object['createVertexArrayOES'];
        deleteVertexArray: OES_vertex_array_object['deleteVertexArrayOES'];
        isVertexArray: OES_vertex_array_object['isVertexArrayOES'];
        bindVertexArray: OES_vertex_array_object['bindVertexArrayOES'];
        drawArraysInstanced: ANGLE_instanced_arrays['drawArraysInstancedANGLE'];
        drawElementsInstanced: ANGLE_instanced_arrays['drawElementsInstancedANGLE'];
        vertexAttribDivisor: ANGLE_instanced_arrays['vertexAttribDivisorANGLE'];
        getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): number;
        uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: number, uniformBlockBinding: number): void;
        bindBufferBase(target: number, index: number, buffer: WebGLBuffer): void;
        readonly UNIFORM_BUFFER: number;
        createQuery(): WebGLQuery;
        beginQuery(target: number, query: WebGLQuery): void;
        endQuery(target: number): WebGLQuery;
        getQueryParameter(query: WebGLQuery, pname: number): any;
        readonly QUERY_RESULT_AVAILABLE: number;
        readonly QUERY_RESULT: number;
    }
    interface HTMLCanvasElement {
        getContext(contextId: 'webgl2', contextAttributes?: WebGLContextAttributes): WebGL2RenderingContext | null;
    }
}
export declare type ColorTriplet = [number, number, number];
export declare type ColorQuadruplet = [number, number, number, number];
export declare const normalizeColorTriplet: (unnormalized: ColorTriplet) => ColorTriplet;
export declare const normalizeColorQuadruplet: (unnormalized: ColorQuadruplet) => ColorQuadruplet;
export declare const colorTripletToCSSString: (color: ColorTriplet) => string;
export interface IUpdatePatternItem {
    key: string;
    type: UpdateType;
}
export declare const getUpdatePattern: (prevKeys: string[], nextKeys: string[]) => IUpdatePatternItem[];
export declare const resizeViewport: (gl: WebGLRenderingContext, shouldResizeCanvas: boolean) => void;
export declare const compileShader: (gl: WebGLRenderingContext, shaderSource: string, shaderType: number) => WebGLShader;
export declare const createProgram: (gl: WebGLRenderingContext, vertexShader: WebGLShader, fragmentShader: WebGLShader) => WebGLProgram;
export declare const createProgramFromShaderSource: (gl: WebGLRenderingContext | WebGL2RenderingContext, vertexShaderSource: string, fragmentShaderSource: string) => WebGLProgram;
export declare const sendAttributesToGPUWithVAO: (input: {
    gl: WebGLRenderingContext | WebGL2RenderingContext;
    programInfo: IProgramInfo;
    attributeName: string;
    data: Float32Array;
}) => void;
export declare const updateGLBuffer: (input: {
    gl: WebGLRenderingContext;
    data: Float32Array;
    buffer: WebGLBuffer;
}) => void;
export declare const updateUniformBuffer: (input: {
    gl: WebGL2RenderingContext;
    data: Float32Array;
    buffer: WebGLBuffer;
}) => void;
export declare const sendIndicesToGPUWithVAO: (input: {
    gl: WebGLRenderingContext;
    programInfo: IProgramInfo;
    data: Uint16Array | Uint32Array;
}) => void;
export declare const GL_NUM_BYTES_PER_FLOAT: number;
interface IAttributeInfo {
    location: number;
    buffer: WebGLBuffer;
    numFloatsPerVertex: number;
    stride: number;
    offset: number;
}
export declare enum IndexElementType {
    Int16 = 0,
    Int32 = 1
}
declare type IIndexBufferInfo = {
    buffer: WebGLBuffer;
    elementType: number;
};
interface IUniformBlockInfo {
    buffer: WebGLBuffer;
}
export declare type IProgramInfo = {
    program: WebGLProgram;
    attributes: Record<string, IAttributeInfo>;
    uniforms: Record<string, WebGLUniformLocation>;
    indexBuffer: IIndexBufferInfo;
} & ({
    version: WebGLVersion.One;
} | {
    version: WebGLVersion.Two;
    uniformBlocks: Record<string, IUniformBlockInfo>;
});
export declare enum AttributeLocationRequestType {
    Implicit = 0,
    Explicit = 1
}
export declare enum AttributeBufferRequestType {
    Implicit = 0,
    Explicit = 1
}
declare type AttributeBufferRequest = {
    type: AttributeBufferRequestType.Implicit;
    totalSizeAsNumOfFloats: number;
} | {
    type: AttributeBufferRequestType.Explicit;
    buffer: WebGLBuffer;
};
export interface IAttributeRequest {
    name: string;
    numFloatsPerVertex: number;
    stride: number;
    offset: number;
    buffer: AttributeBufferRequest;
    isInstanced: boolean;
}
export interface IIndexRequest {
    totalSizeAsNumOfInts: number;
    elementType: IndexElementType;
}
export declare const createPopulatedGLBuffer: (gl: WebGLRenderingContext | WebGL2RenderingContext, bufferData: PersistentFloat32Array) => {
    buffer: WebGLBuffer;
    rebindBuffer: (bufferDataToBind: PersistentFloat32Array) => void;
};
export declare enum WebGLVersion {
    One = 0,
    Two = 1
}
export interface IUniformBlockRequest {
    name: string;
    assignedBlockIndex: number;
    assignedBuffer: WebGLBuffer;
}
declare type GetProgramInfoInput = {
    vertexShader: string;
    fragmentShader: string;
    attributes: IAttributeRequest[];
    uniforms: string[];
    indexBuffer: IIndexRequest;
    vaoObject: WebGLVertexArrayObjectOES;
} & ({
    version: WebGLVersion.One;
    gl: WebGLRenderingContext;
    vaoExtension: OES_vertex_array_object;
    instancedDrawingExtension: ANGLE_instanced_arrays;
} | {
    version: WebGLVersion.Two;
    gl: WebGL2RenderingContext;
    uniformBlocks: IUniformBlockRequest[];
});
export declare const getProgramInfo: (input: GetProgramInfoInput) => IProgramInfo;
declare type IMeasureGPUTimeOptions = {
    description: string;
} & ({
    version: WebGLVersion.One;
    gl: WebGLRenderingContext;
    timerExtension: EXTDisjointTimerQuery;
} | {
    version: WebGLVersion.Two;
    gl: WebGL2RenderingContext;
    timerExtension: EXT_disjoint_timer_query_webgl2;
});
export declare const measureGPUTime: (options: IMeasureGPUTimeOptions, drawFunction: () => void, reportingDelay?: number) => void;
export {};