ohzi-core 12.2.0 → 12.3.0

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

package/types/components/AudioClip.d.ts

@@ -1,13 +1,25 @@
-export class AudioClip {
-    constructor(buffer: any, loop?: boolean, volume?: number, positional?: boolean);
-    buffer: any;
-    loop: boolean;
-    volume: number;
-    positional: boolean;
-    audio: any;
-    init(audio_listener: any): void;
-    play(): void;
-    pause(): void;
-    stop(): void;
-    get is_playing(): any;
-}
+export class AudioClip {
+    /**
+     * @param {AudioBuffer} buffer
+     * @param {boolean} [loop]
+     * @param {number} [volume]
+     * @param {boolean} [positional]
+     */
+    constructor(buffer: AudioBuffer, loop?: boolean, volume?: number, positional?: boolean);
+    buffer: AudioBuffer;
+    loop: boolean;
+    volume: number;
+    positional: boolean;
+    audio: TPositionalAudio | TAudio<GainNode>;
+    /**
+     * @param {AudioListener} audio_listener
+     */
+    init(audio_listener: AudioListener): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    get is_playing(): boolean;
+}
+import { PositionalAudio as TPositionalAudio } from "three/src/audio/PositionalAudio";
+import { Audio as TAudio } from "three/src/audio/Audio";
+import { AudioListener } from "three/src/audio/AudioListener";

package/types/components/AxisHelper.d.ts

@@ -1,6 +1,6 @@
-export class AxisHelper {
-    constructor(scale?: number);
-    renderOrder: number;
-    update(): void;
-    dispose(): void;
-}
+export class AxisHelper extends Object3D<import("three").Object3DEventMap> {
+    constructor(scale?: number);
+    update(): void;
+    dispose(): void;
+}
+import { Object3D } from "three/src/core/Object3D";

package/types/components/BaseObject.d.ts

@@ -1,5 +1,12 @@
-export class BaseObject {
-    ___temp_w_pos: any;
-    get_world_pos(): any;
-    deep_dispose(obj: any): void;
-}
+export class BaseObject extends Object3D<import("three").Object3DEventMap> {
+    constructor();
+    ___temp_w_pos: Vector3;
+    get_world_pos(): Vector3;
+    /**
+     * @param {Object3D | Mesh} obj
+     */
+    deep_dispose(obj: Object3D | Mesh): void;
+}
+import { Object3D } from "three/src/core/Object3D";
+import { Vector3 } from "three/src/math/Vector3";
+import { Mesh } from "three/src/objects/Mesh";

package/types/components/EdgeMesh.d.ts

@@ -1,13 +1,42 @@
-export class EdgeMesh {
-    constructor(buffer_geometry: any, thickness: any, color: any);
-    edges_material: any;
-    corners_material: any;
-    edges_mesh: any;
-    corners_mesh: any;
-    __get_edges(cube_geometry: any): any[];
-    update(TIME: any): void;
-    __get_edges_geometry(points: any): any;
-    __get_corners_geometry(geometry_vertices: any): any;
-    set_visible(boolean: any): void;
-    dispose(): void;
-}
+export class EdgeMesh extends Object3D<import("three").Object3DEventMap> {
+    /**
+     * @param {BufferGeometry} buffer_geometry
+     * @param {number} [thickness]
+     * @param {string} [color]
+     */
+    constructor(buffer_geometry: BufferGeometry, thickness?: number, color?: string);
+    edges_material: ShaderMaterial;
+    corners_material: ShaderMaterial;
+    edges_mesh: Mesh<BufferGeometry<import("three").NormalBufferAttributes>, ShaderMaterial, import("three").Object3DEventMap>;
+    corners_mesh: Mesh<BufferGeometry<import("three").NormalBufferAttributes>, ShaderMaterial, import("three").Object3DEventMap>;
+    /**
+     * @param {BufferGeometry} cube_geometry
+     * @returns {Vector3[]}
+     */
+    __get_edges(cube_geometry: BufferGeometry): Vector3[];
+    /**
+     * @param {number} TIME
+     */
+    update(TIME: number): void;
+    /**
+     * @param {Vector3[]} points
+     */
+    __get_edges_geometry(points: Vector3[]): BufferGeometry<import("three").NormalBufferAttributes>;
+    /**
+     * @param {BufferAttribute | InterleavedBufferAttribute} geometry_vertices
+     * @returns {BufferGeometry}
+     */
+    __get_corners_geometry(geometry_vertices: BufferAttribute | InterleavedBufferAttribute): BufferGeometry;
+    /**
+     * @param {boolean} boolean
+     */
+    set_visible(boolean: boolean): void;
+    dispose(): void;
+}
+import { Object3D } from "three/src/core/Object3D";
+import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { Mesh } from "three/src/objects/Mesh";
+import { Vector3 } from "three/src/math/Vector3";
+import { BufferAttribute } from "three/src/core/BufferAttribute";
+import { InterleavedBufferAttribute } from "three/src/core/InterleavedBufferAttribute";

