ohzi-core 12.2.0 → 12.2.1

package/src/action_sequencer/ActionSequencer.js

@@ -1,8 +1,13 @@
-
+// @ts-check
 import { OMath } from '../utilities/OMath';
+import { ActionEvent } from './ActionEvent'; // eslint-disable-line no-unused-vars
+import { ActionInterpolator } from './ActionInterpolator'; // eslint-disable-line no-unused-vars
 
 class ActionSequencer
 {
+  /**
+   * @param {any} [context]
+   */
   constructor(context = {})
   {
     this.previous_elapsed_time = -0.00001;
@@ -10,6 +15,7 @@ class ActionSequencer
     this.playback_speed = this.__get_playback_speed();
     this.playing = true;
 
+    /** @type {{action:ActionEvent, trigger_time:number }[]} */
     this.action_events = [];
     this.context = context;
 
@@ -17,6 +23,7 @@ class ActionSequencer
 
     this.tmp_t = 0;
 
+    /** @type {{[key:string]:any[]}} */
     this.channels = {};
 
     const channel_names = Object.keys(context);
@@ -50,6 +57,9 @@ class ActionSequencer
     this.elapsed_time = duration;
   }
 
+  /**
+   * @param {number} delta_time
+   */
   update(delta_time)
   {
     if (this.playing)
@@ -60,6 +70,9 @@ class ActionSequencer
     }
   }
 
+  /**
+   * @param {number} time
+   */
   set_progress(time)
   {
     this.previous_elapsed_time = this.elapsed_time;
@@ -67,6 +80,9 @@ class ActionSequencer
     this.__play_clips(this.elapsed_time, this.elapsed_time);
   }
 
+  /**
+   * @param {number} t
+   */
   set_normalized_progress(t)
   {
     this.previous_elapsed_time = this.elapsed_time;
@@ -84,6 +100,10 @@ class ActionSequencer
     return this.elapsed_time > this.get_duration();
   }
 
+  /**
+   * @param {number} trigger_time
+   * @param {ActionEvent} action
+   */
   add_action_event(trigger_time, action)
   {
     this.action_events.push({
@@ -94,6 +114,12 @@ class ActionSequencer
     this.duration = Math.max(this.duration, trigger_time);
   }
 
+  /**
+   * @param {number} from
+   * @param {number} to
+   * @param {ActionInterpolator} interpolator
+   * @param {boolean} [use_dynamic_from_value]
+   */
   add_action_interpolator(from, to, interpolator, use_dynamic_from_value = false)
   {
     if (use_dynamic_from_value)
@@ -125,6 +151,9 @@ class ActionSequencer
     this.channels[interpolator.attribute_name].push(keyframe);
   }
 
+  /**
+   * @param {string} name
+   */
   get_current_target_value(name)
   {
     const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
@@ -137,6 +166,9 @@ class ActionSequencer
     return keyframe.interpolator.evaluate(1);
   }
 
+  /**
+   * @param {string} name
+   */
   get_current_starting_value(name)
   {
     const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
@@ -144,6 +176,9 @@ class ActionSequencer
     return keyframe.interpolator.evaluate(0);
   }
 
+  /**
+   * @param {string} name
+   */
   get_current_progress(name)
   {
     const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
@@ -157,7 +192,11 @@ class ActionSequencer
     return this.duration;
   }
 
-  __play_clips(from, to)
+  /**
+   * @param {number} from
+   * @param {number} to
+   */
+  __play_clips(from, to) // eslint-disable-line no-unused-vars
   {
     if (this.elapsed_time > this.previous_elapsed_time)
     {
@@ -174,6 +213,10 @@ class ActionSequencer
     }
   }
 
+  /**
+   * @param {number} from
+   * @param {number} to
+   */
   __play_events(from, to)
   {
     for (let i = 0; i < this.action_events.length; i++)
@@ -187,6 +230,10 @@ class ActionSequencer
     }
   }
 
+  /**
+   * @param {any} keyframe
+   * @param {number} time
+   */
   evaluate_keyframe(keyframe, time)
   {
     this.tmp_t = this.__linear_map_01(time, keyframe.from, keyframe.to);
@@ -194,11 +241,17 @@ class ActionSequencer
     return keyframe.interpolator.evaluate(OMath.clamp(this.tmp_t, 0, 1));
   }
 
+  /**
+   * @param {string} channel_name
+   */
   get_keyframes(channel_name)
   {
     return this.channels[channel_name];
   }
 
+  /**
+   * @param {string} channel_name
+   */
   is_channel_redefined(channel_name)
   {
     for (let i = 0; i < this.channels[channel_name].length; i++)
@@ -214,6 +267,12 @@ class ActionSequencer
     return true;
   }
 
+  /**
+   * @param {number} value
+   * @param {number} from_range_start_value
+   * @param {number} from_range_end_value
+   * @returns {number}
+   */
   __linear_map_01(value,
     from_range_start_value,
     from_range_end_value)
@@ -221,6 +280,10 @@ class ActionSequencer
     return OMath.saturate(((value - from_range_start_value) / (from_range_end_value - from_range_start_value)) * (1 - 0) + 0);
   }
 
