Ramp.h

/*
 * Ramp.h
 *
 * (c) 2015 Sofian Audry        :: info(@)sofianaudry(.)com
 * (c) 2015 Thomas O Fredericks :: tof(@)t-o-f(.)info
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef RAMP_H_
#define RAMP_H_
 
#include "PqCore.h"
#include "AbstractTimer.h"
#include "pq_easing.h"
 
namespace pq {
 
enum {
  RAMP_DURATION,
  RAMP_SPEED
};
 
class Ramp : public Unit, public AbstractTimer {
public:
  Ramp(Engine& engine = Engine::primary());
 
  Ramp(float duration, Engine& engine = Engine::primary());
 
  virtual float get();
 
  virtual float put(float value);
 
  virtual float mapTo(float toLow, float toHigh);
 
  void easing(easing_function easing);
 
  void noEasing() { easing(easeNone); }
 
  virtual void to(float to);
 
  virtual void from(float from);
 
  virtual void fromTo(float from, float to);
 
  virtual void duration(float duration);
 
  virtual float duration() const { return AbstractTimer::duration(); }
 
  virtual void speed(float speed);
 
  virtual float speed() const;
 
  virtual void start();
 
  // virtual void go(float from, float to, float durationOrSpeed, uint8_t mode, easing_function easing=0);
  virtual void go(float from, float to, float durationOrSpeed, easing_function easing=0);
 
  virtual void go(float to, float durationOrSpeed, easing_function easing=0);
 
  virtual void go(float to, easing_function easing=0);
 
  virtual void mode(uint8_t mode);
 
  uint8_t mode() const { return _mode; }
 
  virtual bool finished() { return (_finishedState == JUST_FINISHED); }
 
  virtual void onFinish(EventCallback callback) { onEvent(callback, EVENT_FINISH); }
 
  virtual void setTime(float time);
 
  float durationToSpeed(float duration) const;
 
  float speedToDuration(float speed) const;
 
  [[deprecated("Use go(float,easing_function) instead.")]]
  virtual void start(float to, float durationOrSpeed, easing_function easing=0);
 
  [[deprecated("Use go(float,float,easing_function) instead.")]]
  virtual void start(float from, float to, float durationOrSpeed, easing_function easing=0);
 
private:
  // Finished states.
  enum {
    NOT_FINISHED,  // before finished
    JUST_FINISHED, // just finished this step
    POST_FINISHED  // after finished triggered
  };
 
protected:
  virtual void begin();
  virtual void step();
 
  virtual bool eventTriggered(EventType eventType) {
    switch (eventType) {
      case EVENT_FINISH: return finished();
      default:           return Unit::eventTriggered(eventType);
    }
  }
 
  // Sets duration or speed (depending on current mode).
  void _durationOrSpeed(float durationOrSpeed);
  float _durationOrSpeed() const;
 
  // Returns current absolute time (in seconds).
  virtual float _time() const;
 
  // The starting point.
  float _from;
 
  // The end point.
  float _to;
 
  // The current value.
  float _value;
 
  // Optional easing function.
  easing_function _easing;
 
#if PQ_OPTIMIZE_FOR_CPU
  // Speed.
  float _speed;
#endif
 
  // Mode (DURATION or SPEED).
  uint8_t _mode          : 1;
 
  // Finished flag.
  uint8_t _finishedState : 2;
 
  // Flag that makes sure the value is updated only on a need basis.
  bool _valueNeedsUpdate : 1;
 
  // Unused extra space.
  uint8_t _data          : 4;
};
 
}
 
#endif