jmTimelineAnimationInstance.h

#ifndef JUGIMAP_TIMELINE_ANIMATION_INSTANCE_H
#define JUGIMAP_TIMELINE_ANIMATION_INSTANCE_H
 
 
#include "jmMap.h"
#include "jmTimelineAnimation.h"
 
 
 
namespace jugimap{
 
 
 
 
class SourceSprite;
class Sprite;
class VectorShape;
 
 
class TimelineAnimation;
class AnimationQueuePlayer;
class FrameAnimationInstance;
class AnimationMemberState;
class TimelineAnimationInstance;
 
 
 
 
class AnimationTrackState
{
public:
 
    AnimationTrackState(AnimationTrack* _tAnimation, AnimationMemberState* _tAnimationsStatesSet);
    virtual ~AnimationTrackState();
 
 
    bool Empty(){ return (activeStartKey==nullptr && activeEndKey==nullptr); }
    AnimationTrackKind GetKind();
 
    AnimationTrack* GetAnimationTrack(){ return animationTrack; }
    AnimationKey* GetStateKey(){ return stateKey; }
    AnimationKey* GetActiveStartKey(){ return activeStartKey; }
    AnimationKey* GetActiveEndKey(){ return activeEndKey; }
    AnimationKey* GetActiveKey(){ return  (activeStartKey!=nullptr)? activeStartKey : activeEndKey;}
 
    VectorShape * GetPath(){ return path; }
    AnimationQueuePlayer* GetTimelineAnimationQueuePlayer(){ return timelineAnimationPlayer; }
    AnimationQueuePlayer* GetFrameAnimationPlayer(){ return frameAnimationPlayer; }
    AnimationTrackParameters &GetTrackParameters(){ return tp; };
 
    bool IsDisabled(){ return disabled; }
    void SetDisabled(bool _disabled){ disabled = _disabled; }
 
    int Update(int _animationTime, int _flags);
 
    void _ClearLinkPointers(VectorShape* _shape);
 
private:
    AnimationTrackKind kind = AnimationTrackKind::NOT_DEFINED;
 
    AnimationMemberState * animationMemberState = nullptr;                          // LINK to owner
    AnimationTrack* animationTrack = nullptr;                                       // LINK to related tAnimation object
    AnimationKey* activeStartKey = nullptr;                                         // LINK to a key in tAnimation
    AnimationKey* activeEndKey = nullptr;                                           // LINK to a key in tAnimation
 
    //---
    AnimationKey *stateKey = nullptr;                                               // OWNED
 
    AnimationQueuePlayer *frameAnimationPlayer = nullptr;                           // OWNED, sub-player
    std::vector<FrameAnimationInstance*>*frameAnimationInstances = nullptr;        // OWNED, instances for sub-player
    //EFrameAnimationInstance* activeFrameAnimationInstance = nullptr;
 
    AnimationQueuePlayer* timelineAnimationPlayer = nullptr;                        // OWNED, sub-player
    std::vector<TimelineAnimationInstance*>*timelineAnimationInstances = nullptr;   // OWNED, instances for sub-player
    //ETimelineAnimationInstance* activeTimelineAnimationInstance = nullptr;        // LINK
 
    AnimationTrackParameters tp;                                                    // OWNED
 
    //---
    VectorShape *path = nullptr;                                                    // LINK, stored pointer for quicker access
    SourceSprite* sourceObject = nullptr;                                           // LINK, stored pointer for quicker access
 
    bool disabled = false;
 
 
    void SetActiveKeys(int _animationTime);
    int ManageSubTimelineAnimation();
    int ManageSubFrameAnimation();
    void FindSourceObject();
    Map* FindMap();
 
    TimelineAnimationInstance* FindTimelineAnimationInstance(const std::string& _name);
    TimelineAnimationInstance* CreateAndStoreTimelineAnimationInstance(const std::string& _name);
 
