ohzi-core 5.13.2 → 5.14.2

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "ohzi-core",
-  "version": "5.13.2",
+  "version": "5.14.2",
   "description": "OHZI Core Library",
   "module": "build/index.module.js",
   "source": "src/index.js",
+  "types": "types/index.d.ts",
   "files": [
-    "build"
+    "build",
+    "LICENSE",
+    "src",
+    "types",
+    "package.json"
   ],
   "targets": {
     "module": {
@@ -17,7 +22,8 @@
     "create-tag": "cross-var git tag -a \"v$npm_package_version\" -m \"Release Version $npm_package_version\" && cross-var git push origin \"v$npm_package_version\"",
     "build": "rollup -c",
     "update-version": "cross-var echo \"v$npm_package_version\" > .version",
-    "fix-syntax": "standardx --fix"
+    "fix-syntax": "standardx --fix",
+    "generate-types": "npx -p typescript tsc src/components/sdf_text/SDFTextBatch.js --declaration --allowJs --emitDeclarationOnly --outDir types"
   },
   "repository": {
     "type": "git",
@@ -38,11 +44,13 @@
     "three": "^0.128.0"
   },
   "devDependencies": {
+    "@types/node": "^16.9.4",
     "cross-var": "^1.1.0",
     "rollup": "^2.44.0",
     "rollup-plugin-glslify": "^1.2.0",
     "rollup-plugin-sourcemaps": "^0.6.3",
     "rollup-plugin-terser": "^7.0.2",
-    "standardx": "^7.0.0"
+    "standardx": "^7.0.0",
+    "typescript": "^4.4.3"
   }
 }

package/src/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "workbench.tree.indent": 15
+}

package/src/BaseApplication.js

@@ -0,0 +1,20 @@
+export default class BaseApplication
+{
+  on_post_start()
+  {}
+
+  on_enter()
+  {}
+
+  on_exit()
+  {}
+
+  update()
+  {}
+
+  on_post_render()
+  {}
+
+  on_pre_render()
+  {}
+}

package/src/CameraManager.js

@@ -0,0 +1,19 @@
+class CameraManager
+{
+  init()
+  {
+    this._current = undefined;
+  }
+
+  set current(camera)
+  {
+    this._current = camera;
+  }
+
+  get current()
+  {
+    return this._current;
+  }
+}
+
+export default new CameraManager();

package/src/Capabilities.js

@@ -0,0 +1,11 @@
+class Capabilities
+{
+  init()
+  {
+    this.max_anisotropy = 0;
+    this.vertex_texture_sampler_available = false;
+    this.fp_textures_available = false;
+  }
+}
+
+export default new Capabilities();

package/src/Configuration.js

@@ -0,0 +1,22 @@
+/*
+
+  A configuration class used as a singleton
+
+*/
+
+class Configuration
+{
+  init(parameters = {})
+  {
+    this.dpr = 1;
+
+    this.app  = {}; // for arbitrary use in end application
+  }
+
+  from_json(json)
+  {
+
+  }
+}
+
+export default new Configuration();

package/src/CustomBezierCurve.js

@@ -0,0 +1,44 @@
+import { Vector3 } from 'three';
+
+export default class CustomBezierCurve
+{
+  constructor(points)
+  {
+    this.original_points = [];
+    this.tmp_points = [];
+    for (let i = 0; i < points.length; i++)
+    {
+      this.original_points.push(new Vector3().copy(points[i]));
+      this.tmp_points.push(new Vector3());
+    }
+  }
+
+  build(point_amount)
+  {
+    let curve = [];
+    for (let i = 0; i < point_amount; i++)
+    {
+      curve.push(new Vector3().copy(this.get_point_at(i / point_amount)));
+    }
+    return curve;
+  }
+
+  get_point_at(t)
+  {
+    for (let i = 0; i < this.original_points.length; i++)
+    {
+      this.tmp_points[i].copy(this.original_points[i]);
+    }
+
+    let tmp_vec = new Vector3();
+    for (let steps = this.tmp_points.length - 1; steps > 0; steps--)
+    {
+      for (let i = 0; i < steps; i++)
+      {
+        tmp_vec.lerpVectors(this.tmp_points[i], this.tmp_points[i + 1], t);
+        this.tmp_points[i].copy(tmp_vec);
+      }
+    }
+    return this.tmp_points[0].clone();
+  }
+}

