import Class from '../../core/Class';
import Point from '../../geo/Point';
import Extent from '../../geo/Extent';
import { TileRenderingCanvas } from '../types';
import { ResourceCache } from '../../core/ResourceCacheManager';
import { SizeLike } from '../../geo/Size';
/**
 * 在 HTMLCanvasElement 上渲染图层的基类
 * @english
 * Base Class to render layer on HTMLCanvasElement
 * @abstract
 * @protected
 * @memberOf renderer
 * @extends Class
 */
declare class LayerAbstractRenderer extends Class {
    layer: any;
    resources: ResourceCache;
    context: any;
    canvas: TileRenderingCanvas;
    middleWest: Point;
    canvasExtent2D: Extent;
    mapDPR?: number;
    gl: WebGLRenderingContext | WebGL2RenderingContext;
    reglGL: WebGLRenderingContext | WebGL2RenderingContext;
    regl: any;
    device: any;
    drawOnInteracting?(...args: any[]): void;
    checkResources?(): any[];
    getImageData?(): ImageData;
    draw?(...args: any[]): void;
    /**
     * @param  {Layer} layer the layer to render
     */
    constructor(layer: any);
    /**
     * Render the layer.
     * Call checkResources
     */
    render(framestamp?: number): void;
    getFrameTimestamp(): number;
    checkAndDraw(drawFn: any, ...args: any[]): void;
    /**
     * Check if has any external resources to load
     * If yes, load the resources before calling draw method
     * @abstract
     * @method checkResources
     * @instance
     * @returns {Array[]} an array of resource arrays [ [url1, width, height], [url2, width, height], [url3, width, height] .. ]
     * @memberOf renderer.LayerAbstractRenderer
     */
    /**
     * a required abstract method to implement
     * draw the layer when map is not interacting
     * @abstract
     * @instance
     * @method draw
     * @memberOf renderer.LayerAbstractRenderer
     */
    /**
     * an optional abstract method to implement
     * draw the layer when map is interacting (moving/zooming/dragrotating)
     * @abstract
     * @instance
     * @method drawOnInteracting
     * @param {Object} eventParam event parameters
     * @memberOf renderer.LayerAbstractRenderer
     */
    /**
     * @private
     */
    testIfNeedRedraw(): boolean;
    /**
     * Ask whether the layer renderer needs to redraw
     */
    needToRedraw(): boolean;
    /**
     * A callback for overriding when drawOnInteracting is skipped due to low fps
     */
    onSkipDrawOnInteracting(): void;
    isLoadingResource(): boolean;
    isRenderComplete(): boolean;
    /**
     * Whether must call render instead of drawOnInteracting when map is interacting
     */
    mustRenderOnInteracting(): boolean;
    /**
     * Set to redraw, ask map to call draw/drawOnInteracting to redraw the layer
     */
    setToRedraw(): this;
    /**
     * Remove the renderer, will be called when layer is removed
     */
    remove(): void;
    onRemove(): void;
    onAdd(): void;
    /**
     * Get map
     */
    getMap(): any;
    /**
     * Clear canvas
     */
    clear(): void;
    /**
     * A method to help improve performance.
     * If you are sure that layer's canvas is blank, returns true to save unnecessary layer works of maps.
     */
    isBlank(): boolean;
    /**
     * Show the layer
     */
    show(): void;
    /**
     * Hide the layer
     */
    hide(): void;
    /**
     * Set z-index of layer
     */
    setZIndex(_z?: number): void;
    /**
     * 渲染结果区域截图,主要用于事件检测处理
     * @param x
     * @param y
     * @param width
     * @param height
     * @returns
     */
    screenshotRenderResult(x: number, y: number, width: number, height: number): CanvasRenderingContext2D | null;
    /**
     * Detect if there is anything painted on the given point
     * @param point containerPoint
     */
    hitDetect(point: Point): boolean;
    /**
     * loadResource from resourceUrls
     * @param  {String[]} resourceUrls    - Array of urls to load
     * @returns {Promise[]}
     */
    loadResources(resourceUrls: string[][]): Promise<any>;
    /**
     * Prepare rendering
     * Set necessary properties, like this._renderZoom/ this.canvasExtent2D, this.middleWest
     * @private
     */
    prepareRender(): void;
    /**
     * @english
     * Prepare the canvas for rendering. <br>
     * 1. Clear the canvas to blank. <br>
     * 2. Clip the canvas by mask if there is any and return the mask's extent
     * @return {PointExtent} mask's extent of current zoom's 2d point.
     */
    prepareCanvas(): any;
    initContext(): void;
    prepareContext(): void;
    clearContext(): void;
    createContext(): void;
    /**
     * Get renderer's current view extent in 2d point
     * @return {Object} view.extent, view.maskExtent, view.zoom, view.middleWest
     */
    getViewExtent(): {
        extent: Extent;
        maskExtent: Extent;
        zoom: number;
        middleWest: Point;
    };
    /**
     * call when rendering completes, this will fire necessary events and call setCanvasUpdated
     */
    completeRender(): void;
    /**
     * Get renderer's event map registered on the map
     * @return {Object} events
     */
    getEvents(): {
        _zoomstart: (param: any) => void;
        _zooming: (param: any) => void;
        _zoomend: (param: any) => void;
        _resize: (param: any) => void;
        _movestart: (param: any) => void;
        _moving: (param: any) => void;
        _moveend: (param: any) => void;
        _dragrotatestart: (param: any) => void;
        _dragrotating: (param: any) => void;
        _dragrotateend: (param: any) => void;
        _spatialreferencechange: (param: any) => void;
    };
    /**
     * onZoomStart
     * @param  {Object} param event parameters
     */
    onZoomStart(param: any): void;
    /**
    * onZoomEnd
    * @param  {Object} param event parameters
    */
    onZoomEnd(param: any): void;
    /**
    * onZooming
    * @param  {Object} param event parameters
    */
    onZooming(param: any): void;
    /**
    * onMoveStart
    * @param  {Object} param event parameters
    */
    onMoveStart(param: any): void;
    /**
    * onMoving
    * @param  {Object} param event parameters
    */
    onMoving(param: any): void;
    /**
    * onMoveEnd
    * @param  {Object} param event parameters
    */
    onMoveEnd(param: any): void;
    /**
    * onResize
    * @param  {Object} param event parameters
    */
    onResize(param: any): void;
    /**
    * onDragRotateStart
    * @param  {Object} param event parameters
    */
    onDragRotateStart(param: any): void;
    /**
    * onDragRotating
    * @param  {Object} param event parameters
    */
    onDragRotating(param: any): void;
    /**
    * onDragRotateEnd
    * @param  {Object} param event parameters
    */
    onDragRotateEnd(param: any): void;
    /**
    * onSpatialReferenceChange
    * @param  {Object} param event parameters
    */
    onSpatialReferenceChange(param: any): void;
    /**
     * Get ellapsed time of previous drawing
     * @return {Number}
     */
    getDrawTime(): number;
    /**
     * Only for MapCanvasRenderer
     * Mark layer's canvas updated
     */
    setCanvasUpdated(): this;
    /**
     * Only for MapCanvasRenderer
     * Only called by map's renderer to check whether the layer's canvas is updated
     * @protected
     * @return {Boolean}
     */
    isCanvasUpdated(): boolean;
    /**
     * Only for MapCanvasRenderer
     * Get renderer's Canvas image object
     */
    getCanvasImage(): any;
    clearCanvas(): void;
    /**
     * Only for MapCanvasRenderer
     * Create renderer's Canvas
     */
    createCanvas(): void;
    onCanvasCreate(): void;
    /**
     * Only for MapCanvasRenderer
     * Resize the canvas
     * @param canvasSize the size resizing to
     */
    resizeCanvas(canvasSize?: SizeLike): void;
    /**
     * Only for MapCanvasRenderer
     * @param context
     * @returns
     */
    clipCanvas(context: CanvasRenderingContext2D): boolean;
}
export default LayerAbstractRenderer;
//# sourceMappingURL=LayerAbstractRenderer.d.ts.map