import type { RenderPipelineProps, RenderPipelineParameters, PrimitiveTopology, ShaderLayout, UniformValue, Bindings, BindingsByGroup, RenderPass, VertexArray } from '@luma.gl/core';
import { RenderPipeline } from '@luma.gl/core';
import { WebGLDevice } from "../webgl-device.js";
import { WEBGLShader } from "./webgl-shader.js";
import { WEBGLTransformFeedback } from "./webgl-transform-feedback.js";
/** Creates a new render pipeline */
export declare class WEBGLRenderPipeline extends RenderPipeline {
    /** The WebGL device that created this render pipeline */
    readonly device: WebGLDevice;
    /** Handle to underlying WebGL program */
    readonly handle: WebGLProgram;
    /** vertex shader */
    vs: WEBGLShader;
    /** fragment shader */
    fs: WEBGLShader;
    /** The layout extracted from shader by WebGL introspection APIs */
    introspectedLayout: ShaderLayout;
    /** Compatibility path for direct pipeline.setBindings() usage */
    bindings: Bindings;
    /** Compatibility path for direct pipeline.uniforms usage */
    uniforms: Record<string, UniformValue>;
    /** WebGL varyings */
    varyings: string[] | null;
    _uniformCount: number;
    _uniformSetters: Record<string, Function>;
    get [Symbol.toStringTag](): string;
    constructor(device: WebGLDevice, props: RenderPipelineProps);
    destroy(): void;
    /**
     * Compatibility shim for code paths that still set bindings on the pipeline.
     * Shared-model draws pass bindings per draw and do not rely on this state.
     */
    setBindings(bindings: Bindings | BindingsByGroup, options?: {
        disableWarnings?: boolean;
    }): void;
    /** @todo needed for portable model
     * @note The WebGL API is offers many ways to draw things
     * This function unifies those ways into a single call using common parameters with sane defaults
     */
    draw(options: {
        renderPass: RenderPass;
        parameters?: RenderPipelineParameters;
        topology?: PrimitiveTopology;
        vertexArray: VertexArray;
        isInstanced?: boolean;
        vertexCount?: number;
        indexCount?: number;
        instanceCount?: number;
        firstVertex?: number;
        firstIndex?: number;
        firstInstance?: number;
        baseVertex?: number;
        transformFeedback?: WEBGLTransformFeedback;
        bindings?: Bindings;
        bindGroups?: BindingsByGroup;
        _bindGroupCacheKeys?: Partial<Record<number, object>>;
        uniforms?: Record<string, UniformValue>;
    }): boolean;
    /**
     * Checks if all texture-values uniforms are renderable (i.e. loaded)
     * Update a texture if needed (e.g. from video)
     * Note: This is currently done before every draw call
     */
    _areTexturesRenderable(bindings: Bindings): boolean;
    /** Apply any bindings (before each draw call) */
    _applyBindings(bindings: Bindings, _options?: {
        disableWarnings?: boolean;
    }): void;
    /**
     * Due to program sharing, uniforms need to be reset before every draw call
     * (though caching will avoid redundant WebGL calls)
     */
    _applyUniforms(uniforms: Record<string, UniformValue>): void;
    private _syncLinkStatus;
}
//# sourceMappingURL=webgl-render-pipeline.d.ts.map