ohzi-core 13.0.2 → 13.0.4

package/types/camera_controller/CameraController.d.ts

@@ -0,0 +1,88 @@
+import type { Camera, Points } from 'three';
+import { PlaneHelper, Quaternion, Vector3 } from 'three';
+import { Plane } from 'three';
+import { Box3 } from 'three';
+import type { Input } from '../lib/Input';
+import type { Cube } from '../primitives/Cube';
+import type { Sphere } from '../primitives/Sphere';
+import type { CameraMovementMode } from './movement_mode/CameraMovementMode';
+import { AbstractCameraState } from './states/common/AbstractCameraState';
+export declare class CameraController {
+    __last_reference_position: Vector3;
+    camera: Camera;
+    camera_initial_pos: Vector3;
+    camera_initial_rot: Quaternion;
+    current_azimuth: number;
+    current_mode: CameraMovementMode;
+    current_orientation: number;
+    current_state: AbstractCameraState;
+    current_tilt: number;
+    debug_box: Cube;
+    input: Input;
+    input_enabled: boolean;
+    max_zoom: number;
+    min_zoom: number;
+    normalized_zoom: number;
+    old_orientation: number;
+    orientation: number;
+    point_of_interest: Vector3;
+    projected_points: Points[];
+    projection_plane_helper: PlaneHelper;
+    projection_sphere_helper: Sphere;
+    raised_look_at_position: Vector3;
+    reference_position: Vector3;
+    reference_rotation: Quaternion;
+    reference_zoom: number;
+    tilt: number;
+    tmp_dir: Vector3;
+    tmp_forward: Vector3;
+    tmp_quat: Quaternion;
+    tmp_right: Vector3;
+    tmp_size: Vector3;
+    use_raised_look_at_direction: number;
+    vector_forward_axis: Vector3;
+    vector_right_axis: Vector3;
+    vector_up_axis: Vector3;
+    zoom: number;
+    constructor(input: Input);
+    enable(): void;
+    disable(): void;
+    set_camera(camera: Camera): void;
+    set_state(state: AbstractCameraState): void;
+    set_mode(mode: CameraMovementMode): void;
+    set_normalized_zoom(zoom: number): void;
+    update_normalized_zoom(min_zoom: number, max_zoom: number): void;
+    update(): void;
+    set_idle(): void;
+    camera_is_zoomed_out(): boolean;
+    set_rotation(tilt: number, orientation: number, azimuth?: number): void;
+    set_rotation_delta(tilt: number, orientation: number, azimuth?: number): void;
+    lerp_tilt(from_tilt: number, to_tilt: number, t: number): void;
+    set_quaternion(q: Quaternion): void;
+    lerp_quaternion(q: Quaternion, t: number): void;
+    lerp_orientation(from_orientation: number, to_orientation: number, t: number): void;
+    lerp_azimuth(from_azimuth: number, to_azimuth: number, t: number): void;
+    lerp_rotation(from_tilt: number, to_tilt: number, from_orientation: number, to_orientation: number, from_azimuth: number, to_azimuth: number, t: number): void;
+    build_rotation(tilt: number, orientation: number): Quaternion;
+    translate_forward(amount: number): void;
+    translate_right(amount: number): void;
+    focus_on_bounding_box(bb: Box3, scale?: number): void;
+    get_zoom_to_focus_on_points(points: Vector3[], scale: number): number;
+    get_target_pos_to_focus_on_points(points: Vector3[], scale: number): Vector3;
+    focus_camera_on_sphere(sphere: Sphere, debug: boolean): void;
+    get_zoom_to_sphere(sphere: Sphere, debug: boolean): number;
+    hide_projected_points(): void;
+    show_projected_points(points: Vector3[]): void;
+    show_plane_projection(plane: Plane, size?: number): void;
+    show_sphere_projection(sphere: Sphere): void;
+    fit_points(quaternion: Quaternion, points: Vector3[], zoom_scale?: number): {
+        zoom: number;
+        reference_position: Vector3;
+        camera_position: Vector3;
+    };
+    focus_camera_on_points(points: Vector3[], zoom_scale?: number): void;
+    get_current_tilt(): number;
+    get_current_orientation(): number;
+    get_current_azimuth(): number;
+    __get_zoom_to_show_rect(width: number, height: number, scale?: number): number;
+}

package/types/camera_controller/movement_mode/CameraMovementMode.d.ts

@@ -0,0 +1,6 @@
+export declare class CameraMovementMode {
+    constructor();
+    on_enter(camera_controller: any): void;
+    on_exit(camera_controller: any): void;
+    update(camera_controller: any): void;
+}

package/types/camera_controller/movement_mode/ImmediateMode.d.ts

@@ -0,0 +1,14 @@
+import type { CameraController } from '../CameraController';
+import { CameraMovementMode } from './CameraMovementMode';
+import { Quaternion, Vector2, Vector3 } from 'three';
+export declare class ImmediateMode extends CameraMovementMode {
+    rotation_speed: Vector2;
+    tmp_camera_target_pos: Vector3;
+    tmp_forward: Vector3;
+    tmp_quat: Quaternion;
+    vector_forward_axis: Vector3;
+    constructor();
+    on_enter(camera_controller: CameraController): void;
+    update(camera_controller: CameraController): void;
+    get_target_camera_pos(camera_controller: CameraController): Vector3;
+}

package/types/camera_controller/states/common/AbstractCameraState.d.ts

@@ -0,0 +1,8 @@
+export declare class AbstractCameraState {
+    constructor();
+    on_enter(camera_controller: any): void;
+    on_exit(camera_controller: any): void;
+    update(camera_controller: any): void;
+    lock_zoom(): void;
+    unlock_zoom(): void;
+}

