import * as three from 'three';
import { BoxGeometry, MeshLambertMaterial, Texture, MeshLambertMaterialParameters, Group, PerspectiveCamera, Object3D, Scene, WebGLRenderer, WebGLRendererParameters, Intersection, ColorRepresentation, Mesh, Vector3, MeshBasicMaterial, MeshPhongMaterial, MeshStandardMaterial, MeshPhysicalMaterial, Points } from 'three';
import { GUI } from 'three/examples/jsm/libs/lil-gui.module.min.js';
import { OrbitControls } from 'three/examples/jsm/Addons.js';

type Map2DData = Map<number, number>;
declare class Map2D {
    readonly defaultValue: number;
    private _data;
    get data(): Map2DData;
    get size(): number;
    constructor(defaultValue?: number);
    private _floor;
    private _key;
    private _pos;
    clear(): void;
    get(x: number, y: number, defaultValue?: number): number;
    set(x: number, y: number, value?: number): void;
    forEach(callback: (x: number, y: number, v: number) => void): void;
}

interface AStarPoint {
    x: number;
    y: number;
}
interface AStarFindPathParams {
    /**
     * When true, a path ending adjacent to the target (not just exactly on
     * it) also counts as reaching the goal. Currently hard-coded to `true`
     * internally regardless of this value - see the note on
     * {@link AStar.findPath}.
     */
    useAdjacent?: boolean;
    walkableValues?: number[];
}
declare class AStar {
    map: Map2D;
    constructor(map: Map2D);
    private _manhattan;
    private _isWalkable;
    private _key;
    findPath(a: AStarPoint, b: AStarPoint, params?: AStarFindPathParams): AStarPoint[];
}

type Observer<T> = (value: T, ...args: any[]) => void;
declare class Observable<T> {
    private readonly observers;
    subscribe(observer: Observer<T>): () => void;
    once(observer: Observer<T>, ...args: any[]): () => void;
    notify(value: T, ...args: any[]): void;
    clear(): void;
    get size(): number;
}

declare class Clock {
    private _startTime;
    private _time;
    private _deltaTime;
    private _frameTime;
    private _frameCount;
    private _fps;
    private _isRunning;
    get time(): number;
    get deltaTime(): number;
    get elapsedTime(): number;
    get fps(): number;
    get isRunning(): boolean;
    readonly onFrame: Observable<Clock>;
    start(): this;
    stop(): void;
}

declare class Disposable {
    private readonly disposers;
    add(disposer: () => void): void;
    dispose(): void;
}

