ohzi-core 12.2.0 → 12.2.1

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

package/types/action_sequencer/ActionSequencer.d.ts

@@ -1,36 +1,104 @@
-export class ActionSequencer {
-    constructor(context?: {});
-    previous_elapsed_time: number;
-    elapsed_time: number;
-    playback_speed: number;
-    playing: boolean;
-    action_events: any[];
-    context: {};
-    initial_context: any;
-    tmp_t: number;
-    channels: {};
-    duration: number;
-    play(): void;
-    stop(): void;
-    reset(): void;
-    skip(): void;
-    update(delta_time: any): void;
-    set_progress(time: any): void;
-    set_normalized_progress(t: any): void;
-    get_progress(): number;
-    is_finished(): boolean;
-    add_action_event(trigger_time: any, action: any): void;
-    add_action_interpolator(from: any, to: any, interpolator: any, use_dynamic_from_value?: boolean): void;
-    get_current_target_value(name: any): any;
-    get_current_starting_value(name: any): any;
-    get_current_progress(name: any): any;
-    get_duration(): number;
-    __play_clips(from: any, to: any): void;
-    __play_events(from: any, to: any): void;
-    evaluate_keyframe(keyframe: any, time: any): any;
-    get_keyframes(channel_name: any): any;
-    is_channel_redefined(channel_name: any): boolean;
-    __linear_map_01(value: any, from_range_start_value: any, from_range_end_value: any): number;
-    __get_current_keyframe(channel_name: any, time: any): any;
-    __get_playback_speed(): number;
-}
+export class ActionSequencer {
+    /**
+     * @param {any} [context]
+     */
+    constructor(context?: any);
+    previous_elapsed_time: number;
+    elapsed_time: number;
+    playback_speed: number;
+    playing: boolean;
+    /** @type {{action:ActionEvent, trigger_time:number }[]} */
+    action_events: {
+        action: ActionEvent;
+        trigger_time: number;
+    }[];
+    context: any;
+    initial_context: any;
+    tmp_t: number;
+    /** @type {{[key:string]:any[]}} */
+    channels: {
+        [key: string]: any[];
+    };
+    duration: number;
+    play(): void;
+    stop(): void;
+    reset(): void;
+    skip(): void;
+    /**
+     * @param {number} delta_time
+     */
+    update(delta_time: number): void;
+    /**
+     * @param {number} time
+     */
+    set_progress(time: number): void;
+    /**
+     * @param {number} t
+     */
+    set_normalized_progress(t: number): void;
+    get_progress(): number;
+    is_finished(): boolean;
+    /**
+     * @param {number} trigger_time
+     * @param {ActionEvent} action
+     */
+    add_action_event(trigger_time: number, action: ActionEvent): void;
+    /**
+     * @param {number} from
+     * @param {number} to
+     * @param {ActionInterpolator} interpolator
+     * @param {boolean} [use_dynamic_from_value]
+     */
+    add_action_interpolator(from: number, to: number, interpolator: ActionInterpolator, use_dynamic_from_value?: boolean): void;
+    /**
+     * @param {string} name
+     */
+    get_current_target_value(name: string): any;
+    /**
+     * @param {string} name
+     */
+    get_current_starting_value(name: string): any;
+    /**
+     * @param {string} name
+     */
+    get_current_progress(name: string): any;
+    get_duration(): number;
+    /**
+     * @param {number} from
+     * @param {number} to
+     */
+    __play_clips(from: number, to: number): void;
+    /**
+     * @param {number} from
+     * @param {number} to
+     */
+    __play_events(from: number, to: number): void;
+    /**
+     * @param {any} keyframe
+     * @param {number} time
+     */
+    evaluate_keyframe(keyframe: any, time: number): any;
+    /**
+     * @param {string} channel_name
+     */
+    get_keyframes(channel_name: string): any[];
+    /**
+     * @param {string} channel_name
+     */
+    is_channel_redefined(channel_name: string): boolean;
+    /**
+     * @param {number} value
+     * @param {number} from_range_start_value
+     * @param {number} from_range_end_value
+     * @returns {number}
+     */
+    __linear_map_01(value: number, from_range_start_value: number, from_range_end_value: number): number;
+    /**
+     * @param {string} channel_name
+     * @param {number} time
+     */
+    __get_current_keyframe(channel_name: string, time: number): any;
+    __get_playback_speed(): number;
+}
+import { ActionEvent } from "./ActionEvent";
+import { ActionInterpolator } from "./ActionInterpolator";

