ohzi-core 5.13.2 → 5.14.2

package/src/utilities/ModelUtilities.js

@@ -0,0 +1,161 @@
+import { Mesh } from 'three';
+import { BufferGeometry } from 'three';
+import { Skeleton } from 'three';
+
+class ModelUtilities
+{
+  get_mesh(scene, result_callback)
+  {
+    scene.traverse((child) =>
+    {
+      if (child instanceof Mesh)
+      {
+        if (child.geometry)
+        {
+          child.geometry = new BufferGeometry().fromGeometry(child.geometry);
+        }
+        result_callback(child);
+      }
+    });
+  }
+
+  get_geometries(scene)
+  {
+    let geometries = [];
+
+    this.get_mesh(scene, (child) =>
+    {
+      geometries.push(child.geometry);
+    });
+    return geometries;
+  }
+
+  assign_material(scene, material, name)
+  {
+    scene.traverse((child) =>
+    {
+      if (child instanceof Mesh)
+      {
+        // assign to all if no name is given
+        if (name === undefined)
+        {
+          child.material = material;
+        }
+        else
+        {
+          // if name is given, assign only to that
+          if (child.name === name)
+          {
+            child.material = material;
+          }
+        }
+      }
+    });
+  }
+
+  clone_animated_gltf(gltf)
+  {
+    const clone = {
+      animations: gltf.animations,
+      scene: gltf.scene.clone(true)
+    };
+
+    const skinnedMeshes = {};
+
+    gltf.scene.traverse(node =>
+    {
+      if (node.isSkinnedMesh)
+      {
+        skinnedMeshes[node.name] = node;
+      }
+    });
+
+    const cloneBones = {};
+    const cloneSkinnedMeshes = {};
+
+    clone.scene.traverse(node =>
+    {
+      if (node.isBone)
+      {
+        cloneBones[node.name] = node;
+      }
+
+      if (node.isSkinnedMesh)
+      {
+        cloneSkinnedMeshes[node.name] = node;
+      }
+    });
+
+    for (let name in skinnedMeshes)
+    {
+      const skinnedMesh = skinnedMeshes[name];
+      const skeleton = skinnedMesh.skeleton;
+      const cloneSkinnedMesh = cloneSkinnedMeshes[name];
+
+      const orderedCloneBones = [];
+
+      for (let i = 0; i < skeleton.bones.length; ++i)
+      {
+        const cloneBone = cloneBones[skeleton.bones[i].name];
+        orderedCloneBones.push(cloneBone);
+      }
+
+      cloneSkinnedMesh.bind(
+        new Skeleton(orderedCloneBones, skeleton.boneInverses),
+        cloneSkinnedMesh.matrixWorld);
+    }
+
+    return clone;
+  }
+
+  set_shadow_config(scene, cast, receive)
+  {
+    scene.traverse((child) =>
+    {
+      if (child instanceof Mesh)
+      {
+        child.castShadow = cast;
+        child.receiveShadow = receive;
+      }
+    });
+  }
+
+  __find_object(scene, object_name, result_callback)
+  {
+    scene.traverse((obj) =>
+    {
+      if (obj.name === object_name)
+      {
+        result_callback(obj);
+      }
+    });
+  }
+
+  get_object(scene, object_name)
+  {
+    let object = undefined;
+    scene.traverse((obj) =>
+    {
+      if (obj.name === object_name)
+      {
+        object = obj;
+      }
+    });
+    return object;
+  }
+
+  get_object_by_type(scene, object_type)
+  {
+    let object = undefined;
+    scene.traverse((obj) =>
+    {
+      if (obj.constructor.name === object_type)
+      {
+        object = obj;
+      }
+    });
+    return object;
+  }
+}
+
+export default new ModelUtilities();

package/src/utilities/ObjectUtilities.js

