ohzi-core 13.0.2 → 13.0.4

package/src/camera_controller/movement_mode/ImmediateMode.ts

@@ -0,0 +1,60 @@
+import { OMath } from '../../utilities/OMath';
+import type { CameraController } from '../CameraController';
+import { CameraMovementMode } from './CameraMovementMode';
+
+import { Quaternion, Vector2, Vector3 } from 'three';
+
+export class ImmediateMode extends CameraMovementMode
+{
+  rotation_speed: Vector2;
+  tmp_camera_target_pos: Vector3;
+  tmp_forward: Vector3;
+  tmp_quat: Quaternion;
+  vector_forward_axis: Vector3;
+
+  constructor()
+  {
+    super();
+    this.rotation_speed = new Vector2();
+
+    this.vector_forward_axis = new Vector3(0, 0, -1);
+    this.tmp_forward = new Vector3();
+
+    this.tmp_quat = new Quaternion();
+    this.tmp_camera_target_pos = new Vector3();
+  }
+
+  on_enter(camera_controller: CameraController)
+  {
+    camera_controller.reference_rotation.copy(camera_controller.camera.quaternion);
+  }
+
+  update(camera_controller: CameraController)
+  {
+    camera_controller.camera.quaternion.copy(camera_controller.reference_rotation);
+
+    this.tmp_forward.copy(this.vector_forward_axis);
+    const dir = this.tmp_forward.applyQuaternion(camera_controller.camera.quaternion);
+
+    camera_controller.reference_zoom = OMath.clamp(camera_controller.reference_zoom,
+      camera_controller.min_zoom, camera_controller.max_zoom);
+
+    camera_controller.camera.position.copy(camera_controller.reference_position).sub(dir.multiplyScalar(camera_controller.reference_zoom));
+
+    camera_controller.__last_reference_position.copy(camera_controller.reference_position);
+  }
+
+  get_target_camera_pos(camera_controller: CameraController)
+  {
+    this.tmp_quat.copy(camera_controller.reference_rotation);
+    this.tmp_forward.copy(this.vector_forward_axis);
+
+    const dir = this.tmp_forward.applyQuaternion(this.tmp_quat);
+
+    const zoom = OMath.clamp(camera_controller.reference_zoom,
+      camera_controller.min_zoom, camera_controller.max_zoom);
+
+    this.tmp_camera_target_pos.copy(camera_controller.reference_position).sub(dir.multiplyScalar(zoom));
+    return this.tmp_camera_target_pos;
+  }
+}

package/src/camera_controller/states/common/AbstractCameraState.ts

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

package/src/camera_controller/states/common/CommonCameraState.ts

