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                 unsigned n_uniforms = i->animation.get_n_uniforms();
  98                 for(unsigned j=0; j<n_uniforms; ++j)
  99                         slot.object.set_uniform(i->animation.get_uniform_name(j), i->iterator.get_uniform(j));
 100         }
 101         slot.object.set_matrix(matrix);
 102
 103         if(slot.armature)
 104         {
 105                 unsigned max_index = slot.armature->get_max_link_index();
 106                 for(unsigned i=0; i<=max_index; ++i)
 107                 {
 108                         matrix = Matrix();
 109                         /* XXX This is in all likelihood incorrect.  The stacking should be
 110                         performed on local matrices. */
 111                         for(AnimationList::iterator j=slot.animations.begin(); j!=slot.animations.end(); ++j)
 112                                 if(j->animation.get_armature())
 113                                         matrix *= j->iterator.get_pose_matrix(i);
 114                         slot.object.set_pose_matrix(i, matrix);
 115                 }
 116         }
 117
 118         for(AnimationList::iterator i=slot.animations.begin(); i!=slot.animations.end(); )
 119         {
 120                 if(i->iterator.is_end())
 121                         slot.animations.erase(i++);
 122                 else
 123                         ++i;
 124         }
 125
 126         return !slot.animations.empty();
 127 }
 128
 129
 130 AnimationPlayer::ObjectSlot::ObjectSlot(AnimatedObject &o):
 131         object(o),
 132         armature(0),
 133         stacked(false)
 134 { }
 135
 136
 137 AnimationPlayer::AnimationSlot::AnimationSlot(const Animation &a):
 138         animation(a),
 139         iterator(animation)
 140 { }
 141
 142 } // namespace GL
 143 } // namespace Msp