IAPDemo/Libraries/cocos2d/cocos/editor-support/cocosbuilder/CCBAnimationManager.h

#ifndef __CCB_CCBANIMATION_MANAGER_H__
#define __CCB_CCBANIMATION_MANAGER_H__

#include "base/CCMap.h"
#include "2d/CCActionInterval.h"
#include "2d/CCActionInstant.h"
#include "2d/CCActionEase.h"

#include "extensions/ExtensionMacros.h"
#include "editor-support/cocosbuilder/CCBSequence.h"
#include "editor-support/cocosbuilder/CCBKeyframe.h"
#include "editor-support/cocosbuilder/CCBSequenceProperty.h"
#include "extensions/GUI/CCControlExtension/CCControl.h"

namespace cocosbuilder {

class CC_DLL CCBAnimationManagerDelegate
{
public:
    virtual ~CCBAnimationManagerDelegate() {}
    virtual void completedAnimationSequenceNamed(const char *name) = 0;
};

class CC_DLL CCBAnimationManager : public cocos2d::Ref
{
public:
    bool _jsControlled;
    /**
     * @js ctor
     */
    CCBAnimationManager();
    /**
     * @js NA
     * @lua NA
     */
    ~CCBAnimationManager();


    cocos2d::Ref *_owner;
    
    virtual bool init();
    
    cocos2d::Vector<CCBSequence*>& getSequences();
    void setSequences(const cocos2d::Vector<CCBSequence*>& seq);

    
    int getAutoPlaySequenceId();
    void setAutoPlaySequenceId(int autoPlaySequenceId);
    
    cocos2d::Node* getRootNode();
    void setRootNode(cocos2d::Node* pRootNode); // weak reference    
    

    void addDocumentCallbackNode(cocos2d::Node *node);
    void addDocumentCallbackName(std::string name);
    void addDocumentCallbackControlEvents(cocos2d::extension::Control::EventType eventType);
    
    void addDocumentOutletNode(cocos2d::Node *node);
    void addDocumentOutletName(std::string name);

    void setDocumentControllerName(const std::string &name);
    
    std::string getDocumentControllerName();
    cocos2d::ValueVector& getDocumentCallbackNames();
    cocos2d::Vector<cocos2d::Node*>& getDocumentCallbackNodes();
    cocos2d::ValueVector& getDocumentCallbackControlEvents();
    
    cocos2d::ValueVector& getDocumentOutletNames();
    cocos2d::Vector<cocos2d::Node*>& getDocumentOutletNodes();
    std::string getLastCompletedSequenceName();
    
    cocos2d::ValueVector& getKeyframeCallbacks();
    
    const cocos2d::Size& getRootContainerSize();
    void setRootContainerSize(const cocos2d::Size &rootContainerSize);
    
    CCBAnimationManagerDelegate* getDelegate();
    void setDelegate(CCBAnimationManagerDelegate* pDelegate); // retain
    
    const char* getRunningSequenceName();
    
    const cocos2d::Size& getContainerSize(cocos2d::Node* pNode);
    
    void addNode(cocos2d::Node *pNode, const std::unordered_map<int, cocos2d::Map<std::string, CCBSequenceProperty*>>& seq);
    void setBaseValue(const cocos2d::Value& value, cocos2d::Node *pNode, const std::string& propName);
    void setObject(cocos2d::Ref* obj, cocos2d::Node *pNode, const std::string& propName);
    
    void moveAnimationsFromNode(cocos2d::Node* fromNode, cocos2d::Node* toNode);

