import * as three_webgpu from 'three/webgpu';
import { Node, UniformArrayNode, DataArrayTexture, Object3D, Scene, Camera } from 'three/webgpu';
import * as three_src_nodes_TSL_js from 'three/src/nodes/TSL.js';

type WorkerMode = 'none' | 'image' | 'full' | 'error';
type WorkerResult = {
    bitmap: ImageBitmap;
    mesh?: {
        pos: Float32Array;
        scl: Float32Array;
        cnt: number;
    };
    occ?: Uint8Array;
    mode: WorkerMode;
    memo?: any;
};

declare const createCamera: ({ yaw, pitch, near, far, fov, mode, autoScroll, x, y, z, dash, move, jump, ground, size, gravity, sens, wrap }: {
    yaw?: number | undefined;
    pitch?: number | undefined;
    near?: number | undefined;
    far?: number | undefined;
    fov?: number | undefined;
    mode?: string | undefined;
    autoScroll?: boolean | undefined;
    x?: number | undefined;
    y?: number | undefined;
    z?: number | undefined;
    dash?: number | undefined;
    move?: number | undefined;
    jump?: number | undefined;
    ground?: number | undefined;
    size?: number[] | undefined;
    gravity?: number | undefined;
    sens?: number | undefined;
    wrap?: number | undefined;
}) => {
    pos: number[];
    eye: number[];
    mvp: number[];
    reset: (y?: number, p?: number) => void;
    tick: (dt?: number, pick?: (_x?: number, _y?: number, _z?: number) => number) => void;
    turn: (delta?: number[]) => void;
    shift: (isPress?: boolean) => undefined;
    space: (isPress?: boolean) => void;
    asdw: (axis?: number, delta?: number) => undefined;
    update: (_aspect?: number, _near?: number, _far?: number, _fov?: number) => void;
    mode: (x?: string) => string;
    yaw: () => number;
    pitch: () => number;
    near: () => number;
    far: () => number;
    fov: () => number;
    aspect: () => number;
};
type CameraConfig = Parameters<typeof createCamera>[0];

type CellState = 'visible' | 'prebuild' | 'prefetch' | 'idle' | 'error';
type CellCache = 'empty' | 'fetching' | 'building' | 'cached' | 'purged';
type DebugCell = {
    i: number;
    j: number;
    state: CellState;
    cache: CellCache;
    prefetchMs?: number;
    prebuildMs?: number;
};
type DebugEvent = {
    ts: number;
    anchor: [number, number];
    cells: DebugCell[];
};
type Debug = ReturnType<typeof createDebug>;
declare const createDebug: () => {
    onDebug: (handler: (event: DebugEvent) => void) => () => undefined;
    setAnchor: (i: number, j: number) => void;
    setState: (i: number, j: number, state: CellState, isError?: boolean) => void;
    setCache: (i: number, j: number, cache: CellCache) => void;
    taskStart: (i: number, j: number, mode: "image" | "full") => void;
    taskDone: (i: number, j: number, mode: "image" | "full") => void;
    taskAbort: (i: number, j: number) => void;
    prune: (active: Set<string>) => void;
};

interface VoxelConfig {
    x0: number;
    x1: number;
    y0: number;
    y1: number;
    slot: number;
    prebuild: number;
    prefetch: number;
    prepurge: number;
    atlasExt: string;
    atlasUrl: string;
}

type SlotUpdate = {
    at: number;
    atlas: ImageBitmap;
    offset: [number, number, number];
};

declare const createVoxel: ({ worker, i, j, camera: cc, debug, onReady, ...opts }: {
    worker: Worker;
    i?: number;
    j?: number;
    camera?: CameraConfig;
    debug?: Debug;
    onReady?: () => void;
} & Partial<VoxelConfig>) => {
    cam: {
        pos: number[];
        eye: number[];
        mvp: number[];
        reset: (y?: number, p?: number) => void;
        tick: (dt?: number, pick?: (_x?: number, _y?: number, _z?: number) => number) => void;
        turn: (delta?: number[]) => void;
        shift: (isPress?: boolean) => undefined;
        space: (isPress?: boolean) => void;
        asdw: (axis?: number, delta?: number) => undefined;
        update: (_aspect?: number, _near?: number, _far?: number, _fov?: number) => void;
        mode: (x?: string) => string;
        yaw: () => number;
        pitch: () => number;
        near: () => number;
        far: () => number;
        fov: () => number;
        aspect: () => number;
    };
    i: number;
    j: number;
    center: [number, number];
    updates: (fn: (u: SlotUpdate) => void) => void;
    updated: () => boolean;
    overflow: () => boolean;
    pos: () => Float32Array<ArrayBuffer>;
    scl: () => Float32Array<ArrayBuffer>;
    aid: () => Float32Array<ArrayBuffer>;
    count: () => number;
    pick: (wx?: number, wy?: number, wz?: number) => number;
    geo2xyz: (lat: number, lng: number, y?: number) => [number, number, number];
    xyz2geo: (wx?: number, _wy?: number, wz?: number) => [number, number];
    map: Map<number, {
        id: number;
        x: number;
        y: number;
        z: number;
        i: number;
        j: number;
        prefetch: (mode: "image" | "full", priority?: number) => Promise<WorkerResult | undefined>;
        image: (priority?: number) => Promise<ImageBitmap>;
        build: (index?: number) => boolean;
        pick: (lx?: number, ly?: number, lz?: number) => number;
        dispose: () => boolean;
        fetching: () => boolean;
        reset: () => undefined;
        tune: (mode: WorkerMode, priority?: number) => void;
        slot: number;
        bitmap: () => ImageBitmap | undefined;
        occ: () => Uint8Array<ArrayBufferLike> | undefined;
        memo: () => any;
        setMemo: (m: any) => void;
        isError: () => boolean;
    }>;
};

declare const xyz2m: three_src_nodes_TSL_js.FnNode<[Node<"ivec3">], Node<"int">>;
declare const m2uv: three_src_nodes_TSL_js.FnNode<[Node<"int">], three_webgpu.VarNode<"ivec2", three_webgpu.JoinNode<"ivec2">>>;
declare const atlas: three_src_nodes_TSL_js.FnNode<[Node<"ivec3">], three_webgpu.VarNode<"ivec2", three_webgpu.JoinNode<"ivec2">>>;

type Req = Parameters<typeof createVoxel>[0];
type Res = ReturnType<typeof createVoxel>;
type Renderer = Parameters<Object3D['onBeforeRender']>[0];
declare class Voxel extends three_webgpu.InstancedMesh {
    voxel: Res;
    offsetNode: UniformArrayNode<'vec3'>;
    dstTexture: DataArrayTexture;
    private _isThree;
    private _writeAtlas?;
    constructor(params: Req & {
        controls?: 'three' | 'voxel';
    });
    onBeforeRender(renderer: Renderer, _scene: Scene, camera: Camera): void;
    private _setAttribute;
}

export { Voxel, atlas, Voxel as default, m2uv, xyz2m };