source/animationplayer.cpp

   1 #include "animatedobject.h"
   2 #include "animationplayer.h"
   3 #include "armature.h"
   4
   5 using namespace std;
   6
   7 namespace Msp {
   8 namespace GL {
   9
  10 AnimationPlayer::ObjectSlot &AnimationPlayer::get_slot(AnimatedObject &obj)
  11 {
  12         ObjectMap::iterator i = objects.find(&obj);
  13         if(i!=objects.end())
  14                 return i->second;
  15
  16         return objects.insert(ObjectMap::value_type(&obj, ObjectSlot(obj))).first->second;
  17 }
  18
  19 void AnimationPlayer::play(AnimatedObject &obj, const Animation &anim)
  20 {
  21         ObjectSlot &obj_slot = get_slot(obj);
  22         obj_slot.animations.clear();
  23         obj_slot.base_matrix = Matrix();
  24         obj_slot.stacked = false;
  25         obj_slot.armature = anim.get_armature();
  26         obj_slot.animations.push_back(AnimationSlot(anim));
  27 }
  28
  29 void AnimationPlayer::play_stacked(AnimatedObject &obj, const Animation &anim)
  30 {
  31         ObjectSlot &obj_slot = get_slot(obj);
  32         if(obj_slot.animations.empty())
  33                 obj_slot.base_matrix = *obj.get_matrix();
  34         // TODO check for incompatible armature
  35         obj_slot.stacked = true;
  36         obj_slot.armature = anim.get_armature();
  37         obj_slot.animations.push_back(AnimationSlot(anim));
  38 }
  39
  40 unsigned AnimationPlayer::get_n_active_animations(const AnimatedObject &obj) const
  41 {
  42         ObjectMap::const_iterator i = objects.find(&obj);
  43         return (i!=objects.end() ? i->second.animations.size() : 0);
  44 }
  45
  46 void AnimationPlayer::stop(AnimatedObject &obj)
  47 {
  48         objects.erase(&obj);
  49 }
  50
  51 void AnimationPlayer::tick(const Time::TimeDelta &dt)
  52 {
  53         for(ObjectMap::iterator i=objects.begin(); i!=objects.end(); )
  54         {
  55                 bool keep = false;
  56                 if(i->second.stacked)
  57                         keep = tick_stacked(i->second, dt);
  58                 else
  59                         keep = tick_single(i->second, dt);
  60
  61                 if(!keep)
  62                         objects.erase(i++);
  63                 else
  64                         ++i;
  65         }
  66 }
  67
  68 bool AnimationPlayer::tick_single(ObjectSlot &slot, const Time::TimeDelta &dt)
  69 {
  70         AnimatedObject &obj = slot.object;
  71         AnimationSlot &anim = slot.animations.front();
  72         anim.iterator += dt;
  73         obj.set_matrix(anim.iterator.get_matrix());
  74
  75         unsigned n_uniforms = anim.animation.get_n_uniforms();
  76         for(unsigned i=0; i<n_uniforms; ++i)
  77                 obj.set_uniform(anim.animation.get_uniform_name(i), anim.iterator.get_uniform(i));
  78
  79         if(slot.armature)
  80         {
  81                 unsigned max_index = slot.armature->get_max_link_index();
  82                 for(unsigned i=0; i<=max_index; ++i)
  83                         obj.set_pose_matrix(i, anim.iterator.get_pose_matrix(i));
  84         }
  85
  86         return !anim.iterator.is_end();
  87 }
  88
  89 bool AnimationPlayer::tick_stacked(ObjectSlot &slot, const Time::TimeDelta &dt)
  90 {
  91         Matrix matrix = slot.base_matrix;
  92         for(AnimationList::iterator i=slot.animations.begin(); i!=slot.animations.end(); ++i)
  93         {
  94                 i->iterator += dt;
  95                 matrix *= i->iterator.get_matrix();
  96         }
  97         slot.object.set_matrix(matrix);
  98
  99         if(slot.armature)
 100         {
 101                 unsigned max_index = slot.armature->get_max_link_index();
 102                 for(unsigned i=0; i<=max_index; ++i)
 103                 {
 104                         matrix = Matrix();
 105                         /* XXX This is in all likelihood incorrect.  The stacking should be
 106                         performed on local matrices. */
 107                         for(AnimationList::iterator j=slot.animations.begin(); j!=slot.animations.end(); ++j)
 108                                 if(j->animation.get_armature())
 109                                         matrix *= j->iterator.get_pose_matrix(i);
 110                         slot.object.set_pose_matrix(i, matrix);
 111                 }
 112         }
 113
 114         for(AnimationList::iterator i=slot.animations.begin(); i!=slot.animations.end(); )
 115         {
 116                 if(i->iterator.is_end())
 117                         slot.animations.erase(i++);
 118                 else
 119                         ++i;
 120         }
 121
 122         return !slot.animations.empty();
 123 }
 124
 125
 126 AnimationPlayer::ObjectSlot::ObjectSlot(AnimatedObject &o):
 127         object(o),
 128         armature(0),
 129         stacked(false)
 130 { }
 131
 132
 133 AnimationPlayer::AnimationSlot::AnimationSlot(const Animation &a):
 134         animation(a),
 135         iterator(animation)
 136 { }
 137
 138 } // namespace GL
 139 } // namespace Msp