ohzi-core 12.2.0 → 12.2.1

package/src/ui/ui_element_state/OnMouseEnter.js

@@ -1,3 +1,6 @@
+// @ts-check
+import { Vector2 } from 'three'; // eslint-disable-line no-unused-vars
+import { UIElement } from '../../components/UIElement'; // eslint-disable-line no-unused-vars
 import { UIElementState } from './UIElementState';
 
 class OnMouseEnter extends UIElementState
@@ -7,11 +10,19 @@ class OnMouseEnter extends UIElementState
     super();
   }
 
+  /**
+   *
+   * @param {UIElement} ui_element
+   */
   on_enter(ui_element)
   {
     ui_element.on_mouse_enter();
   }
 
+  /**
+   * @param {UIElement} ui_element
+   * @param {Vector2} normalized_mouse_position
+   */
   update(ui_element, normalized_mouse_position)
   {
     if (ui_element.is_mouse_over(normalized_mouse_position))

package/src/ui/ui_element_state/OnMouseExit.js

@@ -1,3 +1,5 @@
+// @ts-check
+import { UIElement } from '../../components/UIElement'; // eslint-disable-line no-unused-vars
 import { UIElementState } from './UIElementState';
 
 class OnMouseExit extends UIElementState
@@ -7,6 +9,9 @@ class OnMouseExit extends UIElementState
     super();
   }
 
+  /**
+   * @param {UIElement} ui_element
+   */
   on_enter(ui_element)
   {
     ui_element.on_mouse_exit();

package/src/ui/ui_element_state/OnMouseHover.js

@@ -1,3 +1,6 @@
+// @ts-check
+import { Vector2 } from 'three'; // eslint-disable-line no-unused-vars
+import { UIElement } from '../../components/UIElement'; // eslint-disable-line no-unused-vars
 import { UIElementState } from './UIElementState';
 
 class OnMouseHover extends UIElementState
@@ -7,11 +10,18 @@ class OnMouseHover extends UIElementState
     super();
   }
 
+  /**
+   * @param {UIElement} ui_element
+   */
   on_enter(ui_element)
   {
     this.__trigger_on_hover(ui_element);
   }
 
+  /**
+   * @param {UIElement} ui_element
+   * @param {Vector2} normalized_mouse_position
+   */
   update(ui_element, normalized_mouse_position)
   {
     if (ui_element.is_mouse_over(normalized_mouse_position))
@@ -24,6 +34,9 @@ class OnMouseHover extends UIElementState
     }
   }
 
+  /**
+   * @param {UIElement} ui_element
+   */
   __trigger_on_hover(ui_element)
   {
     ui_element.on_mouse_hover();

package/src/ui/ui_element_state/UIElementState.js

@@ -1,3 +1,7 @@
+// @ts-check
+import { Vector2 } from 'three'; // eslint-disable-line no-unused-vars
+import { UIElement } from '../../components/UIElement'; // eslint-disable-line no-unused-vars
+
 class UIElementState
 {
   constructor()
@@ -5,15 +9,25 @@ class UIElementState
 
   }
 
-  update(ui_element, normalized_mouse_position)
+  /**
+   * @param {UIElement} ui_element
+   * @param {Vector2} normalized_mouse_position
+   */
+  update(ui_element, normalized_mouse_position) // eslint-disable-line no-unused-vars
   {
 
   }
 
-  on_enter(ui_element)
+  /**
+   * @param {UIElement} ui_element
+   */
+  on_enter(ui_element) // eslint-disable-line no-unused-vars
   {}
 
-  on_exit(ui_element)
+  /**
+   * @param {UIElement} ui_element
+   */
+  on_exit(ui_element) // eslint-disable-line no-unused-vars
   {}
 }
 

package/src/utilities/EasingFunctions.js

@@ -1,3 +1,4 @@
+
 class EasingFunctions
 {
   constructor()
@@ -223,4 +224,8 @@ class EasingFunctions
   }
 }
 