@@ -0,0 +1,55 @@
+export default class ObjectUtilities
+{
+  constructor()
+  {}
+
+  // Changes XML to JSON
+  static xml_to_json(xml)
+  {
+    // Create the return object
+    let obj = {};
+
+    if (xml.nodeType === 1)
+    { // element
+      // do attributes
+      if (xml.attributes.length > 0)
+      {
+        obj['@attributes'] = {};
+        for (let j = 0; j < xml.attributes.length; j++)
+        {
+          let attribute = xml.attributes.item(j);
+          obj['@attributes'][attribute.nodeName] = attribute.nodeValue;
+        }
+      }
+    }
+    else if (xml.nodeType === 3)
+    { // text
+      obj = xml.nodeValue;
+    }
+
+    // do children
+    if (xml.hasChildNodes())
+    {
+      for (let i = 0; i < xml.childNodes.length; i++)
+      {
+        let item = xml.childNodes.item(i);
+        let nodeName = item.nodeName;
+        if (typeof (obj[nodeName]) === 'undefined')
+        {
+          obj[nodeName] = this.xml_to_json(item);
+        }
+        else
+        {
+          if (typeof (obj[nodeName].push) === 'undefined')
+          {
+            let old = obj[nodeName];
+            obj[nodeName] = [];
+            obj[nodeName].push(old);
+          }
+          obj[nodeName].push(this.xml_to_json(item));
+        }
+      }
+    }
+    return obj;
+  }
+}

package/src/utilities/OrthographicFrustumPointFitter.js

@@ -0,0 +1,47 @@
+import { Vector3, Box3 } from 'three';
+
+export default class OrthographicFrustumPointFitter
+{
+  constructor()
+  {
+
+  }
+
+  fit_points(points, camera_quaternion, vertical_fov, aspect)
+  {
+    let inverse_camera_quat = camera_quaternion.clone().inverse();
+
+    let inverted_points = [];
+
+    for (let i = 0; i < points.length; i++)
+    {
+      inverted_points.push(points[i].clone().applyQuaternion(inverse_camera_quat));
+    }
+
+    let box = new Box3().setFromPoints(inverted_points);
+    let size = new Vector3();
+    box.getSize(size);
+
+    let distance = this.get_distance_to_fit_rect(size.x / 2, size.y / 2, vertical_fov, aspect);
+
+    let center = new Vector3();
+    box.getCenter(center);
+
+    center.applyQuaternion(camera_quaternion);
+
+    return {
+      center: center,
+      distance_to_center: distance
+    };
+  }
+
+  get_distance_to_fit_rect(width, height, vertical_fov, aspect)
+  {
+    let v_fov = (vertical_fov / 2) * Math.PI / 180;
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * 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));
+  }
+}

package/src/utilities/PerspectiveFrustumPointFitter.js

