ohzi-core 6.3.4 → 6.4.0

package/package.json

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

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/resource_loader/BasisLoader.js

@@ -4,19 +4,11 @@ import { sRGBEncoding } from 'three';
 
 export default class BasisLoader extends AbstractLoader
 {
-  constructor(resource_id, url, renderer, loader, size)
+  constructor(resource_id, url, loader, size)
   {
     super(resource_id, url, size);
 
     this.loader = loader;
-
-    this.loader.setWorkerLimit(1);
-
-    this.loader.setTranscoderPath(
-      'libs/basis/'
-    );
-
-    this.loader.detectSupport(renderer);
   }
 
   on_preloaded_finished(resource_container)

package/src/resource_loader/TextureLoader.js

@@ -30,6 +30,11 @@ export default class TextureLoader extends AbstractLoader
         this.__update_downloaded_bytes(1, 1);
         this.__loading_ended();
       };
+
+      image.onerror = () =>
+      {
+        console.error('Error loading texture. Maybe the resource is not an image?', this.url);
+      };
     });
   }
 }

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;