]> git.tdb.fi Git - libs/gl.git/blob - source/animation.cpp
Improve pipeline render target management
[libs/gl.git] / source / animation.cpp
1 #include <cmath>
2 #include <msp/datafile/collection.h>
3 #include <msp/time/units.h>
4 #include "animation.h"
5 #include "armature.h"
6 #include "error.h"
7 #include "keyframe.h"
8 #include "pose.h"
9
10 using namespace std;
11
12 namespace Msp {
13 namespace GL {
14
15 Animation::Animation():
16         armature(0),
17         looping(false)
18 { }
19
20 void Animation::set_armature(const Armature &a)
21 {
22         armature = &a;
23 }
24
25 void Animation::add_keyframe(const Time::TimeDelta &t, const KeyFrame &kf)
26 {
27         if(!keyframes.empty() && t<keyframes.back().time)
28                 throw invalid_argument("Animation::add_keyframe");
29
30         TimedKeyFrame tkf(*this);
31         tkf.time = t;
32         tkf.keyframe = &kf;
33         tkf.keyframe.keep();
34         prepare_keyframe(tkf);
35         keyframes.push_back(tkf);
36 }
37
38 void Animation::set_looping(bool l)
39 {
40         looping = l;
41 }
42
43 void Animation::prepare_keyframe(TimedKeyFrame &tkf)
44 {
45         tkf.prev = (keyframes.empty() ? 0 : &keyframes.back());
46         if(!tkf.prev)
47                 return;
48
49         tkf.prepare();
50 }
51
52
53 Animation::AxisInterpolation::AxisInterpolation():
54         slope(0),
55         scale(0)
56 { }
57
58 Animation::AxisInterpolation::AxisInterpolation(const double *axis1, const double *axis2)
59 {
60         // Compute a normalized vector halfway between the two endpoints
61         double half[3];
62         double len = 0;
63         for(unsigned i=0; i<3; ++i)
64         {
65                 half[i] = (axis1[i]+axis2[i])/2;
66                 len += half[i]*half[i];
67         }
68         len = sqrt(len);
69         for(unsigned i=0; i<3; ++i)
70                 half[i] /= len;
71
72         // Compute correction factors for smooth interpolation
73         double cos_half = axis1[0]*half[0]+axis1[1]*half[1]+axis1[2]*half[2];
74         double angle = acos(cos_half);
75         slope = (angle ? angle/tan(angle) : 1);
76         scale = cos_half;
77 }
78
79
80 Animation::MatrixInterpolation::MatrixInterpolation():
81         matrix1(0),
82         matrix2(0)
83 { }
84
85 Animation::MatrixInterpolation::MatrixInterpolation(const Matrix &m1, const Matrix &m2):
86         matrix1(&m1),
87         matrix2(&m2)
88 {
89         const double *m1_data = matrix1->data();
90         const double *m2_data = matrix2->data();
91         for(unsigned i=0; i<3; ++i)
92                 axes[i] = AxisInterpolation(m1_data+i*4, m2_data+i*4);
93 }
94
95 Matrix Animation::MatrixInterpolation::get(float t) const
96 {
97         float u = t*2.0f-1.0f;
98
99         double matrix[16];
100         for(unsigned i=0; i<4; ++i)
101         {
102                 const double *m1_col = matrix1->data()+i*4;
103                 const double *m2_col = matrix2->data()+i*4;
104                 double *out_col = matrix+i*4;
105
106                 if(i<3)
107                 {
108                         /* Linear interpolation will produce vectors that fall on the line
109                         between the two endpoints, and has a higher angular velocity near the
110                         middle.  We compensate for the velocity by interpolating the angle
111                         around the halfway point and computing its tangent.  This is
112                         approximated by a third degree polynomial, scaled so that the result
113                         will be in the range [-1, 1]. */
114                         float w = (axes[i].slope+(1-axes[i].slope)*u*u)*u*0.5f+0.5f;
115
116                         /* The interpolate vectors will also be shorter than unit length.  At
117                         the halfway point the length will be equal to the cosine of half the
118                         angle, which was computed earlier.  Use a second degree polynomial to
119                         approximate. */
120                         float n = (axes[i].scale+(1-axes[i].scale)*u*u);
121
122                         for(unsigned j=0; j<3; ++j)
123                                 out_col[j] = ((1-w)*m1_col[j]+w*m2_col[j])/n;
124                 }
125                 else
126                 {
127                         for(unsigned j=0; j<3; ++j)
128                                 out_col[j] = (1-t)*m1_col[j]+t*m2_col[j];
129                 }
130         }
131
132         matrix[3] = 0;
133         matrix[7] = 0;
134         matrix[11] = 0;
135         matrix[15] = 1;
136
137         return matrix;
138 }
139
140
141 Animation::TimedKeyFrame::TimedKeyFrame(const Animation &a):
142         animation(a),
143         prev(0)
144 { }
145
146 void Animation::TimedKeyFrame::prepare()
147 {
148         delta_t = time-prev->time;
149         matrix = MatrixInterpolation(prev->keyframe->get_matrix(), keyframe->get_matrix());
150         if(animation.armature)
151         {
152                 unsigned max_index = animation.armature->get_max_link_index();
153                 pose_matrices.resize(max_index+1);
154                 const Pose *pose1 = prev->keyframe->get_pose();
155                 const Pose *pose2 = keyframe->get_pose();
156                 static Matrix identity;
157                 for(unsigned i=0; i<=max_index; ++i)
158                 {
159                         const Matrix &matrix1 = (pose1 ? pose1->get_link_matrix(i) : identity);
160                         const Matrix &matrix2 = (pose2 ? pose2->get_link_matrix(i) : identity);
161                         pose_matrices[i] = MatrixInterpolation(matrix1, matrix2);
162                 }
163         }
164 }
165
166
167 Animation::Iterator::Iterator(const Animation &a):
168         animation(a),
169         iter(animation.keyframes.begin()),
170         end(false)
171 { }
172
173 Animation::Iterator &Animation::Iterator::operator+=(const Time::TimeDelta &t)
174 {
175         time_since_keyframe += t;
176         while(time_since_keyframe>iter->delta_t)
177         {
178                 KeyFrameList::const_iterator next = iter;
179                 ++next;
180                 if(next==animation.keyframes.end())
181                 {
182                         if(animation.looping)
183                                 next = animation.keyframes.begin();
184                         else
185                         {
186                                 end = true;
187                                 time_since_keyframe = iter->delta_t;
188                                 break;
189                         }
190                 }
191
192                 time_since_keyframe -= iter->delta_t;
193                 iter = next;
194         }
195
196         return *this;
197 }
198
199 Matrix Animation::Iterator::get_matrix() const
200 {
201         if(!iter->prev)
202                 return iter->keyframe->get_matrix();
203
204         return iter->matrix.get(time_since_keyframe/iter->delta_t);
205 }
206
207 Matrix Animation::Iterator::get_pose_matrix(unsigned link) const
208 {
209         if(!animation.armature)
210                 throw invalid_operation("Animation::Iterator::get_pose_matrix");
211         if(link>animation.armature->get_max_link_index())
212                 throw out_of_range("Animation::Iterator::get_pose_matrix");
213
214         if(!iter->prev)
215         {
216                 if(const Pose *pose = iter->keyframe->get_pose())
217                         return pose->get_link_matrix(link);
218                 else
219                         return Matrix();
220         }
221
222         // We must redo the base point correction since interpolation throws if off
223         Matrix result = iter->pose_matrices[link].get(time_since_keyframe/iter->delta_t);
224         const Vector3 &base = animation.armature->get_link(link).get_base();
225         Vector3 new_base = result*base;
226         result = Matrix::translation(base.x-new_base.x, base.y-new_base.y, base.z-new_base.z)*result;
227         return result;
228 }
229
230
231 Animation::Loader::Loader(Animation &a):
232         DataFile::CollectionObjectLoader<Animation>(a, 0)
233 {
234         init();
235 }
236
237 Animation::Loader::Loader(Animation &a, Collection &c):
238         DataFile::CollectionObjectLoader<Animation>(a, &c)
239 {
240         init();
241 }
242
243 void Animation::Loader::init()
244 {
245         add("armature", &Animation::armature);
246         add("interval", &Loader::interval);
247         add("keyframe", &Loader::keyframe);
248         add("keyframe", &Loader::keyframe_inline);
249         add("looping", &Animation::looping);
250 }
251
252 void Animation::Loader::keyframe(const string &n)
253 {
254         obj.add_keyframe(current_time, get_collection().get<KeyFrame>(n));
255 }
256
257 void Animation::Loader::keyframe_inline()
258 {
259         RefPtr<KeyFrame> kf = new KeyFrame;
260         if(coll)
261                 load_sub(*kf, get_collection());
262         else
263                 load_sub(*kf);
264
265         TimedKeyFrame tkf(obj);
266         tkf.time = current_time;
267         tkf.keyframe = kf;
268         obj.prepare_keyframe(tkf);
269         obj.keyframes.push_back(tkf);
270 }
271
272 void Animation::Loader::interval(float t)
273 {
274         current_time += t*Time::sec;
275 }
276
277 } // namespace GL
278 } // namespace Msp