@@ -0,0 +1,250 @@
+import { Vector3, Plane, Quaternion, Sphere, Math as TMath, Line3 } from 'three';
+export default class PerspectiveFrustumPointFitter
+{
+  constructor()
+  {
+    this.sphere = new Sphere();
+  }
+
+  fit_points(points, camera_quaternion, vertical_fov, aspect)
+  {
+    this.sphere.setFromPoints(points);
+
+    let v_fov = TMath.degToRad(vertical_fov / 2);
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * aspect)) / 2;
+
+    let up_plane_normal = this.get_up_plane_normal(camera_quaternion, v_fov);
+    let down_plane_normal = this.get_down_plane_normal(camera_quaternion, v_fov);
+    let left_plane_normal = this.get_left_plane_normal(camera_quaternion, h_fov);
+    let right_plane_normal = this.get_right_plane_normal(camera_quaternion, h_fov);
+
+    let camera_forward_dir = new Vector3(0, 0, -1).applyQuaternion(camera_quaternion);
+
+    let sphere_center = this.sphere.center.clone();
+
+    let pull_back_distance = this.get_distance_to_fit_rect(this.sphere.radius * 2, this.sphere.radius * 2, vertical_fov, aspect);
+    let far_pos = sphere_center.clone().add(camera_forward_dir.clone().multiplyScalar(pull_back_distance * -1));
+
+    let up_plane    = new Plane().setFromNormalAndCoplanarPoint(up_plane_normal, far_pos);
+    let down_plane  = new Plane().setFromNormalAndCoplanarPoint(down_plane_normal, far_pos);
+
+    let left_plane   = new Plane().setFromNormalAndCoplanarPoint(left_plane_normal, far_pos);
+    let right_plane  = new Plane().setFromNormalAndCoplanarPoint(right_plane_normal, far_pos);
+
+    this.apply_center_correction_to_pos(far_pos, points, camera_quaternion, up_plane, down_plane, left_plane, right_plane);
+
+    up_plane.setFromNormalAndCoplanarPoint(up_plane_normal, far_pos);
+    down_plane.setFromNormalAndCoplanarPoint(down_plane_normal, far_pos);
+
+    left_plane.setFromNormalAndCoplanarPoint(left_plane_normal, far_pos);
+    right_plane.setFromNormalAndCoplanarPoint(right_plane_normal, far_pos);
+
+    let closest_distance = Infinity;
+
+    let inverse_dir = camera_forward_dir.clone().multiplyScalar(pull_back_distance * -2);
+    for (let i = 0; i < points.length; i++)
+    {
+      let line = new Line3(points[i].clone(), points[i].clone().add(inverse_dir));
+
+      let up_line_intersection  = new Vector3();
+      let down_line_intersection = new Vector3();
+
+      let left_line_intersection  = new Vector3();
+      let right_line_intersection = new Vector3();
+
+      up_plane.intersectLine(line,  up_line_intersection);
+      down_plane.intersectLine(line, down_line_intersection);
+
+      left_plane.intersectLine(line,  left_line_intersection);
+      right_plane.intersectLine(line, right_line_intersection);
+
+      if (up_line_intersection.length() < 0.0001)
+      {
+        console.log('up intersection not found', i);
+      }
+      if (down_line_intersection.length() < 0.0001)
+      {
+        console.log('down intersection not found', i);
+      }
+      if (left_line_intersection.length() < 0.0001)
+      {
+        console.log('left intersection not found', i);
+      }
+      if (right_line_intersection.length() < 0.0001)
+      {
+        console.log('right intersection not found', i);
+      }
+
+      let new_up_distance   = points[i].clone().sub(up_line_intersection).length();
+      let new_down_distance = points[i].clone().sub(down_line_intersection).length();
+
+      let new_left_distance   = points[i].clone().sub(left_line_intersection).length();
+      let new_right_distance  = points[i].clone().sub(right_line_intersection).length();
+
+      let vertical_min    = Math.min(new_up_distance, new_down_distance);
+      let horizontal_min  = Math.min(new_left_distance, new_right_distance);
+
+      let min = Math.min(vertical_min, horizontal_min);
+
+      if (min < closest_distance)
+      {
+        closest_distance = min;
+      }
+    }
+
+    let forward_correction = camera_forward_dir.clone().multiplyScalar(closest_distance);
+    let closest_position = far_pos.clone().add(forward_correction);
+
+    return closest_position;
+  }
+
+  apply_center_correction_to_pos(target_pos, points, camera_quaternion, up_plane, down_plane, left_plane, right_plane)
+  {
+    let vertical_offset = this.get_vertical_correction(points, down_plane, up_plane, camera_quaternion);
+    let horizontal_offset = this.get_horizontal_correction(points, left_plane, right_plane, camera_quaternion);
+
+    target_pos.add(vertical_offset);
+    target_pos.add(horizontal_offset);
+  }
+
+  get_vertical_correction(points, down_plane, up_plane, camera_quaternion)
+  {
+    let closest_distance_to_up_plane = Infinity;
+    let closest_distance_to_down_plane  = Infinity;
+    // let closest_up_point = undefined;
+    // let closest_down_point = undefined;
+
+    let up_dir = new Vector3(0, 1, 0).applyQuaternion(camera_quaternion);
+    for (let i = 0; i < points.length; i++)
+    {
+      let down_line   = new Line3(points[i].clone(), points[i].clone().add(up_dir.clone().multiplyScalar(-5000000)));
+      let up_line     = new Line3(points[i].clone(), points[i].clone().add(up_dir.clone().multiplyScalar(5000000)));
+
+      let down_line_intersection  = new Vector3();
+      let up_line_intersection = new Vector3();
+
+      down_plane.intersectLine(down_line,  down_line_intersection);
+      up_plane.intersectLine(up_line, up_line_intersection);
+
+      let down_dist   = down_line_intersection.distanceTo(points[i]);
+      let up_dist     = up_line_intersection.distanceTo(points[i]);
+
+      if (up_line_intersection.length() < 0.0001)
+      {
+        console.log('vertical up intersection not found', i);
+      }
+      if (down_line_intersection.length() < 0.0001)
+      {
+        console.log('vertical down intersection not found', i);
+      }
+
+      if (down_dist < closest_distance_to_down_plane)
+      {
+        closest_distance_to_down_plane = down_dist;
+        // closest_down_point = points[i];
+      }
+      if (up_dist < closest_distance_to_up_plane)
+      {
+        closest_distance_to_up_plane = up_dist;
+        // closest_up_point = points[i];
+      }
+    }
+
+    let correction = (closest_distance_to_up_plane - closest_distance_to_down_plane) / 2;
+
+    // console.log("vertical_correction", correction)
+    return up_dir.clone().multiplyScalar(-correction);
+  }
+
+  get_horizontal_correction(points, left_plane, right_plane, camera_quaternion)
+  {
+    let closest_distance_to_right_plane = Infinity;
+    let closest_distance_to_left_plane  = Infinity;
+    // let closest_right_point = undefined;
+    // let closest_left_point = undefined;
+
+    let right_dir = new Vector3(1, 0, 0).applyQuaternion(camera_quaternion);
+
+    for (let i = 0; i < points.length; i++)
+    {
+      let left_line  = new Line3(points[i].clone(), points[i].clone().add(right_dir.clone().multiplyScalar(-5000000)));
+      let right_line = new Line3(points[i].clone(), points[i].clone().add(right_dir.clone().multiplyScalar(5000000)));
+
+      let left_line_intersection  = new Vector3();
+      let right_line_intersection = new Vector3();
+
+      left_plane.intersectLine(left_line,  left_line_intersection);
+      right_plane.intersectLine(right_line, right_line_intersection);
+
+      let left_dist  = left_line_intersection.distanceTo(points[i]);
+      let right_dist = right_line_intersection.distanceTo(points[i]);
+
+      if (left_line_intersection.length() < 0.0001)
+      {
+        console.log('left intersection not found', i);
+      }
+      if (right_line_intersection.length() < 0.0001)
+      {
+        console.log('right intersection not found', i);
+      }
+
+      if (left_dist < closest_distance_to_left_plane)
+      {
+        closest_distance_to_left_plane = left_dist;
+        // closest_left_point = points[i];
+      }
+      if (right_dist < closest_distance_to_right_plane)
+      {
+        closest_distance_to_right_plane = right_dist;
+        // closest_right_point = points[i];
+      }
+    }
+
+    let correction = (closest_distance_to_right_plane - closest_distance_to_left_plane) / 2;
+    // console.log("horizontal_correction", correction)
+
+    return right_dir.clone().multiplyScalar(-correction);
+  }
+
+  get_up_plane_normal(camera_quaternion, v_fov)
+  {
+    let up_plane_normal = new Vector3(0, -1, 0);
+    up_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), v_fov));
+    up_plane_normal.applyQuaternion(camera_quaternion);
+    return up_plane_normal;
+  }
+
+  get_down_plane_normal(camera_quaternion, v_fov)
+  {
+    let down_plane_normal = new Vector3(0, 1, 0);
+    down_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -v_fov));
+    down_plane_normal.applyQuaternion(camera_quaternion);
+    return down_plane_normal;
+  }
+
+  get_left_plane_normal(camera_quaternion, h_fov)
+  {
+    let left_plane_normal = new Vector3(1, 0, 0);
+    left_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), h_fov));
+    left_plane_normal.applyQuaternion(camera_quaternion);
+    return left_plane_normal;
+  }
+
+  get_right_plane_normal(camera_quaternion, h_fov)
+  {
+    let right_plane_normal = new Vector3(-1, 0, 0);
+    right_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -h_fov));
+    right_plane_normal.applyQuaternion(camera_quaternion);
+    return right_plane_normal;
+  }
+
+  get_distance_to_fit_rect(width, height, vertical_fov, aspect)
+  {
+    let v_fov = (vertical_fov / 2) * Math.PI / 180;
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * 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));
+  }
+}

