ohzi-core 12.2.0 → 12.2.1

package/types/Graphics.d.ts

@@ -1,61 +1,143 @@
-export { graphics as Graphics };
-declare const graphics: Graphics;
-declare class Graphics {
-    init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
-        canvas: any;
-        core_attributes: any;
-        context_attributes: any;
-        threejs_attributes: any;
-        dpr: any;
-    }): void;
-    _renderer: any;
-    blitter: Blitter;
-    canvas: any;
-    no_render: BaseRender;
-    current_render_mode: any;
-    generateDepthNormalTexture: boolean;
-    depth_and_normals_renderer: DepthAndNormalsRenderer;
-    is_webgl2: boolean;
-    canvas_context: any;
-    context_attributes: {
-        alpha: boolean;
-        antialias: boolean;
-        depth: boolean;
-        desynchronized: boolean;
-        failIfMajorPerformanceCaveat: boolean;
-        powerPreference: string;
-        premultipliedAlpha: boolean;
-        preserveDrawingBuffer: boolean;
-        stencil: boolean;
-    };
-    core_attributes: {
-        force_webgl2: boolean;
-        xr_enabled: boolean;
-    };
-    threejs_attributes: {
-        logarithmicDepthBuffer: boolean;
-    };
-    get dom_element(): any;
-    get depth_normals_RT(): any;
-    set_state(new_state: any): void;
-    update(): void;
-    __update_current_camera(): void;
-    render(scene: any, camera: any, RT: any, override_mat: any): void;
-    compile(scene: any, camera: any, RT: any, override_mat: any): void;
-    compile_async(scene: any, camera: any, RT: any, override_mat: any, target_scene: any): Promise<any>;
-    render_scene(scene: any): void;
-    __apply_override_material(scene: any, mat: any): void;
-    readback_RT(RT: any, buffer: any): void;
-    clear(RT: any, camera: any, clear_depth: any, clear_stencil: any): void;
-    on_resize(entries: any, dpr: any): void;
-    material_pass(mat: any, dst: any): void;
-    blit(src_RT: any, dst_RT: any, mat: any): void;
-    blit_clear_with_material(dst_RT: any, mat: any): void;
-    take_screenshot(blob_callback: any, width?: any, height?: any): void;
-    download_screenshot(blob: any): void;
-    dispose(): void;
-    is_floating_point_texture_available(): boolean;
-}
-import { Blitter } from "./render_utilities/Blitter";
-import { BaseRender } from "./render_mode/BaseRender";
-import { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
+export { graphics as Graphics };
+declare const graphics: Graphics;
+declare class Graphics {
+    /**
+     * @param {Object} options
+     * @param {HTMLCanvasElement} options.canvas
+     * @param {Record<string, any>} options.core_attributes
+     * @param {Record<string, any>} options.context_attributes
+     * @param {Record<string, any>} options.threejs_attributes
+     * @param {number} options.dpr
+     */
+    init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
+        canvas: HTMLCanvasElement;
+        core_attributes: Record<string, any>;
+        context_attributes: Record<string, any>;
+        threejs_attributes: Record<string, any>;
+        dpr: number;
+    }): void;
+    _renderer: WebGLRenderer;
+    blitter: Blitter;
+    canvas: HTMLCanvasElement;
+    no_render: BaseRender;
+    current_render_mode: BaseRender;
+    generateDepthNormalTexture: boolean;
+    depth_and_normals_renderer: DepthAndNormalsRenderer;
+    is_webgl2: boolean;
+    canvas_context: RenderingContext;
+    context_attributes: {
+        alpha: boolean;
+        antialias: boolean;
+        depth: boolean;
+        desynchronized: boolean;
+        failIfMajorPerformanceCaveat: boolean;
+        powerPreference: string;
+        premultipliedAlpha: boolean;
+        preserveDrawingBuffer: boolean;
+        stencil: boolean;
+    };
+    core_attributes: {
+        force_webgl2: boolean;
+        xr_enabled: boolean;
+    };
+    /** @type {Record<string, any>} */
+    threejs_attributes: Record<string, any>;
+    get dom_element(): HTMLCanvasElement;
+    get depth_normals_RT(): WebGLRenderTarget<import("three").Texture>;
+    /**
+     * @param {BaseRender} new_state
+     */
+    set_state(new_state: BaseRender): void;
+    update(): void;
+    __update_current_camera(): void;
+    /**
+     * @param {Scene} [scene]
+     * @param {PerspectiveCamera | OrthographicCamera} [camera]
+     * @param {WebGLRenderTarget} [RT]
+     * @param {Material} [override_mat]
+     */
+    render(scene?: Scene, camera?: PerspectiveCamera | OrthographicCamera, RT?: WebGLRenderTarget, override_mat?: Material): void;
+    /**
+     * @param {Scene} scene
+     * @param {PerspectiveCamera} camera
+     * @param {WebGLRenderTarget} RT
+     * @param {Material} override_mat
+     */
+    compile(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material): void;
+    /**
+     * @param {Scene} scene
+     * @param {PerspectiveCamera} camera
+     * @param {WebGLRenderTarget} RT
+     * @param {Material} override_mat
+     * @param {Scene} target_scene
+     * @returns {Promise<Object3D>}
+     */
+    compile_async(scene: Scene, camera: PerspectiveCamera, RT: WebGLRenderTarget, override_mat: Material, target_scene: Scene): Promise<Object3D>;
+    /**
+     * @param {BaseApplication | Scene | {render:()=>void}} scene
+     */
+    render_scene(scene: BaseApplication | Scene | {
+        render: () => void;
+    }): void;
+    /**
+     * @param {Scene} scene
+     * @param {Material} mat
+     */
+    __apply_override_material(scene: Scene, mat: Material): void;
+    /**
+     * @param {WebGLRenderTarget} RT
+     * @param {import('three').TypedArray} buffer
+     */
+    readback_RT(RT: WebGLRenderTarget, buffer: import('three').TypedArray): void;
+    /**
+     * @param {WebGLRenderTarget} RT
+     * @param {PerspectiveCamera} camera
+     * @param {boolean} clear_depth
+     * @param {boolean} clear_stencil
+     */
+    clear(RT: WebGLRenderTarget, camera: PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
+    /**
+     * @param {ResizeObserverEntry[]} entries
+     * @param {number} dpr
+     */
+    on_resize(entries: ResizeObserverEntry[], dpr: number): void;
+    /**
+     * @param {Material} mat
+     * @param {WebGLRenderTarget} dst
+     */
+    material_pass(mat: Material, dst: WebGLRenderTarget): void;
+    /**
+     * @param {WebGLRenderTarget} src_RT
+     * @param {WebGLRenderTarget} dst_RT
+     * @param {Material} mat
+     */
+    blit(src_RT: WebGLRenderTarget, dst_RT: WebGLRenderTarget, mat: Material): void;
+    /**
+     * @param {WebGLRenderTarget} dst_RT
+     * @param {Material} mat
+     */
+    blit_clear_with_material(dst_RT: WebGLRenderTarget, mat: Material): void;
+    /**
+     * @param {BlobCallback} blob_callback
+     * @param {number} width
+     * @param {number} height
+     */
+    take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
+    /**
+     * @param {Blob} blob
+     */
+    download_screenshot(blob: Blob): void;
+    dispose(): void;
+    is_floating_point_texture_available(): boolean;
+}
+import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";
+import { Blitter } from "./render_utilities/Blitter";
+import { BaseRender } from "./render_mode/BaseRender";
+import { DepthAndNormalsRenderer } from "./render_utilities/DepthAndNormalsRenderer";
+import { WebGLRenderTarget } from "three/src/renderers/WebGLRenderTarget";
+import { Scene } from "three/src/scenes/Scene";
+import { PerspectiveCamera } from "./PerspectiveCamera";
+import { OrthographicCamera } from "./OrthographicCamera";
+import { Material } from "three/src/materials/Material";
+import { Object3D } from "three/src/core/Object3D";
+import { BaseApplication } from "./BaseApplication";