    /** @deprecated This interface will be deprecated sooner or later.*/
    CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName, float fTweenDuration);
    /** @deprecated This interface will be deprecated sooner or later.*/
    CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName);
    /** @deprecated This interface will be deprecated sooner or later.*/
    CC_DEPRECATED_ATTRIBUTE void runAnimations(int nSeqId, float fTweenDuraiton);

    int runAnimationsForSequenceNamedTweenDuration(const char *pName, float fTweenDuration);
    int runAnimationsForSequenceNamed(const char *pName);
    void runAnimationsForSequenceIdTweenDuration(int nSeqId, float fTweenDuraiton);
    cocos2d::Spawn* getNodeAniByName(const char *pName,cocos2d::Node *pNode,cocos2d::Vec2 orginPos);
    /**
     * when this function bound to js ,the second param are callfunc_selector
     * @lua NA
     */
    void setAnimationCompletedCallback(cocos2d::Ref *target, cocos2d::SEL_CallFunc callbackFunc);

    void debug();
    /**
     * @js setCallFuncForJSCallbackNamed
     */
    void setCallFunc(cocos2d::CallFunc *callFunc, const std::string &callbackNamed);

    cocos2d::Sequence* actionForCallbackChannel(CCBSequenceProperty* channel);
    cocos2d::Sequence* actionForSoundChannel(CCBSequenceProperty* channel);

	// return -1 if timeline not exist
    int getSequenceId(const char* pSequenceName);
    
    // get timeline duration
    float getSequenceDuration(const char* pSequenceName);
    
    std::string getCCBFileName();
    void setCCBFileName(std::string filename);
    
    CC_SYNTHESIZE(float, _speed, AnimationSpeed);
    void updateSpeed(float speed);
    const std::unordered_map<cocos2d::Node*, std::unordered_map<int, cocos2d::Map<std::string, CCBSequenceProperty*>>> & getNodeSequences();
private:
    const cocos2d::Value& getBaseValue(cocos2d::Node *pNode, const std::string& propName);
    Ref* getObject(cocos2d::Node *pNode, const std::string& propName);
    
    CCBSequence* getSequence(int nSequenceId);
    cocos2d::ActionInterval* getAction(CCBKeyframe *pKeyframe0, CCBKeyframe *pKeyframe1, const std::string& propName, cocos2d::Node *pNode);
    void setAnimatedProperty(const std::string& propName, cocos2d::Node *pNode, const cocos2d::Value& value, Ref* obj, float fTweenDuration);
    void setFirstFrame(cocos2d::Node *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration);
    cocos2d::ActionInterval* getEaseAction(cocos2d::ActionInterval *pAction, CCBKeyframe::EasingType easingType, float fEasingOpt);
    void runAction(cocos2d::Node *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration);
    void sequenceCompleted();
    void updateSpeed(float speed, cocos2d::Node* node);
    
private:
    cocos2d::Vector<CCBSequence*> _sequences;
    std::unordered_map<cocos2d::Node*, std::unordered_map<int, cocos2d::Map<std::string, CCBSequenceProperty*>>> _nodeSequences;
    std::unordered_map<cocos2d::Node*, std::unordered_map<std::string, cocos2d::Value>> _baseValues;
    std::unordered_map<cocos2d::Node*, std::unordered_map<std::string, cocos2d::Ref*>> _objects;
    
    int _autoPlaySequenceId;
    
    cocos2d::Node *_rootNode;
    
    cocos2d::Size _rootContainerSize;
    
    CCBAnimationManagerDelegate *_delegate;
    CCBSequence *_runningSequence;
    
    cocos2d::ValueVector _documentOutletNames;
    cocos2d::Vector<cocos2d::Node*> _documentOutletNodes;
    cocos2d::ValueVector _documentCallbackNames;
    cocos2d::Vector<cocos2d::Node*> _documentCallbackNodes;
    cocos2d::ValueVector _documentCallbackControlEvents;
    cocos2d::ValueVector _keyframeCallbacks;
    cocos2d::Map<std::string, cocos2d::CallFunc*> _keyframeCallFuncs;
    
    std::string _documentControllerName;
    std::string _lastCompletedSequenceName;
    
    cocos2d::SEL_CallFunc _animationCompleteCallbackFunc;
    cocos2d::Ref *_target;
    std::string _ccbFileName;
    
};