package/types/components/GeometryEdgeVisualizer.d.ts

@@ -1,4 +1,12 @@
-export class GeometryEdgeVisualizer {
-    constructor(geometry: any, line_color: any);
-    hide_faces(): void;
-}
+export class GeometryEdgeVisualizer extends Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+    /**
+     * @param {BufferGeometry} geometry
+     * @param {string | number} [line_color]
+     */
+    constructor(geometry: BufferGeometry, line_color?: string | number);
+    material: ShaderMaterial;
+    hide_faces(): void;
+}
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { Mesh } from "three/src/objects/Mesh";
+import { ShaderMaterial } from "three/src/materials/ShaderMaterial";

package/types/components/Grid.d.ts

@@ -1,2 +1,4 @@
-export class Grid {
-}
+export class Grid extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+    constructor();
+}
+import { Mesh } from "three/src/objects/Mesh";

package/types/components/Line.d.ts

@@ -1,16 +1,42 @@
-export class Line {
-    constructor(points: any);
-    setup(points: any): void;
-    _length: number;
-    set thickness(arg: any);
-    get thickness(): any;
-    __get_previous_position(points: any, i: any): any;
-    __get_next_position(points: any, i: any): any;
-    update(): void;
-    distance(): any;
-    total_length(): any;
-    dispose(): void;
-    set color(arg: any);
-    get color(): any;
-    copy_color(col: any): void;
-}
+export class Line extends Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+    /**
+     * @param {Vector3[]} [points]
+     */
+    constructor(points?: Vector3[]);
+    material: ShaderMaterial;
+    /**
+     * @param {Vector3[]} points
+     */
+    setup(points: Vector3[]): void;
+    _length: number;
+    accumulated_length: number;
+    set thickness(arg: any);
+    get thickness(): any;
+    /**
+     * @param {Vector3[]} points
+     * @param {number} i
+     * @returns {Vector3}
+     */
+    __get_previous_position(points: Vector3[], i: number): Vector3;
+    /**
+     * @param {Vector3[]} points
+     * @param {number} i
+     * @returns {Vector3}
+     */
+    __get_next_position(points: Vector3[], i: number): Vector3;
+    update(): void;
+    distance(): number;
+    total_length(): number;
+    dispose(): void;
+    set color(arg: any);
+    get color(): any;
+    /**
+     * @param {Color} col
+     */
+    copy_color(col: Color): void;
+}
+import { BufferGeometry } from "three/src/core/BufferGeometry";
+import { Mesh } from "three/src/objects/Mesh";
+import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { Vector3 } from "three/src/math/Vector3";
+import { Color } from "three/src/math/Color";

package/types/components/MultiLinePath.d.ts

@@ -1,4 +1,10 @@
-export class MultiLinePath {
-    constructor(paths: any, webgl: any);
-    paths: any[];
-}
+export class MultiLinePath extends Object3D<import("three").Object3DEventMap> {
+    /**
+     * @param {Array<Vector3[]>} paths
+     */
+    constructor(paths: Array<Vector3[]>);
+    paths: Line[];
+}
+import { Object3D } from "three/src/core/Object3D";
+import { Line } from "./Line";
+import { Vector3 } from "three/src/math/Vector3";