+/**
+ * @typedef {'linear'|'triangular'|'ease_in_sine'|'ease_out_sine'|'ease_in_out_sine'|'ease_in_cubic'|'ease_out_cubic'|'ease_in_out_cubic'|'ease_in_quad'|'ease_out_quad'|'ease_in_out_quad'|'ease_in_quart'|'ease_out_quart'|'ease_in_out_quart'|'ease_in_quint'|'ease_out_quint'|'ease_in_out_quint'|'ease_in_expo'|'ease_out_expo'|'ease_in_out_expo'|'ease_in_circ'|'ease_out_circ'|'ease_in_out_circ'|'ease_in_back'|'ease_out_back'|'ease_in_out_back'|'ease_in_elastic'|'ease_out_elastic'|'ease_in_out_elastic'|'ease_in_bounce'|'ease_out_bounce'|'ease_in_out_bounce'|'heartbeat'} EasingFunctionType
+ */
+
 export { EasingFunctions };

package/types/BaseApplication.d.ts

@@ -1,11 +1,18 @@
-export class BaseApplication {
-    on_post_start(): void;
-    on_enter(): void;
-    on_exit(): void;
-    before_update(): void;
-    update(): void;
-    fixed_update(): void;
-    on_post_render(): void;
-    on_pre_render(): void;
-    on_frame_end(): void;
-}
+export class BaseApplication {
+    on_post_start(): void;
+    /**
+      * @param {RenderLoop} [loop]
+     */
+    on_enter(loop?: RenderLoop): void;
+    /**
+      * @param {RenderLoop} [loop]
+     */
+    on_exit(loop?: RenderLoop): void;
+    before_update(): void;
+    update(): void;
+    fixed_update(): void;
+    on_post_render(): void;
+    on_pre_render(): void;
+    on_frame_end(): void;
+}
+import { RenderLoop } from "./RenderLoop";

package/types/Browser.d.ts

@@ -1,19 +1,20 @@
-export { browser as Browser };
-declare const browser: Browser;
-declare class Browser {
-    init(): Promise<void>;
-    browser_name: string;
-    agent: string;
-    has_web_xr_support: boolean;
-    is_vr: any;
-    version: number;
-    get name(): string;
-    get is_safari(): boolean;
-    get is_chrome(): boolean;
-    get is_edge(): boolean;
-    get is_edge_chromium(): boolean;
-    get has_webm(): boolean;
-    get has_hvec(): boolean;
-    get preferred_video_extension(): "webm" | "hvec.mp4" | "mp4";
-    get_version(): number;
-}
+export { browser as Browser };
+declare const browser: Browser;
+declare class Browser {
+    init(): Promise<void>;
+    browser_name: string;
+    agent: string;
+    has_web_xr_support: boolean;
+    is_vr: boolean;
+    version: number;
+    get name(): string;
+    get is_safari(): boolean;
+    get is_chrome(): boolean;
+    get is_firefox(): boolean;
+    get is_edge(): boolean;
+    get is_edge_chromium(): boolean;
+    get has_webm(): boolean;
+    get has_hvec(): boolean;
+    get preferred_video_extension(): "webm" | "hvec.mp4" | "mp4";
+    get_version(): number;
+}

package/types/CameraManager.d.ts

@@ -1,13 +1,14 @@
-import { Camera } from "three";
-
-export { camera_manager as CameraManager };
-declare const camera_manager: CameraManager;
-declare class CameraManager {
-    init(): void;
-    _current: Camera;
-    _spectator: Camera;
-    set current(arg: any);
-    get current(): any;
-    set spectator(arg: any);
-    get spectator(): any;
-}
+export { camera_manager as CameraManager };
+declare const camera_manager: CameraManager;
+declare class CameraManager {
+    init(): void;
+    _current: PerspectiveCamera;
+    _spectator: PerspectiveCamera;
+    set current(arg: PerspectiveCamera);
+    /** @type {PerspectiveCamera} */
+    get current(): PerspectiveCamera;
+    set spectator(arg: PerspectiveCamera);
+    /** @type {PerspectiveCamera} */
+    get spectator(): PerspectiveCamera;
+}
+import { PerspectiveCamera } from "./PerspectiveCamera";

package/types/Capabilities.d.ts

@@ -1,8 +1,8 @@
-export { capabilities as Capabilities };
-declare const capabilities: Capabilities;
-declare class Capabilities {
-    init(): void;
-    max_anisotropy: number;
-    vertex_texture_sampler_available: boolean;
-    fp_textures_available: boolean;
-}
+export { capabilities as Capabilities };
+declare const capabilities: Capabilities;
+declare class Capabilities {
+    init(): void;
+    max_anisotropy: number;
+    vertex_texture_sampler_available: boolean;
+    fp_textures_available: boolean;
+}

