source/animation/animation.h

   1 #ifndef MSP_GL_ANIMATION_H_
   2 #define MSP_GL_ANIMATION_H_
   3
   4 #include <msp/core/refptr.h>
   5 #include <msp/datafile/objectloader.h>
   6 #include <msp/interpolate/spline.h>
   7 #include <msp/time/timedelta.h>
   8 #include "keyframe.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 class AnimationEventObserver;
  14 class Armature;
  15 class Matrix;
  16 class Pose;
  17
  18 /**
  19 An Animation is a sequence of KeyFrames combined with timing information.  The
  20 state at any point in the animation can be interpolated from the keyframes.
  21 */
  22 class Animation
  23 {
  24 public:
  25         class Loader: public DataFile::CollectionObjectLoader<Animation>
  26         {
  27         private:
  28                 Time::TimeDelta current_time;
  29                 float start_slope;
  30                 float end_slope;
  31                 int slopes_set;
  32
  33         public:
  34                 Loader(Animation &a): Loader(a, 0) { }
  35                 Loader(Animation &a, Collection &c): Loader(a, &c) { }
  36         private:
  37                 Loader(Animation &, Collection *);
  38                 virtual void finish();
  39
  40                 void check_slopes_and_control(bool, bool);
  41                 void add_kf(const KeyFrame *, bool, bool);
  42                 void load_kf(const std::string &, bool);
  43                 void load_kf_inline(bool);
  44
  45                 void control_keyframe(const std::string &);
  46                 void control_keyframe_inline();
  47                 void event(const std::string &);
  48                 void event1i(const std::string &, int);
  49                 void event1f(const std::string &, float);
  50                 void event2f(const std::string &, float, float);
  51                 void event3f(const std::string &, float, float, float);
  52                 void event4f(const std::string &, float, float, float, float);
  53                 void interval(float);
  54                 void keyframe(const std::string &);
  55                 void keyframe_inline();
  56                 void slopes(float, float);
  57         };
  58
  59 private:
  60         enum CurveTarget
  61         {
  62                 POSITION,
  63                 EULER,
  64                 SCALE,
  65                 UNIFORM
  66         };
  67
  68         class Curve
  69         {
  70         protected:
  71                 CurveTarget target;
  72                 int component;
  73
  74                 Curve(CurveTarget, int);
  75         public:
  76                 virtual ~Curve() { }
  77
  78                 virtual void apply(float, Matrix &) const = 0;
  79                 virtual void apply(float, KeyFrame::AnimatedUniform &) const = 0;
  80         };
  81
  82         template<unsigned N>
  83         class ValueCurve: public Curve
  84         {
  85         public:
  86                 typedef typename Interpolate::SplineKnot<double, N> Knot;
  87
  88         private:
  89                 Interpolate::Spline<double, 3, N> spline;
  90
  91         public:
  92                 ValueCurve(CurveTarget, int, const std::vector<Knot> &);
  93
  94                 virtual void apply(float, Matrix &) const;
  95                 virtual void apply(float, KeyFrame::AnimatedUniform &) const;
  96         };
  97
  98         struct ExtractComponent
  99         {
 100                 typedef bool (*Extract)(const KeyFrame &, Vector3 &);
 101
 102                 Extract extract;
 103                 unsigned index;
 104                 Transform::ComponentMask mask;
 105
 106                 ExtractComponent(Extract e, unsigned i, Transform::ComponentMask m): extract(e), index(i), mask(m) { }
 107
 108                 bool operator()(const KeyFrame &, float &) const;
 109         };
 110
 111         template<unsigned N>
 112         struct ExtractUniform
 113         {
 114                 const std::string &name;
 115
 116                 ExtractUniform(const std::string &n): name(n) { }
 117
 118                 bool operator()(const KeyFrame &, typename Interpolate::SplineValue<float, N>::Type &) const;
 119         };
 120
 121         struct TimedKeyFrame
 122         {
 123                 Time::TimeDelta time;
 124                 const KeyFrame *keyframe;
 125                 bool control;
 126                 bool owned;
 127         };
 128
 129         struct Event
 130         {
 131                 Time::TimeDelta time;
 132                 std::string name;
 133                 Variant value;
 134         };
 135
 136         struct UniformInfo
 137         {
 138                 std::string name;
 139                 unsigned size;
 140
 141                 UniformInfo(const std::string &, unsigned);
 142         };
 143
 144 public:
 145         class Iterator
 146         {
 147         private:
 148                 const Animation *animation;
 149                 Time::TimeDelta elapsed;
 150                 std::vector<Event>::const_iterator event_iter;
 151                 bool end;
 152
 153         public:
 154                 Iterator(const Animation &);
 155
 156                 Iterator &operator+=(const Time::TimeDelta &);
 157                 void dispatch_events(AnimationEventObserver &);
 158
 159                 bool is_end() const { return end; }
 160                 Matrix get_matrix() const;
 161                 KeyFrame::AnimatedUniform get_uniform(unsigned) const;
 162                 Matrix get_pose_matrix(unsigned) const;
 163         };
 164
 165 private:
 166         const Armature *armature = 0;
 167         std::vector<TimedKeyFrame> keyframes;
 168         std::vector<Event> events;
 169         bool looping = false;
 170         std::vector<UniformInfo> uniforms;
 171         std::vector<Curve *> curves;
 172         unsigned uniform_curve_offset = 0;
 173
 174 public:
 175         ~Animation();
 176
 177         void set_armature(const Armature &);
 178         const Armature *get_armature() const { return armature; }
 179
 180         unsigned get_n_uniforms() const { return uniforms.size(); }
 181         unsigned get_slot_for_uniform(const std::string &) const;
 182         const std::string &get_uniform_name(unsigned) const;
 183
 184         void add_keyframe(const Time::TimeDelta &, const KeyFrame &);
 185         void add_keyframe_owned(const Time::TimeDelta &, const KeyFrame *);
 186         DEPRECATED void add_keyframe(const Time::TimeDelta &, const KeyFrame &, float);
 187         DEPRECATED void add_keyframe(const Time::TimeDelta &, const KeyFrame &, float, float);
 188         void add_control_keyframe(const KeyFrame &);
 189         void add_control_keyframe_owned(const KeyFrame *);
 190 private:
 191         void add_keyframe(const Time::TimeDelta &, const KeyFrame *, float, float, bool);
 192         void add_keyframe(const Time::TimeDelta &, const KeyFrame *, bool, bool);
 193         void prepare_keyframe(TimedKeyFrame &);
 194         void create_curves();
 195         void create_curve(CurveTarget, Transform::ComponentMask, ExtractComponent::Extract);
 196         template<unsigned N, typename T>
 197         void create_curve(CurveTarget target, int, const T &);
 198         static bool extract_position(const KeyFrame &, Vector3 &);
 199         static bool extract_euler(const KeyFrame &, Vector3 &);
 200         static bool extract_scale(const KeyFrame &, Vector3 &);
 201 public:
 202         void add_event(const Time::TimeDelta &, const std::string &, const Variant & = Variant());
 203
 204         const Msp::Time::TimeDelta &get_duration() const;
 205
 206         void set_looping(bool);
 207         bool is_looping() const { return looping; }
 208 };
 209
 210 } // namespace GL
 211 } // namespace Msp
 212
 213 #endif