ohzi-core 5.13.2 → 5.14.2

package/src/components/Line.js

@@ -0,0 +1,199 @@
+import line_vs from '../shaders/basic_line/basic_line.vert';
+import line_fs from '../shaders/basic_line/basic_line.frag';
+
+import { Mesh } from 'three';
+import { BufferAttribute } from 'three';
+import { BufferGeometry } from 'three';
+import { ShaderMaterial } from 'three';
+import { Color } from 'three';
+
+export default class Line extends Mesh
+{
+  constructor(points)
+  {
+    let geometry = new BufferGeometry();
+    geometry.setAttribute('position',           new BufferAttribute(new Float32Array([]), 3));
+    geometry.setAttribute('next_position',      new BufferAttribute(new Float32Array([]), 3));
+    geometry.setAttribute('previous_position',  new BufferAttribute(new Float32Array([]), 3));
+    geometry.setAttribute('orientation',        new BufferAttribute(new Float32Array([]), 1));
+    geometry.setAttribute('coverage',           new BufferAttribute(new Float32Array([]), 1));
+
+    let material = new ShaderMaterial({
+      uniforms: {
+        _Thickness: { value: 0.2 },
+        _Length: { value: 0 },
+        _ElapsedTime: { value: 0 },
+        _Color: { value: new Color('#FF0000') }
+      },
+      vertexShader: line_vs,
+      fragmentShader: line_fs,
+      transparent: true,
+      depthWrite: false,
+      extensions: { derivatives: true }
+
+    });
+
+    super(geometry, material);
+
+    if (points)
+    {
+      this.setup(points);
+    }
+  }
+
+  setup(points)
+  {
+    let vertices = [];
+    let next_position = [];
+    let previous_position = [];
+    let orientation = [];
+    let coverage = [];
+    let accumulated_length = 0;
+
+    for (let i = 0; i < points.length; i++)
+    {
+      vertices.push(points[i].x);
+      vertices.push(points[i].y);
+      vertices.push(points[i].z);
+      orientation.push(1);
+
+      vertices.push(points[i].x);
+      vertices.push(points[i].y);
+      vertices.push(points[i].z);
+      orientation.push(-1);
+
+      let next_point = this.__get_next_position(points, i);
+      next_position.push(next_point.x);
+      next_position.push(next_point.y);
+      next_position.push(next_point.z);
+
+      next_position.push(next_point.x);
+      next_position.push(next_point.y);
+      next_position.push(next_point.z);
+
+      let previous_point = this.__get_previous_position(points, i);
+      previous_position.push(previous_point.x);
+      previous_position.push(previous_point.y);
+      previous_position.push(previous_point.z);
+
+      previous_position.push(previous_point.x);
+      previous_position.push(previous_point.y);
+      previous_position.push(previous_point.z);
+
+      coverage.push(accumulated_length);
+      coverage.push(accumulated_length);
+
+      if (i < points.length - 1)
+      {
+        accumulated_length += points[i].distanceTo(next_point);
+      }
+    }
+    let vertexList            = new Float32Array(vertices);
+    let nextPositionList      = new Float32Array(next_position);
+    let previousPositionList  = new Float32Array(previous_position);
+    let orientationList       = new Float32Array(orientation);
+    let coverageList          = new Float32Array(coverage);
+
+    let indices = [];
+    for (let i = 0; i < ((vertexList.length / 3) - 2) / 2; i++)
+    {
+      let index = (i * 2) + 1;
+      indices.push(index);
+      indices.push(index + 1);
+      indices.push(index - 1);
+
+      indices.push(index);
+      indices.push(index + 2);
+      indices.push(index + 1);
+    }
+
+    this.geometry.setIndex(indices);
+    this.geometry.getAttribute('position').copy(new BufferAttribute(vertexList, 3));
+    this.geometry.getAttribute('next_position').copy(new BufferAttribute(nextPositionList, 3));
+    this.geometry.getAttribute('previous_position').copy(new BufferAttribute(previousPositionList, 3));
+    this.geometry.getAttribute('orientation').copy(new BufferAttribute(orientationList, 1));
+    this.geometry.getAttribute('coverage').copy(new BufferAttribute(coverageList, 1));
+
+    this.geometry.getAttribute('position').needsUpdate = true;
+    this.geometry.getAttribute('next_position').needsUpdate = true;
+    this.geometry.getAttribute('previous_position').needsUpdate = true;
+    this.geometry.getAttribute('orientation').needsUpdate = true;
+    this.geometry.getAttribute('coverage').needsUpdate = true;
+
+    this.material.uniforms._Length.value = accumulated_length;
+    this._length = accumulated_length;
+  }
+
+  set thickness(value)
+  {
+    this.material.uniforms._Thickness.value = value;
+  }
+
+  get thickness()
+  {
+    return this.material.uniforms._Thickness.value;
+  }
+
+  __get_previous_position(points, i)
+  {
+    if (i === 0)
+    {
+      return points[1].clone().sub(points[0]).multiplyScalar(-1).add(points[0]);
+    }
+    else
+    {
+      return points[i - 1];
+    }
+  }
+
+  __get_next_position(points, i)
+  {
+    if (i === points.length - 1)
+    {
+      return points[points.length - 2].clone().sub(points[points.length - 1]).multiplyScalar(-1).add(points[points.length - 1]);
+    }
+    else
+    {
+      return points[i + 1];
+    }
+  }
+
+  update()
+  {
+  }
+
+  distance()
+  {
+    return this.accumulated_length;
+  }
+
+  total_length()
+  {
+    return this.accumulated_length;
+  }
+
+  dispose()
+  {
+    this.geometry.dispose();
+    this.material.dispose();
+    if (this.parent)
+    {
+      this.parent.remove(this);
+    }
+  }
+
+  set color(col)
+  {
+    this.material.uniforms._Color.value.set(col);
+  }
+
+  get color()
+  {
+    return this.material.uniforms._Color.value;
+  }
+
+  copy_color(col)
+  {
+    this.material.uniforms._Color.value.copy(col);
+  }
+}

