Check the flat qualifier from the correct member

[libs/gl.git] / source / animation / animationplayer.cpp

diff --git a/source/animation/animationplayer.cpp b/source/animation/animationplayer.cpp
index ac16321874a7abd612ad6cf39fdb69cf1fdb8cf4..44b8e466542b61fa573d9336ab5dc1f6724bfc6f 100644 (file)
--- a/source/animation/animationplayer.cpp
+++ b/source/animation/animationplayer.cpp
@@ -11,11 +11,11 @@ namespace GL {
 
 AnimationPlayer::Target &AnimationPlayer::get_slot(Placeable &obj)
 {
-       ObjectMap::iterator i = objects.find(&obj);
+       auto i = objects.find(&obj);
        if(i!=objects.end())
                return i->second;
 
-       return objects.insert(ObjectMap::value_type(&obj, Target(obj))).first->second;
+       return objects.insert(make_pair(&obj, Target(obj))).first->second;
 }
 
 AnimationPlayer::Target &AnimationPlayer::play_(Placeable &obj, const Animation &anim, bool stacked, float speed)
@@ -31,7 +31,7 @@ AnimationPlayer::Target &AnimationPlayer::play_(Placeable &obj, const Animation
        target.stacked = stacked;
        // TODO check for incompatible armature
        target.armature = anim.get_armature();
-       target.animations.push_back(PlayingAnimation(anim, speed));
+       target.animations.emplace_back(anim, speed);
        return target;
 }
 
@@ -59,7 +59,7 @@ void AnimationPlayer::play_stacked(Placeable &obj, const Animation &anim, float
 
 unsigned AnimationPlayer::get_n_active_animations(const AnimatedObject &obj) const
 {
-       ObjectMap::const_iterator i = objects.find(&obj);
+       auto i = objects.find(&obj);
        return (i!=objects.end() ? i->second.animations.size() : 0);
 }
 
@@ -72,22 +72,22 @@ void AnimationPlayer::observe_events(AnimatedObject &obj, AnimationEventObserver
 
 void AnimationPlayer::unobserve_events(AnimatedObject &obj, AnimationEventObserver &observer)
 {
-       ObjectMap::iterator i = objects.find(&obj);
+       auto i = objects.find(&obj);
        if(i==objects.end())
                return;
 
-       vector<AnimationEventObserver *>::iterator j = find(i->second.event_observers, &observer);
+       auto j = find(i->second.event_observers, &observer);
        if(j!=i->second.event_observers.end())
                i->second.event_observers.erase(j);
 }
 
 void AnimationPlayer::unobserve_events(AnimationEventObserver &observer)
 {
-       for(ObjectMap::iterator i=objects.begin(); i!=objects.end(); ++i)
+       for(auto &kvp: objects)
        {
-               vector<AnimationEventObserver *>::iterator j = find(i->second.event_observers, &observer);
-               if(j!=i->second.event_observers.end())
-                       i->second.event_observers.erase(j);
+               auto j = find(kvp.second.event_observers, &observer);
+               if(j!=kvp.second.event_observers.end())
+                       kvp.second.event_observers.erase(j);
        }
 }
 
@@ -98,16 +98,13 @@ void AnimationPlayer::stop(Placeable &obj)
 
 void AnimationPlayer::stop(Placeable &obj, const Animation &anim)
 {
-       ObjectMap::iterator i = objects.find(&obj);
+       auto i = objects.find(&obj);
        if(i==objects.end())
                return;
 
-       for(vector<PlayingAnimation>::iterator j=i->second.animations.begin(); j!=i->second.animations.end(); ++j)
-               if(j->animation==&anim)
-               {
-                       i->second.animations.erase(j);
-                       break;
-               }
+       auto j = find_member(i->second.animations, &anim, &PlayingAnimation::animation);
+       if(j!=i->second.animations.end())
+               i->second.animations.erase(j);
 
        if(i->second.animations.empty())
                objects.erase(i);
@@ -115,7 +112,7 @@ void AnimationPlayer::stop(Placeable &obj, const Animation &anim)
 
 void AnimationPlayer::tick(const Time::TimeDelta &dt)
 {
-       for(ObjectMap::iterator i=objects.begin(); i!=objects.end(); )
+       for(auto i=objects.begin(); i!=objects.end(); )
        {
                if(i->second.stacked)
                        tick_stacked(i->second, dt);
@@ -158,16 +155,16 @@ void AnimationPlayer::tick_single(Target &target, const Time::TimeDelta &dt)
 void AnimationPlayer::tick_stacked(Target &target, const Time::TimeDelta &dt)
 {
        Matrix matrix = target.base_matrix;
-       for(vector<PlayingAnimation>::iterator i=target.animations.begin(); i!=target.animations.end(); ++i)
+       for(PlayingAnimation &a: target.animations)
        {
-               i->iterator += dt*i->speed;
-               matrix *= i->iterator.get_matrix();
+               a.iterator += dt*a.speed;
+               matrix *= a.iterator.get_matrix();
 
                if(target.object)
                {
-                       unsigned n_uniforms = i->animation->get_n_uniforms();
+                       unsigned n_uniforms = a.animation->get_n_uniforms();
                        for(unsigned j=0; j<n_uniforms; ++j)
-                               set_object_uniform(*target.object, i->animation->get_uniform_name(j), i->iterator.get_uniform(j));
+                               set_object_uniform(*target.object, a.animation->get_uniform_name(j), a.iterator.get_uniform(j));
                }
        }
        target.placeable.set_matrix(matrix);
@@ -180,14 +177,14 @@ void AnimationPlayer::tick_stacked(Target &target, const Time::TimeDelta &dt)
                        matrix = Matrix();
                        /* XXX This is in all likelihood incorrect.  The stacking should be
                        performed on local matrices. */
-                       for(vector<PlayingAnimation>::iterator j=target.animations.begin(); j!=target.animations.end(); ++j)
-                               if(j->animation->get_armature())
-                                       matrix *= j->iterator.get_pose_matrix(i);
+                       for(const PlayingAnimation &a: target.animations)
+                               if(a.animation->get_armature())
+                                       matrix *= a.iterator.get_pose_matrix(i);
                        target.object->set_pose_matrix(i, matrix);
                }
        }
 
-       for(vector<PlayingAnimation>::iterator i=target.animations.begin(); i!=target.animations.end(); )
+       for(auto i=target.animations.begin(); i!=target.animations.end(); )
        {
                i->iterator.dispatch_events(target);
 
@@ -232,8 +229,8 @@ AnimationPlayer::Target::Target(Placeable &p):
 
 void AnimationPlayer::Target::animation_event(Placeable *, const string &name, const Variant &value)
 {
-       for(vector<AnimationEventObserver *>::const_iterator i=event_observers.begin(); i!=event_observers.end(); ++i)
-               (*i)->animation_event(&placeable, name, value);
+       for(AnimationEventObserver *o: event_observers)
+               o->animation_event(&placeable, name, value);
 }
 
 } // namespace GL