]> git.tdb.fi Git - libs/gl.git/blob - source/animation.cpp
Disable core version of primitive restart on Radeon as well
[libs/gl.git] / source / animation.cpp
1 #include <cmath>
2 #include <msp/core/maputils.h>
3 #include <msp/datafile/collection.h>
4 #include <msp/time/units.h>
5 #include "animation.h"
6 #include "armature.h"
7 #include "error.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 // Avoid synthesizing ~RefPtr in files including animation.h
21 Animation::~Animation()
22 { }
23
24 void Animation::set_armature(const Armature &a)
25 {
26         armature = &a;
27 }
28
29 unsigned Animation::get_slot_for_uniform(const string &n) const
30 {
31         for(unsigned i=0; i<uniforms.size(); ++i)
32                 if(uniforms[i].name==n)
33                         return i;
34         throw key_error(n);
35 }
36
37 const string &Animation::get_uniform_name(unsigned i) const
38 {
39         if(i>=uniforms.size())
40                 throw out_of_range("Animation::get_uniform_name");
41         return uniforms[i].name;
42 }
43
44 void Animation::add_keyframe(const Time::TimeDelta &t, const KeyFrame &kf)
45 {
46         if(!keyframes.empty() && t<keyframes.back().time)
47                 throw invalid_argument("Animation::add_keyframe");
48
49         TimedKeyFrame tkf(*this);
50         tkf.time = t;
51         tkf.keyframe = &kf;
52         tkf.keyframe.keep();
53         prepare_keyframe(tkf);
54         keyframes.push_back(tkf);
55 }
56
57 void Animation::set_looping(bool l)
58 {
59         looping = l;
60 }
61
62 void Animation::prepare_keyframe(TimedKeyFrame &tkf)
63 {
64         tkf.prev = (keyframes.empty() ? 0 : &keyframes.back());
65
66         const KeyFrame::UniformMap &kf_uniforms = tkf.keyframe->get_uniforms();
67         for(KeyFrame::UniformMap::const_iterator i=kf_uniforms.begin(); i!=kf_uniforms.end(); ++i)
68         {
69                 bool found = false;
70                 for(unsigned j=0; (!found && j<uniforms.size()); ++j)
71                         if(uniforms[j].name==i->first)
72                         {
73                                 if(uniforms[j].size!=i->second.size)
74                                         throw invalid_operation("Animation::prepare_keyframe");
75                                 found = true;
76                         }
77
78                 if(!found)
79                         uniforms.push_back(UniformInfo(i->first, i->second.size));
80         }
81
82         tkf.prepare();
83 }
84
85
86 Animation::AxisInterpolation::AxisInterpolation():
87         slope(0),
88         scale(0)
89 { }
90
91 Animation::AxisInterpolation::AxisInterpolation(const float *axis1, const float *axis2)
92 {
93         // Compute a normalized vector halfway between the two endpoints
94         float half[3];
95         float a1_len = 0;
96         float h_len = 0;
97         for(unsigned i=0; i<3; ++i)
98         {
99                 half[i] = (axis1[i]+axis2[i])/2;
100                 a1_len += axis1[i]*axis1[i];
101                 h_len += half[i]*half[i];
102         }
103
104         // Compute correction factors for smooth interpolation
105         float cos_half = (axis1[0]*half[0]+axis1[1]*half[1]+axis1[2]*half[2])/sqrt(a1_len*h_len);
106         float angle = acos(cos_half);
107         slope = (angle ? angle/tan(angle) : 1);
108         scale = cos_half;
109 }
110
111
112 Animation::MatrixInterpolation::MatrixInterpolation():
113         matrix1(0),
114         matrix2(0)
115 { }
116
117 Animation::MatrixInterpolation::MatrixInterpolation(const Matrix &m1, const Matrix &m2):
118         matrix1(&m1),
119         matrix2(&m2)
120 {
121         const float *m1_data = matrix1->data();
122         const float *m2_data = matrix2->data();
123         for(unsigned i=0; i<3; ++i)
124                 axes[i] = AxisInterpolation(m1_data+i*4, m2_data+i*4);
125 }
126
127 Matrix Animation::MatrixInterpolation::get(float t) const
128 {
129         float u = t*2.0f-1.0f;
130
131         float matrix[16];
132         for(unsigned i=0; i<4; ++i)
133         {
134                 const float *m1_col = matrix1->data()+i*4;
135                 const float *m2_col = matrix2->data()+i*4;
136                 float *out_col = matrix+i*4;
137
138                 if(i<3)
139                 {
140                         /* Linear interpolation will produce vectors that fall on the line
141                         between the two endpoints, and has a higher angular velocity near the
142                         middle.  We compensate for the velocity by interpolating the angle
143                         around the halfway point and computing its tangent.  This is
144                         approximated by a third degree polynomial, scaled so that the result
145                         will be in the range [-1, 1]. */
146                         float w = (axes[i].slope+(1-axes[i].slope)*u*u)*u*0.5f+0.5f;
147
148                         /* The interpolate vectors will also be shorter than unit length.  At
149                         the halfway point the length will be equal to the cosine of half the
150                         angle, which was computed earlier.  Use a second degree polynomial to
151                         approximate. */
152                         float n = (axes[i].scale+(1-axes[i].scale)*u*u);
153
154                         for(unsigned j=0; j<3; ++j)
155                                 out_col[j] = ((1-w)*m1_col[j]+w*m2_col[j])/n;
156                 }
157                 else
158                 {
159                         for(unsigned j=0; j<3; ++j)
160                                 out_col[j] = (1-t)*m1_col[j]+t*m2_col[j];
161                 }
162         }
163
164         matrix[3] = 0;
165         matrix[7] = 0;
166         matrix[11] = 0;
167         matrix[15] = 1;
168
169         return matrix;
170 }
171
172
173 Animation::TimedKeyFrame::TimedKeyFrame(const Animation &a):
174         animation(a),
175         prev(0)
176 { }
177
178 void Animation::TimedKeyFrame::prepare()
179 {
180         const KeyFrame::UniformMap &kf_uniforms = keyframe->get_uniforms();
181         for(KeyFrame::UniformMap::const_iterator i=kf_uniforms.begin(); i!=kf_uniforms.end(); ++i)
182         {
183                 unsigned j = animation.get_slot_for_uniform(i->first);
184                 uniforms.reserve(j+1);
185                 for(unsigned k=uniforms.size(); k<=j; ++k)
186                         uniforms.push_back(KeyFrame::AnimatedUniform(animation.uniforms[k].size, 0.0f));
187
188                 uniforms[j] = i->second;
189         }
190
191         if(!prev)
192                 return;
193
194         delta_t = time-prev->time;
195         matrix = MatrixInterpolation(prev->keyframe->get_matrix(), keyframe->get_matrix());
196
197         if(animation.armature)
198         {
199                 unsigned max_index = animation.armature->get_max_link_index();
200                 pose_matrices.resize(max_index+1);
201                 const Pose *pose1 = prev->keyframe->get_pose();
202                 const Pose *pose2 = keyframe->get_pose();
203                 static Matrix identity;
204                 for(unsigned i=0; i<=max_index; ++i)
205                 {
206                         const Matrix &matrix1 = (pose1 ? pose1->get_link_matrix(i) : identity);
207                         const Matrix &matrix2 = (pose2 ? pose2->get_link_matrix(i) : identity);
208                         pose_matrices[i] = MatrixInterpolation(matrix1, matrix2);
209                 }
210         }
211 }
212
213
214 Animation::UniformInfo::UniformInfo(const string &n, unsigned s):
215         name(n),
216         size(s)
217 { }
218
219
220 Animation::Iterator::Iterator(const Animation &a):
221         animation(a),
222         iter(animation.keyframes.begin()),
223         end(false)
224 { }
225
226 Animation::Iterator &Animation::Iterator::operator+=(const Time::TimeDelta &t)
227 {
228         time_since_keyframe += t;
229         while(time_since_keyframe>iter->delta_t)
230         {
231                 KeyFrameList::const_iterator next = iter;
232                 ++next;
233                 if(next==animation.keyframes.end())
234                 {
235                         if(animation.looping)
236                                 next = animation.keyframes.begin();
237                         else
238                         {
239                                 end = true;
240                                 time_since_keyframe = iter->delta_t;
241                                 break;
242                         }
243                 }
244
245                 time_since_keyframe -= iter->delta_t;
246                 iter = next;
247         }
248
249         return *this;
250 }
251
252 Matrix Animation::Iterator::get_matrix() const
253 {
254         if(!iter->prev)
255                 return iter->keyframe->get_matrix();
256
257         return iter->matrix.get(time_since_keyframe/iter->delta_t);
258 }
259
260 KeyFrame::AnimatedUniform Animation::Iterator::get_uniform(unsigned i) const
261 {
262         if(!iter->prev)
263         {
264                 if(iter->uniforms.size()>i)
265                         return iter->uniforms[i];
266                 else
267                         return KeyFrame::AnimatedUniform(animation.uniforms[i].size, 0.0f);
268         }
269
270         unsigned size = animation.uniforms[i].size;
271         float t = time_since_keyframe/iter->delta_t;
272         KeyFrame::AnimatedUniform result(size, 0.0f);
273         for(unsigned j=0; j<size; ++j)
274                 result.values[j] = iter->prev->uniforms[i].values[j]*(1-t)+iter->uniforms[i].values[j]*t;
275         return result;
276 }
277
278 Matrix Animation::Iterator::get_pose_matrix(unsigned link) const
279 {
280         if(!animation.armature)
281                 throw invalid_operation("Animation::Iterator::get_pose_matrix");
282         if(link>animation.armature->get_max_link_index())
283                 throw out_of_range("Animation::Iterator::get_pose_matrix");
284
285         if(!iter->prev)
286         {
287                 if(const Pose *pose = iter->keyframe->get_pose())
288                         return pose->get_link_matrix(link);
289                 else
290                         return Matrix();
291         }
292
293         // We must redo the base point correction since interpolation throws if off
294         // XXX This should probably be done on local matrices
295         Matrix result = iter->pose_matrices[link].get(time_since_keyframe/iter->delta_t);
296         const Vector3 &base = animation.armature->get_link(link).get_base();
297         Vector3 new_base = result*base;
298         result = Matrix::translation(base-new_base)*result;
299         return result;
300 }
301
302
303 Animation::Loader::Loader(Animation &a):
304         DataFile::CollectionObjectLoader<Animation>(a, 0)
305 {
306         init();
307 }
308
309 Animation::Loader::Loader(Animation &a, Collection &c):
310         DataFile::CollectionObjectLoader<Animation>(a, &c)
311 {
312         init();
313 }
314
315 void Animation::Loader::init()
316 {
317         add("armature", &Animation::armature);
318         add("interval", &Loader::interval);
319         add("keyframe", &Loader::keyframe);
320         add("keyframe", &Loader::keyframe_inline);
321         add("looping", &Animation::looping);
322 }
323
324 void Animation::Loader::keyframe(const string &n)
325 {
326         obj.add_keyframe(current_time, get_collection().get<KeyFrame>(n));
327 }
328
329 void Animation::Loader::keyframe_inline()
330 {
331         RefPtr<KeyFrame> kf = new KeyFrame;
332         if(coll)
333                 load_sub(*kf, get_collection());
334         else
335                 load_sub(*kf);
336
337         TimedKeyFrame tkf(obj);
338         tkf.time = current_time;
339         tkf.keyframe = kf;
340         obj.prepare_keyframe(tkf);
341         obj.keyframes.push_back(tkf);
342 }
343
344 void Animation::Loader::interval(float t)
345 {
346         current_time += t*Time::sec;
347 }
348
349 } // namespace GL
350 } // namespace Msp