package/src/components/MultiLinePath.js

@@ -0,0 +1,19 @@
+import Line from '../Line';
+
+import { Object3D } from 'three';
+
+export default class MultiLinePath extends Object3D
+{
+  constructor(paths, webgl)
+  {
+    super();
+
+    this.paths = [];
+    for (let i = 0; i < paths.length; i++)
+    {
+      let line = new Line(paths[i], webgl);
+      this.paths.push = line;
+      this.add(line);
+    }
+  }
+}

package/src/components/MultiLineText2D.js

@@ -0,0 +1,62 @@
+import Text2D from './Text2D';
+
+import { Object3D } from 'three';
+import { Vector2 } from 'three';
+
+export default class MultiLineText2D extends Object3D
+{
+  constructor(text_array, font, color, pivot, is_static)
+  {
+    super();
+
+    font = font || '200px Arial';
+    color = color || '#000000';
+    pivot = pivot || new Vector2();
+
+    this.text_array = [];
+
+    for (let i = 0; i < text_array.length; i++)
+    {
+      let text2D = new Text2D(text_array[i], font, color, pivot);
+      this.text_array.push(text2D);
+      this.add(text2D);
+    }
+
+    this.update_text_positions();
+  }
+
+  update_text_positions()
+  {
+    for (let i = 0; i < this.text_array.length; i++)
+    {
+      this.text_array[i].position.y = -this.text_array[i].size.y * i;
+    }
+  }
+
+  set texts(text_array)
+  {
+    for (let i = 0; i < this.text_array.length; i++)
+    {
+      this.text_array[i].text = text_array[i];
+    }
+  }
+
+  set size(value)
+  {
+    for (let i = 0; i < this.text_array.length; i++)
+    {
+      this.text_array[i].size = value;
+    }
+    this.update_text_positions();
+  }
+
+  get texts()
+  {
+    return [];
+  }
+
+  get size()
+  {
+    return 1;
+  }
+}

package/src/components/ObjectAxis.js