declare const PI: number;
declare const TAU: number;
declare const HALF_PI: number;
declare const QUARTER_PI: number;
declare const E: number;
declare const DEG2RAD: number;
declare const RAD2DEG: number;
declare const LN2: number;
declare const LN10: number;
declare const LOG2E: number;
declare const LOG10E: number;
declare const SQRT2: number;
declare const SQRT1_2: number;
declare const EPSILON: number;
interface XY {
    readonly x: number;
    readonly y: number;
}
interface XYZ {
    readonly x: number;
    readonly y: number;
    readonly z: number;
}
interface XYZW {
    readonly x: number;
    readonly y: number;
    readonly z: number;
    readonly w: number;
}
interface RGB {
    readonly r: number;
    readonly g: number;
    readonly b: number;
}
interface RGBA {
    readonly r: number;
    readonly g: number;
    readonly b: number;
    readonly a: number;
}
declare const abs: (x: number) => number;
declare const min: (...values: number[]) => number;
declare const max: (...values: number[]) => number;
declare const floor: (x: number) => number;
declare const ceil: (x: number) => number;
declare const round: (x: number) => number;
declare const trunc: (x: number) => number;
declare const sign: (x: number) => number;
declare const sqrt: (x: number) => number;
declare const cbrt: (x: number) => number;
declare const pow: (x: number, y: number) => number;
declare const exp: (x: number) => number;
declare const expm1: (x: number) => number;
declare const log: (x: number) => number;
declare const log1p: (x: number) => number;
declare const log2: (x: number) => number;
declare const log10: (x: number) => number;
declare const hypot: (...values: number[]) => number;
declare const imul: (x: number, y: number) => number;
declare const sin: (x: number) => number;
declare const cos: (x: number) => number;
declare const tan: (x: number) => number;
declare const asin: (x: number) => number;
declare const acos: (x: number) => number;
declare const atan: (x: number) => number;
declare const atan2: (y: number, x: number) => number;
declare const sinh: (x: number) => number;
declare const cosh: (x: number) => number;
declare const tanh: (x: number) => number;
declare const clamp: (value: number, minValue: number, maxValue: number) => number;
declare const saturate: (value: number) => number;
declare const lerp: (start: number, end: number, t: number) => number;
declare const inverseLerp: (start: number, end: number, value: number) => number;
declare const map: (value: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
declare const smoothstep: (edge0: number, edge1: number, value: number) => number;
declare const fract: (value: number) => number;
declare const mod: (value: number, divisor: number) => number;
declare const wrap: (value: number, minValue: number, maxValue: number) => number;
declare const radians: (degrees: number) => number;
declare const degrees: (radians: number) => number;
declare const normalizeRadians: (radians: number) => number;
declare const hypot2: (x: number, y: number) => number;
declare const hypot3: (x: number, y: number, z: number) => number;
declare const distance2d: (x1: number, y1: number, x2: number, y2: number) => number;
declare const distance3d: (x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) => number;
declare const squaredDistance: (x1: number, y1: number, x2: number, y2: number) => number;
declare const manhattanDistance: (x1: number, y1: number, x2: number, y2: number) => number;
declare const nearlyEqual: (a: number, b: number, epsilon?: number) => boolean;
declare const roundTo: (value: number, digits?: number) => number;
declare const isFinite: (number: unknown) => boolean;
declare const isInteger: (number: unknown) => boolean;
declare const isNaN: (number: unknown) => boolean;

declare class Vector {
    x: number;
    y: number;
    constructor(x?: number, y?: number);
    clone(): Vector;
    copy(that: Vector): this;
    copyTo(target: {
        x: number;
        y: number;
    }): this;
    set(x: number, y: number): this;
    equals(that: Vector): boolean;
    distanceTo(that: Vector): number;
    length(): number;
    normalize(): this;
    setLength(length: number): this;
    dot(that: Vector): number;
    angle(): number;
    angleTo(that: Vector): number;
    rotate(radians: number): this;
    rotateAround(origin: Vector, radians: number): this;
    floored(): Vector;
    plus(x: number | Vector, y?: number): this;
    minus(x: number | Vector, y?: number): this;
    times(x: number | Vector, y?: number): this;
    dividedBy(x: number | Vector, y?: number): this;
    static from(value: XY): Vector;
    static get ZERO(): Vector;
    static get NORTH(): Vector;
    static get SOUTH(): Vector;
    static get EAST(): Vector;
    static get WEST(): Vector;
}

declare class Rectangle {
    x: number;
    y: number;
    width: number;
    height: number;
    constructor(x?: number, y?: number, width?: number, height?: number);
    area(): number;
    contains(target: Vector | Rectangle, padding?: number): boolean;
    intersects(other: Rectangle, padding?: number): boolean;
    center(): Vector;
    distanceTo(other: Rectangle): number;
    clone(): Rectangle;
    equals(other: Rectangle): boolean;
    grow(padding: number): Rectangle;
    vectorInside(vec: Vector, padding?: number): boolean;
}

type RectPair = {
    a: Rectangle;
    b: Rectangle;
};
type PointPair = {
    a: XY;
    b: XY;
};
interface RoomsParams {
    size?: number;
    minSize?: number;
    maxSize?: number;
    padding?: number;
    maxIterations?: number;
}
interface PathsParams {
    timeout?: number;
    extraPaths?: number;
    extraPathDensity?: number;
    astarFindPathParams?: AStarFindPathParams;
}
interface DoorsParams {
    plotDoors?: boolean;
    chanceExists?: number;
    chanceOpen?: number;
    chanceLocked?: number;
}
interface GenerateRoomsParams {
    map?: Map2D;
    rooms?: RoomsParams;
    paths?: PathsParams;
}
declare const TILE_EMPTY = 0;
declare const TILE_FLOOR = 1;
declare const TILE_PATH = 2;
declare function GenerateRooms(params?: GenerateRoomsParams): {
    map: Map2D;
    rooms: Rectangle[];
    paths: XY[][];
};
declare function GenerateDoors(map: Map2D, paths: XY[][], params?: DoorsParams): XY[];
declare function GenerateWalls(map: Map2D): XY[];

type Entity = number;
declare class ECS {
    private nextEntityId;
    private components;
    createEntity(): Entity;
    addComponent<T>(entity: Entity, name: string, data: T): void;
    getComponent<T>(entity: Entity, name: string): T | undefined;
    removeComponent(entity: Entity, name: string): void;
    getEntitiesWithComponents(...componentNames: string[]): Entity[];
}

declare class EventQueue<T> {
    private readonly events;
    emit(event: T): void;
    consume(): readonly T[];
    clear(): void;
    drain(): T[];
    get size(): number;
}

interface InputEventState {
    state: number;
    time: number;
}
declare const DOWN = 1;
declare const UP = 0;
declare class Input {
    private static _instance;
    static get instance(): Input;
    private _keyStates;
    private _buttonStates;
    private _pointerPosition;
    inputThreshold: number;
    get pointerPosition(): Vector;
    readonly onKeyDown: Observable<Input>;
    readonly onKeyUp: Observable<Input>;
    readonly onKeyPressed: Observable<Input>;
    readonly onPointerDown: Observable<Input>;
    readonly onPointerUp: Observable<Input>;
    readonly onPointerPressed: Observable<Input>;
    readonly onPointerMove: Observable<Input>;
    readonly onWheel: Observable<Input>;
    private constructor();
    isDown(key: string): boolean;
}

type Map3DData = Map<number, number>;
declare class Map3D {
    readonly defaultValue: number;
    private _data;
    get data(): Map3DData;
    get size(): number;
    constructor(defaultValue?: number);
    private _floor;
    private _key;
    private _pos;
    clear(): void;
    get(x: number, y: number, z: number, defaultValue?: number): number;
    set(x: number, y: number, z: number, value?: number): void;
    forEach(callback: (x: number, y: number, z: number, v: number) => void): void;
}

declare type KeyValue = {
    [key: string]: any;
};

declare function isNullOrUndefined(target: any): boolean;
declare function isPositiveString(target: string): boolean;
declare const getRedYellowGreenGradientHex: (min: number, max?: number) => string;
declare function GetUrlParams(): KeyValue;
declare const xy2k: (x: number, y: number, delimiter?: string) => string;
declare const k2xy: (key: string, delimiter?: string) => [number, number];
declare const xyz2k: (x: number, y: number, z: number, delimiter?: string) => string;
declare const k2xyz: (key: string, delimiter?: string) => [number, number];

interface FractalParams {
    octaves: number;
    frequency: number;
    persistence: number;
    amplitude: number;
    lacunarity: number;
}
declare class Noise {
    private static _n2d;
    private static _n3d;
    private static _n4d;
    static noise2d(x: number, y: number): number;
    static noise3d(x: number, y: number, z: number): number;
    static noise4d(x: number, y: number, z: number, w: number): number;
    static fractal2d(x: number, y: number, fractalParams: FractalParams): number;
    static fractal3d(x: number, y: number, z: number, fractalParams: FractalParams): number;
}

type CanvasColor = string | CanvasGradient | CanvasPattern;
declare const DEFAULT_COLOR: CanvasColor;
declare const DEFAULT_PIXEL_SIZE: number;
declare const DEFAULT_FONT_SIZE = 14;
declare const DEFAULT_FONT_NAME = "monospace";
declare const DEFAULT_FONT = "14px monospace";
declare const DEFAULT_TEXTALIGN = "left";
declare const DEFAULT_TEXTBASELINE = "alphabetic";
interface DrawParams {
    color?: CanvasColor;
    filled?: boolean;
    size?: number;
    lineDash?: number[];
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: string;
    fontName?: string;
}
interface SpriteParams extends DrawParams {
    sourceX?: number;
    sourceY?: number;
    sourceWidth?: number;
    sourceHeight?: number;
}
declare class CanvasRenderer {
    context: CanvasRenderingContext2D;
    get canvas(): HTMLCanvasElement;
    get width(): number;
    get height(): number;
    constructor(canvas?: HTMLCanvasElement);
    resize(width?: number, height?: number): boolean;
    clear(): void;
    render(callback: () => void, camera?: XYZ): void;
    private drawPath;
    drawRect(x: number, y: number, width: number, height: number, params?: DrawParams): void;
    drawPixel(x: number, y: number, params?: DrawParams): void;
    drawLine(x1: number, y1: number, x2: number, y2: number, params?: DrawParams): void;
    drawCircle(x: number, y: number, radius: number, params?: DrawParams): void;
    drawPolygon(x: number, y: number, radius: number, sides: number, params?: DrawParams): void;
    drawText(x: number, y: number, text: string, params?: DrawParams): void;
    drawSprite(x: number, y: number, image: CanvasImageSource, width: number, height: number, params?: SpriteParams): void;
}

declare class Color {
    private _hex;
    private _r;
    private _g;
    private _b;
    private _a;
    get r(): number;
    set r(value: number);
    get g(): number;
    set g(value: number);
    get b(): number;
    set b(value: number);
    get a(): number;
    set a(value: number);
    get hexStr(): string;
    set hexStr(value: string);
    get rgba(): number[];
    constructor(r?: string | number, g?: number, b?: number, a?: number);
    private static _normalize;
    private _to_hex;
    private _parse_hex_color_string;
    static fromHsv(h: number, s: number, v: number, a?: number): Color;
    static get BLACK(): Color;
    static get GRAY(): Color;
    static get WHITE(): Color;
    static get RED(): Color;
    static get GREEN(): Color;
    static get BLUE(): Color;
    static get YELLOW(): Color;
    static get ORANGE(): Color;
    static get PURPLE(): Color;
    static get CYAN(): Color;
    static get MAGENTA(): Color;
    static fromName(name: string): Color;
    static get TRANSPARENT(): Color;
}

declare class ParticleRenderer {
    private _screenCanvas;
    private _bufferCanvas;
    screenContext: CanvasRenderingContext2D;
    bufferContext: OffscreenCanvasRenderingContext2D;
    get width(): number;
    get height(): number;
    constructor(canvas?: HTMLCanvasElement);
    appendTo(target: HTMLElement, autoResize?: boolean): void;
    resize(displayWidth?: number, displayHeight?: number): boolean;
    setPixel(x: number, y: number, color: Color, size?: number): void;
    render(): void;
}

declare class CubeSphereGeometry extends BoxGeometry {
    readonly size: number;
    readonly segments: number;
    private _halfSize;
    constructor(size: number, segments: number);
    applyFractalBrownianMotion(octaves: number, persistence: number, scale: number, amplitude: number): void;
    private fBm;
}

interface TextureData {
    width: number;
    height: number;
    texture: Texture;
}
declare function LoadTexture(url: string): Promise<TextureData>;
declare function CreateSubTexture(texture: Texture, x: number, y: number, w: number, h: number): Texture;
declare class TextureAtlas extends MeshLambertMaterial {
    readonly textureData: TextureData;
    readonly textureWidth: number;
    readonly textureHeight: number;
    private _uw;
    private _uh;
    constructor(textureData: TextureData, textureWidth: number, textureHeight?: number, params?: MeshLambertMaterialParameters);
    getUv(voxel: number, ux: number, uy: number): [number, number];
    static CreateFromUrl(url: string, textureWidth: number, textureHeight?: number, params?: MeshLambertMaterialParameters): Promise<TextureAtlas>;
}
interface AtlasParams {
    tilePixelWidth?: number;
    tilePixelHeight?: number;
    tilePixelOffsetWidth?: number;
    tilePixelOffsetHeight?: number;
}
interface AtlasTextureMaterialParams extends MeshLambertMaterialParameters {
}
declare class AtlasTextureMaterial extends MeshLambertMaterial {
    readonly textureData: TextureData;
    readonly tilePixelWidth: number;
    readonly tilePixelHeight: number;
    private _tileCount;
    private _uvWidth;
    private _uvHeight;
    private _textureOffsetWidth;
    private _textureOffsetHeight;
    constructor(textureData: TextureData, atlasParams?: AtlasParams, materialParams?: AtlasTextureMaterialParams);
    getTileUVs(tileIndex: number, vertexIndex: number): [number, number];
    static fromUrl(url: string, atlasParams?: AtlasParams, materialParams?: AtlasTextureMaterialParams): Promise<AtlasTextureMaterial>;
}

declare class Random {
    private _seed;
    constructor(seed?: number);
    get seed(): number;
    set seed(value: number);
    private static _mix;
    static hash(...values: number[]): number;
    static uint(...values: number[]): number;
    static float(...values: number[]): number;
    static bool(...values: number[]): boolean;
    static sign(...values: number[]): -1 | 1;
    static angle(...values: number[]): number;
    uint(): number;
    float(): number;
    bool(): boolean;
    sign(): -1 | 1;
    angle(): number;
}

declare class RandomTools {
    readonly rng: Random;
    get seed(): number;
    set seed(seed: number);
    constructor(seed?: number | Random);
    nextFloat(): number;
    nextUint(): number;
    floatRange(min: number, max?: number): number;
    range(min: number, max?: number): number;
    pick<T>(array: readonly T[]): T;
    sample<T>(array: readonly T[], count: number): T[];
    shuffle<T>(array: readonly T[]): T[];
    chance(probability: number): boolean;
    vector2(): [number, number];
    pointOnCircle(radius?: number): [number, number];
    pointInCircle(radius?: number): [number, number];
    pointOnSphere(radius?: number): [number, number, number];
    pointInSphere(radius?: number): [number, number, number];
    gaussian(mean?: number, standardDeviation?: number): number;
    matrix(rows: number, columns?: number, min?: number, max?: number): number[][];
    transformMatrix(rows: number, columns?: number): number[][];
}
declare const rng: RandomTools;

interface ThreeJsCameraRigParams {
    camera?: PerspectiveCamera;
    fov?: number;
    aspect?: number;
    near?: number;
    far?: number;
}
declare class ThreeJsCameraRig extends Group {
    gimbal: Group;
    camera: PerspectiveCamera;
    target: Object3D | undefined;
    mouseSensitivity: number;
    wheelSensitivity: number;
    minCameraDistance: number;
    maxCameraDistance: number;
    minTiltAngle: number;
    maxTiltAngle: number;
    clampTiltAngle: boolean;
    constructor(params?: ThreeJsCameraRigParams);
    orbit(deltaX: number, deltaY: number): void;
    dolly(deltaY: number): void;
}

interface SetupBasicSceneParams {
    ambientLight?: boolean;
    directionalLight?: boolean;
    gridHelper?: boolean;
    cameraDistance?: number;
    enableControls?: boolean;
}
interface ThreeJsBoilerPlateParams {
    parentElement?: HTMLElement;
    renderer?: WebGLRendererParameters;
    camera?: {
        fov?: number;
        aspect?: number;
        near?: number;
        far?: number;
    };
    seed?: number;
    setupBasicSceneParams?: boolean | SetupBasicSceneParams;
}
declare class ThreeJsBoilerPlate {
    clock: Clock;
    scene: Scene<three.Object3DEventMap>;
    input: Input;
    private raycaster;
    renderer: WebGLRenderer;
    cameraRig: ThreeJsCameraRig;
    orbitControls?: OrbitControls;
    get canvas(): HTMLCanvasElement;
    get camera(): PerspectiveCamera;
    rng: RandomTools;
    constructor(params?: ThreeJsBoilerPlateParams);
    enableCameraRigControls(): void;
    enableOrbitControls(): Promise<void>;
    update(): void;
    appendTo(htmlElement?: HTMLElement): void;
    resize(displayWidth?: number, displayHeight?: number): boolean;
    setupBasicScene(params?: SetupBasicSceneParams): void;
    pick(): Intersection | null;
    static CreateCubeMesh(size?: number, color?: ColorRepresentation): Mesh;
    static CreatePlaneMesh(size?: number, segments?: number, color?: ColorRepresentation): Mesh;
}

declare class ThreeJsPlayerController extends Group {
    moveSpeed: number;
    cameraRig: ThreeJsCameraRig;
    velocity: Vector3;
    constructor(camera: PerspectiveCamera);
    update(deltaTime: number): void;
}

type Voxel = {
    x: number;
    y: number;
    z: number;
    color: number;
};
type VoxelMap = Map<string, number>;
type VoxelMaterial = MeshBasicMaterial | MeshLambertMaterial | MeshPhongMaterial | MeshStandardMaterial | MeshPhysicalMaterial;
interface VoxelData {
    name: string;
    width: number;
    depth: number;
    height: number;
    palette: ColorRepresentation[];
    voxels: Voxel[];
}
declare class VoxelMesh extends Mesh {
    readonly type: string;
    width: number;
    depth: number;
    height: number;
    colorPalette: ColorRepresentation[];
    voxels: VoxelMap;
    needsGeometryUpdate: boolean;
    constructor(width: number, depth: number, height: number, material: VoxelMaterial, name?: string);
    private _xyz2k;
    private _k2xyz;
    get(x: number, y: number, z: number): number;
    set(x: number, y: number, z: number, n?: number): void;
    clearVoxels(): void;
    setSize(width: number, depth: number, height: number): void;
    forEachVoxel(callback: (x: number, y: number, z: number, n: number) => void): void;
    importVoxelData(voxelData: VoxelData): void;
    updateGeometry(): void;
    exportData(): VoxelData;
}
declare const VoxelFaces: Array<Array<number[]>>;
declare function BuildDefaultPalette(palette?: ColorRepresentation[]): ColorRepresentation[];
declare const Colors: {
    rgb12: string[];
    rgb24: string[];
    rgb48: string[];
    rgb64: string[];
};

declare class ParticleSystem3d extends Group {
    readonly particleCount = 1000;
    private _geometry;
    private _particles;
    private _frictionHalfLife;
    private _range;
    private _rangeFactor;
    private _attractionMatrix;
    private _spatialPartition;
    constructor();
    private _calcForce;
    private _updateVelocities;
    private _updatePositions;
    private _sortParticles;
    private _updateGeometry;
    update(camera: PerspectiveCamera, dt: number): void;
}

interface AsteroidOptions {
    radius?: number;
    detail?: number;
    noiseScale?: number;
    displacement?: number;
    secondaryNoise?: boolean;
    color?: number;
}
declare class AsteroidMesh extends Mesh {
    constructor(options?: AsteroidOptions);
}

declare function CreateStarfield(radius?: number, count?: number, color?: number): Points;
declare function CreateSystemStar(position?: Vector3): Group;

interface ColorSelectionOptions {
    signal: AbortSignal;
}
interface ColorSelectionResult {
    sRGBHex: ColorRepresentation;
}
interface EyeDropper {
    new (): EyeDropper;
    open: (options?: ColorSelectionOptions) => Promise<ColorSelectionResult>;
}
declare global {
    interface Window {
        EyeDropper?: EyeDropper;
    }
}
type PaletteControllerOnChange = (colorIndex: number) => void;
interface PaletteController {
    $innerDiv: HTMLDivElement;
    colorButtons: HTMLElement[];
    colorButtonSize: number;
    selectedBorderStyle: string;
    currentColorIndex: number;
    colorPalette: ColorRepresentation[];
    updatePaletteColors(): void;
    setSelectedColor(colorIndex?: number): void;
    findClosestColorMatchIndex(color: ColorRepresentation): number;
}
declare function CreatePaletteController(parentGui: GUI, colorPalette: ColorRepresentation[], onChange?: PaletteControllerOnChange, folderName?: string): Promise<PaletteController>;

type ThreeComponent = Record<string, any>;
interface ThreeEntity extends Object3D {
    userData: {
        entityId: string;
        components: Record<string, ThreeComponent>;
        [key: string]: any;
    };
}
declare function GenerateEntityId(): string;
declare function CreateThreeEntity(obj?: Object3D): ThreeEntity;
declare function AddThreeComponent<T extends ThreeComponent>(entity: ThreeEntity, name: string, component: T): void;
declare function GetThreeComponent<T extends ThreeComponent>(entity: ThreeEntity, name: string): T | undefined;
declare function RemoveThreeComponent(entity: ThreeEntity, name: string): void;
declare function IsThreeEntity(obj: Object3D): boolean;
type ThreeSystem = (entities: Map<string, ThreeEntity>, delta: number, ...args: any) => void;

declare enum ShaderType {
    VERTEX,
    FRAGMENT
}
type ProgramLocations = {
    attributes: KeyValue;
    uniforms: KeyValue;
};
type ProgramInfo = {
    program: WebGLProgram;
    attributes: KeyValue;
    uniforms: KeyValue;
};
declare function CreateWebGlContext(canvas?: HTMLCanvasElement): WebGL2RenderingContext;
declare function ResizeWebGlContext(gl: WebGL2RenderingContext, displayWidth?: number, displayHeight?: number): boolean;
declare function CompileShader(gl: WebGL2RenderingContext, type: ShaderType, source: string): WebGLShader;
declare function CreateProgram(gl: WebGL2RenderingContext, vertexShader: WebGLShader | string, fragmentShader: WebGLShader | string): WebGLProgram;
declare function GetProgramLocations(gl: WebGL2RenderingContext, program: WebGLProgram): ProgramLocations;
declare function CreateProgramInfo(gl: WebGL2RenderingContext, vertexShaderSource: string, fragmentShaderSource: string): ProgramInfo;

interface RendererParams {
    canvas?: HTMLCanvasElement;
    parent?: HTMLElement;
}
declare class WebGlRenderer {
    gl: WebGL2RenderingContext;
    programInfo: ProgramInfo | undefined;
    get canvas(): HTMLCanvasElement;
    get width(): number;
    get height(): number;
    constructor();
    appendTo(htmlElement?: HTMLElement): void;
    resize(displayWidth?: number, displayHeight?: number): boolean;
    render(_deltaTime: number): void;
}

declare function randomMatrix(size: number): number[][];
declare class ParticleSystem2d {
    readonly particleCount = 2000;
    private _particleSize;
    private _frictionHalfLife;
    private _range;
    private _rangeFactor;
    private _attractionMatrix;
    private _particles;
    private _spatialPartition;
    constructor();
    private _calcForce;
    private _updateVelocities;
    private _updatePositions;
    update(renderer: ParticleRenderer, dt: number): void;
}

interface Vec2 {
    x: number;
    y: number;
}
declare function PoissonDiskSampler(width: number, height: number, minDist: number, maxPoints?: number): Vec2[];

type Subscriber<T> = (value: T) => void;
declare class Signal<T> {
    private value;
    private readonly subscribers;
    constructor(initialValue: T);
    get(): T;
    set(value: T): void;
    subscribe(subscriber: Subscriber<T>): () => void;
}

declare class SimplexNoise {
    grad3: number[][];
    p: number[];
    perm: number[];
    constructor();
    dot(g: number[], x: number, y: number, z?: number): number;
    noise2d(xin: number, yin: number): number;
    noise3d(xin: number, yin: number, zin: number): number;
}

interface SpatialPartitionEntity2d {
    x: number;
    y: number;
}
declare class SpatialPartition2d {
    cells: SpatialPartitionEntity2d[][][];
    cellSize: number;
    entities: SpatialPartitionEntity2d[];
    constructor(cellSize: number, entities: SpatialPartitionEntity2d[]);
    addEntity(entity: SpatialPartitionEntity2d): void;
    getCell(x: number, y: number): SpatialPartitionEntity2d[];
    getCellNeighbors(x: number, y: number): SpatialPartitionEntity2d[][];
}

interface SpatialPartitionEntity3d {
    x: number;
    y: number;
    z: number;
}
declare class SpatialPartition3d {
    cells: SpatialPartitionEntity3d[][][][];
    cellSize: number;
    entities: SpatialPartitionEntity3d[];
    constructor(cellSize: number, entities: SpatialPartitionEntity3d[]);
    getCell(x: number, y: number, z: number): SpatialPartitionEntity3d[];
    getCellNeighbors(cx: number, cy: number, cz: number): SpatialPartitionEntity3d[][];
    addEntity(entity: SpatialPartitionEntity3d): void;
}

declare class Tilemap<T = number> {
    map: Map<string, T>;
    private _key;
    get(x: number, y: number): T | undefined;
    set(x: number, y: number, v: T): void;
}

declare class WorkerInterface {
    private _worker;
    readonly onError: Observable<WorkerInterface>;
    readonly onMessage: Observable<WorkerInterface>;
    constructor(url: string | URL);
    postMessage(message: any, options?: StructuredSerializeOptions | undefined): void;
    terminate(): void;
}

export { AStar, type AStarFindPathParams, type AStarPoint, AddThreeComponent, AsteroidMesh, type AsteroidOptions, type AtlasParams, AtlasTextureMaterial, type AtlasTextureMaterialParams, BuildDefaultPalette, type CanvasColor, CanvasRenderer, Clock, Color, type ColorSelectionOptions, type ColorSelectionResult, Colors, CompileShader, CreatePaletteController, CreateProgram, CreateProgramInfo, CreateStarfield, CreateSubTexture, CreateSystemStar, CreateThreeEntity, CreateWebGlContext, CubeSphereGeometry, DEFAULT_COLOR, DEFAULT_FONT, DEFAULT_FONT_NAME, DEFAULT_FONT_SIZE, DEFAULT_PIXEL_SIZE, DEFAULT_TEXTALIGN, DEFAULT_TEXTBASELINE, DEG2RAD, DOWN, Disposable, type DoorsParams, type DrawParams, E, ECS, EPSILON, type Entity, EventQueue, type EyeDropper, type FractalParams, GenerateDoors, GenerateEntityId, GenerateRooms, type GenerateRoomsParams, GenerateWalls, GetProgramLocations, GetThreeComponent, GetUrlParams, HALF_PI, Input, type InputEventState, IsThreeEntity, type KeyValue, LN10, LN2, LOG10E, LOG2E, LoadTexture, Map2D, type Map2DData, Map3D, type Map3DData, Noise, Observable, PI, type PaletteController, type PaletteControllerOnChange, ParticleRenderer, ParticleSystem2d, ParticleSystem3d, type PathsParams, type PointPair, PoissonDiskSampler, type ProgramInfo, type ProgramLocations, QUARTER_PI, RAD2DEG, type RGB, type RGBA, Random, RandomTools, type RectPair, Rectangle, RemoveThreeComponent, type RendererParams, ResizeWebGlContext, type RoomsParams, SQRT1_2, SQRT2, type SetupBasicSceneParams, ShaderType, Signal, SimplexNoise, SpatialPartition2d, SpatialPartition3d, type SpatialPartitionEntity2d, type SpatialPartitionEntity3d, type SpriteParams, TAU, TILE_EMPTY, TILE_FLOOR, TILE_PATH, TextureAtlas, type TextureData, type ThreeComponent, type ThreeEntity, ThreeJsBoilerPlate, type ThreeJsBoilerPlateParams, ThreeJsCameraRig, type ThreeJsCameraRigParams, ThreeJsPlayerController, type ThreeSystem, Tilemap, UP, Vector, type Voxel, type VoxelData, VoxelFaces, type VoxelMap, type VoxelMaterial, VoxelMesh, WebGlRenderer, WorkerInterface, type XY, type XYZ, type XYZW, abs, acos, asin, atan, atan2, cbrt, ceil, clamp, cos, cosh, degrees, distance2d, distance3d, exp, expm1, floor, fract, getRedYellowGreenGradientHex, hypot, hypot2, hypot3, imul, inverseLerp, isFinite, isInteger, isNaN, isNullOrUndefined, isPositiveString, k2xy, k2xyz, lerp, log, log10, log1p, log2, manhattanDistance, map, max, min, mod, nearlyEqual, normalizeRadians, pow, radians, randomMatrix, rng, round, roundTo, saturate, sign, sin, sinh, smoothstep, sqrt, squaredDistance, tan, tanh, trunc, wrap, xy2k, xyz2k };