ohzi-core 5.13.2 → 5.14.2

package/src/ui/ui_element_state/OnMouseEnter.js

@@ -0,0 +1,26 @@
+import UIElementState from './UIElementState';
+
+export default class OnMouseEnter extends UIElementState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(ui_element)
+  {
+    ui_element.on_mouse_enter();
+  }
+
+  update(ui_element, normalized_mouse_position)
+  {
+    if (ui_element.is_mouse_over(normalized_mouse_position))
+    {
+      ui_element.set_state(ui_element._on_hover_state);
+    }
+    else
+    {
+      ui_element.set_state(ui_element._on_exit_state);
+    }
+  }
+}

package/src/ui/ui_element_state/OnMouseExit.js

@@ -0,0 +1,15 @@
+import UIElementState from './UIElementState';
+
+export default class OnMouseExit extends UIElementState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(ui_element)
+  {
+    ui_element.on_mouse_exit();
+    ui_element.set_state(ui_element._on_idle_state);
+  }
+}

package/src/ui/ui_element_state/OnMouseHover.js

@@ -0,0 +1,31 @@
+import UIElementState from './UIElementState';
+
+export default class OnMouseHover extends UIElementState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(ui_element)
+  {
+    this.__trigger_on_hover(ui_element);
+  }
+
+  update(ui_element, normalized_mouse_position)
+  {
+    if (ui_element.is_mouse_over(normalized_mouse_position))
+    {
+      this.__trigger_on_hover(ui_element);
+    }
+    else
+    {
+      ui_element.set_state(ui_element._on_exit_state);
+    }
+  }
+
+  __trigger_on_hover(ui_element)
+  {
+    ui_element.on_mouse_hover();
+  }
+}

package/src/ui/ui_element_state/UIElementState.js

@@ -0,0 +1,18 @@
+export default class UIElementState
+{
+  constructor()
+  {
+
+  }
+
+  update(ui_element, normalized_mouse_position)
+  {
+
+  }
+
+  on_enter(ui_element)
+  {}
+
+  on_exit(ui_element)
+  {}
+}

package/src/utilities/ArrayUtilities.js

@@ -0,0 +1,55 @@
+export default class ArrayUtilities
+{
+  constructor()
+  {}
+
+  static merge_from_to(source, target)
+  {
+    target.push.apply(target, source);
+  }
+
+  static expand_vec3_array(array, size)
+  {
+    let items_left_count = size - array.length;
+
+    for (let i = 0; i < items_left_count; i++)
+    {
+      array.push(array[i].clone());
+    }
+  }
+
+  static remove_elem(array, elem)
+  {
+    let index = array.indexOf(elem);
+    if (index > -1)
+    {
+      array.splice(index, 1);
+    }
+  }
+
+  static get_closest_point(points, target)
+  {
+    let closest_point = points[0];
+    let closest_distance = closest_point.distanceTo(target);
+    for (let i = 1; i < points.length; i++)
+    {
+      if (points[i].distanceTo(target) < closest_distance)
+      {
+        closest_point = points[i];
+        closest_distance = points[i].distanceTo(target);
+      }
+    }
+    return closest_point;
+  }
+
+  static object_values_to_array(obj)
+  {
+    let ids = Object.keys(obj);
+    let arr = [];
+    for (let i = 0; i < ids.length; i++)
+    {
+      arr.push(obj[ids[i]]);
+    }
+    return arr;
+  }
+}

package/src/utilities/CameraUtilities.js