+  /**
+   * @param {string} channel_name
+   * @param {number} time
+   */
   __get_current_keyframe(channel_name, time)
   {
     let current = undefined;

package/src/action_sequencer/NumberInterpolator.js

@@ -1,8 +1,16 @@
+// @ts-check
 import { ActionInterpolator } from './ActionInterpolator';
 import { OMath } from '../utilities/OMath';
 
 class NumberInterpolator extends ActionInterpolator
 {
+  /**
+   * @param {string} attribute_name
+   * @param {number} [from]
+   * @param {number} [to]
+   * @param {boolean} [initial]
+   * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} [easing_function]
+   */
   constructor(attribute_name, from = 0, to = 1, initial = false, easing_function = 'linear')
   {
     super(easing_function);
@@ -13,11 +21,18 @@ class NumberInterpolator extends ActionInterpolator
     this.initial = initial;
   }
 
+  /**
+   * @param {any} context
+   * @param {number} t
+   */
   update(context, t)
   {
     context[this.attribute_name] = OMath.lerp(this.from, this.to, this.easing_function(t));
   }
 
+  /**
+   * @param {number} t
+   */
   evaluate(t)
   {
     return OMath.lerp(this.from, this.to, this.easing_function(t));

package/src/action_sequencer/VectorInterpolator.js

@@ -1,8 +1,16 @@
+// @ts-check
+import { Vector3 } from 'three';
 import { ActionInterpolator } from './ActionInterpolator';
 
 class VectorInterpolator extends ActionInterpolator
 {
-  constructor(attribute_name, from = 0, to = 1, easing_function = 'linear')
+  /**
+   * @param {string} attribute_name
+   * @param {Vector3} [from]
+   * @param {Vector3} [to]
+   * @param {import('../utilities/EasingFunctions').EasingFunctionType | function} [easing_function]
+   */
+  constructor(attribute_name, from = new Vector3(), to = new Vector3(1, 1, 1), easing_function = 'linear')
   {
     super(easing_function);
 
@@ -11,6 +19,10 @@ class VectorInterpolator extends ActionInterpolator
     this.to = to;
   }
 
+  /**
+   * @param {any} context
+   * @param {number} t
+   */
   update(context, t)
   {
     const tmp = this.from.clone();

package/src/blitter_index.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { MedianFilter } from './render_utilities/MedianFilter';
 import { GaussianBlurrer } from './render_utilities/GaussianBlurrer';
 import { Blurrer } from './render_utilities/Blurrer';

package/src/canvas_drawer/CanvasDrawer.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { CanvasTexture } from 'three';
 import { Vector2 } from 'three';
 import { UVMapping } from 'three';
@@ -6,9 +7,12 @@ import { NearestFilter } from 'three';
 
 class CanvasDrawer
 {
+  /**
+   * @param {boolean} [uses_dynamic_font]
+   */
   constructor(uses_dynamic_font)
   {
-    this.uses_dynamic_font = uses_dynamic_font;
+    this.uses_dynamic_font = !!uses_dynamic_font;
     this.__textHeight = null;
 
     this.canvas = document.createElement('canvas');
@@ -31,6 +35,10 @@ class CanvasDrawer
     return this.__textHeight;
   }
 
+  /**
+   * @param {string} text
+   * @param {string} font
+   */
   get_text_size(text, font = '24px Arial')
   {
     const size = new Vector2();
@@ -40,6 +48,10 @@ class CanvasDrawer
     return size;
   }
 
+  /**
+   * @param {string} text
+   * @param {any} [ctxOptions]
+   */
   draw_canvas(text, ctxOptions = {})
   {
     ctxOptions.font = ctxOptions.font || '24px Arial';
@@ -49,6 +61,10 @@ class CanvasDrawer
     return this.canvas;
   }
 
+  /**
+   * @param {string} text
+   * @param {any} [ctxOptions]
+   */
   draw_on_texture(text, ctxOptions)
   {
     const canvas = this.draw_canvas(text, ctxOptions);
@@ -57,15 +73,31 @@ class CanvasDrawer
       ClampToEdgeWrapping,
       NearestFilter,
       NearestFilter);
-    canvas_texture.generateMipMaps = false;
+    canvas_texture.generateMipmaps = false;
     canvas_texture.needsUpdate = true;
 
     return canvas_texture;
   }
 
-  __draw(text, ctxOptions)
+  /**
+   * @param {string[] | string} text
+   * @param {any} [ctxOptions]
+   * @param {HTMLCanvasElement} [canvas]
+   * @param {CanvasRenderingContext2D} [ctx]
+   */
+  __draw(text, ctxOptions, canvas, ctx) // eslint-disable-line no-unused-vars
   {}
 
+  /**
+   * @param {CanvasRenderingContext2D} ctx
+   * @param {number} x
+   * @param {number} y
+   * @param {number} width
+   * @param {number} height
+   * @param {number | {tl:number, tr:number, br:number, bl:number}} radius
+   * @param {boolean} fill
+   * @param {boolean} stroke
+   */
   roundRect(ctx, x, y, width, height, radius, fill, stroke)
   {
     if (typeof stroke === 'undefined')
@@ -85,7 +117,8 @@ class CanvasDrawer
       const defaultRadius = { tl: 0, tr: 0, br: 0, bl: 0 };
       for (const side in defaultRadius)
       {
-        radius[side] = radius[side] || defaultRadius[side];
+        const _side = /** @type {keyof typeof defaultRadius} */ (side);
+        radius[_side] = radius[_side] || defaultRadius[_side];
       }
     }
     ctx.beginPath();

package/src/canvas_drawer/MultiLineTextDrawer.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { CanvasDrawer } from './CanvasDrawer';
 
 import { Vector2 } from 'three';
@@ -10,6 +11,12 @@ class MultiLineTextDrawer extends CanvasDrawer
     this.text_margin = new Vector2(2, 0);
   }
 
+  /**
+   * @param {string[]} text_array
+   * @param {any} [ctxOptions]
+   * @param {HTMLCanvasElement} [canvas]
+   * @param {CanvasRenderingContext2D} [ctx]
+   */
   __draw(text_array, ctxOptions, canvas, ctx)
   {
     ctx.font = ctxOptions.font;
@@ -37,7 +44,7 @@ class MultiLineTextDrawer extends CanvasDrawer
     ctx.font = ctxOptions.font;
     ctx.fillStyle = ctxOptions.font_color;
     ctx.textBaseline = 'middle';
-    ctx.textAlignment = 'left';
+    ctx.textAlign = 'left';
 
     const word_height = canvas.height / text_array.length;
     for (let i = 0; i < text_array.length; i++)

package/src/canvas_drawer/SimpleTextDrawer.js

@@ -1,4 +1,4 @@
-
+// @ts-check
 import { CanvasDrawer } from './CanvasDrawer';
 
 import { Vector2 } from 'three';
@@ -11,6 +11,12 @@ class SimpleTextDrawer extends CanvasDrawer
     this.text_margin = new Vector2(2, 0);
   }
 
+  /**
+   * @param {string} text
+   * @param {any} [ctxOptions]
+   * @param {HTMLCanvasElement} [canvas]
+   * @param {CanvasRenderingContext2D} [ctx]
+   */
   __draw(text, ctxOptions, canvas, ctx)
   {
     ctx.font = ctxOptions.font;

package/src/components/AudioClip.js

@@ -1,8 +1,15 @@
-import { Audio as TAudio } from 'three';
+// @ts-check
+import { AudioListener, Audio as TAudio } from 'three'; // eslint-disable-line no-unused-vars
 import { PositionalAudio as TPositionalAudio } from 'three';
 
 class AudioClip
 {
+  /**
+   * @param {AudioBuffer} buffer
+   * @param {boolean} [loop]
+   * @param {number} [volume]
+   * @param {boolean} [positional]
+   */
   constructor(buffer, loop = true, volume = 1, positional = false)
   {
     this.buffer = buffer;
@@ -13,6 +20,9 @@ class AudioClip
     this.audio = undefined;
   }
 
+  /**
+   * @param {AudioListener} audio_listener
+   */
   init(audio_listener)
   {
     if (this.positional)

package/src/components/AxisHelper.js

@@ -1,4 +1,4 @@
-
+// @ts-check
 import { Object3D } from 'three';
 import { LineBasicMaterial } from 'three';
 import { AlwaysDepth } from 'three';

package/src/components/BaseObject.js

@@ -1,5 +1,5 @@
-
-import { Object3D } from 'three';
+// @ts-check
+import { Mesh, Object3D } from 'three'; // eslint-disable-line no-unused-vars
 import { Vector3 } from 'three';
 
 class BaseObject extends Object3D
@@ -16,6 +16,9 @@ class BaseObject extends Object3D
     return this.___temp_w_pos;
   }
 
+  /**
+   * @param {Object3D | Mesh} obj
+   */
   deep_dispose(obj)
   {
     if (obj !== null)
@@ -24,13 +27,13 @@ class BaseObject extends Object3D
       {
         this.deep_dispose(obj.children[i]);
       }
-      if (obj.geometry)
+      if ('geometry' in obj)
       {
         obj.geometry.dispose();
       }
-      if (obj.material)
+      if ('material' in obj)
       {
-        if (obj.material.map)
+        if ('map' in obj.material)
         {
           obj.material.map.dispose();
         }

package/src/components/EdgeMesh.js

@@ -1,14 +1,25 @@
+// @ts-check
+// @ts-ignore
 import corners_frag from '../shaders/edges/corners.frag';
+// @ts-ignore
 import corners_vert from '../shaders/edges/corners.vert';
+// @ts-ignore
 import edge_line_frag from '../shaders/edges/edges.frag';
+// @ts-ignore
 import edge_line_vert from '../shaders/edges/edges.vert';
 
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
-import { BufferAttribute, Color, EdgesGeometry, LineBasicMaterial, LineSegments, Mesh, Object3D, PlaneGeometry, ShaderMaterial, Vector3 } from 'three';
+// eslint-disable-next-line no-unused-vars
+import { BufferAttribute, BufferGeometry, Color, EdgesGeometry, InterleavedBufferAttribute, LineBasicMaterial, LineSegments, Mesh, Object3D, PlaneGeometry, ShaderMaterial, Vector3 } from 'three';
 
 class EdgeMesh extends Object3D
 {
+  /**
+   * @param {BufferGeometry} buffer_geometry
+   * @param {number} [thickness]
+   * @param {string} [color]
+   */
   constructor(buffer_geometry, thickness, color)
   {
     super();
@@ -48,6 +59,10 @@ class EdgeMesh extends Object3D
     this.add(this.corners_mesh);
   }
 
+  /**
+   * @param {BufferGeometry} cube_geometry
+   * @returns {Vector3[]}
+   */
   __get_edges(cube_geometry)
   {
     const edges = new EdgesGeometry(cube_geometry);
@@ -62,11 +77,17 @@ class EdgeMesh extends Object3D
     return points;
   }
 
-  update(TIME)
+  /**
+   * @param {number} TIME
+   */
+  update(TIME) // eslint-disable-line no-unused-vars
   {
 
   }
 
+  /**
+   * @param {Vector3[]} points
+   */
   __get_edges_geometry(points)
   {
     const buffer_geometries = [];
@@ -108,6 +129,10 @@ class EdgeMesh extends Object3D
     return BufferGeometryUtils.mergeGeometries(buffer_geometries);
   }
 
+  /**
+   * @param {BufferAttribute | InterleavedBufferAttribute} geometry_vertices
+   * @returns {BufferGeometry}
+   */
   __get_corners_geometry(geometry_vertices)
   {
     const circle_buffer_geometries = [];
@@ -129,6 +154,9 @@ class EdgeMesh extends Object3D
     return BufferGeometryUtils.mergeGeometries(circle_buffer_geometries);
   }
 
+  /**
+   * @param {boolean} boolean
+   */
   set_visible(boolean)
   {
     this.edges_mesh.visible = boolean;

package/src/components/GeometryEdgeVisualizer.js

@@ -1,14 +1,21 @@
+// @ts-check
+// @ts-ignore
 import edge_visualizer_frag from '../shaders/edge_visualizer/edge_visualizer.frag';
+// @ts-ignore
 import edge_visualizer_vert from '../shaders/edge_visualizer/edge_visualizer.vert';
 
 import { GeometryUtilities } from '../utilities/GeometryUtilities';
 
-import { Mesh } from 'three';
+import { BufferGeometry, Mesh } from 'three'; // eslint-disable-line no-unused-vars
 import { Color } from 'three';
 import { ShaderMaterial } from 'three';
 
 class GeometryEdgeVisualizer extends Mesh
 {
+  /**
+   * @param {BufferGeometry} geometry
+   * @param {string | number} [line_color]
+   */
   constructor(geometry, line_color)
   {
     line_color = line_color || '#91EE91';
@@ -23,6 +30,7 @@ class GeometryEdgeVisualizer extends Mesh
       },
       vertexShader: edge_visualizer_vert,
       fragmentShader: edge_visualizer_frag,
+      // @ts-ignore
       extensions: { derivatives: true },
       transparent: true,
       depthWrite: false
@@ -37,6 +45,7 @@ class GeometryEdgeVisualizer extends Mesh
     GeometryUtilities.add_barycentric_attribute(non_indexed_geometry);
 
     super(non_indexed_geometry, material);
+    this.material = material;
   }
 
   hide_faces()

package/src/components/Grid.js

@@ -1,4 +1,7 @@
+// @ts-check
+// @ts-ignore
 import grid_frag from '../shaders/grid/grid.frag';
+// @ts-ignore
 import grid_vert from '../shaders/grid/grid.vert';
 
 import { GeometryUtilities } from '../utilities/GeometryUtilities';
@@ -18,6 +21,7 @@ class Grid extends Mesh
       },
       vertexShader: grid_vert,
       fragmentShader: grid_frag,
+      // @ts-ignore
       extensions: { derivatives: true },
       transparent: true,
       depthWrite: false

package/src/components/Line.js

@@ -1,7 +1,10 @@
+// @ts-check
+// @ts-ignore
 import line_vs from '../shaders/basic_line/basic_line.vert';
+// @ts-ignore
 import line_fs from '../shaders/basic_line/basic_line.frag';
 
-import { Mesh } from 'three';
+import { Mesh, Vector3 } from 'three'; // eslint-disable-line no-unused-vars
 import { BufferAttribute } from 'three';
 import { BufferGeometry } from 'three';
 import { ShaderMaterial } from 'three';
@@ -9,6 +12,9 @@ import { Color } from 'three';
 
 class Line extends Mesh
 {
+  /**
+   * @param {Vector3[]} [points]
+   */
   constructor(points)
   {
     const geometry = new BufferGeometry();
@@ -29,18 +35,22 @@ class Line extends Mesh
       fragmentShader: line_fs,
       transparent: true,
       depthWrite: false,
+      // @ts-ignore
       extensions: { derivatives: true }
 
     });
 
     super(geometry, material);
-
+    this.material = material;
     if (points)
     {
       this.setup(points);
     }
   }
 
+  /**
+   * @param {Vector3[]} points
+   */
   setup(points)
   {
     const vertices = [];
@@ -108,11 +118,11 @@ class Line extends Mesh
     }
 
     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));
+    /** @type {BufferAttribute} */(this.geometry.getAttribute('position')).copy(new BufferAttribute(vertexList, 3));
+    /** @type {BufferAttribute} */(this.geometry.getAttribute('next_position')).copy(new BufferAttribute(nextPositionList, 3));
+    /** @type {BufferAttribute} */(this.geometry.getAttribute('previous_position')).copy(new BufferAttribute(previousPositionList, 3));
+    /** @type {BufferAttribute} */(this.geometry.getAttribute('orientation')).copy(new BufferAttribute(orientationList, 1));
+    /** @type {BufferAttribute} */(this.geometry.getAttribute('coverage')).copy(new BufferAttribute(coverageList, 1));
 
     this.geometry.getAttribute('position').needsUpdate = true;
     this.geometry.getAttribute('next_position').needsUpdate = true;
@@ -122,6 +132,7 @@ class Line extends Mesh
 
     this.material.uniforms._Length.value = accumulated_length;
     this._length = accumulated_length;
+    this.accumulated_length = accumulated_length;
   }
 
   set thickness(value)
@@ -134,6 +145,11 @@ class Line extends Mesh
     return this.material.uniforms._Thickness.value;
   }
 
+  /**
+   * @param {Vector3[]} points
+   * @param {number} i
+   * @returns {Vector3}
+   */
   __get_previous_position(points, i)
   {
     if (i === 0)
@@ -146,6 +162,11 @@ class Line extends Mesh
     }
   }
 
+  /**
+   * @param {Vector3[]} points
+   * @param {number} i
+   * @returns {Vector3}
+   */
   __get_next_position(points, i)
   {
     if (i === points.length - 1)
@@ -192,6 +213,9 @@ class Line extends Mesh
     return this.material.uniforms._Color.value;
   }
 
+  /**
+   * @param {Color} col
+   */
   copy_color(col)
   {
     this.material.uniforms._Color.value.copy(col);