    FrameAnimationInstance* FindFrameAnimationInstance(const std::string& _name);
    FrameAnimationInstance* CreateAndStoreFrameAnimationInstance(const std::string& _name);
 
};
 
 
//================================================================
 
 
class AnimationMemberState
{
public:
    friend class AnimationTrackState;
    friend class TimelineAnimationInstance;
 
 
    AnimationMember *GetAnimationMember(){ return animationMember; }
    std::vector<AnimationTrackState*> &GetAnimationTrackStates(){ return animationsTrackStates; }
    Sprite* _GetSprite(){ return sprite;}
    std::vector<Sprite*>* _GetSprites(){ return sprites;}
 
    bool IsDisabled(){ return disabled; }
    void SetDisabled(bool _disabled){ disabled = _disabled; }
 
 
private:
 
    AnimationMemberState(AnimationMember *_animationMember);
    AnimationMemberState(const AnimationMember &_animationMember) = delete;
    AnimationMemberState& operator=(const AnimationMember &_animationMember) = delete;
    ~AnimationMemberState();
 
 
    int Update(int msTimePoint, int _flags);
    void StopSubPlayers();
    void PauseSubPlayers();
    void ResumeSubPlayers();
    void ResetAnimatedProperties();
 
 
    AnimationMember * animationMember = nullptr;                     //LINK
    std::vector<AnimationTrackState*>animationsTrackStates;
 
    Sprite* sprite = nullptr;                                       // LINK
    std::vector<Sprite*>*sprites = nullptr;                         // vector OWNED, sprites LINKS
    AnimatedProperties ap;
    bool disabled = false;
 
    TimelineAnimationInstance* animationInstance = nullptr;         // LINK
 
 
    int UpdateAnimatedProperties(AnimationTrackState & _ats);
    void ResetSpritesAnimatedProperties();
    void UpdateAnimatedSprites();
 
};
 
 
 
//================================================================
 
 
class TimelineAnimationInstance : public AnimationInstance
{
public:
 
    //friend class AnimationQueuePlayer;
 
 
    TimelineAnimationInstance(TimelineAnimation *_timelineAnimation, Sprite *_sprite);
 
 
    TimelineAnimationInstance(TimelineAnimation *_timelineAnimation, std::vector<Sprite*>&_sprites);
 
 
    ~TimelineAnimationInstance() override;
 
 
    Sprite* GetSprite(){ return animationsMemberStates.front()->_GetSprite();}
 
 
    std::vector<Sprite*>* GetSprites(){ return animationsMemberStates.front()->_GetSprites();}
 
 
    std::vector<AnimationMemberState*>& GetAnimationsMemberStates(){ return animationsMemberStates;}
 
 
    AnimationTrackState* GetMetaAnimationTrackState(){ return metaAnimationTrackState;}
 
 
 
    int Update(int msTimePoint, int _flags) override;
    void StopSubPlayers();
    void PauseSubPlayers();
    void ResumeSubPlayers();
 
    void UpdateAnimatedSprites(bool _resetSpriteAnimatedProperties) override;
    void ResetAnimatedProperties() override;
 
    void ClearLinkPointers(VectorShape* _shape);
 
 
    AnimationMemberState* FindAnimationMemberState(AnimationMember* _animationMember);
 
 
    AnimationTrackState* FindAnimationTrackState(AnimationTrackKind _animationTrackKind, const std::string &_memberName="");
 
 
    AnimationTrackState* FindAnimationTrackState(AnimationTrack* _animationTrack);
 
 
private:
    std::vector<AnimationMemberState*>animationsMemberStates;                   // OWNED
    AnimationTrackState* metaAnimationTrackState = nullptr;                // OWNED
 
    TimelineAnimationInstance(){};
    TimelineAnimationInstance(const TimelineAnimationInstance &src) = delete;
    TimelineAnimationInstance& operator=(const TimelineAnimationInstance &src) = delete;
};
 
 
 
 
 
}
 
 
 
 
#endif