@@ -0,0 +1,197 @@
+import CameraManager from '../CameraManager';
+import Input from '../Input';
+import MathUtilities from '../utilities/MathUtilities';
+import Screen from '../Screen';
+
+import { Vector3 } from 'three';
+import { Matrix4 } from 'three';
+import { Plane } from 'three';
+import { Ray } from 'three';
+import { Sphere } from 'three';
+import { Box3 } from 'three';
+
+class CameraUtilities
+{
+  init()
+  {
+    this.tmp_mat = new Matrix4();
+    this.tmp_vec = new Vector3(0, 0, 1);
+    this.tmp_vec2 = new Vector3(0, 0, 0);
+    this.plane = new Plane();
+    this.ray = new Ray();
+
+    this.tmp_size = new Vector3();
+    this.tmp_unproj = new Vector3();
+  }
+
+  get_up_dir(camera)
+  {
+    camera = camera || CameraManager.current;
+    this.tmp_vec.set(0, 1, 0);
+    this.tmp_vec.applyQuaternion(camera.quaternion);
+
+    return this.tmp_vec;
+  }
+
+  get_forward_dir(camera)
+  {
+    camera = camera || CameraManager.current;
+    this.tmp_vec.set(0, 0, -1);
+    this.tmp_vec.applyQuaternion(camera.quaternion);
+
+    return this.tmp_vec;
+  }
+
+  get_right_dir(camera)
+  {
+    camera = camera || CameraManager.current;
+    this.tmp_vec.set(1, 0, 0);
+    this.tmp_vec.applyQuaternion(camera.quaternion);
+    return this.tmp_vec;
+  }
+
+  unproject_mouse_position(NDC, camera)
+  {
+    camera = camera || CameraManager.current;
+    let v_fov = (camera.fov / 2) * Math.PI / 180;
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * camera.aspect)) / 2;
+
+    let distV = Math.tan(v_fov) * camera.far;
+    let distH = Math.tan(h_fov) * camera.far;
+
+    this.tmp_vec.set(distH * NDC.x, distV * NDC.y, -camera.far).normalize();
+
+    return this.tmp_vec.applyQuaternion(camera.quaternion);
+  }
+
+  get_plane_intersection(plane_position, plane_normal, NDC, camera)
+  {
+    camera = camera || CameraManager.current;
+    NDC = NDC || Input.NDC;
+
+    this.plane.setFromNormalAndCoplanarPoint(plane_normal || this.get_forward_dir(camera), plane_position);
+    if (camera.isPerspectiveCamera)
+    {
+      this.ray.set(camera.position, this.unproject_mouse_position(NDC, camera));
+    }
+    else
+    {
+      this.tmp_unproj.set(NDC.x, NDC.y, 1).unproject(camera);
+      this.ray.set(camera.position, this.tmp_unproj);
+    }
+
+    this.ray.intersectPlane(this.plane, this.tmp_vec2);
+    return this.tmp_vec2;
+  }
+
+  fit_points_on_camera(points, zoom_scale = 1)
+  {
+    let points_sphere = new Sphere().setFromPoints(points);
+    let world_space_center = points_sphere.center;
+    let camera_forward = this.get_forward_dir(CameraManager.current).clone();
+
+    let plane = new Plane().setFromNormalAndCoplanarPoint(camera_forward, world_space_center);
+
+    let points_on_plane = MathUtilities.project_points_on_plane(points, plane);
+
+    let projected_points_center = new Vector3();
+    let box =  new Box3().setFromPoints(points_on_plane);
+    box.getCenter(projected_points_center);
+
+    let up = new Vector3(0, 1, 0).applyQuaternion(CameraManager.current.quaternion);
+    let right = up.clone().cross(camera_forward).normalize();
+    let mat = new Matrix4().set(right.x, up.x, camera_forward.x, world_space_center.x,
+      right.y, up.y, camera_forward.y, world_space_center.y,
+      right.z, up.z, camera_forward.z, world_space_center.z,
+      0,    0,                0,        1);
+
+    let inverse_mat = new Matrix4().getInverse(mat);
+    for (let i = 0; i < points_on_plane.length; i++)
+    {
+      points_on_plane[i].applyMatrix4(inverse_mat);
+    }
+
+    let size = new Vector3();
+    box =  new Box3().setFromPoints(points_on_plane);
+    box.getSize(size);
+    size.multiplyScalar(zoom_scale);
+    let projected_center = new Vector3();
+    box.getCenter(projected_center);
+
+    return {
+      position: projected_points_center,
+      zoom: this.get_zoom_to_fit_rect(size.x / 2, size.y / 2)
+    };
+  }
+
+  get_zoom_to_fit_rect(width, height)
+  {
+    let v_fov = (CameraManager.current.fov / 2) * Math.PI / 180;
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * CameraManager.current.aspect)) / 2;
+
+    let distV = height / Math.tan(v_fov);
+    let distH = width / Math.tan(h_fov);
+
+    return Math.max(Math.abs(distH), Math.abs(distV));
+  }
+
+  get_zoom_to_fit_box(bb, camera)
+  {
+    if (camera.isOrthographicCamera)
+    {
+      bb.getSize(this.tmp_size);
+
+      let obj_x = this.tmp_size.x;
+      let obj_y = this.tmp_size.y;
+      let object_aspect = obj_x / obj_y;
+      if (Screen.aspect_ratio / object_aspect > 1)
+      {
+        return Screen.height / obj_y;
+      }
+      else
+      {
+        return Screen.width / obj_x;
+      }
+    }
+    else
+    {
+      // return this.fit_points_on_camera([bb.min, bb.max], 1).zoom;
+      let size = new Vector3();
+      bb.getSize(size);
+      return this.get_zoom_to_fit_rect(size.x, size.y);
+    }
+  }
+
+  get_html_screen_pos(object, camera)
+  {
+    object.getWorldPosition(this.tmp_vec);
+    this.tmp_vec.project(camera);
+
+    this.tmp_vec.x = (this.tmp_vec.x * 0.5 + 0.5) * (Screen.width);
+    this.tmp_vec.y = (1 - (this.tmp_vec.y * 0.5 + 0.5)) * Screen.height;
+    return this.tmp_vec;
+  }
+
+  world_pos_to_screen(pos, camera)
+  {
+    camera = camera || CameraManager.current;
+    this.tmp_vec.copy(pos);
+    this.tmp_vec.project(camera);
+
+    this.tmp_vec.x = (this.tmp_vec.x * 0.5 + 0.5) * (Screen.width);
+    this.tmp_vec.y = (1 - (this.tmp_vec.y * 0.5 + 0.5)) * Screen.height;
+    return this.tmp_vec;
+  }
+
+  update_projection(camera)
+  {
+    camera.left   = -Screen.width / 2;
+    camera.right  = Screen.width / 2;
+    camera.top    = Screen.height / 2;
+    camera.bottom = -Screen.height / 2;
+    camera.aspect = Screen.aspect_ratio;
+    camera.updateProjectionMatrix(true);
+  }
+}
+
+export default new CameraUtilities();