package/types/Initializer.d.ts

@@ -1,6 +1,10 @@
-export { initializer as Initializer };
-declare const initializer: Initializer;
-declare class Initializer {
-    init(input: any): void;
-    dispose(render_loop: any): void;
-}
+export { initializer as Initializer };
+declare const initializer: Initializer;
+declare class Initializer {
+    init(input: any): void;
+    /**
+     * @param {RenderLoop} render_loop
+     */
+    dispose(render_loop: RenderLoop): void;
+}
+import { RenderLoop } from "./index";

package/types/KeyboardInput.d.ts

@@ -1,20 +1,65 @@
-export class KeyboardInput {
-    init(container: any): void;
-    ctrlz_pressed: boolean;
-    ctrlz_fired: boolean;
-    keys: {};
-    keys_keys: any[] | string[];
-    container: any;
-    on_key_down(e: any): void;
-    on_key_up(e: any): void;
-    clear(): void;
-    release_key(key_name: any): void;
-    release_keys(): void;
-    press_key(key_name: any): void;
-    is_key_pressed(key_name: any): any;
-    is_key_down(key_name: any): any;
-    is_key_released(key_name: any): any;
-    register_key(key: any): void;
-    unregister_key(key_name: any): void;
-    dispose(): void;
-}
+export class KeyboardInput {
+    /**
+     * @param {HTMLElement} container
+     */
+    init(container: HTMLElement): void;
+    ctrlz_pressed: boolean;
+    ctrlz_fired: boolean;
+    /**
+     * @type {{[key:string]:{key_name: string, pressed: boolean, down: boolean, fired: boolean, released: boolean}}}
+     */
+    keys: {
+        [key: string]: {
+            key_name: string;
+            pressed: boolean;
+            down: boolean;
+            fired: boolean;
+            released: boolean;
+        };
+    };
+    /** @type {string[]} */
+    keys_keys: string[];
+    container: HTMLElement;
+    /**
+     * @param {KeyboardEvent} e
+     */
+    on_key_down(e: KeyboardEvent): void;
+    /**
+     * @param {KeyboardEvent} e
+     */
+    on_key_up(e: KeyboardEvent): void;
+    clear(): void;
+    /**
+     * @param {string} key_name
+     */
+    release_key(key_name: string): void;
+    release_keys(): void;
+    /**
+     * @param {string} key_name
+     */
+    press_key(key_name: string): void;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_pressed(key_name: string): boolean;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_down(key_name: string): boolean;
+    /**
+     * @param {string} key_name
+     * @returns {boolean}
+     */
+    is_key_released(key_name: string): boolean;
+    /**
+     * @param {string} key
+     */
+    register_key(key: string): void;
+    /**
+     * @param {string} key_name
+     */
+    unregister_key(key_name: string): void;
+    dispose(): void;
+}