package/src/Debug.js

@@ -0,0 +1,260 @@
+import AxisHelper from './components/AxisHelper';
+import basic_color_vert from './shaders/basic_color/basic_color.vert';
+import basic_color_frag from './shaders/basic_color/basic_color.frag';
+import SceneManager from './SceneManager';
+import Cube from './primitives/Cube';
+import Sphere from './primitives/Sphere';
+import Arrow from './primitives/Arrow';
+import Screen from './Screen';
+import ScreenSpaceTextureMaterial from './materials/ScreenSpaceTextureMaterial';
+import { Vector3 } from 'three';
+import { LineBasicMaterial } from 'three';
+import { BufferGeometry } from 'three';
+import { Line } from 'three';
+import { PlaneBufferGeometry } from 'three';
+import { ShaderMaterial } from 'three';
+import { Vector4 } from 'three';
+import { Mesh } from 'three';
+import { Box3 } from 'three';
+import { Box3Helper } from 'three';
+import { Scene } from 'three';
+import { CatmullRomCurve3 } from 'three';
+import { SphereGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+import PerspectiveCamera from './PerspectiveCamera';
+
+class Debug
+{
+  init()
+  {
+    this.Vector3_one = new Vector3(1, 1, 1);
+    this.Vector3_zero = new Vector3(0, 0, 0);
+    this.canvas_renderer = undefined;
+
+    this.display_texture_meshes = [];
+
+    this.ctx = undefined;
+    this.scene = new Scene();
+    this.camera = new PerspectiveCamera();
+    // this.camera.clear_alpha = 0;
+  }
+
+  draw_arrow(origin, dir, color = 0xff0000)
+  {
+    let arrow = new Arrow(color, dir.length(), dir.clone().normalize());
+    arrow.position.copy(origin);
+    SceneManager.current.add(arrow);
+    return arrow;
+  }
+
+  draw_axis()
+  {
+    let axis = new AxisHelper();
+    SceneManager.current.add(axis);
+    return axis;
+  }
+
+  set_debug_RT(RT)
+  {
+    this.rt_debug = RT;
+  }
+
+  draw_rectangle(position_2d, width, height, color)
+  {
+    width  = width || 100;
+    height = height || 100;
+    this.ctx.fillStyle =  color || 'rgba(255, 0, 0, 1)';
+    this.ctx.fillRect(position_2d.x - width / 2,
+      (this.ctx.canvas.height - position_2d.y) - height / 2, width, height);
+  }
+
+  clear()
+  {
+    if (this.ctx)
+    {
+      this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
+    }
+  }
+
+  draw_line_2D(from, to, color)
+  {
+    this.ctx.strokeStyle =  color || 'rgba(255, 0, 0, 1)';
+    this.ctx.beginPath();
+    this.ctx.moveTo(from.x, from.y);
+    this.ctx.lineTo(to.x, to.y);
+    this.ctx.closePath();
+    this.ctx.stroke();
+  }
+
+  draw_line(points, color = 0xff0000)
+  {
+    let material = new LineBasicMaterial({
+      color: color
+    });
+
+    let geometry = new BufferGeometry().setFromPoints(points);
+
+    let line = new Line(geometry, material);
+    line.frustumCulled = false;
+    SceneManager.current.add(line);
+    return line;
+  }
+
+  draw_cube(pos, size, color)
+  {
+    size = size || 1;
+    color = color || 0xff0000;
+    pos = pos || new Vector3();
+
+    let cube = new Cube(new Vector3(size, size, size), undefined, color);
+    cube.position.copy(pos);
+    SceneManager.current.add(cube);
+    return cube;
+  }
+
+  draw_oriented_cube(from, to, height = 1, color = '#FF0000', depth = 0.1)
+  {
+    let size = from.distanceTo(to);
+    let cube = new Cube(new Vector3(depth, height, size), undefined, color);
+
+    let center = to.clone().sub(from).multiplyScalar(0.5);
+    let forward_dir = center.clone().normalize();
+    center.add(from);
+
+    cube.position.copy(center);
+
+    // let up = new Vector3(0, 1, 0);
+    // let forward = forward_dir.clone();
+    // let right = forward.clone().cross(up);
+
+    // cube.quaternion.setFromRotationMatrix(new Matrix4().makeBasis(right,up,forward));
+    cube.quaternion.setFromUnitVectors(new Vector3(0, 0, -1), forward_dir);
+
+    SceneManager.current.add(cube);
+    return cube;
+  }
+
+  draw_plane(width, height, color)
+  {
+    let geometry = new PlaneBufferGeometry(width, height);
+    let material = new ShaderMaterial({
+      uniforms: {
+        _Color: { value: new Vector4(0, 1, 0, 0.2) }
+      },
+      vertexShader: basic_color_vert,
+      fragmentShader: basic_color_frag,
+      transparent: true,
+      depthWrite: false
+    });
+
+    let plane = new Mesh(geometry, material);
+    plane.renderOrder = -10000;
+    SceneManager.current.add(plane);
+    return plane;
+  }
+
+  draw_empty_cube(pos, size, color)
+  {
+    size = size || 1;
+    color = color || 0xff0000;
+
+    let box = new Box3().setFromCenterAndSize(new Vector3(), new Vector3(size, size, size));
+    let helper = new Box3Helper(box, color);
+    helper.position.copy(pos || new Vector3());
+    return helper;
+  }
+
+  draw_sphere(pos, size, color)
+  {
+    size = size || 1;
+    color = color || 0xff0000;
+    pos = pos || new Vector3();
+
+    let sphere = new Sphere(size, color);
+    sphere.position.copy(pos);
+    SceneManager.current.add(sphere);
+    return sphere;
+  }
+
+  draw_point_array(input_points, open = false, color = 0xff0000)
+  {
+    let catmull = new CatmullRomCurve3(input_points, open);
+    catmull.updateArcLengths();
+    let points = catmull.getSpacedPoints(200);
+    let line_helper = this.draw_line(points, 0x00ff00);
+    // line_helper.position.y = 1.5;
+    return line_helper;
+  }
+
+  draw_sphere_helper(sphere, color)
+  {
+    color = color || 0xff0000;
+    let geometry = new SphereGeometry(sphere.radius, 32, 32);
+    let material = new MeshBasicMaterial({ color: color });
+    let sphere_mesh = new Mesh(geometry, material);
+    sphere_mesh.position.copy(sphere.center);
+    SceneManager.current.add(sphere_mesh);
+    return sphere_mesh;
+  }
+
+  draw_math_sphere(sphere)
+  {
+    let geometry = new SphereGeometry(sphere.radius, 32, 32);
+    let material = new ShaderMaterial({
+      uniforms: {
+        _Color: { value: new Vector4(1, 0, 0, 0.2) }
+      },
+      vertexShader: basic_color_vert,
+      fragmentShader: basic_color_frag,
+      transparent: true
+    });
+    // var material = new MeshBasicMaterial( {color: 0xff0000, transparent = true} );
+    let sphere1 = new Mesh(geometry, material);
+    sphere1.position.copy(sphere.center);
+    SceneManager.current.add(sphere1);
+  }
+
+  draw_bounding_box(bb)
+  {
+    let helper = new Box3Helper(bb, 0xffff00);
+    SceneManager.current.add(helper);
+  }
+
+  draw_curve(curve, options)
+  {
+    let offset = new Vector3(0, 0, 0);
+    if (options)
+    {
+      offset.y = options.offset || 0;
+    }
+
+    for (let i = 0; i < curve.length - 1; i++)
+    {
+      this.draw_line(curve[i].clone().add(offset), curve[i + 1].clone().add(offset));
+    }
+  }
+
+  draw_texture(tex, w, h)
+  {
+    let mesh = new Mesh(new PlaneBufferGeometry(1, 1), new ScreenSpaceTextureMaterial());
+    this.display_texture_meshes.push(mesh);
+    this.scene.add(mesh);
+
+    mesh.material.set_texture(tex, w, h);
+    return mesh;
+  }
+
+  render(graphics)
+  {
+    for (let i = 0; i < this.display_texture_meshes.length; i++)
+    {
+      this.display_texture_meshes[i].material.set_screen_size(Screen.width, Screen.height);
+    }
+    if (this.scene.children.length > 0)
+    {
+      graphics.render(this.scene, this.camera);
+    }
+  }
+}
+
+export default new Debug();

package/src/EventManager.js

@@ -0,0 +1,150 @@
+class EventManager
+{
+  init()
+  {
+    this.queue = {};
+
+    this.zoom_changed_evt           = 'zoom_changed';
+    this.store_clickd_evt           = 'store_clicked';
+    this.point_selected_evt         = 'point_selected';
+    this.config_changed             = 'config_changed';
+
+    this.path_substep_completed     = 'path_substep_completed';
+    this.path_completed             = 'path_completed';
+    this.go_to_store_requested_evt  = 'go_to_store_requested';
+
+    this.resource_loaded_evt        = 'resource_loaded';
+    this.service_clicked_evt        = 'service_clicked';
+    this.unit_pos_updated_evt       = 'unit_position_updated';
+
+    this.floor_changed_evt          = 'floor_changed';
+
+    this.on_enter_floor_navigation  = 'on_enter_floor_navigation';
+    this.on_exit_floor_navigation   = 'on_exit_floor_navigation';
+
+    this.on_enter_floor_selection   = 'on_enter_floor_selection';
+    this.on_exit_floor_selection    = 'on_exit_floor_selection';
+
+    this.on_enter_outside_navigation  = 'on_enter_outside_navigation';
+    this.on_exit_outside_navigation   = 'on_exit_outside_navigation';
+
+    this.step_selected_evt = 'step_selected';
+  }
+
+  fire(event, payload)
+  {
+    let queue = this.queue[event];
+
+    if (queue === undefined)
+    {
+      return;
+    }
+    let i = queue.length;
+    while (i--)
+    {
+      queue[i](payload);
+    }
+  }
+
+  on(event, callback)
+  {
+    if (typeof this.queue[event] === 'undefined')
+    {
+      this.queue[event] = [];
+    }
+
+    this.queue[event].push(callback);
+  }
+
+  fire_zoom_changed(zoom)
+  {
+    this.fire(this.zoom_changed_evt, zoom);
+  }
+
+  fire_store_selected(store_id)
+  {
+    this.fire(this.store_clickd_evt, store_id);
+  }
+
+  fire_point_selected(hit_data)
+  {
+    this.fire(this.point_selected_evt, hit_data);
+  }
+
+  fire_config_changed()
+  {
+    this.fire(this.config_changed);
+  }
+
+  fire_path_substep_completed(step_number)
+  {
+    this.fire(this.path_substep_completed, step_number);
+  }
+
+  fire_path_completed()
+  {
+    this.fire(this.path_completed);
+  }
+
+  fire_step_selected(step_index)
+  {
+    this.fire(this.step_selected_evt, step_index);
+  }
+
+  fire_go_to_store_requested(store_id)
+  {
+    this.fire(this.go_to_store_requested_evt, store_id);
+  }
+
+  fire_resource_loaded(resource)
+  {
+    this.fire(this.resource_loaded_evt, resource);
+  }
+
+  fire_service_clicked(service)
+  {
+    this.fire(this.service_clicked_evt, service);
+  }
+
+  fire_unit_position_updated(unit_data)
+  {
+    this.fire(this.unit_pos_updated_evt, unit_data);
+  }
+
+  fire_floor_switched(floor_id)
+  {
+    this.fire(this.floor_changed_evt, floor_id);
+  }
+
+  fire_on_enter_floor_navigation(state)
+  {
+    this.fire(this.on_enter_floor_navigation, state);
+  }
+
+  fire_on_exit_floor_navigation(state)
+  {
+    this.fire(this.on_exit_floor_navigation, state);
+  }
+
+  fire_on_enter_floor_selection(state)
+  {
+    this.fire(this.on_enter_floor_selection, state);
+  }
+
+  fire_on_exit_floor_selection(state)
+  {
+    this.fire(this.on_exit_floor_selection, state);
+  }
+
+  fire_on_enter_outside_navigation(state)
+  {
+    this.fire(this.on_enter_outside_navigation, state);
+  }
+
+  fire_on_exit_outside_navigation(state)
+  {
+    this.fire(this.on_exit_outside_navigation, state);
+  }
+}
+
+export default new EventManager();