ohzi-core 6.3.3 → 6.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohzi-core",
-  "version": "6.3.3",
+  "version": "6.3.6",
   "description": "OHZI Core Library",
   "source": "src/index.js",
   "module": "build/index.module.js",

package/src/Graphics.js

@@ -25,18 +25,20 @@ class Graphics
     this.canvas_context = undefined;
     this.context_attributes = undefined;
 
-    this.context_attributes = context_attributes || {
+    this.context_attributes = {
       alpha: true,
       depth: true,
       desynchronized: false,
       stencil: false,
       antialias: false,
       premultipliedAlpha: true,
-      preserveDrawingBuffer: false,
+      preserveDrawingBuffer: true,
       powerPreference: 'high-performance',
       logarithmicDepthBuffer: false
     };
 
+    Object.assign(this.context_attributes, context_attributes);
+
     if (context_attributes.force_webgl2)
     {
       this.canvas_context = canvas.getContext('webgl2', this.context_attributes) ||
@@ -57,6 +59,7 @@ class Graphics
       canvas: canvas,
       context: this.canvas_context
     });
+
     this._renderer.autoClear = false;
 
     this._renderer.setPixelRatio(1);

package/src/action_sequencer/ActionSequencer.js

@@ -1,5 +1,6 @@
 
 import { Math as TMath } from 'three';
+import OMath from '../utilities/OMath';
 
 export default class ActionSequencer
 {
@@ -121,9 +122,9 @@ export default class ActionSequencer
     this.channels[interpolator.attribute_name].push(keyframe);
   }
 
-  get_property_target_value(name)
+  get_current_target_value(name)
   {
-    const keyframe = this.__get_nearest_keyframe(name, this.elapsed_time);
+    const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
 
     if (this.elapsed_time < keyframe.from)
     {
@@ -133,6 +134,21 @@ export default class ActionSequencer
     return keyframe.interpolator.evaluate(1);
   }
 
+  get_current_starting_value(name)
+  {
+    const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
+
+    return keyframe.interpolator.evaluate(0);
+  }
+
+  get_current_progress(name)
+  {
+    const keyframe = this.__get_current_keyframe(name, this.elapsed_time);
+    const t = this.__linear_map_01(this.elapsed_time, keyframe.from, keyframe.to);
+
+    return keyframe.interpolator.easing_function(t);
+  }
+
   get_duration()
   {
     return this.duration;
@@ -154,7 +170,8 @@ export default class ActionSequencer
     for (let i = 0; i < channel_names.length; i++)
     {
       const name = channel_names[i];
-      const keyframe = this.__get_nearest_keyframe(name, from);
+      const keyframe = this.__get_current_keyframe(name, from);
+
       this.context[name] = this.evaluate_keyframe(keyframe, from);
     }
   }
@@ -162,6 +179,7 @@ export default class ActionSequencer
   evaluate_keyframe(keyframe, time)
   {
     this.tmp_t = this.__linear_map_01(time, keyframe.from, keyframe.to);
+
     return keyframe.interpolator.evaluate(TMath.clamp(this.tmp_t, 0, 1));
   }
 
@@ -170,30 +188,59 @@ export default class ActionSequencer
     return this.channels[channel_name];
   }
 
+  is_channel_redefined(channel_name)
+  {
+    for (let i = 0; i < this.channels[channel_name].length; i++)
+    {
+      const keyframe = this.channels[channel_name][i];
+
+      if (keyframe.interpolator.initial)
+      {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   __linear_map_01(value,
     from_range_start_value,
     from_range_end_value)
   {
-    return ((value - from_range_start_value) / (from_range_end_value - from_range_start_value)) * (1 - 0) + 0;
+    return OMath.saturate(((value - from_range_start_value) / (from_range_end_value - from_range_start_value)) * (1 - 0) + 0);
   }
 
-  __get_nearest_keyframe(channel_name, time)
+  __get_current_keyframe(channel_name, time)
   {
-    let closest = undefined;
-    let min_time = 9999999;
+    let current = undefined;
+
     const keyframes = this.channels[channel_name];
+
     for (let i = 0; i < keyframes.length; i++)
     {
       const keyframe = keyframes[i];
-      const middle_time = (keyframe.to - keyframe.from) / 2 + keyframe.from;
-      const distance_to_middle_time = Math.abs(time - middle_time);
 
-      if (distance_to_middle_time < min_time)
+      if (time >= keyframe.from && time <= keyframe.to)
       {
-        min_time = distance_to_middle_time;
-        closest = keyframe;
+        current = keyframe;
+        return current;
       }
     }
-    return closest;
+
+    let min = Infinity;
+
+    for (let i = 0; i < keyframes.length; i++)
+    {
+      const keyframe = keyframes[i];
+      const distance = Math.abs(keyframe.to - time);
+
+      if (distance < min)
+      {
+        current = keyframe;
+        min = distance;
+      }
+    }
+
+    return current;
   }
 }

package/src/action_sequencer/NumberInterpolator.js

@@ -3,13 +3,14 @@ import { Math as TMath } from 'three';
 
 export default class NumberInterpolator extends ActionInterpolator
 {
-  constructor(attribute_name, from = 0, to = 1, easing_function = 'linear')
+  constructor(attribute_name, from = 0, to = 1, initial = false, easing_function = 'linear')
   {
     super(easing_function);
 
     this.attribute_name = attribute_name;
     this.from = from;
     this.to = to;
+    this.initial = initial;
   }
 
   update(context, t)

package/src/view_components/transition/ActionSequencerBuilder.js

@@ -31,7 +31,14 @@ export default class ActionSequencerBuilder
     for (let i = 0; i < tracks.length; i++)
     {
       const t = tracks[i];
-      const interpolator = new NumberInterpolator(t.attribute_name, current_context[t.attribute_name], t.to_value, t.easing_function);
+      const interpolator = new NumberInterpolator(
+        t.attribute_name,
+        current_context[t.attribute_name],
+        t.to_value,
+        t.initial,
+        t.easing_function
+      );
+
       sequencer.add_action_interpolator(t.from_time, t.to_time, interpolator, true);
     }
 
@@ -58,6 +65,7 @@ export default class ActionSequencerBuilder
         from_time: 0,
         to_time: 1,
         to_value: state[keys[i]],
+        initial: true,
         easing_function: 'ease_in_out_cubic'
       });
     }
@@ -75,7 +83,14 @@ export default class ActionSequencerBuilder
     for (let i = 0; i < tracks.length; i++)
     {
       const t = tracks[i];
-      const interpolator = new NumberInterpolator(t.attribute_name, context[t.attribute_name], t.to_value, t.easing_function);
+      const interpolator = new NumberInterpolator(
+        t.attribute_name,
+        context[t.attribute_name],
+        t.to_value,
+        t.initial,
+        t.easing_function
+      );
+
       sequencer.add_action_interpolator(t.from_time, t.to_time, interpolator, true);
     }
 

package/types/action_sequencer/ActionSequencer.d.ts

@@ -19,7 +19,9 @@ export class ActionSequencer {
     is_finished(): boolean;
     add_action_event(trigger_time: any, action: any): void;
     add_action_interpolator(from: any, to: any, interpolator: any, use_dynamic_from_value?: boolean): void;
-    get_property_target_value(name: any): any;
+    get_current_starting_value(name: string): number;
+    get_current_target_value(name: string): number;
+    get_current_progress(name: string): number;
     get_duration(): number;
     __play_clips(from: any, to: any): void;
     evaluate_keyframe(keyframe: any, time: any): any;