package/types/components/MultiLineText2D.d.ts

@@ -1,10 +1,22 @@
-export class MultiLineText2D {
-    constructor(text_array: any, font: any, color: any, pivot: any, is_static: any);
-    text_array: Text2D[];
-    update_text_positions(): void;
-    set texts(arg: any[]);
-    get texts(): any[];
-    set size(arg: number);
-    get size(): number;
-}
-import { Text2D } from "./Text2D";
+export class MultiLineText2D extends Object3D<import("three").Object3DEventMap> {
+    /**
+     * @param {string[]} text_array
+     * @param {string} [font]
+     * @param {string | number} [color]
+     * @param {Vector2} [pivot]
+     * @param {boolean} [is_static]
+     */
+    constructor(text_array: string[], font?: string, color?: string | number, pivot?: Vector2, is_static?: boolean);
+    text_array: Text2D[];
+    update_text_positions(): void;
+    set texts(arg: string[]);
+    /**
+     * @returns {string[]}
+     */
+    get texts(): string[];
+    set size(arg: number);
+    get size(): number;
+}
+import { Object3D } from "three/src/core/Object3D";
+import { Text2D } from "./Text2D";
+import { Vector2 } from "three/src/math/Vector2";

package/types/components/ObjectAxis.d.ts

@@ -1,3 +1,8 @@
-export class ObjectAxis {
-    constructor(obj: any, size: any);
-}
+export class ObjectAxis extends Object3D<import("three").Object3DEventMap> {
+    /**
+     * @param {Object3D} obj
+     * @param {number} [size]
+     */
+    constructor(obj: Object3D, size?: number);
+}
+import { Object3D } from "three/src/core/Object3D";

package/types/components/ObjectOrientedBoundingBox.d.ts

@@ -1,18 +1,45 @@
-export class ObjectOrientedBoundingBox {
-    constructor(points: any);
-    axis_to_world: any;
-    world_to_axis: any;
-    min: any;
-    max: any;
-    center: any;
-    bounds: any[];
-    get_center(points: any): any;
-    box_volume(min: any, max: any): number;
-    getSize(): any;
-    is_inside_XZ(point: any): boolean;
-    closest_point_on_bounds(reference_point: any): any;
-    world_to_local(point: any): any;
-    local_to_world(point: any): any;
-    local_to_world_dir(direction: any): any;
-    get_corners(): any[];
-}
+export class ObjectOrientedBoundingBox {
+    /**
+     * @param {Vector3[]} points
+     */
+    constructor(points: Vector3[]);
+    axis_to_world: Quaternion;
+    world_to_axis: Quaternion;
+    min: Vector3;
+    max: Vector3;
+    center: Vector3;
+    bounds: Vector3[];
+    /**
+     * @param {Vector3[]} points
+     */
+    get_center(points: Vector3[]): Vector3;
+    /**
+     * @param {Vector3} min
+     * @param {Vector3} max
+     */
+    box_volume(min: Vector3, max: Vector3): number;
+    getSize(): Vector3;
+    /**
+     * @param {Vector3} point
+     */
+    is_inside_XZ(point: Vector3): boolean;
+    /**
+     * @param {Vector3} reference_point
+     */
+    closest_point_on_bounds(reference_point: Vector3): Vector3;
+    /**
+     * @param {Vector3} point
+     */
+    world_to_local(point: Vector3): Vector3;
+    /**
+     * @param {Vector3} point
+     */
+    local_to_world(point: Vector3): Vector3;
+    /**
+     * @param {Vector3} direction
+     */
+    local_to_world_dir(direction: Vector3): Vector3;
+    get_corners(): Vector3[];
+}
+import { Quaternion } from "three/src/math/Quaternion";
+import { Vector3 } from "three/src/math/Vector3";