class CC_DLL CCBSetSpriteFrame : public cocos2d::ActionInstant
{
public:
    /** creates a Place action with a position */
    static CCBSetSpriteFrame* create(cocos2d::SpriteFrame *pSpriteFrame);
    /**
     * @js NA
     * @lua NA
     */
    ~CCBSetSpriteFrame();
    
    bool initWithSpriteFrame(cocos2d::SpriteFrame *pSpriteFrame);

    // Overrides
    virtual void update(float time) override;
	virtual CCBSetSpriteFrame* clone() const override;
	virtual CCBSetSpriteFrame* reverse() const override;

private:
    cocos2d::SpriteFrame *_spriteFrame;
};


class CC_DLL CCBSoundEffect : public cocos2d::ActionInstant
{
public:
    static CCBSoundEffect* actionWithSoundFile(const std::string &file, float pitch, float pan, float gain);
    /**
     * @js NA
     * @lua NA
     */
    ~CCBSoundEffect();
    bool initWithSoundFile(const std::string &file, float pitch, float pan, float gain);

    // Overrides
    virtual void update(float time) override;
	virtual CCBSoundEffect* clone() const override;
	virtual CCBSoundEffect* reverse() const override;

private:
    std::string _soundFile;
    float _pitch, _pan, _gain;
};


class CC_DLL CCBRotateTo : public cocos2d::ActionInterval
{
public:
    static CCBRotateTo* create(float fDuration, float fAngle);
    bool initWithDuration(float fDuration, float fAngle);

    // Override
    virtual void update(float time) override;
	virtual CCBRotateTo* clone() const override;
	virtual CCBRotateTo* reverse() const override;
    virtual void startWithTarget(cocos2d::Node *pNode) override;

private:
    float _startAngle;
    float _dstAngle;
    float _diffAngle;
};


class CC_DLL CCBRotateXTo: public cocos2d::ActionInterval
{
public:
    static CCBRotateXTo* create(float fDuration, float fAngle);
    bool initWithDuration(float fDuration, float fAngle);

    // Overrides
    virtual void startWithTarget(cocos2d::Node *pNode) override;
	virtual CCBRotateXTo* clone() const override;
	virtual CCBRotateXTo* reverse() const override;
    virtual void update(float time) override;

private:
    float _startAngle;
    float _dstAngle;
    float _diffAngle;
};


class CC_DLL CCBRotateYTo: public cocos2d::ActionInterval
{
public:
    static CCBRotateYTo* create(float fDuration, float fAngle);
    bool initWithDuration(float fDuration, float fAngle);

    // Override
    virtual void startWithTarget(cocos2d::Node *pNode) override;
	virtual CCBRotateYTo* clone() const override;
	virtual CCBRotateYTo* reverse() const override;
    virtual void update(float time) override;

private:
    float _startAngle;
    float _dstAngle;
    float _diffAngle;
};

    
    
class CC_DLL CCBFrameIndexTo : public cocos2d::ActionInterval {
    
public:
    static CCBFrameIndexTo* create(float fDuration, int startIndex, int endIndex);
    bool initWithDuration(float fDuration, int startIndex, int endIndex);
    
    // Override
    virtual void startWithTarget(cocos2d::Node *pNode) override;
    virtual CCBFrameIndexTo* clone() const override;
    virtual CCBFrameIndexTo* reverse() const override;
    virtual void update(float time) override;
    
private:
    int _startIndex;
    int _endIndex;
    float _diffIndex;
    
};

// add zml 粒子属性动画
    // 粒子生成器尺寸
    class CC_DLL CCBParticlePosVarTo : public cocos2d::ActionInterval {
    public:
        static CCBParticlePosVarTo* create(float fDuration, cocos2d::Vec2 size);
        bool initWithDuration(float fDuration, cocos2d::Vec2 size);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticlePosVarTo* clone() const override;
        virtual CCBParticlePosVarTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startGravity;
        cocos2d::Vec2 _endGravity;
        cocos2d::Vec2 _diffGravity;
    };
    
    
    
    // 重力