package/src/utilities/EasingFunctions.js

@@ -0,0 +1,215 @@
+class EasingFunctions
+{
+  constructor()
+  { }
+
+  linear(x)
+  {
+    return x;
+  }
+
+  triangular(x)
+  {
+    return 1 - Math.abs((x * 2) % (1 * 2) - 1);
+  }
+
+  ease_in_sine(x)
+  {
+    return 1 - Math.cos(x * 3.1415926 / 2);
+  }
+
+  ease_out_sine(x)
+  {
+    return Math.sin(x * 3.1415926 / 2);
+  }
+
+  ease_in_out_sine(x)
+  {
+    return -(Math.cos(3.1415926 * x) - 1) / 2;
+  }
+
+  ease_in_cubic(x)
+  {
+    return x * x * x;
+  }
+
+  ease_out_cubic(x)
+  {
+    return 1 - Math.pow(1 - x, 3);
+  }
+
+  ease_in_out_cubic(x)
+  {
+    return x < 0.5
+      ? 4 * x * x * x
+      : 1 - Math.pow(-2 * x + 2, 3) / 2;
+  }
+
+  ease_in_quad(x)
+  {
+    return x * x;
+  }
+
+  ease_out_quad(x)
+  {
+    return 1 - (1 - x) * (1 - x);
+  }
+
+  ease_in_out_quad(x)
+  {
+    return x < 0.5
+      ? 2 * x * x
+      : 1 - Math.pow(-2 * x + 2, 2) / 2;
+  }
+
+  ease_in_quart(x)
+  {
+    return x * x * x * x;
+  }
+
+  ease_out_quart(x)
+  {
+    return 1 - Math.pow(1 - x, 4);
+  }
+
+  ease_in_out_quart(x)
+  {
+    return x < 0.5
+      ? 8 * x * x * x * x
+      : 1 - Math.pow(-2 * x + 2, 4) / 2;
+  }
+
+  ease_in_quint(x)
+  {
+    return x * x * x * x * x;
+  }
+
+  ease_out_quint(x)
+  {
+    return 1 - Math.pow(1 - x, 5);
+  }
+
+  ease_in_out_quint(x)
+  {
+    return x < 0.5
+      ? 16 * x * x * x * x * x
+      : 1 - Math.pow(-2 * x + 2, 5) / 2;
+  }
+
+  ease_in_expo(x)
+  {
+    return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
+  }
+
+  ease_out_expo(x)
+  {
+    return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);
+  }
+
+  ease_in_out_expo(x)
+  {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5
+      ? Math.pow(2, 20 * x - 10) / 2
+      : (2 - Math.pow(2, -20 * x + 10)) / 2;
+  }
+
+  ease_in_circ(x)
+  {
+    return 1 - Math.sqrt(1 - Math.pow(x, 2));
+  }
+
+  ease_out_circ(x)
+  {
+    return Math.sqrt(1 - Math.pow(x - 1, 2));
+  }
+
+  ease_in_out_circ(x)
+  {
+    return x < 0.5
+      ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2
+      : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
+  }
+
+  ease_in_back(x)
+  {
+    return 2.7015 * x * x * x - 1.7015 * x * x;
+  }
+
+  ease_out_back(x)
+  {
+    return 1 + 2.7015 * Math.pow(x - 1, 3) + 1.7015 * Math.pow(x - 1, 2);
+  }
+
+  ease_in_out_back(x)
+  {
+    return x < 0.5
+      ? (Math.pow(2 * x, 2) * ((2.5949095 + 1) * 2 * x - 2.5949095)) / 2
+      : (Math.pow(2 * x - 2, 2) * ((2.5949095 + 1) * (x * 2 - 2) + 2.5949095) + 2) / 2;
+  }
+
+  ease_in_elastic(x)
+  {
+    const c4 = (2 * Math.PI) / 3;
+
+    return x === 0
+      ? 0
+      : x === 1
+        ? 1
+        : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);
+  }
+
+  ease_out_elastic(x)
+  {
+    return x === 0 ? 0 : x === 1 ? 1
+      : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * 2.0943950) + 1;
+  }
+
+  ease_in_out_elastic(x)
+  {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5
+      ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * 1.3962633)) / 2
+      : Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * 1.3962633) / 2 + 1;
+  }
+
+  ease_in_bounce(x)
+  {
+    return 1 - this.ease_out_bounce(1 - x);
+  }
+
+  ease_out_bounce(x)
+  {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+
+    if (x < 1 / d1)
+    {
+      return n1 * x * x;
+    }
+    else if (x < 2 / d1)
+    {
+      return n1 * (x -= 1.5 / d1) * x + 0.75;
+    }
+    else if (x < 2.5 / d1)
+    {
+      return n1 * (x -= 2.25 / d1) * x + 0.9375;
+    }
+    else
+    {
+      return n1 * (x -= 2.625 / d1) * x + 0.984375;
+    }
+  }
+
+  ease_in_out_bounce(x)
+  {
+    return x < 0.5
+      ? (1 - this.ease_out_bounce(1 - 2 * x)) / 2
+      : (1 + this.ease_out_bounce(2 * x - 1)) / 2;
+  }
+
+  heartbeat(t)
+  {
+    return 1.0 - Math.pow(Math.abs(Math.sin(t + 1.0)), 63.0) * Math.sign(Math.sin(t)) * Math.sin(t + 1.5 + 1.0) * 0.8;
+  }
+}
+
+export default new EasingFunctions();