]> git.tdb.fi Git - libs/gl.git/blob - source/animation/animationplayer.cpp
Replace the instance variables of exporters by function parameters
[libs/gl.git] / source / animation / animationplayer.cpp
1 #include <msp/core/algorithm.h>
2 #include "animatedobject.h"
3 #include "animationplayer.h"
4 #include "armature.h"
5 #include "programdata.h"
6
7 using namespace std;
8
9 namespace Msp {
10 namespace GL {
11
12 AnimationPlayer::Target &AnimationPlayer::get_slot(Placeable &obj)
13 {
14         auto i = objects.find(&obj);
15         if(i!=objects.end())
16                 return i->second;
17
18         return objects.insert(make_pair(&obj, Target(obj))).first->second;
19 }
20
21 AnimationPlayer::Target &AnimationPlayer::play_(Placeable &obj, const Animation &anim, bool stacked, float speed)
22 {
23         Target &target = get_slot(obj);
24         if(!stacked)
25         {
26                 target.animations.clear();
27                 target.base_matrix = Matrix();
28         }
29         else if(target.animations.empty())
30                 target.base_matrix = *obj.get_matrix();
31         target.stacked = stacked;
32         // TODO check for incompatible armature
33         target.armature = anim.get_armature();
34         target.animations.push_back(PlayingAnimation(anim, speed));
35         return target;
36 }
37
38 void AnimationPlayer::play(AnimatedObject &obj, const Animation &anim, float speed)
39 {
40         Target &target = play_(obj, anim, false, speed);
41         target.object = &obj;
42 }
43
44 void AnimationPlayer::play(Placeable &obj, const Animation &anim, float speed)
45 {
46         play_(obj, anim, false, speed);
47 }
48
49 void AnimationPlayer::play_stacked(AnimatedObject &obj, const Animation &anim, float speed)
50 {
51         Target &target = play_(obj, anim, true, speed);
52         target.object = &obj;
53 }
54
55 void AnimationPlayer::play_stacked(Placeable &obj, const Animation &anim, float speed)
56 {
57         play_(obj, anim, true, speed);
58 }
59
60 unsigned AnimationPlayer::get_n_active_animations(const AnimatedObject &obj) const
61 {
62         auto i = objects.find(&obj);
63         return (i!=objects.end() ? i->second.animations.size() : 0);
64 }
65
66 void AnimationPlayer::observe_events(AnimatedObject &obj, AnimationEventObserver &observer)
67 {
68         Target &target = get_slot(obj);
69         if(find(target.event_observers, &observer)==target.event_observers.end())
70                 target.event_observers.push_back(&observer);
71 }
72
73 void AnimationPlayer::unobserve_events(AnimatedObject &obj, AnimationEventObserver &observer)
74 {
75         auto i = objects.find(&obj);
76         if(i==objects.end())
77                 return;
78
79         auto j = find(i->second.event_observers, &observer);
80         if(j!=i->second.event_observers.end())
81                 i->second.event_observers.erase(j);
82 }
83
84 void AnimationPlayer::unobserve_events(AnimationEventObserver &observer)
85 {
86         for(auto &kvp: objects)
87         {
88                 auto j = find(kvp.second.event_observers, &observer);
89                 if(j!=kvp.second.event_observers.end())
90                         kvp.second.event_observers.erase(j);
91         }
92 }
93
94 void AnimationPlayer::stop(Placeable &obj)
95 {
96         objects.erase(&obj);
97 }
98
99 void AnimationPlayer::stop(Placeable &obj, const Animation &anim)
100 {
101         auto i = objects.find(&obj);
102         if(i==objects.end())
103                 return;
104
105         auto j = find_member(i->second.animations, &anim, &PlayingAnimation::animation);
106         if(j!=i->second.animations.end())
107                 i->second.animations.erase(j);
108
109         if(i->second.animations.empty())
110                 objects.erase(i);
111 }
112
113 void AnimationPlayer::tick(const Time::TimeDelta &dt)
114 {
115         for(auto i=objects.begin(); i!=objects.end(); )
116         {
117                 if(i->second.stacked)
118                         tick_stacked(i->second, dt);
119                 else if(!i->second.animations.empty())
120                         tick_single(i->second, dt);
121
122                 if(i->second.animations.empty() && i->second.event_observers.empty())
123                         objects.erase(i++);
124                 else
125                         ++i;
126         }
127 }
128
129 void AnimationPlayer::tick_single(Target &target, const Time::TimeDelta &dt)
130 {
131         PlayingAnimation &anim = target.animations.front();
132         anim.iterator += dt*anim.speed;
133         target.placeable.set_matrix(anim.iterator.get_matrix());
134
135         if(target.object)
136         {
137                 unsigned n_uniforms = anim.animation->get_n_uniforms();
138                 for(unsigned i=0; i<n_uniforms; ++i)
139                         set_object_uniform(*target.object, anim.animation->get_uniform_name(i), anim.iterator.get_uniform(i));
140
141                 if(target.armature)
142                 {
143                         unsigned max_index = target.armature->get_max_link_index();
144                         for(unsigned i=0; i<=max_index; ++i)
145                                 target.object->set_pose_matrix(i, anim.iterator.get_pose_matrix(i));
146                 }
147         }
148
149         anim.iterator.dispatch_events(target);
150
151         if(anim.iterator.is_end())
152                 target.animations.clear();
153 }
154
155 void AnimationPlayer::tick_stacked(Target &target, const Time::TimeDelta &dt)
156 {
157         Matrix matrix = target.base_matrix;
158         for(PlayingAnimation &a: target.animations)
159         {
160                 a.iterator += dt*a.speed;
161                 matrix *= a.iterator.get_matrix();
162
163                 if(target.object)
164                 {
165                         unsigned n_uniforms = a.animation->get_n_uniforms();
166                         for(unsigned j=0; j<n_uniforms; ++j)
167                                 set_object_uniform(*target.object, a.animation->get_uniform_name(j), a.iterator.get_uniform(j));
168                 }
169         }
170         target.placeable.set_matrix(matrix);
171
172         if(target.object && target.armature)
173         {
174                 unsigned max_index = target.armature->get_max_link_index();
175                 for(unsigned i=0; i<=max_index; ++i)
176                 {
177                         matrix = Matrix();
178                         /* XXX This is in all likelihood incorrect.  The stacking should be
179                         performed on local matrices. */
180                         for(const PlayingAnimation &a: target.animations)
181                                 if(a.animation->get_armature())
182                                         matrix *= a.iterator.get_pose_matrix(i);
183                         target.object->set_pose_matrix(i, matrix);
184                 }
185         }
186
187         for(auto i=target.animations.begin(); i!=target.animations.end(); )
188         {
189                 i->iterator.dispatch_events(target);
190
191                 if(i->iterator.is_end())
192                         i = target.animations.erase(i);
193                 else
194                         ++i;
195         }
196
197         if(target.animations.empty())
198                 target.stacked = false;
199 }
200
201 void AnimationPlayer::set_object_uniform(AnimatedObject &obj, const string &name, const KeyFrame::AnimatedUniform &uni)
202 {
203         ProgramData &shdata = obj.get_shader_data();
204
205         if(uni.size==1)
206                 shdata.uniform(name, uni.values[0]);
207         else if(uni.size==2)
208                 shdata.uniform2(name, uni.values);
209         else if(uni.size==3)
210                 shdata.uniform3(name, uni.values);
211         else if(uni.size==4)
212                 shdata.uniform4(name, uni.values);
213 }
214
215
216 AnimationPlayer::PlayingAnimation::PlayingAnimation(const Animation &a, float s):
217         animation(&a),
218         speed(s),
219         iterator(*animation)
220 { }
221
222
223 AnimationPlayer::Target::Target(Placeable &p):
224         placeable(p),
225         object(0),
226         armature(0),
227         stacked(false)
228 { }
229
230 void AnimationPlayer::Target::animation_event(Placeable *, const string &name, const Variant &value)
231 {
232         for(AnimationEventObserver *o: event_observers)
233                 o->animation_event(&placeable, name, value);
234 }
235
236 } // namespace GL
237 } // namespace Msp