class CC_DLL CCBGravityTo : public cocos2d::ActionInterval {
public:
    static CCBGravityTo* create(float fDuration, cocos2d::Vec2 gravity);
    bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
    // Override
    virtual void startWithTarget(cocos2d::Node *pNode) override;
    virtual CCBGravityTo* clone() const override;
    virtual CCBGravityTo* reverse() const override;
    virtual void update(float time) override;
    
private:
    cocos2d::Vec2 _startGravity;
    cocos2d::Vec2 _endGravity;
    cocos2d::Vec2 _diffGravity;
};
    
//粒子速度
class CC_DLL CCBParticleSpeedTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleSpeedTo* create(float fDuration, cocos2d::Vec2 gravity);
        bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleSpeedTo* clone() const override;
        virtual CCBParticleSpeedTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
};
    
    //粒子生命
    class CC_DLL CCBParticleLifeTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleLifeTo* create(float fDuration, cocos2d::Vec2 gravity);
        bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleLifeTo* clone() const override;
        virtual CCBParticleLifeTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子开始大小
    class CC_DLL CCBParticleStartSizeTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleStartSizeTo* create(float fDuration, cocos2d::Vec2 gravity);
        bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleStartSizeTo* clone() const override;
        virtual CCBParticleStartSizeTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子结束尺寸
    class CC_DLL CCBParticleEndSizeTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleEndSizeTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleEndSizeTo* clone() const override;
        virtual CCBParticleEndSizeTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子开始旋转角度
    class CC_DLL CCBParticleStartSpinTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleStartSpinTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleStartSpinTo* clone() const override;
        virtual CCBParticleStartSpinTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子结束旋转角度
    class CC_DLL CCBParticleEndSpinTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleEndSpinTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleEndSpinTo* clone() const override;
        virtual CCBParticleEndSpinTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子发射角度
    class CC_DLL CCBParticleAngleTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleAngleTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleAngleTo* clone() const override;
        virtual CCBParticleAngleTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子重力模式切向加速度
    class CC_DLL CCBParticleTangentialAccelTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleTangentialAccelTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleTangentialAccelTo* clone() const override;
        virtual CCBParticleTangentialAccelTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子径向加速度
    class CC_DLL CCBParticleRadialAccelTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleRadialAccelTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleRadialAccelTo* clone() const override;
        virtual CCBParticleRadialAccelTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子半径模式开始半径
    class CC_DLL CCBParticleStartRadiusTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleStartRadiusTo* create(float fDuration, cocos2d::Vec2 floatVar);
        bool initWithDuration(float fDuration, cocos2d::Vec2 floatVar);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleStartRadiusTo* clone() const override;
        virtual CCBParticleStartRadiusTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子半径模式结束半径
    class CC_DLL CCBParticleEndRadiusTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleEndRadiusTo* create(float fDuration, cocos2d::Vec2 gravity);
        bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleEndRadiusTo* clone() const override;
        virtual CCBParticleEndRadiusTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };
    
    //粒子半径模式每秒旋转
    class CC_DLL CCBParticleRotatePerSecondTo : public cocos2d::ActionInterval {
    public:
        static CCBParticleRotatePerSecondTo* create(float fDuration, cocos2d::Vec2 gravity);
        bool initWithDuration(float fDuration, cocos2d::Vec2 gravity);
        // Override
        virtual void startWithTarget(cocos2d::Node *pNode) override;
        virtual CCBParticleRotatePerSecondTo* clone() const override;
        virtual CCBParticleRotatePerSecondTo* reverse() const override;
        virtual void update(float time) override;
        
    private:
        cocos2d::Vec2 _startFloatVar;
        cocos2d::Vec2 _endFloatVar;
        cocos2d::Vec2 _diffFloatVar;
    };

class CC_DLL CCBEaseInstant : public cocos2d::ActionEase
{
public:
    static CCBEaseInstant* create(cocos2d::ActionInterval *pAction);

	virtual CCBEaseInstant* clone() const override;
	virtual CCBEaseInstant* reverse() const override;
    virtual void update(float dt) override;
};

}

#endif // __CCB_CCBANIMATION_MANAGER_H__