package/src/utilities/StringUtilities.js

@@ -0,0 +1,32 @@
+export default class StringUtilities
+{
+  constructor()
+  {}
+
+  static capitalize(string)
+  {
+    const words = string.split(' ');
+
+    for (let i = 0; i < words.length; i++)
+    {
+      words[i] = words[i][0].toUpperCase() + words[i].substr(1);
+    }
+
+    return words.join(' ');
+  }
+
+  static capitalize_first_letter(string)
+  {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+  }
+
+  static snake_to_camelcase(string)
+  {
+    return string.replace(
+      /([-_][a-z])/g,
+      (group) => group.toUpperCase()
+        .replace('-', '')
+        .replace('_', '')
+    );
+  }
+}

package/src/utilities/TimeUtilities.js

@@ -0,0 +1,22 @@
+export default class TimeUtilities
+{
+  constructor()
+  {}
+
+  // Converts a time string (00:00:00.45) into miliseconds
+  time_str_to_ms(time_str)
+  {
+    time_str = time_str.split(':');
+
+    let hours = Number(time_str[0]);
+    hours = hours * 60 * 60 * 1000;
+
+    let minutes = Number(time_str[1]);
+    minutes = minutes * 60 * 1000;
+
+    let seconds = Number(time_str[2]);
+    seconds = seconds * 1000;
+
+    return hours + minutes + seconds;
+  }
+}

