ohzi-core 5.13.2 → 5.14.2

package/src/object_pool/Pool.js

@@ -0,0 +1,73 @@
+export default class Pool
+{
+  constructor()
+  {
+    this.available = [];
+    this.busy = [];
+  }
+
+  preload(starting_pool_size)
+  {
+    for (let i = 0; i < starting_pool_size; i++)
+    {
+      this.instantiate();
+    }
+  }
+
+  instantiate()
+  {
+    let obj = this.__create();
+    if (obj === undefined)
+    {
+      console.error('Class ' + this.constructor.name + ' does not implement __create() method correctly. It should return a new instance of the pooled object', obj);
+    }
+    if (obj.warm_up === undefined)
+    {
+      console.error('Class ' + obj.constructor.name + ' does not implement warm_up() method needed to allow pooling', obj);
+    }
+    if (obj.tier_down === undefined)
+    {
+      console.error('Class ' + obj.constructor.name + ' does not implement tier_down() method needed to allow pooling', obj);
+    }
+    this.available.push(obj);
+  }
+
+  get()
+  {
+    if (this.available.length === 0)
+    {
+      this.instantiate();
+    }
+
+    let obj = this.available.pop();
+    this.busy.push(obj);
+    obj.warm_up();
+    return obj;
+  }
+
+  release(obj)
+  {
+    let index = this.busy.indexOf(obj);
+    if (index > -1)
+    {
+      this.busy.splice(index, 1);
+      this.available.push(obj);
+      obj.tier_down();
+    }
+  }
+
+  release_all()
+  {
+    while (this.busy.length > 0)
+    {
+      this.release(this.busy[0]);
+    }
+  }
+
+  // @override this one when subclassing
+  // must return a new instance
+  __create()
+  {
+    console.error('__create not implemented');
+  }
+}

package/src/primitives/Arrow.js

