jmAnimationCommon.h

#ifndef JUGIMAP_ANIMATION_COMMON_H
#define JUGIMAP_ANIMATION_COMMON_H
 
#include <vector>
#include "jmCommonFunctions.h"
#include "jmColor.h"
 
#include "jmGlobal.h"
 
 
 
 
namespace jugimap{
 
 
 
 
class GraphicItem;
class AnimationTrackState;
class AKMeta;
class SourceSprite;
class JugiMapBinaryLoader;
 
 
 
 
 
//==================================================================================
 
//Do not change content of this struct!
struct AnimationFrame
{
    GraphicItem *texture = nullptr;              // LINK
    int msTime = 100;                        // in milliseconds
    Vec2f offset;
    Vec2i flip;
    int dataFlags = 0;
};
 
 
 
//==================================================================================
 
 
struct AnimatedProperties
{
 
    Vec2f translation;
    Vec2f scale = Vec2f(1.0f, 1.0f);
    float rotation = 0.0f;
    Vec2i flip;
    bool hidden = false;
    float alpha = 1.0f;
    ColorRGBA colorOverlayRGBA = 0;
    ColorOverlayBlend colorOverlayBlend = ColorOverlayBlend::NORMAL;
    GraphicItem *graphicItem = nullptr;
 
    //----
    void Reset();
    void Append(AnimatedProperties &ap);
 
    //----
    int changeFlags = 0;
 
};
 
 
//==================================================================================
 
 
struct AnimationBaseParameters
{
 
    int startDelay = 0;                     
    int loopCount = 0;                      
    bool loopForever = true;                
    bool repeat = false;                    
    int repeat_DelayTimeStart = 0;          
    int repeat_DelayTimeEnd = 0;            
    bool startAtRepeatTime = true;          
 
};
 
 
 
class  Animation
{
public:
    friend class JugiMapBinaryLoader;
    friend class SourceSprite;
 
 
 
 
 
    AnimationKind GetKind(){ return kind; }
 
 
    SourceSprite* GetSourceSprite(){ return sourceObject; }
 
 
    std::string GetName(){return name;}
 
 
    AnimationBaseParameters &GetBaseParameters(){ return bp;}
 
 
    std::vector<Parameter>& GetParameters(){return parameters;}
 
 
    int GetDataFlags(){return dataFlags;}
 
 
    int GetDuration(){return duration;}
 
 
 
protected:
    AnimationKind kind = AnimationKind::NOT_DEFINED;
    SourceSprite * sourceObject = nullptr;                    // LINK to source sprite where this animation is stored
    std::string name;
    AnimationBaseParameters bp;
    int duration = 0;
 
    // custom data
    unsigned char dataFlags = 0;
    std::vector<Parameter> parameters;
 
 
    //----
    Animation(SourceSprite *_sourceObject);
    Animation(const std::string &_nameID, SourceSprite *_sourceObject);
    Animation(const Animation &mkaSrc);
    Animation& operator=(const Animation &mkaSrc);
 
    virtual ~Animation(){}
 
};
 
 
 
class AnimationInstance
{
public:
 
    virtual ~AnimationInstance(){}
 
 
    AnimationKind GetKind(){ return kind;}
 
 
    virtual int Update(int msTimePoint, int _flags) = 0;
 
 
    virtual void UpdateAnimatedSprites(bool _resetSpriteAnimatedProperties) = 0;
 
 
    virtual void ResetAnimatedProperties() = 0;
    virtual void OnPlayingStart(){}
    virtual void OnPlayingStop(){}
 
 
    Animation * GetAnimation(){ return animation; }
 
 
    AnimationBaseParameters &GetBaseParameters(){ return bp; }
 
 
    void SetCompleteLoops(bool _completeLoops){ completeLoops = _completeLoops; }
 
 
    bool GetCompleteLoops(){ return completeLoops; }
 
 
    void SetSpeedFactor(float _fSpeed) { fSpeed = _fSpeed; }
 
 
    float GetSpeedFactor() {return fSpeed;}
 
 
    void SetStartPlayTimeOffset(int _startPlayTimeOffset){ startPlayTimeOffset = _startPlayTimeOffset; }
 
 
    int GetStartPlayTimeOffset(){ return startPlayTimeOffset; }
 
 
protected:
 
    AnimationKind kind = AnimationKind::NOT_DEFINED;
    Animation * animation = nullptr;                           // LINK to related timelineAnimation
    AnimationBaseParameters bp;
 
 
    float fSpeed = 1.0;
    bool completeLoops = true;
    int startPlayTimeOffset = 0;
 
};
 
 
 
class DummyNoAnimationInstance : public AnimationInstance
{
public:
 
    int Update(int msTimePoint, int _flags) override { return 0;}
    void UpdateAnimatedSprites(bool _resetAnimatedProperties) override {}
    void ResetAnimatedProperties() override {}
 
};
 
 
 
 
 
 
class AnimationPlayer
{
public:
 
    //---
 
    AnimationInstance *GetAnimationInstance() {return animationInstance;}
 
 
    int GetCurrentAnimationTime() { return msCurrentAnimationTime;}
 
 
    AnimationPlayerState GetState() {return state;}
 
 
    AKMeta* GetActiveMetaKey() { return activeControllerKey; }
 
 
    int Play(AnimationInstance * _animationInstance);
 
 
    void Pause();
 
 
    void Resume();
 
 
    int Stop();
 
 
    int Update();
 
 
    void SetParametersForCompletingLoop();
 
 
    AnimationBaseParameters& GetAnimationBaseParameters(){ return bp;}
 
 
private:
    AnimationPlayerState state = AnimationPlayerState::IDLE;
 
    AnimationBaseParameters bp;
 
    int msCurrentAnimationTime = -1;
    int msStartPlayOffset = 0;
    int msAnimationTimeStart = -1;
    int countLoop = 0;
    int msRepeat = -1;
    AnimationPlayerState stateStored = AnimationPlayerState::IDLE;
    int msTimeStored = 0;
 
    AnimationInstance *animationInstance = nullptr;            // LINK
    AKMeta* activeControllerKey = nullptr;                              // LINK
 
 
    int UpdateAnimationInstance();
    int GetRepeatTime(int _msCurrentTime);
};
 
 
 
class AnimationQueuePlayer
{
public:
 
 
    AnimationPlayer & GetPlayer(){ return player; }
 
 
    AnimationInstance *GetAnimationInstance() { return player.GetAnimationInstance();}
 
 
    int GetCurrentAnimationTime() { return player.GetCurrentAnimationTime();}
 
 
    AnimationPlayerState GetState() {return player.GetState(); }
 
 
    AKMeta* GetActiveMetaKey() { return player.GetActiveMetaKey(); }
 
 
    int Play(AnimationInstance *_animationInstance, int _flags=0);
 
 
    int Update();
 
 
    void Pause() { player.Pause(); }
 
 
    void Resume() { player.Resume(); }
 
 
    int Stop();
 
 
private:
    AnimationPlayer player;
    std::vector<AnimationInstance*>animationInstances;
 
    int PlayNextAnimationInQueue();
};
 
 
extern DummyNoAnimationInstance dummyNoAnimationInstance;
extern AnimationPlayer *activeTimelineAnimationPlayer;
 
 
}
 
 
 
 
#endif // EANIMATIONCOMMON_H