@@ -0,0 +1,207 @@
+import { Vector2 } from 'three';
+
+import type { Input } from '../../../lib/Input';
+import type { PerspectiveCamera } from '../../../PerspectiveCamera';
+import { Time } from '../../../Time';
+import { CameraUtilities } from '../../../utilities/CameraUtilities';
+import type { CameraController } from '../../CameraController';
+import { AbstractCameraState } from './AbstractCameraState';
+
+export 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)
+  {
+    super();
+
+    this.input = input;
+
+    // this.vector_down_axis = new Vector3(0, -1, 0);
+    // this.vector_up_axis   = new Vector3(0, 1, 0);
+    // this.vector_back_axis = new Vector3(0, 0, -1);
+    // this.vector_left_axis = new Vector3(-1, 0, 0);
+
+    this.last_point = new Vector2();
+
+    this.rotation_velocity = new Vector2();
+
+    this.forward_dir = 0;
+    this.right_dir = 0;
+    this.y_dir = 0;
+    this.azimuth_dir = 0;
+
+    this.shift_key = false;
+  }
+
+  on_enter(camera_controller: CameraController)
+  {
+  }
+
+  on_exit(camera_controller: CameraController)
+  {
+  }
+
+  update(camera_controller: CameraController)
+  {
+    this.__check_key_down();
+    this.__check_key_up();
+
+    // this.__move_camera(camera_controller);
+    // this.__zoom_camera(camera_controller);
+    // this.__rotate_camera(camera_controller);
+  }
+
+  __show_camera_position(camera_controller: CameraController)
+  {
+    if (this.input.left_mouse_button_released)
+    {
+      console.log({
+        x: camera_controller.reference_position.x,
+        y: camera_controller.reference_position.y,
+        z: camera_controller.reference_position.z,
+        orientation: camera_controller.current_orientation,
+        tilt: camera_controller.current_tilt,
+        azimuth: camera_controller.current_azimuth,
+        zoom: camera_controller.reference_zoom,
+        fov: (camera_controller.camera as PerspectiveCamera).fov
+      });
+    }
+  }
+
+  __zoom_camera(camera_controller: CameraController)
+  {
+    camera_controller.reference_zoom += this.input.zoom_delta * 0.5;
+  }
+
+  __rotate_camera(camera_controller: CameraController)
+  {
+    if (this.input.left_mouse_button_down && this.input.pointer_count === 1)
+    {
+      const delta = new Vector2(this.input.NDC_delta.x * -24, this.input.NDC_delta.y * -8);
+      delta.multiplyScalar(Time.delta_time * 60);
+
+      this.rotation_velocity.add(delta);
+    }
+
+    camera_controller.set_rotation_delta(this.rotation_velocity.y, this.rotation_velocity.x);
+    // camera_controller.set_rotation_delta(0, 0, this.azimuth_dir);
+
+    const blend = 1 - Math.exp(-5 * Time.delta_time);
+    this.rotation_velocity.lerp(new Vector2(0, 0), blend);
+  }
+
+  __move_camera(camera_controller: CameraController)
+  {
+    camera_controller.translate_forward(this.forward_dir);
+    camera_controller.translate_right(this.right_dir);
+
+    camera_controller.reference_position.y -= this.y_dir;
+
+    if (this.input.right_mouse_button_pressed)
+    {
+      this.last_point.copy(this.input.NDC);
+    }
+
+    if (this.input.right_mouse_button_down) // || (this.input.left_mouse_button_down && this.shift_key)
+    {
+      const prev_point    = CameraUtilities.get_plane_intersection(camera_controller.reference_position, undefined, this.last_point).clone();
+      const current_point = CameraUtilities.get_plane_intersection(camera_controller.reference_position, undefined, this.input.NDC).clone();
+      current_point.sub(prev_point);
+
+      camera_controller.reference_position.x -= current_point.x;
+      camera_controller.reference_position.y -= current_point.y;
+      camera_controller.reference_position.z -= current_point.z;
+      this.last_point.copy(this.input.NDC);
+    }
+  }
+
+  __check_key_down()
+  {
+    const speed = 0.12;
+
+    if (this.input.keyboard.is_key_down('KeyW'))
+    {
+      this.forward_dir = -speed;
+    }
+    if (this.input.keyboard.is_key_down('KeyS'))
+    {
+      this.forward_dir = speed;
+    }
+    if (this.input.keyboard.is_key_down('KeyA'))
+    {
+      this.right_dir = -speed;
+    }
+    if (this.input.keyboard.is_key_down('KeyD'))
+    {
+      this.right_dir = speed;
+    }
+    if (this.input.keyboard.is_key_down('KeyQ'))
+    {
+      this.azimuth_dir = speed * 4;
+    }
+    if (this.input.keyboard.is_key_down('KeyE'))
+    {
+      this.azimuth_dir = -speed * 4;
+    }
+    if (this.input.keyboard.is_key_down('KeyZ'))
+    {
+      this.y_dir = speed;
+    }
+    if (this.input.keyboard.is_key_down('KeyC'))
+    {
+      this.y_dir = -speed;
+    }
+    if (this.input.keyboard.is_key_down('ShiftLeft'))
+    {
+      this.shift_key = true;
+    }
+  }
+
+  __check_key_up()
+  {
+    if (this.input.keyboard.is_key_released('KeyW'))
+    {
+      this.forward_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyS'))
+    {
+      this.forward_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyA'))
+    {
+      this.right_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyD'))
+    {
+      this.right_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyQ'))
+    {
+      this.azimuth_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyE'))
+    {
+      this.azimuth_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyZ'))
+    {
+      this.y_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('KeyC'))
+    {
+      this.y_dir = 0;
+    }
+    if (this.input.keyboard.is_key_released('ShiftLeft'))
+    {
+      this.shift_key = false;
+    }
+  }
+}

package/src/components/mouse_interactors/ObjectRotator.ts

@@ -3,7 +3,7 @@ import { RaycastResolver } from '../../raycast/RaycastResolver';
 
 import type { Object3D } from 'three';
 import { Quaternion, Vector3 } from 'three';
-import type { Input } from '../Input';
+import type { Input } from '../../lib/Input';
 
 class ObjectRotator extends RaycastResolver
 {

package/src/index.ts

@@ -118,10 +118,16 @@ import { ResourceContainer } from './ResourceContainer';
 import { Compilator } from './scenes/Compilator';
 import { TransitionManager } from './view_components/TransitionManager';
 
+import { CameraController } from './camera_controller/CameraController';
+import { CameraMovementMode } from './camera_controller/movement_mode/CameraMovementMode';
+import { ImmediateMode } from './camera_controller/movement_mode/ImmediateMode';
+import { AbstractCameraState } from './camera_controller/states/common/AbstractCameraState';
+import { CommonCameraState } from './camera_controller/states/common/CommonCameraState';
+
 export {
-    AbstractLoader, AbstractScene, ActionEvent, ActionInterpolator, ActionSequencer, ActionSequencerBuilder, AddMaterial, ApplicationView, ArrayUtilities, Arrow, AsyncAbstractLoader, AsyncAudiosLoader, AsyncObjectsLoader, AsyncTextureLoader, AsyncTexturesLoader, AudioLoader, BaseApplication, BaseRender, BaseShaderMaterial, BasisLoader, BlitMaterial, Blurrer, Browser, BufferGeometryUtils, CameraManager, CameraUtilities, CanvasDrawer, Capabilities, Compilator, CSSAnimator, Cube, CubemapLoader, DAELoader, Debug, DebugNormalsRender, DrawIOAnimationSheet, DualFilteringBlurMaterial, DualFilteringBlurrer, EasingFunctions, FileLoader,
+    AbstractCameraState, AbstractLoader, AbstractScene, ActionEvent, ActionInterpolator, ActionSequencer, ActionSequencerBuilder, AddMaterial, ApplicationView, ArrayUtilities, Arrow, AsyncAbstractLoader, AsyncAudiosLoader, AsyncObjectsLoader, AsyncTextureLoader, AsyncTexturesLoader, AudioLoader, BaseApplication, BaseRender, BaseShaderMaterial, BasisLoader, BlitMaterial, Blurrer, Browser, BufferGeometryUtils, CameraController, CameraManager, CameraMovementMode, CameraUtilities, CanvasDrawer, Capabilities, CommonCameraState, Compilator, CSSAnimator, Cube, CubemapLoader, DAELoader, Debug, DebugNormalsRender, DrawIOAnimationSheet, DualFilteringBlurMaterial, DualFilteringBlurrer, EasingFunctions, FileLoader,
     FontLoader, FrustumPointFitter, GaussianBlurrer, GeometryUtilities, GLTFDRACOLoader, GLTFLoader, GPUParticleSystem, Graphics, Grid, HDRCubeTextureLoader, HDRTextureLoader, HighQualityLoadingState, HorizontalPlane, HTMLUtilities,
-    ImageUtilities, Initializer, JSONLoader, KeyboardInput, Line, LoadingState, MedianFilter, MeshSampler,
+    ImageUtilities, ImmediateMode, Initializer, JSONLoader, KeyboardInput, Line, LoadingState, MedianFilter, MeshSampler,
     ModelUtilities, NormalAORender,
     NormalRender, NumberInterpolator, ObjectUtilities, OBJLoader, OMath, OrthographicCamera, OrthographicFrustumPointFitter, OS, OScreen, ParticleAttribute,
     ParticlePositionAttribute, PerspectiveCamera, PerspectiveFrustumPointFitter, PointArrayLoader, RegularLoadingState, RenderLoop, ResourceBatch,

package/src/{components → lib}/Input.ts

@@ -1,28 +1,16 @@
 // This interface declare the Input component found in PIT.js
 
-import type { Vector2 } from "three";
+import type { Vector2 } from "./Vector2";
 
 export interface Input {
-    active_input_module: any;
-    dom_element: any;
-    mouse_input_module: any;
-    region: any;
-    sub_region_element: any;
-    touch_cooldown: any;
-    touch_input_module: any;
+    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;
-    bind_events(): void;
-    unbind_events(): void;
-    on_wheel(event: any): void;
-    on_touchstart(event: any): void;
-    on_touchmove(event: any): void;
-    on_touchcancel(event: any): void;
-    on_touchend(event: any): void;
-    on_mousedown(event: any): void;
-    on_mousemove(event: any): void;
-    on_mouseup(event: any): void;
-    on_mouseleave(event: any): void;
+    update(): void;
     clear(): void;
     mouse_input_allowed(): boolean;
     set_mouse_input_active(): void;
@@ -45,8 +33,6 @@ export interface Input {
 
     pointer_is_over_element(elem: any): boolean;
 
-    get pointers(): Vector2[];
-    get pointer_pos(): Vector2;
     get pointer_pos_delta(): Vector2;
     get NDC(): Vector2;
     get NDC_delta(): Vector2;
@@ -59,5 +45,6 @@ export interface Input {
     get_pointer_pos_delta(index?: number): Vector2;
     get_pointer_NDC(index?: number): Vector2;
     get_pointer_NDC_delta(index?: number): Vector2;
+
     dispose(): void;
 }

package/src/lib/Vector2.ts

@@ -0,0 +1,49 @@
+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/src/raycast/GroupRaycaster.ts

@@ -1,5 +1,5 @@
 import { CameraManager } from '../CameraManager';
-import type { Input } from '../components/Input';
+import type { Input } from '../lib/Input';
 import { RaycastResolver } from './RaycastResolver';
 import { IdleState } from './states/IdleState';
 

package/src/raycast/PlaneDragResolver.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';
 

package/src/raycast/SurfaceDragResolver.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';
 

package/src/resource_loader/ResourceBatch.ts

@@ -17,7 +17,7 @@ class ResourceBatch
     this.resource_loaders.push(loader);
   }
 
-  load(resource_container: ResourceContainer)
+  load(resource_container?: ResourceContainer)
   {
     for (let i = 0; i < this.resource_loaders.length; i++)
     {

package/src/scenes/AbstractScene.ts

@@ -1,20 +1,26 @@
+import type { Object3D } from 'three';
 import { Mesh, Scene } from 'three';
 // import { AvatarSystem } from '../../components/avatar/AvatarSystem';
 
+import type { CameraController } from '../camera_controller/CameraController';
+import { CameraManager } from '../CameraManager';
 import { Graphics } from '../Graphics';
-import { CameraManager } from '../index';
 import { HighQualityLoadingState } from './loading_states/HighQualityLoadingState';
 import { LoadingState } from './loading_states/LoadingState';
 import { RegularLoadingState } from './loading_states/RegularLoadingState';
 
 class AbstractScene extends Scene
 {
-  current_loading_state: any;
+  current_loading_state: LoadingState;
   initialized: boolean;
   is_high_loaded: boolean;
   is_loaded: boolean;
-  loading_states: any;
+  loading_states: {
+    high: HighQualityLoadingState;
+    regular: RegularLoadingState;
+  };
   name: string;
+  camera_controller: CameraController;
   
   constructor({
     name,
@@ -61,7 +67,7 @@ class AbstractScene extends Scene
 
   get_objects()
   {
-    const objects: any = [];
+    const objects: Object3D[] = [];
 
     this.traverse(child =>
     {
@@ -133,17 +139,17 @@ class AbstractScene extends Scene
     this.initialized = false;
   }
 
-  set_assets(scene_objects: any, scene_textures: any, scene_sounds: any, custom_loaders: any, custom_compilators: any, custom_data: any)
+  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: Compilator[], custom_data?: any[])
   {
     this.loading_states.regular.set_assets(scene_objects, scene_textures, scene_sounds, custom_loaders, custom_compilators, custom_data);
   }
 
-  set_high_assets(scene_objects: any, scene_textures: any, scene_sounds: any, custom_loaders: any, custom_compilators: any, custom_data: any)
+  set_high_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: Compilator[], custom_data?: any[])
   {
     this.loading_states.high.set_assets(scene_objects, scene_textures, scene_sounds, custom_loaders, custom_compilators, custom_data);
   }
 
-  set_loading_state(state: any)
+  set_loading_state(state: LoadingState)
   {
     this.current_loading_state.on_exit();
     this.current_loading_state = state;

package/src/scenes/loading_states/LoadingState.ts

@@ -1,4 +1,4 @@
-import type { AbstractLoader } from '../../../types/index';
+import type { AsyncAbstractLoader } from '../../loaders/AsyncAbstractLoader';
 import { AsyncAudiosLoader } from '../../loaders/AsyncAudiosLoader';
 import { AsyncObjectsLoader } from '../../loaders/AsyncObjectsLoader';
 import { AsyncTexturesLoader } from '../../loaders/AsyncTexturesLoader';
@@ -14,21 +14,21 @@ export class LoadingState
   TexturesCompilator: Compilator;
   callback_called: boolean;
   compilator_manager: CompilatorManager;
-  compilators: Array<Compilator>;
-  custom_compilators: Array<Compilator>;
-  custom_data: any;
-  custom_loaders: any;
-  loaders: Array<AbstractLoader>;
+  compilators: Compilator[];
+  custom_compilators: Compilator[];
+  custom_data: any[];
+  custom_loaders: any[];
+  loaders: AsyncAbstractLoader[];
   scene: AbstractScene;
-  scene_objects: any;
-  scene_sounds: any;
-  scene_textures: any;
+  scene_objects: any[];
+  scene_sounds: any[];
+  scene_textures: any[];
   
   constructor(scene: AbstractScene, {
     SceneCompilator,
     TexturesCompilator,
     AudiosCompilator
-  }: any)
+  }: { SceneCompilator: Compilator, TexturesCompilator: Compilator, AudiosCompilator: Compilator })
   {
     this.scene = scene;
 
@@ -42,7 +42,7 @@ export class LoadingState
     this.callback_called = false;
   }
 
-  set_assets(scene_objects: any, scene_textures: any, scene_sounds: any, custom_loaders: any[] = [], custom_compilators: any[] = [], custom_data: any[] = [])
+  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders: any[] = [], custom_compilators: Compilator[] = [], custom_data: any[] = [])
   {
     this.scene_objects = scene_objects;
     this.scene_textures = scene_textures;

package/src/utilities/CameraUtilities.ts

@@ -4,8 +4,9 @@ import { OMath } from '../utilities/OMath';
 
 import type { Camera, Object3D } from 'three';
 import { Box3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three';
-import type { Vector2 } from '../../../pit/types/Vector2';
-import type { Input } from '../components/Input';
+
+import type { Input } from '../lib/Input';
+import type { Vector2 } from '../lib/Vector2';
 import type { PerspectiveCamera } from '../PerspectiveCamera';
 import { OrthographicFrustumPointFitter } from './OrthographicFrustumPointFitter';
 import { PerspectiveFrustumPointFitter } from './PerspectiveFrustumPointFitter';
@@ -90,9 +91,9 @@ class CameraUtilities
     const tmp_vec = new Vector3();
 
     this.plane.setFromNormalAndCoplanarPoint(plane_normal || this.get_forward_dir(camera), plane_position);
-    if (camera.isPerspectiveCamera)
+    if ((camera as PerspectiveCamera).isPerspectiveCamera)
     {
-      this.ray.set(camera.position, this.unproject_mouse_position(NDC, camera));
+      this.ray.set(camera.position, this.unproject_mouse_position(NDC, camera as PerspectiveCamera));
     }
     else
     {

package/src/utilities/ModelUtilities.ts

@@ -1,5 +1,5 @@
 import { Mesh, Skeleton } from 'three';
-import type { AbstractScene } from '../index';
+import type { AbstractScene } from '../scenes/AbstractScene';
 
 class ModelUtilities
 {

package/src/view_components/ViewComponent.ts

@@ -30,7 +30,7 @@ export class ViewComponent
     this.hidden = false;
   }
 
-  update()
+  update(current_state_data: any)
   {
   }
 

package/src/view_components/ViewComponentManager.ts

@@ -1,4 +1,4 @@
-import type { ViewComponent } from '../index';
+import type { ViewComponent } from '../view_components/ViewComponent';
 import { TransitionManager } from './TransitionManager';
 
 class ViewComponentManager

package/src/view_components/ViewManager.ts

@@ -80,7 +80,7 @@ class ViewManager
     this.get(view_name);
   }
 
-  get(view_name: string)
+  get(view_name: string): ApplicationView | undefined
   {
     for (let i = 0; i < this.views.length; i++)
     {

package/src/view_components/transition/ViewStateTransitionHandler.ts

@@ -7,8 +7,8 @@ class ViewStateTransitionHandler
 {
   action_sequencer: ActionSequencer;
   current_state: ViewState;
-  current_state_data: object;
-  default_state_data: object;
+  current_state_data: { [key: string]: any };
+  default_state_data: { [key: string]: any };
   last_state: ViewState;
   transition_table: TransitionTable;
   transitioning: boolean;