nowtime() is time consuming operation, to provide a functional way to get values like getCurrentTime, getGlobalTime, getEntropy, getGlobalEntropy with ntime param. think about we have thousands of timeline based sprites need to do animiation, we can schedule a task to defeind nowtime just once, and pass it around to calc the time as needed, we can save tons of cpu time.

Author: SijieCai

src/index.js

@@ -32,18 +32,20 @@ class Timeline {
     // timeMark sorted by entropy
     // If you reset entropy, all the timeMarks behind the new entropy
     // should be dropped
+    const ntime = options.ntime === undefined ? nowtime() : options.ntime;
+
     this[_timeMark] = [{
-      globalTime: this.globalTime,
+      globalTime: this.getGlobalTime(ntime),
       localTime: -options.originTime,
       entropy: -options.originTime,
       playbackRate: options.playbackRate,
       globalEntropy: 0,
     }];
 
-    this[_createTime] = nowtime();
+    this[_createTime] = ntime;
 
     if(this[_parent]) {
-      this[_timeMark][0].globalEntropy = this[_parent].entropy;
+      this[_timeMark][0].globalEntropy = this[_parent].getEntropy(ntime);
     }
 
     this[_originTime] = options.originTime;
@@ -59,13 +61,15 @@ class Timeline {
     return this[_timeMark][this[_timeMark].length - 1];
   }
 
-  markTime({time = this.currentTime, entropy = this.entropy, playbackRate = this.playbackRate} = {}) {
+  markTime(options = {}) {
+    const ntime = nowtime();
+    const {time = this.getCurrentTime(ntime), entropy = this.getEntropy(ntime), playbackRate = this.playbackRate} = options;
     const timeMark = {
-      globalTime: this.globalTime,
+      globalTime: this.getGlobalTime(ntime),
       localTime: time,
       entropy,
       playbackRate,
-      globalEntropy: this.globalEntropy,
+      globalEntropy: this.getGlobalEntropy(ntime),
     };
     this[_timeMark].push(timeMark);
   }
@@ -75,6 +79,11 @@ class Timeline {
     return localTime + (this.globalTime - globalTime) * this.playbackRate;
   }
 
+  getCurrentTime(ntime) {
+    const {localTime, globalTime} = this.lastTimeMark;
+    return localTime + (this.getGlobalTime(ntime) - globalTime) * this.playbackRate;
+  }
+
   set currentTime(time) {
     const from = this.currentTime,
       to = time,
@@ -111,10 +120,22 @@ class Timeline {
     return entropy + Math.abs((this.globalEntropy - globalEntropy) * this.playbackRate);
   }
 
+  getEntropy(ntime) {
+    const {entropy, globalEntropy} = this.lastTimeMark;
+    return entropy + Math.abs((this.getGlobalEntropy(ntime) - globalEntropy) * this.playbackRate);
+  }
+
   get globalEntropy() {
     return this[_parent] ? this[_parent].entropy : nowtime() - this[_createTime];
   }
 
+  getGlobalEntropy(ntime) {
+    if(this[_parent]) {
+      return this[_parent].getEntropy(ntime);
+    }
+    return (ntime === undefined ? nowtime() : ntime) - this[_createTime];
+  }
+
   get globalTime() {
     if(this[_parent]) {
       return this[_parent].currentTime;
@@ -123,6 +144,13 @@ class Timeline {
     return nowtime();
   }
 
+  getGlobalTime(ntime) {
+    if(this[_parent]) {
+      return this[_parent].getCurrentTime(ntime);
+    }
+    return ntime === undefined ? nowtime() : ntime;
+  }
+
   // change entropy will NOT cause currentTime changing but may influence the pass
   // and the future of the timeline. (It may change the result of seek***Time)
   // While entropy is set, all the marks behind will be droped
@@ -291,7 +319,6 @@ class Timeline {
       globalTimeout = parent ? parent.setTimeout.bind(parent) : setTimeout;
 
     const heading = time.heading;
-    // console.log(heading, parent, delay)
     if(!parent && heading === false && delay < 0) {
       delay = Infinity;
     }
@@ -322,3 +349,4 @@ class Timeline {
 }
 
 export default Timeline;
+export {nowtime};

test/get-methods.js

@@ -0,0 +1,78 @@
+import Timeline, {nowtime} from '../src/index'
+const colors = require('colors')
+const test = require("ava")
+
+function makeTimeCompare(startTime) {
+  return function (time, expect) {
+    const precision = Math.abs(time - expect),
+      passedTime = Math.max(Date.now() - startTime, 100),
+      percent = precision / passedTime
+
+    let color = colors.green,
+      pass = true
+
+    if(percent > 0.05 && percent <= 0.10) {
+      color = colors.cyan
+    }
+    if(percent > 0.10 && percent <= 0.20) {
+      color = colors.yellow
+    }
+    if(percent > 0.20) {
+      color = colors.red
+      pass = false
+    }
+
+    return pass
+  }
+}
+
+function _caseSync(fn) {
+  return function (t) {
+    const startTime = Date.now()
+    t.time_compare = makeTimeCompare(startTime)
+    return fn(t)
+  }
+}
+test('default nowtime', _caseSync(t => {
+
+  const timeline = new Timeline();
+
+  // no pass ntime will default to nowtime()
+  t.truthy(t.time_compare(timeline.getCurrentTime(), 0));
+  t.truthy(t.time_compare(timeline.getGlobalEntropy(), 0));
+}))
+
+
+test('timeline originTime', t => {
+  const timeline = new Timeline({ntime: 0, originTime: 50})
+  t.truthy(timeline.getCurrentTime(10) === -40);
+})
+
+test('timeline paused', t => {
+  const timeline = new Timeline({playbackRate: 0, ntime: 0});
+  t.truthy(timeline.getCurrentTime(100) === 0);
+})
+
+test('timeline playbackRate', t => {
+  var timeline = new Timeline({ntime: 0, playbackRate: 2})
+  t.truthy(timeline.getCurrentTime(100) === 200);
+
+
+  timeline = new Timeline({ntime: 0, playbackRate: -2})
+  t.truthy(timeline.getCurrentTime(100) === -200);
+})
+
+test('timeline entropy', t => {
+  const timeline = new Timeline({ntime: 0, playbackRate: -2});
+
+  t.truthy(timeline.getEntropy(200) === 400);
+})
+
+test('timeline fork', t => {
+  const timeline = new Timeline({playbackRate: 2, ntime: 0}),
+    timeline2 = timeline.fork({playbackRate: 3, ntime: 80})
+
+  const passedTime = 100;
+  t.truthy(timeline.getEntropy(passedTime) === passedTime * 2)
+  t.truthy(timeline2.getEntropy(passedTime) === 20 * 6)
+})