@@ -0,0 +1,20 @@
+import Arrow from '../primitives/Arrow';
+
+import { Object3D } from 'three';
+import { Vector3 } from 'three';
+
+export default class ObjectAxis extends Object3D
+{
+  constructor(obj, size)
+  {
+    super();
+    size = size || 1.5;
+    let right = new Vector3(1, 0, 0).applyQuaternion(obj.quaternion);
+    let up = new Vector3(0, 1, 0).applyQuaternion(obj.quaternion);
+    let forward = new Vector3(0, 0, 1).applyQuaternion(obj.quaternion);
+    console.log(right, up, forward);
+    this.add(new Arrow('#FF0000', size, right));
+    this.add(new Arrow('#00FF00', size, up));
+    this.add(new Arrow('#0000FF', size, forward));
+  }
+}

package/src/components/ObjectOrientedBoundingBox.js

@@ -0,0 +1,201 @@
+
+import { Vector3 } from 'three';
+import { Quaternion } from 'three';
+
+export default class ObjectOrientedBoundingBox
+{
+  constructor(points)
+  {
+    let degrees = 0;
+    let center = this.get_center(points);
+    // console.log(points);
+
+    let min = new Vector3(90000, 90000, 90000);
+    let max = new Vector3(-90000, -90000, -90000);
+
+    for (let deg = 0; deg < 359; deg++)
+    {
+      let local_min = new Vector3(100000, 100000, 100000);
+      let local_max = new Vector3(-100000, -100000, -100000);
+
+      for (let i = 0; i < points.length; i++)
+      {
+        let store_pos = points[i].clone();
+        // store_pos.set(points[i].x, points[i].z, points[i].y);
+
+        store_pos.sub(center);
+
+        let quaternion = new Quaternion();
+
+        quaternion.setFromAxisAngle(new Vector3(0, 1, 0), (deg / 359) * Math.PI * 2);
+
+        store_pos.applyQuaternion(quaternion);
+
+        if (store_pos.x < local_min.x)
+        {
+          local_min.x = store_pos.x;
+        }
+        if (store_pos.y < local_min.y)
+        {
+          local_min.y = store_pos.y;
+        }
+        if (store_pos.z < local_min.z)
+        {
+          local_min.z = store_pos.z;
+        }
+
+        if (store_pos.x > local_max.x)
+        {
+          local_max.x = store_pos.x;
+        }
+        if (store_pos.y > local_max.y)
+        {
+          local_max.y = store_pos.y;
+        }
+        if (store_pos.z > local_max.z)
+        {
+          local_max.z = store_pos.z;
+        }
+      }
+      if (this.box_volume(local_min, local_max) < this.box_volume(min, max))
+      {
+        max = local_max;
+        min = local_min;
+        degrees = deg;
+      }
+    }
+
+    this.axis_to_world = new Quaternion().setFromAxisAngle(new Vector3(0, -1, 0), (degrees / 359) * Math.PI * 2);
+    this.world_to_axis = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0),  (degrees / 359) * Math.PI * 2);
+
+    this.min = min.clone();
+    this.max = max.clone();
+    this.center = center;
+
+    let left_down   = min;
+    // let left_up     = min.clone().add(new Vector3(0, max.y - min.y, 0));
+    // let right_up    = max;
+    let right_down  = min.clone().add(new Vector3(max.x - min.x, 0, 0));
+
+    let deep_left   = min.clone().add(new Vector3(0, 0, max.z - min.z));
+    let deep_right  = min.clone().add(new Vector3(max.x - min.x, 0, max.z - min.z));
+
+    this.bounds = [];
+    this.bounds[0] = left_down.clone();
+    this.bounds[1] = right_down.clone();
+    this.bounds[2] = deep_right.clone();
+    this.bounds[3] = deep_left.clone();
+    this.bounds[4] = left_down.clone();
+    // ######################################
+
+    // DEBUG
+    // left_down.applyQuaternion(this.axis_to_world);
+    //   left_up.applyQuaternion(this.axis_to_world);
+    //   right_up.applyQuaternion(this.axis_to_world);
+    //   right_down.applyQuaternion(this.axis_to_world);
+
+    //   deep_left.applyQuaternion(this.axis_to_world);
+    //   deep_right.applyQuaternion(this.axis_to_world);
+
+    // Debug.draw_line(center.clone().add(left_down),center.clone().add(right_down));
+    //   Debug.draw_line(center.clone().add(left_down),center.clone().add(left_up));
+    //   Debug.draw_line(center.clone().add(left_down),center.clone().add(deep_left));
+    //   Debug.draw_line(center.clone().add(right_down),center.clone().add(deep_right));
+    //   Debug.draw_line(center.clone().add(deep_left),center.clone().add(deep_right));
+  }
+
+  get_center(points)
+  {
+    let v = new Vector3();
+    for (let i = 0; i < points.length; i++)
+    {
+      v.add(points[i]);
+    }
+    v.multiplyScalar(1 / points.length);
+    return v;
+  }
+
+  box_volume(min, max)
+  {
+    let difference = max.clone().sub(min);
+    return Math.abs(difference.x * difference.y * difference.x);
+  }
+
+  getSize()
+  {
+    return this.max.clone().sub(this.min);
+  }
+
+  is_inside_XZ(point)
+  {
+    let pos = point.clone();
+    pos.sub(this.center);
+    pos.applyQuaternion(this.world_to_axis);
+    if (pos.x > this.min.x &&
+        pos.z > this.min.z &&
+        pos.x < this.max.x &&
+        pos.z < this.max.z)
+    {
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  closest_point_on_bounds(reference_point)
+  {
+    let force = new Vector3();
+    for (let i = 0; i < this.bounds.length - 1; i++)
+    {
+      let dir = this.bounds[i + 1].clone().sub(this.bounds[i]);
+      dir.y = 0;
+      dir.normalize();
+      dir = new Vector3(dir.z, 0, -dir.x);
+
+      let dir_to_point = this.world_to_local(reference_point);
+      dir_to_point.sub(this.bounds[i]);
+      dir_to_point.y = 0;
+
+      if (dir_to_point.clone().normalize().dot(dir) > 0)
+      {
+        let dot = dir_to_point.clone().dot(dir);
+        force.add(dir.multiplyScalar(dot));
+      }
+    }
+    return this.local_to_world_dir(force);
+  }
+
+  world_to_local(point)
+  {
+    let pos = point.clone().sub(this.center);
+    pos.applyQuaternion(this.world_to_axis);
+    return pos;
+  }
+
+  local_to_world(point)
+  {
+    let pos = point.clone();
+    pos.applyQuaternion(this.axis_to_world);
+    pos.add(this.center);
+    return pos;
+  }
+
+  local_to_world_dir(direction)
+  {
+    let dir = direction.clone();
+    dir.applyQuaternion(this.axis_to_world);
+    return dir;
+  }
+
+  get_corners()
+  {
+    let corners = [];
+    for (let i = 0; i < this.bounds.length; i++)
+    {
+      corners.push(this.local_to_world(this.bounds[i]));
+    }
+    return corners;
+  }
+}

package/src/components/PlaneHelper.js

@@ -0,0 +1,36 @@
+
+import { Object3D } from 'three';
+import { MeshBasicMaterial } from 'three';
+import { PlaneGeometry } from 'three';
+import { Mesh } from 'three';
+
+export default class PlaneHelper extends Object3D
+{
+  constructor(scale = 1.0)
+  {
+    super();
+
+    const lineMat = new MeshBasicMaterial({ color: 0x4444ff, wireframe: true });
+    const geo = new PlaneGeometry(1, 1, 1, 1);
+    geo.rotateX(-Math.PI * 0.5);
+
+    const line = new Mesh(geo, lineMat);
+
+    const meshMat = new MeshBasicMaterial({ color: 0x00ff00, transparent: true, opacity: 0.8 });
+    const mesh = new Mesh(geo, meshMat);
+
+    this.renderOrder = 100000;
+    this.add(line);
+    this.add(mesh);
+    this.scale.set(scale, scale, scale);
+  }
+
+  update()
+  {
+  }
+
+  dispose()
+  {
+
+  }
+}

package/src/components/Shape2D.js

@@ -0,0 +1,42 @@
+import GeometryEdgeVisualizer from './GeometryEdgeVisualizer';
+
+import { Mesh } from 'three';
+import { Shape } from 'three';
+import { ShapeBufferGeometry } from 'three';
+import { MeshBasicMaterial } from 'three';
+
+export default class Shape2D extends Mesh
+{
+  constructor(points_2D, show_edges)
+  {
+    let shape = new Shape(points_2D);
+    let geometry = new ShapeBufferGeometry(shape);
+    geometry.rotateX(3.14 / 2);
+
+    let material = new MeshBasicMaterial({ color: 0xff0000 });
+    super(geometry, material);
+    this.invert_normals(geometry);
+
+    if (show_edges)
+    {
+      let edge_mesh = new GeometryEdgeVisualizer(geometry);
+      edge_mesh.hide_faces();
+      edge_mesh.material.depthTest = false;
+      this.add(edge_mesh);
+    }
+  }
+
+  invert_normals(geometry)
+  {
+    let indices = geometry.index.array;
+    for (let i = 0; i < indices.length; i += 3)
+    {
+      let x = indices[i + 0];
+      let z = indices[i + 2];
+
+      indices[i + 0] = z;
+      indices[i + 2] = x;
+    }
+    geometry.computeVertexNormals();
+  }
+}

package/src/components/Shape3D.js

@@ -0,0 +1,38 @@
+import GeometryEdgeVisualizer from './GeometryEdgeVisualizer';
+
+import { Mesh } from 'three';
+import { Shape } from 'three';
+import { ExtrudeBufferGeometry } from 'three';
+import { MeshNormalMaterial } from 'three';
+
+export default class Shape3D extends Mesh
+{
+  constructor(points_2D, show_edges, height)
+  {
+    let shape = new Shape(points_2D);
+    height = height || 1;
+
+    let extrudeSettings = {
+      steps: 2,
+      depth: height,
+      bevelEnabled: false,
+      bevelThickness: 1,
+      bevelSize: 1,
+      bevelSegments: 1
+    };
+
+    let geometry = new ExtrudeBufferGeometry(shape, extrudeSettings);
+    geometry.rotateX(3.14 / 2);
+    geometry.translate(0, height, 0);
+
+    let material = new MeshNormalMaterial({ color: 0xff0000 });
+    super(geometry, material);
+
+    if (show_edges)
+    {
+      let edge_mesh = new GeometryEdgeVisualizer(geometry, '#FF0000');
+      edge_mesh.hide_faces();
+      this.add(edge_mesh);
+    }
+  }
+}

package/src/components/Text2D.js

@@ -0,0 +1,39 @@
+import WorldImage from './WorldImage';
+import SimpleTextDrawer from '../canvas_drawer/SimpleTextDrawer';
+
+import { LinearMipMapLinearFilter } from 'three';
+import { LinearFilter } from 'three';
+
+export default class Text2D extends WorldImage
+{
+  constructor(text, font, color, pivot, is_static)
+  {
+    let simple_text_drawer = new SimpleTextDrawer(is_static);
+
+    let draw_settings = {
+      font: font,
+      font_color: color || '#000000'
+    };
+    let canvas_texture = simple_text_drawer.draw_on_texture(text, draw_settings);
+
+    canvas_texture.minFilter = LinearMipMapLinearFilter;
+    canvas_texture.minFilter = LinearFilter;
+    canvas_texture.needsUpdate = true;
+    super(canvas_texture, pivot);
+
+    this.simple_text_drawer = simple_text_drawer;
+    this.canvas_texture = canvas_texture;
+    this.draw_settings = draw_settings;
+  }
+
+  set text(value)
+  {
+    this.simple_text_drawer.draw_canvas(value, this.draw_settings);
+    this.update_texture();
+  }
+
+  get text()
+  {
+    return 'not implemented';
+  }
+}