import { CoreRenderer, type BufferInfo, type CoreRendererOptions, type QuadOptions } from '../CoreRenderer.js';
import { WebGlRenderOp } from './WebGlRenderOp.js';
import type { CoreContextTexture } from '../CoreContextTexture.js';
import { type CoreWebGlParameters, type CoreWebGlExtensions, type WebGlColor } from './internal/RendererUtils.js';
import { Texture, type TextureCoords } from '../../textures/Texture.js';
import { BufferCollection } from './internal/BufferCollection.js';
import { WebGlShaderProgram } from './WebGlShaderProgram.js';
import { WebGlContextWrapper } from '../../lib/WebGlContextWrapper.js';
import { type CoreNode } from '../../CoreNode.js';
import type { WebGlShaderType } from './WebGlShaderNode.js';
import { WebGlShaderNode } from './WebGlShaderNode.js';
export type WebGlRendererOptions = CoreRendererOptions;
interface CoreWebGlSystem {
    parameters: CoreWebGlParameters;
    extensions: CoreWebGlExtensions;
}
export declare class WebGlRenderer extends CoreRenderer {
    glw: WebGlContextWrapper;
    system: CoreWebGlSystem;
    quadBuffer: ArrayBuffer;
    fQuadBuffer: Float32Array;
    uiQuadBuffer: Uint32Array;
    renderOps: WebGlRenderOp[];
    curBufferIdx: number;
    curRenderOp: WebGlRenderOp | null;
    rttNodes: CoreNode[];
    activeRttNode: CoreNode | null;
    defaultTextureCoords: TextureCoords;
    defaultShaderNode: WebGlShaderNode | null;
    quadBufferCollection: BufferCollection;
    clearColor: WebGlColor;
    /**
     * White pixel texture used by default when no texture is specified.
     */
    quadBufferUsage: number;
    numQuadsRendered: number;
    /**
     * Whether the renderer is currently rendering to a texture.
     */
    renderToTextureActive: boolean;
    constructor(options: WebGlRendererOptions);
    reset(): void;
    createShaderProgram(shaderType: WebGlShaderType, props: Record<string, unknown>): WebGlShaderProgram;
    createShaderNode(shaderKey: string, shaderType: WebGlShaderType, props?: Record<string, unknown>, program?: WebGlShaderProgram): WebGlShaderNode<Record<string, unknown>>;
    supportsShaderType(shaderType: Readonly<WebGlShaderType>): boolean;
    createCtxTexture(textureSource: Texture): CoreContextTexture;
    /**
     * This function adds a quad (a rectangle composed of two triangles) to the WebGL rendering pipeline.
     *
     * It takes a set of options that define the quad's properties, such as its dimensions, colors, texture, shader, and transformation matrix.
     * The function first updates the shader properties with the current dimensions if necessary, then sets the default texture if none is provided.
     * It then checks if a new render operation is needed, based on the current shader and clipping rectangle.
     * If a new render operation is needed, it creates one and updates the current render operation.
     * The function then adjusts the texture coordinates based on the texture options and adds the texture to the texture manager.
     *
     * Finally, it calculates the vertices for the quad, taking into account any transformations, and adds them to the quad buffer.
     * The function updates the length and number of quads in the current render operation, and updates the current buffer index.
     */
    addQuad(params: QuadOptions): void;
    /**
     * Replace the existing RenderOp with a new one that uses the specified Shader
     * and starts at the specified buffer index.
     *
     * @param shader
     * @param bufferIdx
     */
    private newRenderOp;
    /**
     * Add a texture to the current RenderOp. If the texture cannot be added to the
     * current RenderOp, a new RenderOp will be created and the texture will be added
     * to that one.
     *
     * If the texture cannot be added to the new RenderOp, an error will be thrown.
     *
     * @param texture
     * @param bufferIdx
     * @param recursive
     * @returns Assigned Texture Index of the texture in the render op
     */
    private addTexture;
    /**
     * Test if the current Render operation can be reused for the specified parameters.
     * @param params
     * @returns
     */
    reuseRenderOp(params: QuadOptions): boolean;
    /**
     * add RenderOp to the render pipeline
     */
    addRenderOp(renderable: WebGlRenderOp): void;
    /**
     * Render the current set of RenderOps to render to the specified surface.
     *
     * TODO: 'screen' is the only supported surface at the moment.
     *
     * @param surface
     */
    render(surface?: 'screen' | CoreContextTexture): void;
    getQuadCount(): number;
    renderToTexture(node: CoreNode): void;
    /**
     * Inserts an RTT node into `this.rttNodes` while maintaining the correct rendering order based on hierarchy.
     *
     * Rendering order for RTT nodes is critical when nested RTT nodes exist in a parent-child relationship.
     * Specifically:
     *  - Child RTT nodes must be rendered before their RTT-enabled parents to ensure proper texture composition.
     *  - If an RTT node is added and it has existing RTT children, it should be rendered after those children.
     *
     * This function addresses both cases by:
     * 1. **Checking Upwards**: It traverses the node's hierarchy upwards to identify any RTT parent
     *    already in `rttNodes`. If an RTT parent is found, the new node is placed before this parent.
     * 2. **Checking Downwards**: It traverses the node’s children recursively to find any RTT-enabled
     *    children that are already in `rttNodes`. If such children are found, the new node is inserted
     *    after the last (highest index) RTT child node.
     *
     * The final calculated insertion index ensures the new node is positioned in `rttNodes` to respect
     * both parent-before-child and child-before-parent rendering rules, preserving the correct order
     * for the WebGL renderer.
     *
     * @param node - The RTT-enabled CoreNode to be added to `rttNodes` in the appropriate hierarchical position.
     */
    private insertRTTNodeInOrder;
    private findMaxChildRTTIndex;
    renderRTTNodes(): void;
    removeRTTNode(node: CoreNode): void;
    getBufferInfo(): BufferInfo | null;
    getDefaultShaderNode(): WebGlShaderNode;
    getTextureCoords(node: CoreNode): TextureCoords;
    /**
     * Updates the WebGL context's clear color and clears the color buffer.
     *
     * @param color - The color to set as the clear color, represented as a 32-bit integer.
     */
    updateClearColor(color: number): void;
}
export {};