PixiJS

Source: animate/AnimatorTimeline.js

animate/AnimatorTimeline.js

  1. const pool = [];
  2. import { Animator } from './Animator';
  3. /**
  4.  * Represents a single animation play.
  5.  * @class AnimatorTimeline
  6.  * @memberof PIXI.animate
  7.  */
  8. class AnimatorTimeline {
  9.     constructor() {
  10.         this._update = this.update.bind(this);
  11.         this.init(null, 0, 0, false, null);
  12.     }
  14.     /**
  15.      * The pool of timelines to use
  16.      * @method PIXI.animate.AnimatorTimeline#init
  17.      * @param {PIXI.animate.MovieClip} instance
  18.      * @param {Number} start
  19.      * @param {Number} end
  20.      * @param {Boolean} loop
  21.      * @param {Function} callback
  22.      * @private
  23.      */
  24.     init(instance, start, end, loop, callback) {
  26.         /**
  27.          * Instance of clip to play.
  28.          * @name PIXI.animate.AnimatorTimeline#instance
  29.          * @type {PIXI.animate.MovieClip}
  30.          * @readOnly
  31.          */
  32.         this.instance = instance;
  34.         /**
  35.          * `true` if the timeline is suppose to loop.
  36.          * @name PIXI.animate.AnimatorTimeline#loop
  37.          * @type {Boolean}
  38.          * @readOnly
  39.          */
  40.         this.loop = loop;
  42.         /**
  43.          * Frame number of the starting farme.
  44.          * @name PIXI.animate.AnimatorTimeline#start
  45.          * @type {int}
  46.          * @readOnly
  47.          */
  48.         this.start = start;
  50.         /**
  51.          * Frame number of the ending frame.
  52.          * @name PIXI.animate.AnimatorTimeline#end
  53.          * @type {int}
  54.          * @readOnly
  55.          */
  56.         this.end = end;
  58.         /**
  59.          * Callback called when completed (non-looping animation).
  60.          * @name PIXI.animate.AnimatorTimeline#callback
  61.          * @type {Function}
  62.          * @readOnly
  63.          */
  64.         this.callback = callback;
  66.         if (instance) {
  67.             //Prevent overshooting the end frame and looping back around:
  68.             instance.loop = false;
  69.             instance.gotoAndStop(start);
  70.             instance._beforeUpdate = this._update;
  71.         }
  72.     }
  74.     /**
  75.      * Don't use after this
  76.      * @method PIXI.animate.AnimatorTimeline#destroy
  77.      * @private
  78.      */
  79.     destroy() {
  80.         this.instance._beforeUpdate = null;
  81.         this.init(null, 0, 0, false, null);
  82.         AnimatorTimeline._pool.push(this);
  83.     }
  85.     /**
  86.      * Is the animation complete
  87.      * @method PIXI.animate.AnimatorTimeline#update
  88.      * @param {PIXI.animate.MovieClip} instance
  89.      * @return {Function} Callback to do after updateTimeline
  90.      * @private
  91.      */
  92.     update(instance) {
  93.         let completed;
  94.         if (instance.currentFrame >= this.end) {
  96.             // In case we over-shoot the current frame becuase of low FPS
  97.             instance.currentFrame = this.end;
  99.             if (this.loop) {
  100.                 // Update timeline so we get actions at the end frame
  101.                 instance._updateTimeline();
  102.                 instance.gotoAndPlay(this.start);
  103.             } else {
  104.                 instance.stop();
  105.                 if (this.callback) {
  106.                     completed = this.callback;
  107.                 }
  108.                 this.stop(); // cleanup timeline
  109.             }
  110.         }
  111.         return completed;
  112.     }
  114.     /**
  115.      * Stop the animation, cannot be reused.
  116.      * @method PIXI.animate.AnimatorTimeline#stop
  117.      */
  118.     stop() {
  119.         // PIXI.animate.Animator._internalStop(this);
  120.         Animator._internalStop(this);
  121.     }
  123.     /**
  124.      * The progress from 0 to 1 of the playback.
  125.      * @name PIXI.animate.AnimatorTimeline#progress
  126.      * @type {Number}
  127.      * @readOnly
  128.      */
  129.     get progress() {
  130.         const progress = (this.instance.currentFrame - this.start) / (this.end - this.start);
  131.         return Math.max(0, Math.min(1, progress)); // clamp
  132.     }
  134.     /**
  135.      * The pool of timelines to use
  136.      * @name PIXI.animate.AnimatorTimeline._pool
  137.      * @type {Array<PIXI.animate.AnimatorTimeline>}
  138.      * @static
  139.      * @private
  140.      */
  141.     static get _pool() {
  142.         return pool;
  143.     }
  145.     /**
  146.      * Create a new timeline
  147.      * @method PIXI.animate.AnimatorTimeline.create
  148.      * @static
  149.      * @param {PIXI.animate.MovieClip} instance
  150.      * @param {Number} start
  151.      * @param {Number} end
  152.      * @param {Boolean} loop
  153.      * @param {Function} callback
  154.      * @return {PIXI.animate.AnimatorTimeline}
  155.      */
  156.     static create(instance, start, end, loop, callback) {
  157.         var timeline;
  158.         if (this._pool.length) {
  159.             timeline = this._pool.pop();
  160.         } else {
  161.             timeline = new AnimatorTimeline();
  162.         }
  163.         timeline.init(instance, start, end, loop, callback);
  164.         return timeline;
  165.     }
  166. }
  168. module.exports = AnimatorTimeline;