package/types/OS.d.ts

@@ -1,20 +1,20 @@
-export { os as OS };
-declare const os: OS;
-declare class OS {
-    init(): void;
-    operating_systems: {
-        ANDROID: string;
-        IOS: string;
-        LINUX: string;
-        MAC: string;
-        WINDOWS: string;
-    };
-    is_mobile: boolean;
-    is_ipad: boolean;
-    is_ios: boolean;
-    is_android: boolean;
-    is_linux: boolean;
-    is_mac: boolean;
-    is_windows: boolean;
-    get_os(): string;
-}
+export { os as OS };
+declare const os: OS;
+declare class OS {
+    init(): void;
+    operating_systems: {
+        ANDROID: string;
+        IOS: string;
+        LINUX: string;
+        MAC: string;
+        WINDOWS: string;
+    };
+    is_mobile: boolean;
+    is_ipad: boolean;
+    is_ios: boolean;
+    is_android: boolean;
+    is_linux: boolean;
+    is_mac: boolean;
+    is_windows: boolean;
+    get_os(): string;
+}

package/types/OScreen.d.ts

@@ -1,22 +1,37 @@
-export { oscreen as OScreen };
-declare const oscreen: OScreen;
-declare class OScreen {
-    init(): void;
-    width: any;
-    height: any;
-    position: any;
-    render_width: number;
-    render_height: number;
-    width_height: any;
-    dpr: number;
-    pixel_size: any;
-    update_position(x: any, y: any): void;
-    update(): void;
-    size_changed: boolean;
-    update_size(width: any, height: any): void;
-    apply_pixel_density_v2(vector2: any): any;
-    apply_pixel_density(value: any): number;
-    get_pixel_size(): any;
-    get aspect_ratio(): number;
-    get portrait(): boolean;
-}
+export { oscreen as OScreen };
+declare const oscreen: OScreen;
+declare class OScreen {
+    init(): void;
+    width: number;
+    height: number;
+    position: Vector2;
+    render_width: number;
+    render_height: number;
+    width_height: Vector2;
+    dpr: number;
+    pixel_size: Vector2;
+    /**
+     * @param {number} x
+     * @param {number} y
+     */
+    update_position(x: number, y: number): void;
+    update(): void;
+    size_changed: boolean;
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    update_size(width: number, height: number): void;
+    /**
+     * @param {Vector2} vector2
+     */
+    apply_pixel_density_v2(vector2: Vector2): Vector2;
+    /**
+     * @param {number} value
+     */
+    apply_pixel_density(value: number): number;
+    get_pixel_size(): Vector2;
+    get aspect_ratio(): number;
+    get portrait(): boolean;
+}
+import { Vector2 } from "three/src/math/Vector2";