package/types/camera_controller/states/common/CommonCameraState.d.ts

@@ -0,0 +1,24 @@
+import { Vector2 } from 'three';
+import type { Input } from '../../../lib/Input';
+import type { CameraController } from '../../CameraController';
+import { AbstractCameraState } from './AbstractCameraState';
+export declare class CommonCameraState extends AbstractCameraState {
+    azimuth_dir: number;
+    forward_dir: number;
+    last_point: Vector2;
+    right_dir: number;
+    rotation_velocity: Vector2;
+    shift_key: boolean;
+    y_dir: number;
+    input: Input;
+    constructor(input: Input);
+    on_enter(camera_controller: CameraController): void;
+    on_exit(camera_controller: CameraController): void;
+    update(camera_controller: CameraController): void;
+    __show_camera_position(camera_controller: CameraController): void;
+    __zoom_camera(camera_controller: CameraController): void;
+    __rotate_camera(camera_controller: CameraController): void;
+    __move_camera(camera_controller: CameraController): void;
+    __check_key_down(): void;
+    __check_key_up(): void;
+}

package/types/components/mouse_interactors/ObjectRotator.d.ts

@@ -1,7 +1,7 @@
 import { GroupRaycaster } from '../../raycast/GroupRaycaster';
 import { RaycastResolver } from '../../raycast/RaycastResolver';
 import type { Object3D } from 'three';
-import type { Input } from '../Input';
+import type { Input } from '../../lib/Input';
 declare class ObjectRotator extends RaycastResolver {
     group_raycaster: GroupRaycaster;
     input: Input;

package/types/lib/Input.d.ts

@@ -0,0 +1,41 @@
+import type { Vector2 } from "./Vector2";
+export interface Input {
+    keyboard: {
+        is_key_down(key: string): boolean;
+        is_key_pressed(key: string): boolean;
+        is_key_released(key: string): boolean;
+    };
+    init(dom_element: any, sub_region_element: any): void;
+    update(): void;
+    clear(): void;
+    mouse_input_allowed(): boolean;
+    set_mouse_input_active(): void;
+    set_touch_input_active(): void;
+    get left_mouse_button_pressed(): boolean;
+    get left_mouse_button_down(): boolean;
+    get left_mouse_button_released(): boolean;
+    get right_mouse_button_pressed(): boolean;
+    get right_mouse_button_down(): boolean;
+    get right_mouse_button_released(): boolean;
+    get middle_mouse_button_pressed(): boolean;
+    get middle_mouse_button_down(): boolean;
+    get middle_mouse_button_released(): boolean;
+    get is_touchscreen(): boolean;
+    get scroll_delta(): number;
+    get zoom_delta(): number;
+    get pointer_count(): number;
+    get pointer_is_within_bounds(): boolean;
+    pointer_is_over_element(elem: any): boolean;
+    get pointer_pos_delta(): Vector2;
+    get NDC(): Vector2;
+    get NDC_delta(): Vector2;
+    get pointer_center(): Vector2;
+    get pointer_center_delta(): Vector2;
+    get pointer_center_NDC(): Vector2;
+    get pointer_center_NDC_delta(): Vector2;
+    get_pointer_pos(index?: number): Vector2;
+    get_pointer_pos_delta(index?: number): Vector2;
+    get_pointer_NDC(index?: number): Vector2;
+    get_pointer_NDC_delta(index?: number): Vector2;
+    dispose(): void;
+}

package/types/lib/Vector2.d.ts

@@ -0,0 +1,48 @@
+export interface Vector2 {
+    x: number;
+    y: number;
+    set(x: number, y: number): this;
+    clone(): Vector2;
+    copy(v: {
+        x: number;
+        y: number;
+    }): this;
+    add(v: {
+        x: number;
+        y: number;
+    }): this;
+    sub(v: {
+        x: number;
+        y: number;
+    }): this;
+    multiplyScalar(scalar: number): this;
+    divide(v: {
+        x: number;
+        y: number;
+    }): this;
+    divideScalar(scalar: number): this;
+    dot(v: {
+        x: number;
+        y: number;
+    }): number;
+    cross(v: {
+        x: number;
+        y: number;
+    }): number;
+    lengthSq(): number;
+    length(): number;
+    normalize(): this;
+    angle(): number;
+    distanceTo(v: {
+        x: number;
+        y: number;
+    }): number;
+    distanceToSquared(v: {
+        x: number;
+        y: number;
+    }): number;
+    lerp(v: {
+        x: number;
+        y: number;
+    }, alpha: number): this;
+}

package/types/raycast/GroupRaycaster.d.ts

@@ -1,4 +1,4 @@
-import type { Input } from '../components/Input';
+import type { Input } from '../lib/Input';
 import { RaycastResolver } from './RaycastResolver';
 import { IdleState } from './states/IdleState';
 import type { Camera, Intersection, Object3D } from 'three';

package/types/raycast/PlaneDragResolver.d.ts

@@ -1,5 +1,5 @@
 import type { Vector3 } from 'three';
-import type { Input } from '../components/Input';
+import type { Input } from '../lib/Input';
 import { PlaneRaycaster } from './PlaneRaycaster';
 import { PlaneRaycastResolver } from './PlaneRaycastResolver';
 declare class PlaneDragResolver extends PlaneRaycastResolver {

package/types/raycast/SurfaceDragResolver.d.ts

@@ -1,5 +1,5 @@
 import type { Mesh, Vector3 } from 'three';
-import type { Input } from '../components/Input';
+import type { Input } from '../lib/Input';
 import { GroupRaycaster } from './GroupRaycaster';
 import { RaycastResolver } from './RaycastResolver';
 declare class SurfaceDragResolver extends RaycastResolver {