package/types/CustomBezierCurve.d.ts

@@ -1,7 +1,19 @@
-export class CustomBezierCurve {
-    constructor(points: any);
-    original_points: any[];
-    tmp_points: any[];
-    build(point_amount: any): any[];
-    get_point_at(t: any): any;
-}
+export class CustomBezierCurve {
+    /**
+     * @param {Vector3[]} points
+     */
+    constructor(points: Vector3[]);
+    original_points: Vector3[];
+    tmp_points: Vector3[];
+    /**
+     * @param {number} point_amount
+     * @returns {Vector3[]}
+     */
+    build(point_amount: number): Vector3[];
+    /**
+     * @param {number} t
+     * @returns {Vector3}
+     */
+    get_point_at(t: number): Vector3;
+}
+import { Vector3 } from "three/src/math/Vector3";

package/types/Debug.d.ts

@@ -1,37 +1,198 @@
-export { debug as Debug };
-declare const debug: Debug;
-declare class Debug {
-    init(): void;
-    Vector3_one: any;
-    Vector3_zero: any;
-    canvas_renderer: any;
-    display_texture_meshes: any[];
-    ctx: any;
-    scene: any;
-    camera: PerspectiveCamera;
-    draw_arrow(origin: any, dir: any, color?: number): Arrow;
-    draw_axis(): AxisHelper;
-    set_debug_RT(RT: any): void;
-    rt_debug: any;
-    draw_rectangle(position_2d: any, width: any, height: any, color: any): void;
-    clear(): void;
-    draw_line_2D(from: any, to: any, color: any): void;
-    draw_line(points: any, color?: number): any;
-    draw_cube(pos: any, size: any, color: any): Cube;
-    draw_oriented_cube(from: any, to: any, height?: number, color?: string, depth?: number): Cube;
-    draw_plane(width: any, height: any, color: any): any;
-    draw_empty_cube(pos: any, size: any, color: any): any;
-    draw_sphere(pos: any, size: any, color: any): Sphere;
-    draw_point_array(input_points: any, open?: boolean, color?: number): any;
-    draw_sphere_helper(sphere: any, color: any): any;
-    draw_math_sphere(sphere: any): void;
-    draw_bounding_box(bb: any): void;
-    draw_curve(curve: any, options: any): void;
-    draw_texture(tex: any, w: any, h: any): any;
-    render(graphics: any): void;
-}
-import { PerspectiveCamera } from "./PerspectiveCamera";
-import { Arrow } from "./primitives/Arrow";
-import { AxisHelper } from "./components/AxisHelper";
-import { Cube } from "./primitives/Cube";
-import { Sphere } from "./primitives/Sphere";
+export { debug as Debug };
+declare const debug: Debug;
+declare class Debug {
+    init(): void;
+    Vector3_one: Vector3;
+    Vector3_zero: Vector3;
+    canvas_renderer: any;
+    /** @type { Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[] } */
+    display_texture_meshes: Mesh<PlaneGeometry, ScreenSpaceTextureMaterial>[];
+    ctx: any;
+    scene: Scene;
+    camera: PerspectiveCamera;
+    /**
+     * @param {Vector3} origin
+     * @param {Vector3} dir
+     * @param {number | string} color
+     * @returns {Arrow}
+     */
+    draw_arrow(origin: Vector3, dir: Vector3, color?: number | string): Arrow;
+    draw_axis(): AxisHelper;
+    /**
+     * @param {RenderTarget} RT
+     */
+    set_debug_RT(RT: RenderTarget): void;
+    rt_debug: RenderTarget<Texture>;
+    /**
+     * @param {Vector2 | Vector3} position_2d
+     * @param {number} width
+     * @param {number} height
+     * @param {number | string} color
+     */
+    draw_rectangle(position_2d: Vector2 | Vector3, width: number, height: number, color: number | string): void;
+    clear(): void;
+    /**
+     * @param {Vector3 | Vector2} from
+     * @param {Vector3 | Vector2} to
+     * @param {number | string} color
+     */
+    draw_line_2D(from: Vector3 | Vector2, to: Vector3 | Vector2, color: number | string): void;
+    /**
+     * @param {Vector3[]} points
+     * @param {number | string} color
+     * @returns {Line}
+     */
+    draw_line(points: Vector3[], color?: number | string): Line;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Cube}
+     */
+    draw_cube(pos: Vector3, size: number, color: number | string): Cube;
+    /**
+     * @param {Vector3} from
+     * @param {Vector3} to
+     * @param {number} height
+     * @param {number | string} color
+     * @param {number} depth
+     * @returns {Cube}
+     */
+    draw_oriented_cube(from: Vector3, to: Vector3, height?: number, color?: number | string, depth?: number): Cube;
+    /**
+     *
+     * @param {number} [width]
+     * @param {number} [height]
+     * @param {number | string} [color]
+     * @returns
+     */
+    draw_plane(width?: number, height?: number, color?: number | string): Mesh<PlaneGeometry, ShaderMaterial, import("three").Object3DEventMap>;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Box3Helper}
+     */
+    draw_empty_cube(pos: Vector3, size: number, color: number | string): Box3Helper;
+    /**
+     * @param {Vector3} pos
+     * @param {number} size
+     * @param {number | string} color
+     * @returns {Sphere}
+     */
+    draw_sphere(pos: Vector3, size: number, color: number | string): Sphere;
+    /**
+     *
+     * @param {Vector3[]} input_points
+     * @param {boolean} open
+     * @param {number | string} color
+     * @returns {Line}
+     */
+    draw_point_array(input_points: Vector3[], open?: boolean, color?: number | string): Line;
+    /**
+     * @param {Sphere} sphere
+     * @param {number | string} color
+     * @returns {Mesh}
+     */
+    draw_sphere_helper(sphere: Sphere, color: number | string): Mesh;
+    /**
+     * @param {Sphere} sphere
+     */
+    draw_math_sphere(sphere: Sphere): void;
+    /**
+     * @param {Box3} bb
+     */
+    draw_bounding_box(bb: Box3): void;
+    /**
+     * @param {Vector3[]} curve
+     * @param {object} options
+     * @param {number} options.offset
+     */
+    draw_curve(curve: Vector3[], options: {
+        offset: number;
+    }): void;
+    /**
+     * @param {Texture} tex
+     * @param {number} w
+     * @param {number} h
+     * @returns {Mesh}
+     */
+    draw_texture(tex: Texture, w: number, h: number): Mesh;
+    /**
+     * @param {Graphics} graphics
+     */
+    render(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: 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<Texture>;
+        set_state(new_state: import("./render_mode/BaseRender").BaseRender): void;
+        update(): void;
+        __update_current_camera(): void;
+        render(scene?: Scene, camera?: PerspectiveCamera | import("./OrthographicCamera").OrthographicCamera, RT?: import("three").WebGLRenderTarget<Texture>, override_mat?: import("three").Material): void;
+        compile(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<Texture>, override_mat: import("three").Material): void;
+        compile_async(scene: Scene, camera: PerspectiveCamera, RT: import("three").WebGLRenderTarget<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<Texture>, buffer: import("three").TypedArray): void;
+        clear(RT: import("three").WebGLRenderTarget<Texture>, camera: 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<Texture>): void;
+        blit(src_RT: import("three").WebGLRenderTarget<Texture>, dst_RT: import("three").WebGLRenderTarget<Texture>, mat: import("three").Material): void;
+        blit_clear_with_material(dst_RT: import("three").WebGLRenderTarget<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;
+}
+import { Vector3 } from "three/src/math/Vector3";
+import { Mesh } from "three/src/objects/Mesh";
+import { PlaneGeometry } from "three/src/geometries/PlaneGeometry";
+import { ScreenSpaceTextureMaterial } from "./materials/ScreenSpaceTextureMaterial";
+import { Scene } from "three/src/scenes/Scene";
+import { PerspectiveCamera } from "./PerspectiveCamera";
+import { Arrow } from "./primitives/Arrow";
+import { AxisHelper } from "./components/AxisHelper";
+import { RenderTarget } from "three/src/core/RenderTarget";
+import { Texture } from "three/src/textures/Texture";
+import { Vector2 } from "three/src/math/Vector2";
+import { Line } from "three/src/objects/Line";
+import { Cube } from "./primitives/Cube";
+import { ShaderMaterial } from "three/src/materials/ShaderMaterial";
+import { Box3Helper } from "three/src/helpers/Box3Helper";
+import { Sphere } from "./primitives/Sphere";
+import { Box3 } from "three/src/math/Box3";
+import { WebGLRenderer } from "three/src/renderers/WebGLRenderer";