package/types/OrthographicCamera.d.ts

@@ -1,6 +1,20 @@
-export class OrthographicCamera {
-    constructor(left: any, right: any, top: any, bottom: any, near: any, far: any);
-    clear_color: any;
-    clear_alpha: number;
-    copy(camera: any): OrthographicCamera;
-}
+export class OrthographicCamera extends TOrthographicCamera {
+    /**
+     * @param {number} left
+     * @param {number} right
+     * @param {number} top
+     * @param {number} bottom
+     * @param {number} near
+     * @param {number} far
+     */
+    constructor(left: number, right: number, top: number, bottom: number, near: number, far: number);
+    clear_color: Color;
+    clear_alpha: number;
+    /**
+     * @param {OrthographicCamera} camera
+     * @returns {this}
+     */
+    copy(camera: OrthographicCamera): this;
+}
+import { OrthographicCamera as TOrthographicCamera } from "three/src/cameras/OrthographicCamera";
+import { Color } from "three/src/math/Color";

package/types/PerspectiveCamera.d.ts

@@ -1,6 +1,18 @@
-export class PerspectiveCamera {
-    constructor(fov: any, aspect: any, near: any, far: any);
-    clear_color: any;
-    clear_alpha: number;
-    copy(camera: any): PerspectiveCamera;
-}
+export class PerspectiveCamera extends TPerspectiveCamera {
+    /**
+     * @param {number} fov
+     * @param {number} aspect
+     * @param {number} near
+     * @param {number} far
+     */
+    constructor(fov: number, aspect: number, near: number, far: number);
+    clear_color: Color;
+    clear_alpha: number;
+    /**
+     * @param {PerspectiveCamera} camera
+     * @returns {this}
+     */
+    copy(camera: PerspectiveCamera): this;
+}
+import { PerspectiveCamera as TPerspectiveCamera } from "three/src/cameras/PerspectiveCamera";
+import { Color } from "three/src/math/Color";

package/types/ReflectionPlaneContext.d.ts

@@ -1,8 +1,13 @@
-export { reflection_plane_context as ReflectionPlaneContext };
-declare const reflection_plane_context: ReflectionPlaneContext;
-declare class ReflectionPlaneContext {
-    init(): void;
-    target_geometry: any;
-    target_position: any;
-    set_target_geometry(geometry: any): void;
-}
+export { reflection_plane_context as ReflectionPlaneContext };
+declare const reflection_plane_context: ReflectionPlaneContext;
+declare class ReflectionPlaneContext {
+    init(): void;
+    target_geometry: BufferGeometry<import("three").NormalBufferAttributes>;
+    target_position: Vector3;
+    /**
+     * @param {BufferGeometry} geometry
+     */
+    set_target_geometry(geometry: BufferGeometry): void;
+}
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { Vector3 } from "three/src/math/Vector3";

