mirror of https://github.com/axmolengine/axmol.git
435 lines
12 KiB
C++
435 lines
12 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2013 cocos2d-x.org
|
|
|
|
https://axmolengine.github.io/
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
#ifndef __CCFRAME_H__
|
|
#define __CCFRAME_H__
|
|
|
|
#include <string>
|
|
#include "base/CCRef.h"
|
|
#include "base/CCVector.h"
|
|
#include "2d/CCNode.h"
|
|
#include "2d/CCSprite.h"
|
|
#include "2d/CCTweenFunction.h"
|
|
#include "ActionTimeline/CCTimelineMacro.h"
|
|
#include "CocosStudioExport.h"
|
|
|
|
NS_TIMELINE_BEGIN
|
|
|
|
class Timeline;
|
|
class ActionTimeline;
|
|
|
|
class CCS_DLL Frame : public ax::Ref
|
|
{
|
|
public:
|
|
virtual void setFrameIndex(unsigned int frameIndex) { _frameIndex = frameIndex; }
|
|
virtual unsigned int getFrameIndex() const { return _frameIndex; }
|
|
|
|
virtual void setTimeline(Timeline* timeline) { _timeline = timeline; }
|
|
virtual Timeline* getTimeline() const { return _timeline; }
|
|
|
|
virtual void setNode(ax::Node* node) { _node = node; }
|
|
virtual ax::Node* getNode() const { return _node; }
|
|
|
|
virtual void setTween(bool tween) { _tween = tween; }
|
|
virtual bool isTween() const { return _tween; }
|
|
|
|
virtual void setTweenType(const ax::tweenfunc::TweenType& tweenType) { _tweenType = tweenType; }
|
|
virtual ax::tweenfunc::TweenType getTweenType() const { return _tweenType; }
|
|
|
|
// !to make easing with params, need setTweenType(TweenType::CUSTOM_EASING)
|
|
virtual void setEasingParams(const std::vector<float>& easingParams);
|
|
virtual const std::vector<float>& getEasingParams() const;
|
|
|
|
virtual bool isEnterWhenPassed() { return _enterWhenPassed; }
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) = 0;
|
|
virtual void apply(float percent);
|
|
|
|
virtual Frame* clone() = 0;
|
|
|
|
protected:
|
|
Frame();
|
|
virtual ~Frame();
|
|
|
|
virtual void onApply(float percent){};
|
|
// update percent depends _tweenType, and return the Calculated percent
|
|
virtual float tweenPercent(float percent);
|
|
|
|
virtual void emitEvent();
|
|
virtual void cloneProperty(Frame* frame);
|
|
|
|
protected:
|
|
unsigned int _frameIndex;
|
|
bool _tween;
|
|
bool _enterWhenPassed;
|
|
|
|
ax::tweenfunc::TweenType _tweenType;
|
|
std::vector<float> _easingParam;
|
|
Timeline* _timeline;
|
|
ax::Node* _node;
|
|
};
|
|
|
|
class CCS_DLL VisibleFrame : public Frame
|
|
{
|
|
public:
|
|
static VisibleFrame* create();
|
|
|
|
VisibleFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setVisible(bool visible) { _visible = visible; }
|
|
inline bool isVisible() const { return _visible; }
|
|
|
|
protected:
|
|
bool _visible;
|
|
};
|
|
|
|
class CCS_DLL TextureFrame : public Frame
|
|
{
|
|
public:
|
|
static TextureFrame* create();
|
|
|
|
TextureFrame();
|
|
|
|
virtual void setNode(ax::Node* node) override;
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setTextureName(std::string_view textureName) { _textureName = textureName; }
|
|
inline std::string_view getTextureName() const { return _textureName; }
|
|
|
|
protected:
|
|
ax::Sprite* _sprite;
|
|
std::string _textureName;
|
|
};
|
|
|
|
class CCS_DLL RotationFrame : public Frame
|
|
{
|
|
public:
|
|
static RotationFrame* create();
|
|
|
|
RotationFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setRotation(float rotation) { _rotation = rotation; }
|
|
inline float getRotation() const { return _rotation; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
float _rotation;
|
|
float _betwennRotation;
|
|
};
|
|
|
|
class CCS_DLL SkewFrame : public Frame
|
|
{
|
|
public:
|
|
static SkewFrame* create();
|
|
|
|
SkewFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setSkewX(float skewx) { _skewX = skewx; }
|
|
inline float getSkewX() const { return _skewX; }
|
|
|
|
inline void setSkewY(float skewy) { _skewY = skewy; }
|
|
inline float getSkewY() const { return _skewY; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
float _skewX;
|
|
float _skewY;
|
|
float _betweenSkewX;
|
|
float _betweenSkewY;
|
|
};
|
|
|
|
class CCS_DLL RotationSkewFrame : public SkewFrame
|
|
{
|
|
public:
|
|
static RotationSkewFrame* create();
|
|
|
|
RotationSkewFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
};
|
|
|
|
class CCS_DLL PositionFrame : public Frame
|
|
{
|
|
public:
|
|
static PositionFrame* create();
|
|
|
|
PositionFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setPosition(const ax::Point& position) { _position = position; }
|
|
inline ax::Point getPosition() const { return _position; }
|
|
|
|
inline void setX(float x) { _position.x = x; }
|
|
inline void setY(float y) { _position.y = y; }
|
|
|
|
inline float getX() const { return _position.x; }
|
|
inline float getY() const { return _position.y; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
ax::Point _position;
|
|
float _betweenX;
|
|
float _betweenY;
|
|
};
|
|
|
|
class CCS_DLL ScaleFrame : public Frame
|
|
{
|
|
public:
|
|
static ScaleFrame* create();
|
|
|
|
ScaleFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setScale(float scale)
|
|
{
|
|
_scaleX = scale;
|
|
_scaleY = scale;
|
|
}
|
|
|
|
inline void setScaleX(float scaleX) { _scaleX = scaleX; }
|
|
inline float getScaleX() const { return _scaleX; }
|
|
|
|
inline void setScaleY(float scaleY) { _scaleY = scaleY; }
|
|
inline float getScaleY() const { return _scaleY; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
float _scaleX;
|
|
float _scaleY;
|
|
float _betweenScaleX;
|
|
float _betweenScaleY;
|
|
};
|
|
|
|
class CCS_DLL AnchorPointFrame : public Frame
|
|
{
|
|
public:
|
|
static AnchorPointFrame* create();
|
|
|
|
AnchorPointFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setAnchorPoint(const ax::Point& point) { _anchorPoint = point; }
|
|
inline ax::Point getAnchorPoint() const { return _anchorPoint; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
ax::Vec2 _betweenAnchorPoint;
|
|
ax::Vec2 _anchorPoint;
|
|
};
|
|
|
|
enum InnerActionType
|
|
{
|
|
LoopAction,
|
|
NoLoopAction,
|
|
SingleFrame
|
|
};
|
|
|
|
class CCS_DLL InnerActionFrame : public Frame
|
|
{
|
|
public:
|
|
static const std::string AnimationAllName;
|
|
|
|
static InnerActionFrame* create();
|
|
InnerActionFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setInnerActionType(InnerActionType type) { _innerActionType = type; }
|
|
inline InnerActionType getInnerActionType() const { return _innerActionType; }
|
|
|
|
inline void setEnterWithName(bool isEnterWithName) { _enterWithName = isEnterWithName; }
|
|
|
|
void setStartFrameIndex(int frameIndex);
|
|
inline int getStartFrameIndex() const { return _startFrameIndex; }
|
|
|
|
void setEndFrameIndex(int frameIndex);
|
|
inline int getEndFrameIndex() const { return _endFrameIndex; }
|
|
|
|
void setAnimationName(std::string_view animationNamed);
|
|
|
|
inline void setSingleFrameIndex(int frameIndex) { _singleFrameIndex = frameIndex; }
|
|
inline int getSingleFrameIndex() const { return _singleFrameIndex; }
|
|
|
|
protected:
|
|
InnerActionType _innerActionType;
|
|
int _startFrameIndex;
|
|
int _endFrameIndex;
|
|
int _singleFrameIndex;
|
|
std::string _animationName;
|
|
bool _enterWithName;
|
|
};
|
|
|
|
class CCS_DLL ColorFrame : public Frame
|
|
{
|
|
public:
|
|
static ColorFrame* create();
|
|
ColorFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
/** @deprecated Use method setAlpha() and getAlpha() of AlphaFrame instead */
|
|
AX_DEPRECATED_ATTRIBUTE inline void setAlpha(uint8_t alpha) { _alpha = alpha; }
|
|
AX_DEPRECATED_ATTRIBUTE inline uint8_t getAlpha() const { return _alpha; }
|
|
|
|
inline void setColor(const ax::Color3B& color) { _color = color; }
|
|
inline ax::Color3B getColor() const { return _color; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
uint8_t _alpha;
|
|
ax::Color3B _color;
|
|
|
|
int _betweenRed;
|
|
int _betweenGreen;
|
|
int _betweenBlue;
|
|
};
|
|
|
|
class CCS_DLL AlphaFrame : public Frame
|
|
{
|
|
public:
|
|
static AlphaFrame* create();
|
|
AlphaFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setAlpha(uint8_t alpha) { _alpha = alpha; }
|
|
inline uint8_t getAlpha() const { return _alpha; }
|
|
|
|
protected:
|
|
virtual void onApply(float percent) override;
|
|
|
|
uint8_t _alpha;
|
|
int _betweenAlpha;
|
|
};
|
|
|
|
class CCS_DLL EventFrame : public Frame
|
|
{
|
|
public:
|
|
static EventFrame* create();
|
|
void init();
|
|
|
|
EventFrame();
|
|
|
|
virtual void setNode(ax::Node* node) override;
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setEvent(std::string_view event) { _event = event; }
|
|
inline std::string_view getEvent() const { return _event; }
|
|
|
|
protected:
|
|
std::string _event;
|
|
ActionTimeline* _action;
|
|
};
|
|
|
|
class CCS_DLL ZOrderFrame : public Frame
|
|
{
|
|
public:
|
|
static ZOrderFrame* create();
|
|
|
|
ZOrderFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline void setZOrder(int zorder) { _zorder = zorder; }
|
|
inline int getZOrder() const { return _zorder; }
|
|
|
|
protected:
|
|
int _zorder;
|
|
};
|
|
|
|
class CCS_DLL BlendFuncFrame : public Frame
|
|
{
|
|
public:
|
|
static BlendFuncFrame* create();
|
|
|
|
BlendFuncFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameIndex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline ax::BlendFunc getBlendFunc() const { return _blendFunc; }
|
|
inline void setBlendFunc(ax::BlendFunc blendFunc) { _blendFunc = blendFunc; }
|
|
|
|
protected:
|
|
ax::BlendFunc _blendFunc;
|
|
};
|
|
|
|
class CCS_DLL PlayableFrame : public Frame
|
|
{
|
|
public:
|
|
static PlayableFrame* create();
|
|
|
|
PlayableFrame();
|
|
|
|
virtual void onEnter(Frame* nextFrame, int currentFrameINdex) override;
|
|
virtual Frame* clone() override;
|
|
|
|
inline std::string getPlayableAct() const { return _playableAct; }
|
|
// @param playact, express the interface in PlayableProtocol, should be "start" or "stop"
|
|
inline void setPlayableAct(std::string playact) { _playableAct = playact; }
|
|
|
|
static const std::string PLAYABLE_EXTENTION;
|
|
|
|
private:
|
|
std::string _playableAct; // express the interface in PlayableProtocol
|
|
static const std::string START_ACT;
|
|
static const std::string STOP_ACT;
|
|
};
|
|
NS_TIMELINE_END
|
|
|
|
#endif /*__CCFRAME_H__*/
|