package/src/utilities/Validation.js

@@ -0,0 +1,34 @@
+export default class Validation
+{
+  constructor()
+  {}
+
+  static is_int(n)
+  {
+    return Number(n) === n && n % 1 === 0;
+  }
+
+  static is_float(n)
+  {
+    return Number(n) === n && n % 1 !== 0;
+  }
+
+  static is_number(n)
+  {
+    return this.is_int(n) || this.is_float(n);
+  }
+
+  static is_json(str)
+  {
+    try
+    {
+      JSON.parse(str);
+    }
+    catch (e)
+    {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/view_components/ApplicationView.js

@@ -0,0 +1,60 @@
+import ResourceContainer from '../ResourceContainer';
+import DrawIOAnimationSheet from './transition/DrawIOAnimationSheet';
+import ViewManager from './ViewManager';
+import ViewState from './ViewState';
+
+export default class ApplicationView extends ViewState
+{
+  constructor({ name, url, container })
+  {
+    super(name);
+
+    this.container = container;
+    this.url = url;
+
+    let transition_data = new DrawIOAnimationSheet().parse(ResourceContainer.get(`${name}_data`));
+
+    let transitions = [
+      {
+        to: name,
+        data: transition_data
+      }
+    ];
+
+    ViewManager.register_view(this);
+    ViewManager.add_transitions(transitions);
+  }
+
+  show()
+  {
+    this.container.classList.add('before_enter');
+    this.container.classList.remove('before_exit');
+    this.container.classList.remove('hidden');
+  }
+
+  on_enter()
+  {
+    this.container.classList.remove('before_enter');
+    this.container.classList.remove('before_exit');
+    this.container.classList.remove('hidden');
+  }
+
+  before_exit()
+  {
+    this.container.classList.add('before_exit');
+    this.container.classList.remove('before_enter');
+    this.container.classList.remove('hidden');
+  }
+
+  hide()
+  {
+    this.container.classList.add('hidden');
+    this.container.classList.remove('before_enter');
+    this.container.classList.remove('before_exit');
+  }
+
+  set_opacity(opacity)
+  {
+    this.container.style.opacity = opacity;
+  }
+}

package/src/view_components/ViewComponent.js

@@ -0,0 +1,37 @@
+import ViewComponentManager from './ViewComponentManager';
+
+export default class ViewComponent
+{
+  constructor({ name, container })
+  {
+    this.name = name;
+    this.container = container;
+
+    ViewComponentManager.register_component(this);
+  }
+
+  start()
+  {
+  }
+
+  on_enter()
+  {
+    this.container.classList.remove('hidden');
+    ViewComponentManager.enable_component(this);
+  }
+
+  update()
+  {
+  }
+
+  on_exit()
+  {
+    this.container.classList.add('hidden');
+    ViewComponentManager.disable_component(this);
+  }
+
+  set_opacity(opacity)
+  {
+    this.container.style.opacity = opacity;
+  }
+}