package/types/action_sequencer/NumberInterpolator.d.ts

@@ -1,9 +1,18 @@
-export class NumberInterpolator extends ActionInterpolator {
-    constructor(attribute_name: any, from?: number, to?: number, initial?: boolean, easing_function?: string);
-    attribute_name: any;
-    from: number;
-    to: number;
-    initial: boolean;
-    evaluate(t: any): number;
-}
-import { ActionInterpolator } from "./ActionInterpolator";
+export class NumberInterpolator extends ActionInterpolator {
+    /**
+     * @param {string} attribute_name
+     * @param {number} [from]
+     * @param {number} [to]
+     * @param {boolean} [initial]
+     * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} [easing_function]
+     */
+    constructor(attribute_name: string, from?: number, to?: number, initial?: boolean, easing_function?: import('../utilities/EasingFunctions').EasingFunctionType | Function);
+    from: number;
+    to: number;
+    initial: boolean;
+    /**
+     * @param {number} t
+     */
+    evaluate(t: number): number;
+}
+import { ActionInterpolator } from "./ActionInterpolator";

package/types/action_sequencer/VectorInterpolator.d.ts

@@ -1,7 +1,13 @@
-export class VectorInterpolator extends ActionInterpolator {
-    constructor(attribute_name: any, from?: number, to?: number, easing_function?: string);
-    attribute_name: any;
-    from: number;
-    to: number;
-}
-import { ActionInterpolator } from "./ActionInterpolator";
+export class VectorInterpolator extends ActionInterpolator {
+    /**
+     * @param {string} attribute_name
+     * @param {Vector3} [from]
+     * @param {Vector3} [to]
+     * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} [easing_function]
+     */
+    constructor(attribute_name: string, from?: Vector3, to?: Vector3, easing_function?: import('../utilities/EasingFunctions').EasingFunctionType | Function);
+    from: Vector3;
+    to: Vector3;
+}
+import { ActionInterpolator } from "./ActionInterpolator";
+import { Vector3 } from "three/src/math/Vector3";

package/types/blitter_index.d.ts

@@ -1,6 +1,6 @@
-import { MedianFilter } from "./render_utilities/MedianFilter";
-import { GaussianBlurrer } from "./render_utilities/GaussianBlurrer";
-import { Blurrer } from "./render_utilities/Blurrer";
-import { Blitter } from "./render_utilities/Blitter";
-import { DualFilteringBlurMaterial } from "./materials/DualFilteringBlurMaterial";
-export { MedianFilter, GaussianBlurrer, Blurrer, Blitter, DualFilteringBlurMaterial };
+import { MedianFilter } from "./render_utilities/MedianFilter";
+import { GaussianBlurrer } from "./render_utilities/GaussianBlurrer";
+import { Blurrer } from "./render_utilities/Blurrer";
+import { Blitter } from "./render_utilities/Blitter";
+import { DualFilteringBlurMaterial } from "./materials/DualFilteringBlurMaterial";
+export { MedianFilter, GaussianBlurrer, Blurrer, Blitter, DualFilteringBlurMaterial };

package/types/canvas_drawer/CanvasDrawer.d.ts

