export default WebGLBlock;
declare class WebGLBlock extends FittedBlock {
    /**
     * @mixes Poolable
     *
     * @param {Display} display
     * @param {number} renderer
     * @param {Instance} transformRootInstance - All transforms of this instance and its ancestors will already have been
     *                                           applied. This block will only be responsible for applying transforms of
     *                                           this instance's descendants.
     * @param {Instance} filterRootInstance - All filters (visibility/opacity/filters) of this instance and its ancestors
     *                                        will already have been applied. This block will only be responsible for
     *                                        applying filters of this instance's descendants.
     */
    constructor(display: Display, renderer: number, transformRootInstance: Instance, filterRootInstance: Instance);
    /**
     * @public
     *
     * @param {Display} display
     * @param {number} renderer
     * @param {Instance} transformRootInstance - All transforms of this instance and its ancestors will already have been
     *                                           applied. This block will only be responsible for applying transforms of
     *                                           this instance's descendants.
     * @param {Instance} filterRootInstance - All filters (visibility/opacity/filters) of this instance and its ancestors
     *                                        will already have been applied. This block will only be responsible for
     *                                        applying filters of this instance's descendants.
     * @returns {WebGLBlock} - For chaining
     */
    public initialize(display: Display, renderer: number, transformRootInstance: Instance, filterRootInstance: Instance): WebGLBlock;
    filterRootInstance: any;
    preserveDrawingBuffer: any;
    dirtyDrawables: any;
    spriteSheets: any;
    projectionMatrix: any;
    projectionMatrixArray: Float32Array | undefined;
    customProcessor: any;
    vertexColorPolygonsProcessor: any;
    texturedTrianglesProcessor: any;
    glChangedEmitter: TinyEmitter<[]> | undefined;
    isContextLost: boolean | undefined;
    contextLostListener: ((domEvent: WebGLContextEvent) => void) | undefined;
    contextRestoreListener: ((domEvent: WebGLContextEvent) => void) | undefined;
    domElement: HTMLDivElement | undefined;
    /**
     * Forces a rebuild of the Canvas and its context (as long as a context can be obtained).
     * @private
     *
     * This can be necessary when the browser won't restore our context that was lost (and we need to create another
     * canvas to get a valid context).
     */
    private rebuildCanvas;
    canvas: HTMLCanvasElement | undefined;
    canvasId: string | undefined;
    /**
     * Takes a fresh WebGL context switches the WebGL block over to use it.
     * @private
     *
     * @param {WebGLRenderingContext} gl
     */
    private setupContext;
    gl: WebGLRenderingContext | undefined;
    backingScale: any;
    originalBackingScale: any;
    /**
     * Attempts to force a Canvas rebuild to get a new Canvas/context pair.
     * @private
     */
    private delayedRebuildCanvas;
    /**
     * Callback for whenever our WebGL context is lost.
     * @private
     *
     * @param {WebGLContextEvent} domEvent
     */
    private onContextLoss;
    /**
     * Callback for whenever our WebGL context is restored.
     * @private
     *
     * @param {WebGLContextEvent} domEvent
     */
    private onContextRestoration;
    /**
     * Attempts to get a WebGL context from a Canvas.
     * @private
     *
     * @param {HTMLCanvasElement}
     * @returns {WebGLRenderingContext|*} - If falsy, it did not succeed.
     */
    private getContextFromCanvas;
    /**
     * @public
     *
     * @param {Drawable} drawable
     */
    public markDirtyDrawable(drawable: Drawable): void;
    /**
     * Ensures we have an allocated part of a SpriteSheet for this image. If a SpriteSheet already contains this image,
     * we'll just increase the reference count. Otherwise, we'll attempt to add it into one of our SpriteSheets. If
     * it doesn't fit, we'll add a new SpriteSheet and add the image to it.
     * @public
     *
     * @param {HTMLImageElement | HTMLCanvasElement} image
     * @param {number} width
     * @param {number} height
     *
     * @returns {Sprite} - Throws an error if we can't accommodate the image
     */
    public addSpriteSheetImage(image: HTMLImageElement | HTMLCanvasElement, width: number, height: number): Sprite;
    /**
     * Removes the reference to the sprite in our spritesheets.
     * @public
     *
     * @param {Sprite} sprite
     */
    public removeSpriteSheetImage(sprite: Sprite): void;
    /**
     * @public
     *
     * @param {Drawable} drawable
     */
    public onPotentiallyMovedDrawable(drawable: Drawable): void;
}
import { FittedBlock } from '../imports.js';
import TinyEmitter from '../../../axon/js/TinyEmitter.js';
//# sourceMappingURL=WebGLBlock.d.ts.map