ohzi-core 13.0.0 → 13.0.2

package/types/KeyboardInput.d.ts

@@ -1,13 +1,7 @@
 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;
@@ -17,49 +11,19 @@ export class KeyboardInput {
             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/OScreen.d.ts

@@ -1,3 +1,5 @@
+import type { Vector2 } from "three";
+
 export { oscreen as OScreen };
 declare const oscreen: OScreen;
 declare class OScreen {
@@ -10,28 +12,15 @@ declare class OScreen {
     width_height: Vector2;
     dpr: number;
     pixel_size: Vector2;
-    /**
-     * @param {number} x
-     * @param {number} y
-     */
+    size_changed: boolean;
+
+    get aspect_ratio(): number;
+    get portrait(): boolean;
+
     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,20 +1,10 @@
-export class OrthographicCamera extends TOrthographicCamera {
-    /**
-     * @param {number} left
-     * @param {number} right
-     * @param {number} top
-     * @param {number} bottom
-     * @param {number} near
-     * @param {number} far
-     */
+import { OrthographicCamera as TOrthographicCamera } from "three";
+import { Color } from "three";
+
+t class OrthographicCamera extends TOrthographicCamera {
     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,18 +1,9 @@
+import type { Color } from "three";
+import { PerspectiveCamera as TPerspectiveCamera } from "three";
+
 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/RenderLoop.d.ts

@@ -1,132 +1,18 @@
+import type { BaseApplication } from "./BaseApplication";
+import type { Graphics } from "./Graphics";
+
 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);
+    constructor(target_application: BaseApplication, graphics: typeof Graphics, 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;
-    };
+    graphics: typeof Graphics;
     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/ResourceContainer.d.ts

@@ -1,29 +1,13 @@
-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: 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;
+    
+    init(): void;
+    set_resource(name: string, url: string, resource: any): void;
+    get_resource(name: string): any;
+    get(name: string): any;
 }
+
+declare const resource_container: ResourceContainer;
+export { resource_container as ResourceContainer };
+

package/types/SceneManager.d.ts

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

package/types/Screen.d.ts

@@ -1,27 +1,15 @@
+import type { Vector2 } from "three";
+
 export { screen as Screen };
 declare const screen: Screen;
 declare class Screen {
+    get aspect_ratio(): number;
+
     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,3 +1,5 @@
+import type { Clock, Vector2 } from "three";
+
 export { time as Time };
 declare const time: Time;
 declare class Time {
@@ -18,12 +20,8 @@ declare class Time {
     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/action_sequencer/ActionEvent.d.ts

@@ -1,9 +1,4 @@
 export class ActionEvent {
-    /**
-     * @param {string} name
-     * @param {string} method
-     * @param {string} args
-     */
     constructor(name: string, method: string, args: string);
     name: string;
     method: string;

package/types/action_sequencer/ActionInterpolator.d.ts

@@ -1,18 +1,12 @@
+import type { Vector3 } from "three";
+import type { EasingFunctionType } from "../utilities/EasingFunctions";
+
 export class ActionInterpolator {
-    /**
-     * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} easing_function
-     */
-    constructor(easing_function?: import('../utilities/EasingFunctions').EasingFunctionType | Function);
+    constructor(easing_function?: EasingFunctionType);
     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,13 +1,12 @@
+import type { ActionEvent } from "./ActionEvent";
+import type { ActionInterpolator } from "./ActionInterpolator";
+
 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;
@@ -15,90 +14,32 @@ export class ActionSequencer {
     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,18 +1,10 @@
+import type { EasingFunctionType } from "../utilities/EasingFunctions";
+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);
+    constructor(attribute_name: string, from?: number, to?: number, initial?: boolean, easing_function?: 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,13 +1,9 @@
+import type { Vector3 } from "three";
+import type { EasingFunctionType } from "../utilities/EasingFunctions";
+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);
+    constructor(attribute_name: string, from?: Vector3, to?: Vector3, easing_function?: EasingFunctionType | Function);
     from: Vector3;
     to: Vector3;
 }
-import { ActionInterpolator } from "./ActionInterpolator";
-import { Vector3 } from "three/src/math/Vector3";

package/types/canvas_drawer/CanvasDrawer.d.ts

@@ -1,45 +1,17 @@
+import type { CanvasTexture, Vector2 } from "three";
+
 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;
@@ -47,5 +19,3 @@ export class CanvasDrawer {
         bl: number;
     }, fill: boolean, stroke: boolean): void;
 }
-import { Vector2 } from "three/src/math/Vector2";
-import { CanvasTexture } from "three/src/textures/CanvasTexture";