@@ -0,0 +1,57 @@
+import { BufferGeometryUtils } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+
+import { CylinderBufferGeometry } from 'three';
+import { ConeBufferGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { Vector3, Mesh } from 'three';
+
+export default class Arrow extends Mesh
+{
+  constructor(color, length, dir)
+  {
+    color = color || '#FF0000';
+    length = length || 1;
+
+    let cone_height = 0.4;
+    let cylinder_height = length - cone_height;
+    let cylinder_geo = new CylinderBufferGeometry(0.01, 0.01, cylinder_height, 32);
+    cylinder_geo.translate(0, cylinder_height / 2, 0);
+
+    let cone_geometry = new ConeBufferGeometry(0.1, cone_height, 32);
+    cone_geometry.translate(0, cylinder_height + cone_height / 2, 0);
+
+    let buffer_geometry = BufferGeometryUtils.mergeBufferGeometries([cylinder_geo, cone_geometry]);
+    buffer_geometry.rotateX(3.14 / 2);
+
+    let material = new MeshBasicMaterial({ color: color });
+    super(buffer_geometry, material);
+
+    if (dir)
+    {
+      this.quaternion.setFromUnitVectors(new Vector3(0, 0, 1), dir);
+    }
+
+    this._dir = dir;
+  }
+
+  set dir(dir)
+  {
+    this.quaternion.setFromUnitVectors(new Vector3(0, 0, 1), dir);
+    this._dir = dir;
+  }
+
+  get dir()
+  {
+    return this._dir;
+  }
+
+  set length(value)
+  {
+    this.scale.z = value;
+  }
+
+  get length()
+  {
+    return this.scale.z;
+  }
+}

package/src/primitives/Cube.js

@@ -0,0 +1,17 @@
+
+import { Vector3, Mesh } from 'three';
+import { BoxGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+
+export default class Cube extends Mesh
+{
+  constructor(size, segments, color)
+  {
+    size     = size || new Vector3(1, 1, 1);
+    segments = segments || new Vector3(1, 1, 1);
+    color    = color || 0xff0000;
+    let geometry = new BoxGeometry(size.x, size.y, size.z, segments.x, segments.y, segments.z);
+    let material = new MeshBasicMaterial({ color: color });
+    super(geometry, material);
+  }
+}

package/src/primitives/HorizontalPlane.js

@@ -0,0 +1,18 @@
+import { Mesh } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { PlaneBufferGeometry } from 'three';
+
+export default class HorizontalPlane extends Mesh
+{
+  constructor(width, height, color, material)
+  {
+    width = width || 1;
+    height = height || 1;
+    color = color || '#FF0000';
+    material = material || new MeshBasicMaterial({ color: color });
+
+    let geometry = new PlaneBufferGeometry(width, height);
+    geometry.rotateX(-3.14 / 2);
+    super(geometry, material);
+  }
+}

package/src/primitives/Sphere.js

@@ -0,0 +1,15 @@
+import { Mesh } from 'three';
+import { SphereBufferGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+
+export default class Sphere extends Mesh
+{
+  constructor(radius, color)
+  {
+    color = color || '#FF0000';
+    radius = radius || 1;
+    let geometry = new SphereBufferGeometry(radius, 64, 64);
+    let material = new MeshBasicMaterial({ color: color });
+    super(geometry, material);
+  }
+}

package/src/primitives/VerticalPlane.js

@@ -0,0 +1,17 @@
+import { Mesh } from 'three';
+import { PlaneBufferGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+
+export default class VerticalPlane extends Mesh
+{
+  constructor(width, height, color, material)
+  {
+    width = width || 1;
+    height = height || 1;
+    color = color || '#FF0000';
+    material = material || new MeshBasicMaterial({ color: color });
+
+    let geometry = new PlaneBufferGeometry(width, height);
+    super(geometry, material);
+  }
+}

package/src/raycast/GroupRaycaster.js

@@ -0,0 +1,41 @@
+import CameraManager from '../CameraManager';
+import Input from '../Input';
+import RaycastResolver from './RaycastResolver';
+import IdleState from './states/IdleState';
+
+import { Raycaster } from 'three';
+
+export default class GroupRaycaster
+{
+  constructor(raycastee_group, raycast_resolver, camera)
+  {
+    this.camera = camera || CameraManager.current;
+    this.raycast_resolver = raycast_resolver || new RaycastResolver();
+    this.raycastee_group = raycastee_group || [];
+
+    this.raycaster = new Raycaster();
+    this.current_state = new IdleState();
+    this.current_intersections = undefined;
+  }
+
+  set_raycastee_group(raycastee_group)
+  {
+    this.raycastee_group = raycastee_group;
+  }
+
+  update()
+  {
+    this.raycaster.setFromCamera(Input.NDC, this.camera);
+    this.current_intersections = this.raycaster.intersectObjects(this.raycastee_group);
+    this.current_state.update(this);
+  }
+
+  set_state(new_state)
+  {
+    // console.log("GroupRaycaster switch state to:" + new_state.constructor.name);
+
+    this.current_state.on_exit(this);
+    this.current_state = new_state;
+    this.current_state.on_enter(this);
+  }
+}

package/src/raycast/PlaneDragResolver.js

@@ -0,0 +1,89 @@
+import PlaneRaycaster from './PlaneRaycaster';
+import PlaneRaycastResolver from './PlaneRaycastResolver';
+import Input from '../Input';
+
+export default class PlaneDragResolver extends PlaneRaycastResolver
+{
+  constructor()
+  {
+    super();
+    this._drag_started = false;
+    this._plane_raycaster = new PlaneRaycaster(this);
+  }
+
+  // @virtual
+  on_drag_start(contact_point)
+  {
+    // console.log("on_drag_start");
+  }
+
+  // @virtual
+  on_drag_move(contact_point)
+  {
+    // console.log("on_drag_move");
+  }
+
+  // @virtual
+  on_drag_end()
+  {
+    // console.log("on_drag_end");
+  }
+
+  // @virtual
+  on_update()
+  {
+
+  }
+
+  // @virtual
+  on_drag_button_pressed()
+  {
+    return Input.left_mouse_button_pressed;
+  }
+
+  // @virtual
+  on_drag_button_released()
+  {
+    return Input.left_mouse_button_released;
+  }
+
+  on_hover(intersection_point)
+  {
+    if (this.on_drag_button_released() && this._drag_started)
+    {
+      this._drag_started = false;
+      this.on_drag_end();
+    }
+
+    if (this.drag_started)
+    {
+      this.on_drag_move(intersection_point);
+    }
+
+    if (this.on_drag_button_pressed())
+    {
+      this.on_drag_start(intersection_point);
+      this._drag_started = true;
+    }
+  }
+
+  get drag_started()
+  {
+    return this._drag_started;
+  }
+
+  on_exit()
+  {
+    if (this.drag_started)
+    {
+      this.on_drag_end();
+      this._drag_started = false;
+    }
+  }
+
+  update(reference_position, plane_normal)
+  {
+    this._plane_raycaster.update(reference_position, plane_normal);
+    this.on_update();
+  }
+}

package/src/raycast/PlaneRaycastResolver.js

@@ -0,0 +1,22 @@
+export default class PlaneRaycastResolver
+{
+  constructor()
+  {
+
+  }
+
+  on_enter(intersected_point)
+  {
+    // console.log("on enter");
+  }
+
+  on_hover(intersected_point)
+  {
+    // console.log("on hover", intersected_point);
+  }
+
+  on_exit()
+  {
+    // console.log("on exit");
+  }
+}

package/src/raycast/PlaneRaycaster.js

@@ -0,0 +1,23 @@
+
+import PlaneRaycastResolver from './PlaneRaycastResolver';
+import CameraUtilities from '../utilities/CameraUtilities';
+
+import { Raycaster } from 'three';
+import { Vector3 } from 'three';
+
+export default class PlaneRaycaster
+{
+  constructor(raycast_resolver)
+  {
+    this.raycast_resolver = raycast_resolver || new PlaneRaycastResolver();
+
+    this.raycaster = new Raycaster();
+    this.current_intersected_point = new Vector3();
+  }
+
+  update(reference_position, plane_normal)
+  {
+    this.current_intersected_point.copy(CameraUtilities.get_plane_intersection(reference_position, plane_normal));
+    this.raycast_resolver.on_hover(this.current_intersected_point);
+  }
+}

package/src/raycast/RaycastResolver.js

@@ -0,0 +1,22 @@
+export default class RaycastResolver
+{
+  constructor()
+  {
+
+  }
+
+  on_enter(intersected_object)
+  {
+    // console.log("on enter");
+  }
+
+  on_hover(intersected_object)
+  {
+    // console.log("on hover");
+  }
+
+  on_exit()
+  {
+    // console.log("on exit");
+  }
+}

package/src/raycast/SurfaceDragResolver.js

@@ -0,0 +1,77 @@
+import RaycastResolver from './RaycastResolver';
+import GroupRaycaster from './GroupRaycaster';
+import Input from '../Input';
+
+export default class SurfaceDragResolver extends RaycastResolver
+{
+  constructor(surface_mesh)
+  {
+    super();
+    this._drag_started = false;
+    this._group_raycaster = new GroupRaycaster([surface_mesh], this);
+  }
+
+  // @virtual
+  on_drag_start(contact_point)
+  {
+    // console.log("on_drag_start");
+  }
+
+  // @virtual
+  on_drag_move(contact_point)
+  {
+    // console.log("on_drag_move");
+  }
+
+  // @virtual
+  on_drag_end()
+  {
+    // console.log("on_drag_end");
+  }
+
+  // @virtual
+  _on_update()
+  {
+
+  }
+
+  get drag_started()
+  {
+    return this._drag_started;
+  }
+
+  on_hover(intersected_object, intersection_data)
+  {
+    if (Input.left_mouse_button_released && this._drag_started)
+    {
+      this._drag_started = false;
+      this.on_drag_end();
+    }
+
+    if (this.drag_started)
+    {
+      this.on_drag_move(intersection_data.point);
+    }
+
+    if (Input.left_mouse_button_pressed)
+    {
+      this.on_drag_start(intersection_data.point);
+      this._drag_started = true;
+    }
+  }
+
+  on_exit()
+  {
+    if (this.drag_started)
+    {
+      this.on_drag_end();
+      this._drag_started = false;
+    }
+  }
+
+  update()
+  {
+    this._group_raycaster.update();
+    this._on_update();
+  }
+}

package/src/raycast/states/BaseState.js

@@ -0,0 +1,16 @@
+export default class BaseState
+{
+  constructor()
+  {
+
+  }
+
+  update(group_raycaster_context)
+  {}
+
+  on_enter(group_raycaster_context)
+  {}
+
+  on_exit(group_raycaster_context)
+  {}
+}

package/src/raycast/states/IdleState.js

@@ -0,0 +1,17 @@
+import OnRaycastEnter from './OnRaycastEnter';
+import BaseState from './BaseState';
+export default class IdleState extends BaseState
+{
+  constructor()
+  {
+    super();
+  }
+
+  update(context)
+  {
+    if (context.current_intersections.length > 0)
+    {
+      context.set_state(new OnRaycastEnter());
+    }
+  }
+}

package/src/raycast/states/OnRaycastEnter.js

@@ -0,0 +1,15 @@
+import BaseState from './BaseState';
+import OnRaycastHover from './OnRaycastHover';
+export default class OnRaycastEnter extends BaseState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(context)
+  {
+    context.raycast_resolver.on_enter(context.current_intersections[0].object, context.current_intersections[0]);
+    context.set_state(new OnRaycastHover());
+  }
+}

package/src/raycast/states/OnRaycastExit.js

@@ -0,0 +1,16 @@
+import BaseState from './BaseState';
+import IdleState from './IdleState';
+
+export default class OnRaycastExit extends BaseState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(context)
+  {
+    context.raycast_resolver.on_exit();
+    context.set_state(new IdleState());
+  }
+}

package/src/raycast/states/OnRaycastHover.js

@@ -0,0 +1,25 @@
+import BaseState from './BaseState';
+import OnRaycastExit from './OnRaycastExit';
+export default class OnRaycastHover extends BaseState
+{
+  constructor()
+  {
+    super();
+  }
+
+  on_enter(context)
+  {
+  }
+
+  update(context)
+  {
+    if (context.current_intersections.length > 0)
+    {
+      context.raycast_resolver.on_hover(context.current_intersections[0].object, context.current_intersections[0]);
+    }
+    else
+    {
+      context.set_state(new OnRaycastExit());
+    }
+  }
+}

package/src/render_mode/BaseRender.js

@@ -0,0 +1,32 @@
+export default class BaseRender
+{
+  constructor()
+  {
+
+  }
+
+  render()
+  {
+
+  }
+
+  on_enter(context, renderer)
+  {
+
+  }
+
+  on_exit(context, renderer)
+  {
+
+  }
+
+  resize()
+  {
+
+  }
+
+  dispose()
+  {
+
+  }
+}

package/src/render_mode/BloomRender.js

@@ -0,0 +1,60 @@
+import Screen from '../Screen';
+import BaseRender from '../render_mode/BaseRender';
+import BloomComposeMaterial from '../materials/BloomComposeMaterial';
+
+import { WebGLRenderTarget } from 'three';
+
+import Blurrer from '../render_utilities/Blurrer';
+import Graphics from '../Graphics';
+import CameraManager from '../CameraManager';
+import SceneManager from '../SceneManager';
+
+export default class BloomRender extends BaseRender
+{
+  constructor()
+  {
+    super();
+
+    this.bloom_compose_mat = new BloomComposeMaterial();
+    window.bloom_mat = this.bloom_compose_mat;
+
+    this.main_RT = undefined;
+    this.blur_RT = undefined;
+    this.blurrer = undefined;
+  }
+
+  on_enter()
+  {
+    this.blurrer = new Blurrer();
+    // this.blurrer = new DualFilteringBlurrer()
+    this.main_RT = new WebGLRenderTarget(Screen.render_width, Screen.render_height);
+    this.blur_RT = new WebGLRenderTarget(Screen.render_width, Screen.render_height);
+  }
+
+  render()
+  {
+    this.__check_RT_size();
+
+    Graphics.clear(this.main_RT, CameraManager.current, true, false);
+    Graphics.render(SceneManager.current, CameraManager.current, this.main_RT);
+
+    Graphics.blit(this.main_RT, this.blur_RT);
+
+    // // BLUR
+    this.blurrer.blur(this.blur_RT);
+
+    this.bloom_compose_mat.uniforms._BlurredTex.value = this.blur_RT.texture;
+
+    // // // COMPOSE
+    Graphics.blit(this.main_RT, undefined, this.bloom_compose_mat);
+  }
+
+  __check_RT_size()
+  {
+    if (this.main_RT.width !== Screen.render_width || this.main_RT.height !== Screen.render_height)
+    {
+      this.main_RT.setSize(Screen.render_width, Screen.render_height);
+      this.blur_RT.setSize(Screen.render_width, Screen.render_height);
+    }
+  }
+}

package/src/render_mode/DebugNormalsRender.js

@@ -0,0 +1,20 @@
+import CameraManager from '../CameraManager';
+import SceneManager from '../SceneManager';
+import BaseRender from '../render_mode/BaseRender';
+import Graphics from '../Graphics';
+import NormalMaterial from '../materials/NormalMaterial';
+
+export default class DebugNormalsRender extends BaseRender
+{
+  constructor()
+  {
+    super();
+  }
+
+  render()
+  {
+    Graphics.clear(undefined, CameraManager.current, true, true);
+
+    Graphics.render(SceneManager.current, CameraManager.current, undefined, new NormalMaterial());
+  }
+}