ohzi-core 12.2.0 → 12.3.0

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";

package/types/RenderOrder.d.ts

@@ -1,8 +1,8 @@
-export class RenderOrder {
-    static get kiosk(): number;
-    static get kiosk_circle(): number;
-    static get placeholder_image(): number;
-    static get step_icon(): number;
-    static get line(): number;
-    static get placeholder_text(): number;
-}
+export class RenderOrder {
+    static get kiosk(): number;
+    static get kiosk_circle(): number;
+    static get placeholder_image(): number;
+    static get step_icon(): number;
+    static get line(): number;
+    static get placeholder_text(): number;
+}

package/types/ResourceContainer.d.ts

@@ -1,10 +1,29 @@
-export { resource_container as ResourceContainer };
-declare const resource_container: ResourceContainer;
-declare class ResourceContainer {
-    init(): void;
-    resources: {};
-    resources_by_url: {};
-    set_resource(name: any, url: any, resource: any): void;
-    get_resource(name: any): any;
-    get(name: any): any;
-}
+export { resource_container as ResourceContainer };
+export type Resource = Object3D | Texture;
+declare const resource_container: ResourceContainer;
+import { Object3D } from "three/src/core/Object3D";
+import { Texture } from "three/src/textures/Texture";
+/**
+ * @typedef {Object3D | Texture} Resource
+ */
+declare class ResourceContainer {
+    init(): void;
+    /** @type {Record<string, Resource>} */
+    resources: Record<string, Resource>;
+    /** @type {Record<string, any>} */
+    resources_by_url: Record<string, any>;
+    /**
+     * @param {string} name
+     * @param {string} url
+     * @param {Resource} resource
+     */
+    set_resource(name: string, url: string, resource: Resource): void;
+    /**
+     * @param {string} name
+     */
+    get_resource(name: string): Resource;
+    /**
+     * @param {string} name
+     */
+    get(name: string): Resource;
+}

package/types/SceneManager.d.ts

@@ -1,12 +1,15 @@
-export { scene_manager as SceneManager };
-declare const scene_manager: SceneManager;
-declare class SceneManager {
-    init(): void;
-    _current: Scene;
-    add_scene(name: any): void;
-    set current(arg: any);
-    get current(): any;
-    dispose(): void;
-}
-
-import { Scene } from "three";
+export { scene_manager as SceneManager };
+declare const scene_manager: SceneManager;
+declare class SceneManager {
+    init(): void;
+    _current: Scene;
+    /**
+     * @param {string} name
+     */
+    add_scene(name: string): void;
+    set current(arg: Scene);
+    /** @type {Scene} */
+    get current(): Scene;
+    dispose(): void;
+}
+import { Scene } from "three/src/scenes/Scene";

package/types/Screen.d.ts

@@ -0,0 +1,27 @@
+export { screen as Screen };
+declare const screen: Screen;
+declare class Screen {
+    init(): void;
+    /**
+     * @param {number} x
+     * @param {number} y
+     */
+    update_position(x: number, y: number): void;
+    update(): void;
+    /**
+     * @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;
+}
+import { Vector2 } from "three/src/math/Vector2";

package/types/Time.d.ts

@@ -1,24 +1,29 @@
-export { time as Time };
-declare const time: Time;
-declare class Time {
-    __delta_buffer: number[];
-    init(): void;
-    ___time: any;
-    __delta_time: any;
-    __smooth_delta_time: any;
-    __elapsed_time: any;
-    __allocated_time: any;
-    __frame_interpolation_t: any;
-    fixed_delta_time: number;
-    get elapsed_time(): any;
-    get delta_time(): any;
-    get smooth_delta_time(): any;
-    get shader_time(): any;
-    get frame_interpolation(): any;
-    get fdt(): number;
-    get dt(): any;
-    get sdt(): any;
-    __set_frame_interpolation(value: any): void;
-    __update(): void;
-    __calculate_smooth_delta_time(): void;
-}
+export { time as Time };
+declare const time: Time;
+declare class Time {
+    __delta_buffer: number[];
+    init(): void;
+    ___time: Clock;
+    __delta_time: number;
+    __smooth_delta_time: any;
+    __elapsed_time: number;
+    __allocated_time: Vector2;
+    __frame_interpolation_t: number;
+    fixed_delta_time: number;
+    get elapsed_time(): number;
+    get delta_time(): number;
+    get smooth_delta_time(): any;
+    get shader_time(): Vector2;
+    get frame_interpolation(): number;
+    get fdt(): number;
+    get dt(): number;
+    get sdt(): any;
+    /**
+     * @param {number} value
+     */
+    __set_frame_interpolation(value: number): void;
+    __update(): void;
+    __calculate_smooth_delta_time(): void;
+}
+import { Clock } from "three/src/core/Clock";
+import { Vector2 } from "three/src/math/Vector2";

