animationplayer.h

Go to the documentation of this file.

#ifndef UGDK_ACTION_ANIMATIONPLAYER_H_
#define UGDK_ACTION_ANIMATIONPLAYER_H_

#include <ugdk/action/mediaplayer.h>
#include <ugdk/structure/indexabletable.h>
#include <ugdk/action/animation.h>

#include <string>
#include <vector>
#include <functional>

namespace ugdk {
namespace action {

template<class Frame>
class AnimationPlayer : public MediaPlayer {
  public:
    using Animation = ::ugdk::action::Animation<Frame>;
    using AnimationTable = structure::IndexableTable<Animation>;
    using FrameChangedCallback = std::function<void(const Frame&)>;

    AnimationPlayer(const AnimationTable* table)
        : current_animation_(nullptr)
        , elapsed_time_(0.0)
        , table_(table)
        , notified_(false)
    {}

    void set_frame_change_callback(const FrameChangedCallback& callback) {
        frame_change_callback_ = callback;
    }

    const Animation* current_animation() const {
        return current_animation_;
    }

    const Frame& current_animation_frame() const {
        return *current_animation_->frames()[current_frame_];
    }

    void Update(double dt) {
        if (!current_animation_) return;
        elapsed_time_ += dt;

        double frame_period = current_animation_frame().period();
        if (elapsed_time_ >= frame_period) {
            elapsed_time_ -= frame_period;
            ChangeToNextFrame();
        }
    }

    void RestartAnimation() {
        notified_ = false;
        elapsed_time_  = 0.0;
        current_frame_ = 0;
        ExecuteFrameChangeCallback();
    }


    void Select(const std::string& name) {
        if(table_)
            this->set_current_animation(table_->Search(name));
    }


    void Select(int index) {
        if(table_)
            this->set_current_animation(table_->Get(index));
    }

    void Refresh() {
        if (current_animation_)
            ExecuteFrameChangeCallback();
    }

  private:
    const Animation* current_animation_;
    int current_frame_;
    double elapsed_time_;
    const AnimationTable* table_;
    FrameChangedCallback frame_change_callback_;
    bool notified_;

    void set_current_animation(const Animation* anim) {
        auto previous_anim = current_animation_;
        current_animation_ = anim;
        if (anim != previous_anim)
            RestartAnimation();
    }

    void ExecuteFrameChangeCallback() {
        if (frame_change_callback_)
            frame_change_callback_(current_animation_frame());
    }

    void ChangeToNextFrame() {
        bool notify = false;

        ++current_frame_;
        if(current_frame_ >= current_animation_->frames().size()) {
            if (current_animation_->repeat() == Animation::AnimationRepeat::LOOP) {
                current_frame_ = 0;
                notified_ = false;
            }
            else {
                --current_frame_;
            }
            notify = true;
        }
        ExecuteFrameChangeCallback();
            
        if (notify && !notified_) {
            notifyAllObservers();
            notified_ = true;
        }
    }
};

} /* namespace action */
} /* namespace ugdk */

#endif /* UGDK_ACTION_SPECIALIZEDANIMATIONMANAGER_H_ */