@allmaps/render/dist/renderers/WebGL2Renderer.d.ts

Render functions for WebGL and image buffers

import { BaseRenderer } from './BaseRenderer.js';
import { WebGL2WarpedMap } from '../maps/WebGL2WarpedMap.js';
import { Viewport } from '../viewport/Viewport.js';
import { FetchableTile } from '../tilecache/FetchableTile.js';
import { Renderer, SpecificWebGL2RenderOptions, WebGL2RenderOptions } from '../shared/types.js';

export declare const DEFAULT_SPECIFIC_WEBGL2_RENDER_OPTIONS: SpecificWebGL2RenderOptions;
/**
 * Class that renders WarpedMaps to a WebGL 2 context
 */
export declare class WebGL2Renderer extends BaseRenderer<WebGL2WarpedMap, ImageData> implements Renderer {
    #private;
    gl: WebGL2RenderingContext;
    options: Partial<WebGL2RenderOptions>;
    mapProgram: WebGLProgram;
    linesProgram: WebGLProgram;
    pointsProgram: WebGLProgram;
    private uniformCache;
    previousSignificantViewport: Viewport | undefined;
    lastAnimationFrameRequestId: number | undefined;
    animating: boolean;
    animationStart: number | undefined;
    animationProgress: number;
    disableRender: boolean;
    private throttledPrepareRenderInternal;
    private throttledChanged;
    /**
     * Creates an instance of WebGL2Renderer.
     *
     * @constructor
     * @param gl - WebGL 2 rendering context
     * @param options - options
     */
    constructor(gl: WebGL2RenderingContext, options?: Partial<WebGL2RenderOptions>);
    initializeWebGL(gl: WebGL2RenderingContext): void;
    /**
     * Render the map for a given viewport.
     *
     * If no viewport is specified the current viewport is rerendered.
     * If no current viewport is known, a viewport is deduced based on the WarpedMapList and canvas width and hight.
     *
     * @param viewport - the current viewport
     */
    render(viewport?: Viewport): void;
    clear(): void;
    cancelThrottledFunctions(): void;
    destroy(): void;
    private getUniformLocation;
    protected updateMapsForViewport(allFechableTilesForViewport: FetchableTile[]): {
        mapsInViewportEntering: string[];
        mapsInViewportLeaving: string[];
        mapsWithFetchableTilesForViewportEntering: string[];
        mapsWithFetchableTilesForViewportLeaving: string[];
    };
    protected resetPrevious(mapIds?: string[]): void;
    protected updateVertexBuffers(mapIds?: string[]): void;
    private prepareRenderInternal;
    protected shouldRequestFetchableTiles(): boolean;
    protected shouldAnticipateInteraction(): boolean;
    private renderInternal;
    private renderMapsInternal;
    private renderLinesInternal;
    private renderPointsInternal;
    private setMapProgramUniforms;
    private setMapProgramMapUniforms;
    private setLinesProgramUniforms;
    private setLinesProgramMapUniforms;
    private setPointsProgramUniforms;
    private setPointsProgramMapUniforms;
    private startAnimation;
    private animationFrame;
    private finishAnimation;
    private changed;
    protected imageLoaded(event: Event): void;
    protected clearMap(mapId: string): void;
    protected mapTileLoaded(event: Event): void;
    protected mapTileDeleted(event: Event): void;
    protected warpedMapAdded(event: Event): void;
    protected prepareChange(event: Event): void;
    protected animatedChange(event: Event): void;
    protected immediateChange(event: Event): void;
    private addEventListenersToWebGL2WarpedMap;
    private removeEventListenersFromWebGL2WarpedMap;
    contextLost(): void;
    contextRestored(): void;
}