package/types/UI.d.ts

@@ -1,18 +1,92 @@
-export { ui as UI };
-declare const ui: UI;
-declare class UI {
-    init(input: any): void;
-    input: any;
-    ui_elements: any[];
-    _tmp_normalized_pos: any;
-    ss_scene: any;
-    ws_scene: any;
-    ss_camera: any;
-    delete_element(elem: any): void;
-    add_screen_space_element(elem: any): void;
-    add_world_space_element(elem: any): void;
-    update(): void;
-    render(renderer: any): void;
-    clear(): void;
-    current_clicked_element: any;
-}
+export { ui as UI };
+declare const ui: UI;
+declare class UI {
+    init(input: any): void;
+    input: any;
+    /** @type {UIElement[]} */
+    ui_elements: UIElement[];
+    _tmp_normalized_pos: Vector2;
+    ss_scene: Scene;
+    ws_scene: Scene;
+    ss_camera: OrthographicCamera;
+    /**
+     * @param {UIElement} elem
+     */
+    delete_element(elem: UIElement): void;
+    /**
+     * @param {UIElement} elem
+     */
+    add_screen_space_element(elem: UIElement): void;
+    /**
+     * @param {UIElement} elem
+     */
+    add_world_space_element(elem: UIElement): void;
+    update(): void;
+    /**
+     * @param {Graphics} renderer
+     */
+    render(renderer: {
+        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; /**
+             * @param {UIElement} elem
+             */
+        }): 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?: Scene, camera?: import("./PerspectiveCamera").PerspectiveCamera | OrthographicCamera, RT?: import("three").WebGLRenderTarget<import("three").Texture>, override_mat?: import("three").Material): void;
+        compile(scene: Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material): void;
+        compile_async(scene: Scene, camera: import("./PerspectiveCamera").PerspectiveCamera, RT: import("three").WebGLRenderTarget<import("three").Texture>, override_mat: import("three").Material, target_scene: Scene): Promise<import("three").Object3D<import("three").Object3DEventMap>>;
+        render_scene(scene: Scene | import("./BaseApplication").BaseApplication | {
+            render: () => void;
+        }): void;
+        __apply_override_material(scene: 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;
+    }): void;
+    clear(): void;
+    current_clicked_element: any;
+}
+import { UIElement } from "./components/UIElement";
+import { Vector2 } from "three/src/math/Vector2";
+import { Scene } from "three/src/scenes/Scene";
+import { OrthographicCamera } from "./OrthographicCamera";

package/types/action_sequencer/ActionEvent.d.ts

@@ -1,7 +1,12 @@
-export class ActionEvent {
-    constructor(name: any, method: any, args: any);
-    name: any;
-    method: any;
-    args: any;
-    trigger(): void;
-}
+export class ActionEvent {
+    /**
+     * @param {string} name
+     * @param {string} method
+     * @param {string} args
+     */
+    constructor(name: string, method: string, args: string);
+    name: string;
+    method: string;
+    args: string;
+    trigger(): void;
+}

package/types/action_sequencer/ActionInterpolator.d.ts

@@ -1,5 +1,18 @@
-export class ActionInterpolator {
-    constructor(easing_function?: string);
-    easing_function: any;
-    update(context: any, t: any): void;
-}
+export class ActionInterpolator {
+    /**
+     * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} easing_function
+     */
+    constructor(easing_function?: import('../utilities/EasingFunctions').EasingFunctionType | Function);
+    easing_function: Function;
+    attribute_name: string;
+    /** @type {number | Vector3} */
+    from: number | Vector3;
+    /** @type {number | Vector3} */
+    to: number | Vector3;
+    /**
+     * @param {any} context
+     * @param {number} t
+     */
+    update(context: any, t: number): void;
+}
+import { Vector3 } from "three/src/math/Vector3";