/**
 * Unified GPU raster basemap (Advanced tier) — WebGPU with WebGL fallback.
 *
 * Perf notes (vs DOM tiles / MapLibre):
 * - Coalesce texture uploads → one rAF redraw (never render() per onload)
 * - Same-zoom pan: CSS translate of the last framebuffer when the needed set is unchanged
 * - Draw only needed + retained tiles (not the whole LRU)
 * - Debounce integer zoom switches during continuous camera stress
 */
import { type LatLngBoundsLike } from "../geo.js";
import { Layer, type LayerOptions } from "../layer.js";
import type { RasterTileEventDetail } from "./tile-layer.js";
import type { Orihon } from "../map.js";
import { type RasterTileLayer, type RasterTileRendererKind, type RasterTileStats, type TileRedrawFlag, type TileTemplate } from "./tile-layer.js";
export type GPUTileBackend = "auto" | "webgpu" | "webgl";
export interface GPUTileLayerOptions extends LayerOptions {
    /** Preferred renderer. Auto selects WebGPU, then WebGL. */
    backend?: GPUTileBackend;
    minZoom?: number;
    maxZoom?: number;
    maxNativeZoom?: number;
    tileSize?: number;
    buffer?: number;
    cacheSize?: number;
    maxRequests?: number;
    maxNewPerFrame?: number;
    subdomains?: string | string[];
    crossOrigin?: string;
    referrerPolicy?: ReferrerPolicy | "";
    opacity?: number;
    errorTileUrl?: string;
    noWrap?: boolean;
    tms?: boolean;
    detectRetina?: boolean;
    bounds?: LatLngBoundsLike | null;
    className?: string;
    maxDpr?: number;
}
type ResolvedOptions = Required<Pick<GPUTileLayerOptions, "pane" | "minZoom" | "maxZoom" | "tileSize" | "buffer" | "cacheSize" | "maxRequests" | "maxNewPerFrame" | "subdomains" | "attribution" | "crossOrigin" | "referrerPolicy" | "opacity" | "errorTileUrl" | "noWrap" | "tms" | "detectRetina" | "className" | "maxDpr" | "backend">> & GPUTileLayerOptions;
export interface GPUTileLayerStats extends RasterTileStats {
    renderer: "webgpu" | "webgl" | "none";
    needed: number;
    visibleReady: number;
    preloadNeeded: number;
    preloadReady: number;
    coveragePct: number;
    ready: number;
    loading: number;
    cached: number;
    gpuBytesApprox: number;
}
interface WebGpuTexture {
    destroy(): void;
    createView(): object;
}
interface WebGpuBindGroup {
}
interface WebGpuBuffer {
    destroy(): void;
}
interface GpuTile {
    key: string;
    x: number;
    y: number;
    z: number;
    url: string;
    texture: WebGLTexture | WebGpuTexture | null;
    bindGroup: WebGpuBindGroup | null;
    uniform: WebGpuBuffer | null;
    image: HTMLImageElement | null;
    /** 0 idle · 1 loading · 2 ready · 3 error */
    state: 0 | 1 | 2 | 3;
    lastUsed: number;
    byteSize: number;
    generation: number;
    slot: number;
    priority: number;
}
export interface GPUTileLayerEventMap {
    tileloadstart: Omit<RasterTileEventDetail, "tile">;
    tileload: Omit<RasterTileEventDetail, "tile">;
    tileerror: Omit<RasterTileEventDetail, "tile">;
    tileabort: Omit<RasterTileEventDetail, "tile">;
}
export declare class GPUTileLayer extends Layer<ResolvedOptions, GPUTileLayerEventMap> implements RasterTileLayer {
    #private;
    template: TileTemplate;
    canvas: HTMLCanvasElement | null;
    gl: WebGLRenderingContext | null;
    gl2: WebGL2RenderingContext | null;
    renderer: "webgpu" | "webgl" | "none";
    readonly tiles: Map<string, GpuTile>;
    private program;
    private program2;
    private quadBuffer;
    private instanceBuffer;
    private locs;
    private locs2;
    private _gpuDevice;
    private _gpuContext;
    private _gpuPipeline;
    private _gpuSampler;
    private _gpuFormat;
    private _gpuIniting;
    private _useArray;
    private _arrayTex;
    private _arrayDim;
    private _arrayLayers;
    private _freeSlots;
    private _instanceData;
    private _tileZoom;
    private _needed;
    private _neededCount;
    private _retained;
    /** Next coarser viewport, loaded at low priority for seamless zoom-out. */
    private _preload;
    /** Coarsest level at the start of a zoom-in round-trip, pinned for instant zoom-back. */
    private _zoomBackstop;
    private _zoomBackstopZoom;
    /** View tiles visited during the active zoom round-trip; released at its floor. */
    private _zoomHistory;
    private _drawList;
    private _generation;
    private _loading;
    private _cssW;
    private _cssH;
    private _gpuBytes;
    private _queue;
    private _queuedKeys;
    private _rect;
    private _dirty;
    private _forceGpu;
    private _hasDrawn;
    private _redrawFrame;
    private _settleTimer;
    private _lastGpuMs;
    private _drawnZoom;
    private _drawnOriginX;
    private _drawnOriginY;
    private _pendingSourceZoom;
    private _zoomSwitchTimer;
    private readonly _retina;
    private readonly _bounds;
    private readonly _lfu;
    constructor(template: TileTemplate, options?: GPUTileLayerOptions);
    getStats(): GPUTileLayerStats;
    get rendererKind(): RasterTileRendererKind;
    getTileUrl(x: number, y: number, z: number): string;
    redraw(): this;
    setUrl(template: TileTemplate, redraw?: TileRedrawFlag): this;
    setOpacity(opacity: number): this;
    onAdd(map: Orihon): void;
    onRemove(): void;
    render(): void;
}
export declare function gpuTileLayer(template: TileTemplate, options?: GPUTileLayerOptions): GPUTileLayer;
export {};
//# sourceMappingURL=gpu-tile-layer.d.ts.map