]> git.tdb.fi Git - libs/gl.git/blob - source/animation.h
1ae571e7db217e8e624c6475dc6c4731ebf08a9d
[libs/gl.git] / source / 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/time/timedelta.h>
7 #include "keyframe.h"
8
9 namespace Msp {
10 namespace GL {
11
12 class Armature;
13 class Matrix;
14 class Pose;
15
16 /**
17 An Animation is a sequence of KeyFrames combined with timing information.  The
18 state at any point in the animation can be interpolated from the keyframes.
19 */
20 class Animation
21 {
22 public:
23         class Loader: public DataFile::CollectionObjectLoader<Animation>
24         {
25         private:
26                 Time::TimeDelta current_time;
27
28         public:
29                 Loader(Animation &);
30                 Loader(Animation &, Collection &);
31         private:
32                 void init();
33
34                 void keyframe(const std::string &);
35                 void keyframe_inline();
36                 void interval(float);
37         };
38
39 private:
40         struct AxisInterpolation
41         {
42                 float slope;
43                 float scale;
44
45                 AxisInterpolation();
46                 AxisInterpolation(const float *, const float *);
47         };
48
49         struct MatrixInterpolation
50         {
51                 const Matrix *matrix1;
52                 const Matrix *matrix2;
53                 AxisInterpolation axes[3];
54
55                 MatrixInterpolation();
56                 MatrixInterpolation(const Matrix &, const Matrix &);
57
58                 Matrix get(float) const;
59         };
60
61         struct TimedKeyFrame
62         {
63                 const Animation &animation;
64                 const TimedKeyFrame *prev;
65                 Time::TimeDelta time;
66                 Time::TimeDelta delta_t;
67                 RefPtr<const KeyFrame> keyframe;
68                 MatrixInterpolation matrix;
69                 std::vector<KeyFrame::AnimatedUniform> uniforms;
70                 std::vector<MatrixInterpolation> pose_matrices;
71
72                 TimedKeyFrame(const Animation &);
73                 void prepare();
74         };
75
76         typedef std::list<TimedKeyFrame> KeyFrameList;
77
78         struct UniformInfo
79         {
80                 std::string name;
81                 unsigned size;
82
83                 UniformInfo(const std::string &, unsigned);
84         };
85
86 public:
87         class Iterator
88         {
89         private:
90                 const Animation &animation;
91                 KeyFrameList::const_iterator iter;
92                 Time::TimeDelta time_since_keyframe;
93                 bool end;
94
95         public:
96                 Iterator(const Animation &);
97
98                 Iterator &operator+=(const Time::TimeDelta &);
99
100                 bool is_end() const { return end; }
101                 Matrix get_matrix() const;
102                 KeyFrame::AnimatedUniform get_uniform(unsigned) const;
103                 Matrix get_pose_matrix(unsigned) const;
104         };
105
106 private:
107         const Armature *armature;
108         KeyFrameList keyframes;
109         bool looping;
110         std::vector<UniformInfo> uniforms;
111
112 public:
113         Animation();
114         ~Animation();
115
116         void set_armature(const Armature &);
117         const Armature *get_armature() const { return armature; }
118
119         unsigned get_n_uniforms() const { return uniforms.size(); }
120         unsigned get_slot_for_uniform(const std::string &) const;
121         const std::string &get_uniform_name(unsigned) const;
122
123         void add_keyframe(const Time::TimeDelta &, const KeyFrame &);
124 private:
125         void prepare_keyframe(TimedKeyFrame &);
126
127 public:
128         void set_looping(bool);
129 };
130
131 } // namespace GL
132 } // namespace Msp
133
134 #endif