@@ -1,13 +1,51 @@
-export class CanvasDrawer {
-    constructor(uses_dynamic_font: any);
-    uses_dynamic_font: any;
-    __textHeight: number;
-    canvas: HTMLCanvasElement;
-    ctx: CanvasRenderingContext2D;
-    getFontHeight(fontStyle?: string): number;
-    get_text_size(text: any, font?: string): any;
-    draw_canvas(text: any, ctxOptions?: {}): HTMLCanvasElement;
-    draw_on_texture(text: any, ctxOptions: any): any;
-    __draw(text: any, ctxOptions: any): void;
-    roundRect(ctx: any, x: any, y: any, width: any, height: any, radius: any, fill: any, stroke: any): void;
-}
+export class CanvasDrawer {
+    /**
+     * @param {boolean} [uses_dynamic_font]
+     */
+    constructor(uses_dynamic_font?: boolean);
+    uses_dynamic_font: boolean;
+    __textHeight: number;
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    getFontHeight(fontStyle?: string): number;
+    /**
+     * @param {string} text
+     * @param {string} font
+     */
+    get_text_size(text: string, font?: string): Vector2;
+    /**
+     * @param {string} text
+     * @param {any} [ctxOptions]
+     */
+    draw_canvas(text: string, ctxOptions?: any): HTMLCanvasElement;
+    /**
+     * @param {string} text
+     * @param {any} [ctxOptions]
+     */
+    draw_on_texture(text: string, ctxOptions?: any): CanvasTexture;
+    /**
+     * @param {string[] | string} text
+     * @param {any} [ctxOptions]
+     * @param {HTMLCanvasElement} [canvas]
+     * @param {CanvasRenderingContext2D} [ctx]
+     */
+    __draw(text: string[] | string, ctxOptions?: any, canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D): void;
+    /**
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number | {tl:number, tr:number, br:number, bl:number}} radius
+     * @param {boolean} fill
+     * @param {boolean} stroke
+     */
+    roundRect(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number | {
+        tl: number;
+        tr: number;
+        br: number;
+        bl: number;
+    }, fill: boolean, stroke: boolean): void;
+}
+import { Vector2 } from "three/src/math/Vector2";
+import { CanvasTexture } from "three/src/textures/CanvasTexture";

package/types/canvas_drawer/MultiLineTextDrawer.d.ts

@@ -1,5 +1,13 @@
-export class MultiLineTextDrawer extends CanvasDrawer {
-    constructor();
-    text_margin: any;
-}
-import { CanvasDrawer } from "./CanvasDrawer";
+export class MultiLineTextDrawer extends CanvasDrawer {
+    constructor();
+    text_margin: Vector2;
+    /**
+     * @param {string[]} text_array
+     * @param {any} [ctxOptions]
+     * @param {HTMLCanvasElement} [canvas]
+     * @param {CanvasRenderingContext2D} [ctx]
+     */
+    __draw(text_array: string[], ctxOptions?: any, canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D): void;
+}
+import { CanvasDrawer } from "./CanvasDrawer";
+import { Vector2 } from "three/src/math/Vector2";

package/types/canvas_drawer/SimpleTextDrawer.d.ts

@@ -1,6 +1,13 @@
-export class SimpleTextDrawer extends CanvasDrawer {
-    constructor();
-    text_margin: any;
-    __draw(text: any, ctxOptions: any, canvas: any, ctx: any): void;
-}
-import { CanvasDrawer } from "./CanvasDrawer";
+export class SimpleTextDrawer extends CanvasDrawer {
+    constructor();
+    text_margin: Vector2;
+    /**
+     * @param {string} text
+     * @param {any} [ctxOptions]
+     * @param {HTMLCanvasElement} [canvas]
+     * @param {CanvasRenderingContext2D} [ctx]
+     */
+    __draw(text: string, ctxOptions?: any, canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D): void;
+}
+import { CanvasDrawer } from "./CanvasDrawer";
+import { Vector2 } from "three/src/math/Vector2";