D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/Animation/spAnimationPlayback.hpp

Go to the documentation of this file.

/*
 * Animation playback header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_ANIMATION_PLAYBACK_H__
#define __SP_ANIMATION_PLAYBACK_H__


#include "Base/spStandard.hpp"
#include "Base/spBaseObject.hpp"

#include <map>
#include <boost/function.hpp>


namespace sp
{
namespace scene
{


static const u32 ANIM_LAST_FRAME = ~0;


class AnimationPlayback;

typedef boost::function<void (AnimationPlayback &Playback, bool isSetManual)> PlaybackFrameCallback;


enum EAnimPlaybackModes
{
    PLAYBACK_ONESHOT,       
    PLAYBACK_ONELOOP,       
    PLAYBACK_LOOP,          
    PLAYBACK_PINGPONG,      
    PLAYBACK_PINGPONG_LOOP, 
};


struct SAnimSequence
{
    SAnimSequence() :
        Mode        (PLAYBACK_ONESHOT   ),
        FirstFrame  (0                  ),
        LastFrame   (0                  ),
        Speed       (1.0f               )
    {
    }
    ~SAnimSequence()
    {
    }
    
    /* Members */
    EAnimPlaybackModes Mode;
    u32 FirstFrame;
    u32 LastFrame;
    f32 Speed;
};

struct SP_EXPORT SAnimQueue
{
    SAnimQueue();
    ~SAnimQueue();
    
    /* === Functions === */
    
    void addFrame(u32 Frame, f32 Speed = 1.0f);
    void removeEntry(u32 QueueEntryIndex);
    void clear();
    
    struct SFrame
    {
        SFrame() :
            Frame(0     ),
            Speed(1.0f  )
        {
        }
        SFrame(u32 InitFrame, f32 InitSpeed = 1.0f) :
            Frame(InitFrame),
            Speed(InitSpeed)
        {
        }
        ~SFrame()
        {
        }
        
        /* Members */
        u32 Frame; 
        f32 Speed; 
    };
    
    /* === Members === */
    std::vector<SFrame> Queue;
};


class SP_EXPORT AnimationPlayback : public BaseObject
{
    
    public:
        
        AnimationPlayback();
        ~AnimationPlayback();
        
        /* === Functions === */
        
        bool update(f32 Speed);
        
        bool play(const EAnimPlaybackModes Mode, u32 FirstFrame, u32 LastFrame);
        
        bool play(u32 SeqId);
        
        void pause(bool IsPaused = true);
        
        void stop(bool IsReset = false);
        
        void setFrame(u32 Index);
        
        void setFirstFrame(u32 Index);
        void setLastFrame(u32 Index);
        
        bool addSequence(
            u32 SeqId, const EAnimPlaybackModes Mode, u32 FirstFrame, u32 LastFrame, f32 Speed = 1.0f
        );
        
        bool removeSequence(u32 SeqId);
        
        void clearSequences();
        
        SAnimSequence getSequence(u32 SeqId) const;
        bool playingSeq(u32 SeqId) const;
        
        /* === Static functions === */
        
        static bool interpolateRange(u32 &FirstFrame, u32 &LastFrame, f32 &Interpolation);
        
        /* === Inline functions === */
        
        inline bool playing() const
        {
            return IsPlaying_;
        }
        
        inline bool playing(u32 MinFrame, u32 MaxFrame) const
        {
            return IsPlaying_ && Frame_ >= MinFrame && Frame_ < MaxFrame;
        }
        
        inline u32 getFrame() const
        {
            return Frame_;
        }
        inline u32 getNextFrame() const
        {
            return NextFrame_;
        }
        
        inline u32 getFirstFrame() const
        {
            return FirstFrame_;
        }
        inline u32 getLastFrame() const
        {
            return LastFrame_;
        }
        
        inline void setInterpolation(f32 Interpolation)
        {
            Interpolation_ = Interpolation;
        }
        inline f32 getInterpolation() const
        {
            return Interpolation_;
        }
        
        inline void setMode(const EAnimPlaybackModes Mode)
        {
            Mode_ = Mode;
        }
        inline EAnimPlaybackModes getMode() const
        {
            return Mode_;
        }
        
        inline void setSpeed(f32 Speed)
        {
            Speed_ = Speed;
        }
        inline f32 getSpeed() const
        {
            return Speed_;
        }
        
        inline void setFrameCallback(const PlaybackFrameCallback &FrameCallback)
        {
            FrameCallback_ = FrameCallback;
        }
        inline PlaybackFrameCallback getFrameCallback() const
        {
            return FrameCallback_;
        }
        
    private:
        
        /* === Functions === */
        
        void checkAnimationEnding();
        
        /* === Inline functions === */
        
        inline void frameCallback(bool isSetManual)
        {
            if (FrameCallback_)
                FrameCallback_(*this, isSetManual);
        }
        
        inline void stopAutoAnim()
        {
            Interpolation_ = 0.0f;
            stop();
        }
        
        /* === Members === */
        
        EAnimPlaybackModes Mode_;
        
        bool HasStarted_;                   
        bool IsPlaying_;                    
        
        u32 Frame_;                         
        s32 NextFrame_;                     
        f32 Interpolation_;                 
        
        u32 FirstFrame_, LastFrame_;        
        
        f32 Speed_;                         
        u32 RepeatCount_;                   
        
        std::map<u32, SAnimSequence> Sequences_;
        //std::map<u32, SAnimQueue> Queues_;
        
        PlaybackFrameCallback FrameCallback_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================