package/types/RenderLayers.d.ts

@@ -1,6 +1,6 @@
-export class RenderLayers {
-    static get opaque(): number;
-    static get transparent(): number;
-    static get outline(): number;
-    static get selectable(): number;
-}
+export class RenderLayers {
+    static get opaque(): number;
+    static get transparent(): number;
+    static get outline(): number;
+    static get selectable(): number;
+}

package/types/RenderLoop.d.ts

@@ -1,14 +1,132 @@
-export class RenderLoop {
-    constructor(target_application: any, graphics: any, input: any);
-    target_application: any;
-    graphics: any;
-    input: any;
-    is_running: boolean;
-    frames_passed: number;
-    time_accumulator: number;
-    update(): void;
-    start(): void;
-    stop(): void;
-    set_state(new_state: any): void;
-    dispose(): void;
-}
+export class RenderLoop {
+    /**
+     * @param {BaseApplication} target_application
+     * @param {Graphics} graphics
+     */
+    constructor(target_application: BaseApplication, graphics: {
+        init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
+            canvas: HTMLCanvasElement;
+            core_attributes: Record<string, any>;
+            context_attributes: Record<string, any>;
+            threejs_attributes: Record<string, any>;
+            dpr: number;
+        }): void;
+        _renderer: import("three").WebGLRenderer;
+        blitter: import("./render_utilities/Blitter").Blitter;
+        canvas: HTMLCanvasElement;
+        no_render: import("./render_mode/BaseRender").BaseRender;
+        current_render_mode: import("./render_mode/BaseRender").BaseRender;
+        generateDepthNormalTexture: boolean;
+        depth_and_normals_renderer: import("./render_utilities/DepthAndNormalsRenderer").DepthAndNormalsRenderer;
+        is_webgl2: boolean;
+        canvas_context: RenderingContext;
+        context_attributes: {
+            alpha: boolean;
+            antialias: boolean;
+            depth: boolean;
+            desynchronized: boolean;
+            failIfMajorPerformanceCaveat: boolean;
+            powerPreference: string;
+            premultipliedAlpha: boolean;
+            preserveDrawingBuffer: boolean;
+            stencil: boolean;
+        };
+        core_attributes: {
+            force_webgl2: boolean;
+            xr_enabled: boolean;
+        };
+        threejs_attributes: Record<string, any>;
+        readonly dom_element: HTMLCanvasElement;
+        readonly depth_normals_RT: import("three").WebGLRenderTarget<import("three").Texture>;
+        set_state(new_state: import("./render_mode/BaseRender").BaseRender): void;
+        update(): void;
+        __update_current_camera(): void;
+        render(scene?: import("three").Scene, camera?: import("./PerspectiveCamera").PerspectiveCamera | import("./OrthographicCamera").OrthographicCamera, RT?: import("three").WebGLRenderTarget<import("three").Texture>, override_mat?: import("three").Material): void;
+        compile(scene: import("three").Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material): void;
+        compile_async(scene: import("three").Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material, target_scene: import("three").Scene): Promise<import("three").Object3D<import("three").Object3DEventMap>>;
+        render_scene(scene: import("three").Scene | BaseApplication | {
+            render: () => void;
+        }): void;
+        __apply_override_material(scene: import("three").Scene, mat: import("three").Material): void;
+        readback_RT(RT: import("three").WebGLRenderTarget<import("three").Texture>, buffer: import("three").TypedArray): void;
+        clear(RT: import("three").WebGLRenderTarget<import("three").Texture>, camera: import("./PerspectiveCamera").PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
+        on_resize(entries: ResizeObserverEntry[], dpr: number): void;
+        material_pass(mat: import("three").Material, dst: import("three").WebGLRenderTarget<import("three").Texture>): void;
+        blit(src_RT: import("three").WebGLRenderTarget<import("three").Texture>, dst_RT: import("three").WebGLRenderTarget<import("three").Texture>, mat: import("three").Material): void;
+        blit_clear_with_material(dst_RT: import("three").WebGLRenderTarget<import("three").Texture>, mat: import("three").Material): void;
+        take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
+        download_screenshot(blob: Blob): void;
+        dispose(): void;
+        is_floating_point_texture_available(): boolean;
+    }, input: any);
+    target_application: BaseApplication;
+    graphics: {
+        init({ canvas, core_attributes, context_attributes, threejs_attributes, dpr }: {
+            canvas: HTMLCanvasElement;
+            core_attributes: Record<string, any>;
+            context_attributes: Record<string, any>;
+            threejs_attributes: Record<string, any>;
+            dpr: number;
+        }): void;
+        _renderer: import("three").WebGLRenderer;
+        blitter: import("./render_utilities/Blitter").Blitter;
+        canvas: HTMLCanvasElement;
+        no_render: import("./render_mode/BaseRender").BaseRender;
+        current_render_mode: import("./render_mode/BaseRender").BaseRender;
+        generateDepthNormalTexture: boolean;
+        depth_and_normals_renderer: import("./render_utilities/DepthAndNormalsRenderer").DepthAndNormalsRenderer;
+        is_webgl2: boolean;
+        canvas_context: RenderingContext;
+        context_attributes: {
+            alpha: boolean;
+            antialias: boolean;
+            depth: boolean;
+            desynchronized: boolean;
+            failIfMajorPerformanceCaveat: boolean;
+            powerPreference: string;
+            premultipliedAlpha: boolean;
+            preserveDrawingBuffer: boolean;
+            stencil: boolean;
+        };
+        core_attributes: {
+            force_webgl2: boolean;
+            xr_enabled: boolean;
+        };
+        threejs_attributes: Record<string, any>;
+        readonly dom_element: HTMLCanvasElement;
+        readonly depth_normals_RT: import("three").WebGLRenderTarget<import("three").Texture>;
+        set_state(new_state: import("./render_mode/BaseRender").BaseRender): void;
+        update(): void;
+        __update_current_camera(): void;
+        render(scene?: import("three").Scene, camera?: import("./PerspectiveCamera").PerspectiveCamera | import("./OrthographicCamera").OrthographicCamera, RT?: import("three").WebGLRenderTarget<import("three").Texture>, override_mat?: import("three").Material): void;
+        compile(scene: import("three").Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material): void;
+        compile_async(scene: import("three").Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material, target_scene: import("three").Scene): Promise<import("three").Object3D<import("three").Object3DEventMap>>;
+        render_scene(scene: import("three").Scene | BaseApplication | {
+            render: () => void;
+        }): void;
+        __apply_override_material(scene: import("three").Scene, mat: import("three").Material): void;
+        readback_RT(RT: import("three").WebGLRenderTarget<import("three").Texture>, buffer: import("three").TypedArray): void;
+        clear(RT: import("three").WebGLRenderTarget<import("three").Texture>, camera: import("./PerspectiveCamera").PerspectiveCamera, clear_depth: boolean, clear_stencil: boolean): void;
+        on_resize(entries: ResizeObserverEntry[], dpr: number): void;
+        material_pass(mat: import("three").Material, dst: import("three").WebGLRenderTarget<import("three").Texture>): void;
+        blit(src_RT: import("three").WebGLRenderTarget<import("three").Texture>, dst_RT: import("three").WebGLRenderTarget<import("three").Texture>, mat: import("three").Material): void;
+        blit_clear_with_material(dst_RT: import("three").WebGLRenderTarget<import("three").Texture>, mat: import("three").Material): void;
+        take_screenshot(blob_callback: BlobCallback, width?: number, height?: number): void;
+        download_screenshot(blob: Blob): void;
+        dispose(): void;
+        is_floating_point_texture_available(): boolean;
+    };
+    input: any;
+    is_running: boolean;
+    frames_passed: number;
+    time_accumulator: number;
+    update(): void;
+    start(): void;
+    stop(): void;
+    /**
+     * @param {BaseApplication} new_state
+     */
+    set_state(new_state: BaseApplication): void;
+    dispose(): void;
+}
+import { BaseApplication } from "./BaseApplication";