├── spritebuilder ├── CCNodeLoaderListener.h ├── CCBFileLoader.cpp ├── CCNode+CCBRelativePositioning.h ├── CCMenuLoader.h ├── CCLayerLoader.h ├── CCBFileLoader.h ├── CCBSequenceProperty.h ├── CCBSequenceProperty.cpp ├── CCMenuItemImageLoader.h ├── CCMenuItemLoader.h ├── CCControlLoader.h ├── CCLayerColorLoader.h ├── CCBSequence.h ├── CCMenuItemImageLoader.cpp ├── CCLayerGradientLoader.h ├── CCMenuItemLoader.cpp ├── CCBKeyframe.cpp ├── LICENSE_SpriteBuilder.txt ├── CCSpriteLoader.h ├── CCLabelBMFontLoader.h ├── CCBKeyframe.h ├── CCScrollViewLoader.h ├── Android.mk ├── CCLayerColorLoader.cpp ├── SpriteBuilder.h ├── CCBSelectorResolver.h ├── CCPhysicsNode.h ├── CCTextFieldLoader.h ├── CCLayout.h ├── CCPhysicsNodeLoader.cpp ├── CCLayerLoader.cpp ├── CCBPhysicsBody.h ├── CCBSequence.cpp ├── CCBLocalizationManager.h ├── CCLayout.cpp ├── CCPhysicsNodeLoader.h ├── CCLayoutBox.h ├── CCControlLoader.cpp ├── CCBPhysicsWorld.h ├── CCLabelTTFLoader.h ├── CCLabelBMFontLoader.cpp ├── CCBMemberVariableAssigner.h ├── CCLayoutBoxLoader.h ├── CCLayoutBoxLoader.cpp ├── CCSpriteLoader.cpp ├── CCLayerGradientLoader.cpp ├── CCPhysicsNode.cpp ├── CCScrollViewLoader.cpp ├── CCScale9SpriteLoader.h ├── CCParticleSystemQuadLoader.h ├── CCControlButtonLoader.h ├── CCNode+CCBRelativePositioning.cpp ├── CCBPhysicsBody.cpp ├── CCNodeLoaderLibrary.h ├── CCSliderLoader.h ├── CCBLocalizationManager.cpp ├── CCTextFieldLoader.cpp ├── CCScale9SpriteLoader.cpp ├── CCLayoutBox.cpp ├── CCNodeLoaderLibrary.cpp ├── CCLabelTTFLoader.cpp ├── CCSliderLoader.cpp ├── CCParticleSystemQuadLoader.cpp ├── CCBAnimationManager.h ├── CCBPhysicsJoints.h ├── CCNodeLoader.h ├── CCBPhysicsWorld.cpp ├── CCBReader.h └── CCControlButtonLoader.cpp ├── readme.txt └── LICENSE_SpriteBuilder.txt /spritebuilder/CCNodeLoaderListener.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCNODELOADERLISTENER_H_ 2 | #define _CCB_CCNODELOADERLISTENER_H_ 3 | 4 | 5 | namespace spritebuilder { 6 | 7 | class NodeLoaderListener { 8 | public: 9 | /** 10 | * @js NA 11 | * @lua NA 12 | */ 13 | virtual ~NodeLoaderListener() {}; 14 | /** 15 | * @js NA 16 | * @lua NA 17 | */ 18 | virtual void onNodeLoaded(cocos2d::Node * pNode, NodeLoader * pNodeLoader) = 0; 19 | }; 20 | 21 | } 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /spritebuilder/CCBFileLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCBFileLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | 6 | namespace spritebuilder { 7 | 8 | #define PROPERTY_CCBFILE "ccbFile" 9 | 10 | void CCBFileLoader::onHandlePropTypeCCBFile(Node * pNode, Node * pParent, const char * pPropertyName, Node * pCCBFileNode, CCBReader * ccbReader) { 11 | if(strcmp(pPropertyName, PROPERTY_CCBFILE) == 0) { 12 | ((CCBFile*)pNode)->setCCBFileNode(pCCBFileNode); 13 | } else { 14 | NodeLoader::onHandlePropTypeCCBFile(pNode, pParent, pPropertyName, pCCBFileNode, ccbReader); 15 | } 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /spritebuilder/CCNode+CCBRelativePositioning.h: -------------------------------------------------------------------------------- 1 | #ifndef __CCB_CCNODE_RELATIVEPOSITIONING_H__ 2 | #define __CCB_CCNODE_RELATIVEPOSITIONING_H__ 3 | 4 | #include "CCBReader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | extern cocos2d::Point getAbsolutePosition(cocos2d::Point pt, CCBReader::PositionType type, CCBReader::PositionUnit xUnit, CCBReader::PositionUnit yUnit, const cocos2d::Size &containerSize, const std::string& propName); 9 | 10 | extern void setRelativeScale(cocos2d::Node *node, float scaleX, float scaleY, CCBReader::ScaleType type, const std::string& propName); 11 | 12 | } 13 | 14 | #endif // __CCB_CCNODE_RELATIVEPOSITIONING_H__ 15 | -------------------------------------------------------------------------------- /spritebuilder/CCMenuLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCMENULOADER_H_ 2 | #define _CCB_CCMENULOADER_H_ 3 | 4 | #include "CCLayerLoader.h" 5 | #include "CCRef.h" 6 | #include "CCMenu.h" 7 | 8 | namespace spritebuilder { 9 | 10 | /* Forward declaration. */ 11 | class CCBReader; 12 | 13 | class MenuLoader : public LayerLoader { 14 | public: 15 | /** 16 | * @js NA 17 | * @lua NA 18 | */ 19 | virtual ~MenuLoader() {}; 20 | /** 21 | * @js NA 22 | * @lua NA 23 | */ 24 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(MenuLoader, loader); 25 | 26 | protected: 27 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Menu); 28 | }; 29 | 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCLAYERLOADER_H_ 2 | #define _CCB_CCLAYERLOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | /* Forward declaration. */ 9 | class CCBReader; 10 | 11 | class LayerLoader : public NodeLoader { 12 | public: 13 | /** 14 | * @js NA 15 | * @lua NA 16 | */ 17 | virtual ~LayerLoader() {}; 18 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LayerLoader, loader); 19 | 20 | protected: 21 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Layer); 22 | 23 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader); 24 | }; 25 | 26 | } 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /spritebuilder/CCBFileLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCBFILELOADER_H_ 2 | #define _CCB_CCBFILELOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | #include "CCBReader.h" 6 | 7 | namespace spritebuilder { 8 | 9 | /* Forward declaration. */ 10 | class CCBReader; 11 | 12 | class CCBFileLoader : public NodeLoader { 13 | public: 14 | /** 15 | * @js NA 16 | * @lua NA 17 | */ 18 | virtual ~CCBFileLoader() {}; 19 | /** 20 | * @js NA 21 | * @lua NA 22 | */ 23 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(CCBFileLoader, loader); 24 | 25 | protected: 26 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(CCBFile); 27 | 28 | virtual void onHandlePropTypeCCBFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Node * pCCBFileNode, CCBReader * ccbReader); 29 | }; 30 | 31 | } 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /spritebuilder/CCBSequenceProperty.h: -------------------------------------------------------------------------------- 1 | #ifndef __CCB_SEQUENCE_PROPERTY_H__ 2 | #define __CCB_SEQUENCE_PROPERTY_H__ 3 | 4 | #include "CCRef.h" 5 | #include "CCVector.h" 6 | #include "CCBKeyframe.h" 7 | 8 | namespace spritebuilder { 9 | 10 | class CCBSequenceProperty : public cocos2d::Ref 11 | { 12 | public: 13 | /** 14 | * @js ctor 15 | */ 16 | CCBSequenceProperty(); 17 | /** 18 | * @js NA 19 | * @lua NA 20 | */ 21 | ~CCBSequenceProperty(); 22 | 23 | virtual bool init(); 24 | 25 | const char* getName(); 26 | void setName(const char* pName); 27 | 28 | int getType(); 29 | void setType(int type); 30 | 31 | cocos2d::Vector& getKeyframes(); 32 | 33 | private: 34 | std::string _name; 35 | int _type; 36 | cocos2d::Vector _keyframes; 37 | }; 38 | 39 | } 40 | 41 | #endif // __CCB_SEQUENCE_PROPERTY_H__ 42 | -------------------------------------------------------------------------------- /spritebuilder/CCBSequenceProperty.cpp: -------------------------------------------------------------------------------- 1 | #include "CCBSequenceProperty.h" 2 | 3 | using namespace cocos2d; 4 | using namespace std; 5 | 6 | namespace spritebuilder { 7 | 8 | CCBSequenceProperty::CCBSequenceProperty() 9 | : _name("") 10 | , _type(0) 11 | { 12 | init(); 13 | } 14 | 15 | bool CCBSequenceProperty::init() 16 | { 17 | return true; 18 | } 19 | 20 | CCBSequenceProperty::~CCBSequenceProperty() 21 | { 22 | } 23 | 24 | const char* CCBSequenceProperty::getName() 25 | { 26 | return _name.c_str(); 27 | } 28 | 29 | void CCBSequenceProperty::setName(const char *pName) 30 | { 31 | _name = pName; 32 | } 33 | 34 | int CCBSequenceProperty::getType() 35 | { 36 | return _type; 37 | } 38 | 39 | void CCBSequenceProperty::setType(int type) 40 | { 41 | _type = type; 42 | } 43 | 44 | cocos2d::Vector& CCBSequenceProperty::getKeyframes() 45 | { 46 | return _keyframes; 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /spritebuilder/CCMenuItemImageLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCMENUITEMIMAGELOADER_H_ 2 | #define _CCB_CCMENUITEMIMAGELOADER_H_ 3 | 4 | #include "CCMenuItemLoader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | /* Forward declaration. */ 9 | class CCBReader; 10 | 11 | class MenuItemImageLoader : public MenuItemLoader { 12 | public: 13 | /** 14 | * @js NA 15 | * @lua NA 16 | */ 17 | virtual ~MenuItemImageLoader() {}; 18 | /** 19 | * @js NA 20 | * @lua NA 21 | */ 22 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(MenuItemImageLoader, loader); 23 | 24 | protected: 25 | /** 26 | * @js NA 27 | * @lua NA 28 | */ 29 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::MenuItemImage); 30 | /** 31 | * @js NA 32 | * @lua NA 33 | */ 34 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 35 | }; 36 | 37 | } 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /readme.txt: -------------------------------------------------------------------------------- 1 | This library support for cocos2d-x 3.x and SpriteBuilder 1.1 2 | 3 | 4 | You can pull from git hub: https://github.com/nguyenduong 5 | or my home page: www.jacos2d-x.org 6 | 7 | 8 | How to integrate to cocos2d-x: 9 | 10 | I. Copy spritebuilder folder to cocos2d/cocos/editor-support 11 | 12 | II. iOS: 13 | 1. Open cocos2d_libs project setting/ build target/cocos2dxiOS 14 | 2. Choose Build Phases 15 | 3. Expand Compile Sources 16 | 4. Add all of cpp file under spritebuilder folder 17 | 18 | III. Android: 19 | 1. Open file proj.android/jni/Android.mk 20 | 2. Add following lines: 21 | LOCAL_WHOLE_STATIC_LIBRARIES += spritebuilder_static 22 | LOCAL_WHOLE_STATIC_LIBRARIES += cocos_extension_static 23 | $(call import-module,editor-support/spritebuilder) 24 | 25 | IV. Thanks 26 | 1. Beckheng Lam (beckheng@gmail.com) 27 | 28 | Please let me know if you have any problem. 29 | 30 | Good luck! 31 | 32 | Thanks, 33 | 34 | Nguyen Thai Duong 35 | 36 | home: http://jacos2d-x.org 37 | email: nguyen.duong@jacos2d-x.org 38 | -------------------------------------------------------------------------------- /spritebuilder/CCMenuItemLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCMENUITEMLOADER_H_ 2 | #define _CCB_CCMENUITEMLOADER_H_ 3 | 4 | #include "CCRef.h" 5 | #include "CCMenuItem.h" 6 | 7 | #include "CCLayerLoader.h" 8 | 9 | namespace spritebuilder { 10 | 11 | /* Forward declaration. */ 12 | class CCBReader; 13 | 14 | class MenuItemLoader : public NodeLoader { 15 | public: 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | virtual ~MenuItemLoader() {}; 21 | 22 | protected: 23 | /** 24 | * @js NA 25 | * @lua NA 26 | */ 27 | SB_PURE_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::MenuItem); 28 | /** 29 | * @js NA 30 | * @lua NA 31 | */ 32 | virtual void onHandlePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, BlockData * pBlockData, CCBReader * ccbReader); 33 | /** 34 | * @js NA 35 | * @lua NA 36 | */ 37 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader); 38 | }; 39 | 40 | } 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /spritebuilder/CCControlLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCCONTROLLOADER_H_ 2 | #define _CCB_CCCONTROLLOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | #include "extensions/GUI/CCControlExtension/CCControl.h" 6 | 7 | namespace spritebuilder { 8 | 9 | /* Forward declaration. */ 10 | class CCBReader; 11 | 12 | class ControlLoader : public NodeLoader { 13 | public: 14 | /** 15 | * @js NA 16 | * @lua NA 17 | */ 18 | virtual ~ControlLoader() {}; 19 | 20 | protected: 21 | SB_PURE_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::extension::Control); 22 | 23 | virtual void onHandlePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, BlockData * pBlockData, CCBReader * ccbReader); 24 | virtual void onHandlePropTypeBlockControl(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader); 25 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader); 26 | }; 27 | 28 | } 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerColorLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCLAYERCOLORLOADER_H_ 2 | #define _CCB_CCLAYERCOLORLOADER_H_ 3 | 4 | #include "CCLayerLoader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | /* Forward declaration. */ 9 | class CCBReader; 10 | 11 | class LayerColorLoader : public LayerLoader { 12 | public: 13 | /** 14 | * @js NA 15 | * @lua NA 16 | */ 17 | virtual ~LayerColorLoader() {}; 18 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LayerColorLoader, loader); 19 | 20 | protected: 21 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::LayerColor); 22 | 23 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 24 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 25 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 26 | }; 27 | 28 | } 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /spritebuilder/CCBSequence.h: -------------------------------------------------------------------------------- 1 | #ifndef __CCB_CCSEQUENCE_H__ 2 | #define __CCB_CCSEQUENCE_H__ 3 | 4 | #include 5 | 6 | #include "CCRef.h" 7 | #include "CCBSequenceProperty.h" 8 | 9 | namespace spritebuilder { 10 | 11 | class CCBSequence : public cocos2d::Ref 12 | { 13 | public: 14 | CCBSequence(); 15 | /** 16 | * @js NA 17 | * @lua NA 18 | */ 19 | ~CCBSequence(); 20 | float getDuration(); 21 | void setDuration(float fDuration); 22 | 23 | CCBSequenceProperty* getCallbackChannel(); 24 | void setCallbackChannel(CCBSequenceProperty* callbackChannel); 25 | 26 | CCBSequenceProperty* getSoundChannel(); 27 | void setSoundChannel(CCBSequenceProperty* soundChannel); 28 | 29 | const char* getName(); 30 | void setName(const char *pName); 31 | 32 | int getSequenceId(); 33 | void setSequenceId(int nSequenceId); 34 | 35 | int getChainedSequenceId(); 36 | void setChainedSequenceId(int nChainedSequenceId); 37 | 38 | private: 39 | float _duration; 40 | std::string _name; 41 | int mSequenceId; 42 | int mChainedSequenceId; 43 | CCBSequenceProperty* mCallbackChannel; 44 | CCBSequenceProperty* mSoundChannel; 45 | }; 46 | 47 | 48 | } 49 | 50 | 51 | #endif // __CCB_CCSEQUENCE_H__ 52 | -------------------------------------------------------------------------------- /spritebuilder/CCMenuItemImageLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCMenuItemImageLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | #define PROPERTY_NORMALDISPLAYFRAME "normalSpriteFrame" 6 | #define PROPERTY_SELECTEDDISPLAYFRAME "selectedSpriteFrame" 7 | #define PROPERTY_DISABLEDDISPLAYFRAME "disabledSpriteFrame" 8 | 9 | namespace spritebuilder { 10 | 11 | void MenuItemImageLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 12 | if(strcmp(pPropertyName, PROPERTY_NORMALDISPLAYFRAME) == 0) { 13 | if(pSpriteFrame != NULL) { 14 | ((MenuItemImage *)pNode)->setNormalSpriteFrame(pSpriteFrame); 15 | } 16 | } else if(strcmp(pPropertyName, PROPERTY_SELECTEDDISPLAYFRAME) == 0) { 17 | if(pSpriteFrame != NULL) { 18 | ((MenuItemImage *)pNode)->setSelectedSpriteFrame(pSpriteFrame); 19 | } 20 | } else if(strcmp(pPropertyName, PROPERTY_DISABLEDDISPLAYFRAME) == 0) { 21 | if(pSpriteFrame != NULL) { 22 | ((MenuItemImage *)pNode)->setDisabledSpriteFrame(pSpriteFrame); 23 | } 24 | } else { 25 | MenuItemLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 26 | } 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerGradientLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCLAYERGRADIENTLOADER_H_ 2 | #define _CCB_CCLAYERGRADIENTLOADER_H_ 3 | 4 | #include "CCLayerLoader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | /* Forward declaration. */ 9 | class CCBReader; 10 | 11 | class LayerGradientLoader : public LayerLoader { 12 | public: 13 | /** 14 | * @js NA 15 | * @lua NA 16 | */ 17 | virtual ~LayerGradientLoader() {}; 18 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LayerGradientLoader, loader); 19 | 20 | protected: 21 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::LayerGradient); 22 | 23 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 24 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 25 | virtual void onHandlePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Point pPoint, CCBReader * ccbReader); 26 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 27 | }; 28 | 29 | } 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /spritebuilder/CCMenuItemLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCMenuItemLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | #define PROPERTY_BLOCK "block" 6 | #define PROPERTY_ISENABLED "isEnabled" 7 | 8 | namespace spritebuilder { 9 | 10 | void MenuItemLoader::onHandlePropTypeBlock(Node * pNode, Node * pParent, const char * pPropertyName, BlockData * pBlockData, CCBReader * ccbReader) { 11 | if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 12 | if (NULL != pBlockData) // Add this condition to allow MenuItemImage without target/selector predefined 13 | { 14 | ((MenuItem *)pNode)->setCallback( std::bind( pBlockData->mSELMenuHandler, pBlockData->_target, std::placeholders::_1) ); 15 | // ((MenuItem *)pNode)->setTarget(pBlockData->_target, pBlockData->mSELMenuHandler); 16 | } 17 | } else { 18 | NodeLoader::onHandlePropTypeBlock(pNode, pParent, pPropertyName, pBlockData, ccbReader); 19 | } 20 | } 21 | 22 | void MenuItemLoader::onHandlePropTypeCheck(Node * pNode, Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader) { 23 | if(strcmp(pPropertyName, PROPERTY_ISENABLED) == 0) { 24 | ((MenuItem *)pNode)->setEnabled(pCheck); 25 | } else { 26 | NodeLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader); 27 | } 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /spritebuilder/CCBKeyframe.cpp: -------------------------------------------------------------------------------- 1 | #include "CCBKeyframe.h" 2 | 3 | using namespace cocos2d; 4 | 5 | namespace spritebuilder { 6 | 7 | CCBKeyframe::CCBKeyframe() 8 | : _time(0.0f) 9 | , _easingType(EasingType::INSTANT) 10 | , _easingOpt(0.0f) 11 | , _object(nullptr) 12 | {} 13 | 14 | CCBKeyframe::~CCBKeyframe() 15 | { 16 | CC_SAFE_RELEASE(_object); 17 | } 18 | 19 | const Value& CCBKeyframe::getValue() const 20 | { 21 | return _value; 22 | } 23 | 24 | void CCBKeyframe::setValue(const Value& value) 25 | { 26 | _value = value; 27 | } 28 | 29 | Ref* CCBKeyframe::getObject() const 30 | { 31 | return _object; 32 | } 33 | 34 | void CCBKeyframe::setObject(Ref* obj) 35 | { 36 | CC_SAFE_RETAIN(obj); 37 | CC_SAFE_RELEASE(_object); 38 | _object = obj; 39 | } 40 | 41 | float CCBKeyframe::getTime() 42 | { 43 | return _time; 44 | } 45 | 46 | void CCBKeyframe::setTime(float fTime) 47 | { 48 | _time = fTime; 49 | } 50 | 51 | CCBKeyframe::EasingType CCBKeyframe::getEasingType() 52 | { 53 | return _easingType; 54 | } 55 | 56 | void CCBKeyframe::setEasingType(CCBKeyframe::EasingType easingType) 57 | { 58 | _easingType = easingType; 59 | } 60 | 61 | float CCBKeyframe::getEasingOpt() 62 | { 63 | return _easingOpt; 64 | } 65 | 66 | void CCBKeyframe::setEasingOpt(float fEasingOpt) 67 | { 68 | _easingOpt = fEasingOpt; 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /LICENSE_SpriteBuilder.txt: -------------------------------------------------------------------------------- 1 | SpriteBuilder Reader: http://www.spritebuilder.com 2 | 3 | Copyright (c) 2010-2011 - Viktor Lidholt 4 | Copyright (c) 2011-2012 - Zynga Inc. and contributors 5 | Copyright (c) 2014 - Nguyen Thai Duong 6 | 7 | (see each file to see the different copyright owners) 8 | 9 | 10 | Permission is hereby granted, free of charge, to any person obtaining a copy 11 | of this software and associated documentation files (the "Software"), to deal 12 | in the Software without restriction, including without limitation the rights 13 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 | copies of the Software, and to permit persons to whom the Software is 15 | furnished to do so, subject to the following conditions: 16 | 17 | The above copyright notice and this permission notice shall be included in 18 | all copies or substantial portions of the Software. 19 | 20 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 23 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 | THE SOFTWARE. 27 | -------------------------------------------------------------------------------- /spritebuilder/LICENSE_SpriteBuilder.txt: -------------------------------------------------------------------------------- 1 | SpriteBuilder Reader: http://www.spritebuilder.com 2 | 3 | Copyright (c) 2010-2011 - Viktor Lidholt 4 | Copyright (c) 2011-2012 - Zynga Inc. and contributors 5 | Copyright (c) 2014 - Nguyen Thai Duong 6 | 7 | (see each file to see the different copyright owners) 8 | 9 | 10 | Permission is hereby granted, free of charge, to any person obtaining a copy 11 | of this software and associated documentation files (the "Software"), to deal 12 | in the Software without restriction, including without limitation the rights 13 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 | copies of the Software, and to permit persons to whom the Software is 15 | furnished to do so, subject to the following conditions: 16 | 17 | The above copyright notice and this permission notice shall be included in 18 | all copies or substantial portions of the Software. 19 | 20 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 23 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 | THE SOFTWARE. 27 | -------------------------------------------------------------------------------- /spritebuilder/CCSpriteLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCSPRITELOADER_H_ 2 | #define _CCB_CCSPRITELOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | /* Forward declaration. */ 9 | class CCBReader; 10 | 11 | class SpriteLoader : public NodeLoader { 12 | public: 13 | /** 14 | * @js NA 15 | * @lua NA 16 | */ 17 | virtual ~SpriteLoader() {}; 18 | /** 19 | * @js NA 20 | * @lua NA 21 | */ 22 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(SpriteLoader, loader); 23 | 24 | protected: 25 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Sprite); 26 | 27 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 28 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 29 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pCCBBlendFunc, CCBReader * ccbReader); 30 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 31 | virtual void onHandlePropTypeFlip(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool * pFlip, CCBReader * ccbReader); 32 | }; 33 | 34 | } 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /spritebuilder/CCLabelBMFontLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCLABELBMFONTLOADER_H_ 2 | #define _CCB_CCLABELBMFONTLOADER_H_ 3 | 4 | #include "CCRef.h" 5 | #include "CCLabel.h" 6 | 7 | #include "CCNodeLoader.h" 8 | 9 | namespace spritebuilder { 10 | 11 | /* Forward declaration. */ 12 | class CCBReader; 13 | 14 | class LabelBMFontLoader : public NodeLoader { 15 | public: 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | virtual ~LabelBMFontLoader() {}; 21 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LabelBMFontLoader, loader); 22 | 23 | protected: 24 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Label); 25 | 26 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 27 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 28 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 29 | virtual void onHandlePropTypeFntFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char* pFntFile, CCBReader * ccbReader); 30 | virtual void onHandlePropTypeText(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char* pText, CCBReader * ccbReader); 31 | 32 | }; 33 | 34 | } 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /spritebuilder/CCBKeyframe.h: -------------------------------------------------------------------------------- 1 | #ifndef __CCB_KEYFRAME_H__ 2 | #define __CCB_KEYFRAME_H__ 3 | 4 | #include "CCRef.h" 5 | #include "CCValue.h" 6 | 7 | 8 | namespace spritebuilder { 9 | 10 | class CCBKeyframe : public cocos2d::Ref 11 | { 12 | public: 13 | enum class EasingType 14 | { 15 | INSTANT, 16 | 17 | LINEAR, 18 | 19 | CUBIC_IN, 20 | CUBIC_OUT, 21 | CUBIC_INOUT, 22 | 23 | ELASTIC_IN, 24 | ELASTIC_OUT, 25 | ELASTIC_INOUT, 26 | 27 | BOUNCE_IN, 28 | BOUNCE_OUT, 29 | BOUNCE_INOUT, 30 | 31 | BACK_IN, 32 | BACK_OUT, 33 | BACK_INOUT, 34 | }; 35 | /** 36 | * @js ctor 37 | */ 38 | CCBKeyframe(); 39 | /** 40 | * @js NA 41 | * @lua NA 42 | */ 43 | ~CCBKeyframe(); 44 | 45 | const cocos2d::Value& getValue() const; 46 | void setValue(const cocos2d::Value& value); 47 | 48 | cocos2d::Ref* getObject() const; 49 | void setObject(cocos2d::Ref* obj); 50 | 51 | float getTime(); 52 | void setTime(float fTime); 53 | 54 | EasingType getEasingType(); 55 | void setEasingType(EasingType easingType); 56 | 57 | float getEasingOpt(); 58 | void setEasingOpt(float fEasingOpt); 59 | 60 | private: 61 | cocos2d::Value _value; 62 | cocos2d::Ref* _object; 63 | float _time; 64 | EasingType _easingType; 65 | float _easingOpt; 66 | }; 67 | 68 | } 69 | 70 | #endif // __CCB_KEYFRAME_H__ 71 | -------------------------------------------------------------------------------- /spritebuilder/CCScrollViewLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCSCROLLVIEWLOADER_H_ 2 | #define _CCB_CCSCROLLVIEWLOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | #include "extensions/GUI/CCScrollView/CCScrollView.h" 6 | 7 | namespace spritebuilder { 8 | 9 | /* Forward declaration. */ 10 | class CCBReader; 11 | 12 | class ScrollViewLoader : public NodeLoader { 13 | public: 14 | /** 15 | * @js NA 16 | * @lua NA 17 | */ 18 | virtual ~ScrollViewLoader() {}; 19 | /** 20 | * @js NA 21 | * @lua NA 22 | */ 23 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(ScrollViewLoader, loader); 24 | 25 | protected: 26 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::extension::ScrollView); 27 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 28 | virtual void onHandlePropTypeCCBFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Node * pCCBFileNode, CCBReader * ccbReader); 29 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader); 30 | virtual void onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader); 31 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 32 | }; 33 | 34 | } 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /spritebuilder/Android.mk: -------------------------------------------------------------------------------- 1 | LOCAL_PATH := $(call my-dir) 2 | include $(CLEAR_VARS) 3 | 4 | LOCAL_MODULE := spritebuilder_static 5 | 6 | LOCAL_MODULE_FILENAME := libspritebuilder 7 | 8 | LOCAL_SRC_FILES := CCBAnimationManager.cpp \ 9 | CCBFileLoader.cpp \ 10 | CCBKeyframe.cpp \ 11 | CCBLocalizationManager.cpp \ 12 | CCBReader.cpp \ 13 | CCBSequence.cpp \ 14 | CCBSequenceProperty.cpp \ 15 | CCControlButtonLoader.cpp \ 16 | CCControlLoader.cpp \ 17 | CCLabelBMFontLoader.cpp \ 18 | CCLabelTTFLoader.cpp \ 19 | CCLayerColorLoader.cpp \ 20 | CCLayerGradientLoader.cpp \ 21 | CCLayerLoader.cpp \ 22 | CCLayout.cpp \ 23 | CCLayoutBox.cpp \ 24 | CCLayoutBoxLoader.cpp \ 25 | CCMenuItemImageLoader.cpp \ 26 | CCMenuItemLoader.cpp \ 27 | CCNode+CCBRelativePositioning.cpp \ 28 | CCNodeLoader.cpp \ 29 | CCNodeLoaderLibrary.cpp \ 30 | CCParticleSystemQuadLoader.cpp \ 31 | CCPhysicsNode.cpp \ 32 | CCPhysicsNodeLoader.cpp \ 33 | CCScale9SpriteLoader.cpp \ 34 | CCScrollViewLoader.cpp \ 35 | CCSliderLoader.cpp \ 36 | CCSpriteLoader.cpp \ 37 | CCTextFieldLoader.cpp \ 38 | CCBPhysicsBody.cpp \ 39 | CCBPhysicsWorld.cpp 40 | 41 | LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/.. \ 42 | $(LOCAL_PATH)/../../.. 43 | 44 | LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../2d \ 45 | LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../physics/chipmunk \ 46 | $(LOCAL_PATH) \ 47 | $(LOCAL_PATH)/../../.. 48 | 49 | LOCAL_CFLAGS += -Wno-psabi 50 | LOCAL_EXPORT_CFLAGS += -Wno-psabi 51 | 52 | LOCAL_WHOLE_STATIC_LIBRARIES := cocos_extension_static 53 | 54 | 55 | include $(BUILD_STATIC_LIBRARY) 56 | 57 | $(call import-module,extensions) 58 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerColorLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCLayerColorLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | namespace spritebuilder { 6 | 7 | #define PROPERTY_COLOR "color" 8 | #define PROPERTY_OPACITY "opacity" 9 | #define PROPERTY_BLENDFUNC "blendFunc" 10 | 11 | void LayerColorLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 12 | if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) { 13 | ((LayerColor *)pNode)->setColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 14 | ((LayerColor *)pNode)->setOpacity(pColor4F.a * 255); 15 | } else { 16 | LayerLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 17 | } 18 | } 19 | 20 | void LayerColorLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 21 | if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) { 22 | ((LayerColor *)pNode)->setOpacity(pByte); 23 | } else { 24 | LayerLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 25 | } 26 | } 27 | 28 | void LayerColorLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 29 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 30 | ((LayerColor *)pNode)->setBlendFunc(pBlendFunc); 31 | } else { 32 | LayerLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 33 | } 34 | } 35 | 36 | } -------------------------------------------------------------------------------- /spritebuilder/SpriteBuilder.h: -------------------------------------------------------------------------------- 1 | #ifndef __EDITOR_SUPPORT_SPRITEBUILDER_H__ 2 | #define __EDITOR_SUPPORT_SPRITEBUILDER_H__ 3 | 4 | #include "spritebuilder/CCBAnimationManager.h" 5 | #include "spritebuilder/CCBFileLoader.h" 6 | #include "spritebuilder/CCBKeyframe.h" 7 | #include "spritebuilder/CCBMemberVariableAssigner.h" 8 | #include "spritebuilder/CCBReader.h" 9 | #include "spritebuilder/CCBSelectorResolver.h" 10 | #include "spritebuilder/CCBSequence.h" 11 | #include "spritebuilder/CCBSequenceProperty.h" 12 | #include "spritebuilder/CCControlButtonLoader.h" 13 | #include "spritebuilder/CCControlLoader.h" 14 | #include "spritebuilder/CCLabelBMFontLoader.h" 15 | #include "spritebuilder/CCLabelTTFLoader.h" 16 | #include "spritebuilder/CCLayerColorLoader.h" 17 | #include "spritebuilder/CCLayerGradientLoader.h" 18 | #include "spritebuilder/CCLayerLoader.h" 19 | #include "spritebuilder/CCMenuItemImageLoader.h" 20 | #include "spritebuilder/CCMenuItemLoader.h" 21 | #include "spritebuilder/CCMenuLoader.h" 22 | #include "spritebuilder/CCNode+CCBRelativePositioning.h" 23 | #include "spritebuilder/CCNodeLoader.h" 24 | #include "spritebuilder/CCNodeLoaderLibrary.h" 25 | #include "spritebuilder/CCNodeLoaderListener.h" 26 | #include "spritebuilder/CCParticleSystemQuadLoader.h" 27 | #include "spritebuilder/CCScale9SpriteLoader.h" 28 | #include "spritebuilder/CCScrollViewLoader.h" 29 | #include "spritebuilder/CCSpriteLoader.h" 30 | #include "spritebuilder/CCBLocalizationManager.h" 31 | #include "spritebuilder/CCPhysicsNode.h" 32 | #include "spritebuilder/CCBPhysicsBody.h" 33 | 34 | #endif // __EDITOR_SUPPORT_SPRITEBUILDER_H__ 35 | -------------------------------------------------------------------------------- /spritebuilder/CCBSelectorResolver.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCBSELECTORRESOLVER_H_ 2 | #define _CCB_CCBSELECTORRESOLVER_H_ 3 | 4 | #include "extensions//GUI/CCControlExtension/CCInvocation.h" 5 | 6 | 7 | namespace spritebuilder { 8 | 9 | #define CCB_SELECTORRESOLVER_CCMENUITEM_GLUE(TARGET, SELECTORNAME, METHOD) if(pTarget == TARGET && strcmp(pSelectorName, SELECTORNAME) == 0) { \ 10 | return menu_selector(METHOD); \ 11 | } 12 | 13 | #define CCB_SELECTORRESOLVER_CCCONTROL_GLUE(TARGET, SELECTORNAME, METHOD) if(pTarget == TARGET && strcmp(pSelectorName, SELECTORNAME) == 0) { \ 14 | return cccontrol_selector(METHOD); \ 15 | } 16 | 17 | #define CCB_SELECTORRESOLVER_CALLFUNC_GLUE(TARGET, SELECTORNAME, METHOD) if(pTarget == TARGET && strcmp(pSelectorName, SELECTORNAME) == 0) { \ 18 | return callfuncN_selector(METHOD); \ 19 | } 20 | 21 | class CCBSelectorResolver { 22 | public: 23 | /** 24 | * @js NA 25 | * @lua NA 26 | */ 27 | virtual ~CCBSelectorResolver() {}; 28 | virtual cocos2d::SEL_MenuHandler onResolveCCBCCMenuItemSelector(cocos2d::Ref * pTarget, const char* pSelectorName) = 0; 29 | virtual cocos2d::SEL_CallFuncN onResolveCCBCCCallFuncSelector(cocos2d::Ref * pTarget, const char* pSelectorName) { return NULL; }; 30 | virtual cocos2d::extension::Control::Handler onResolveCCBCCControlSelector(cocos2d::Ref * pTarget, const char* pSelectorName) = 0; 31 | }; 32 | 33 | 34 | class CCBScriptOwnerProtocol { 35 | public: 36 | /** 37 | * @js NA 38 | * @lua NA 39 | */ 40 | virtual ~CCBScriptOwnerProtocol() {}; 41 | virtual CCBSelectorResolver * createNew() = 0; 42 | }; 43 | 44 | } 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /spritebuilder/CCPhysicsNode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | #ifndef __cocos2d_libs__CCPhysicsNode__ 24 | #define __cocos2d_libs__CCPhysicsNode__ 25 | 26 | #include "cocos2d.h" 27 | 28 | 29 | NS_CC_BEGIN 30 | 31 | class PhysicsNode : public Scene { 32 | public: 33 | static PhysicsNode* create(); 34 | 35 | virtual ~PhysicsNode() {} 36 | PhysicsNode(); 37 | 38 | virtual kmMat4 getNodeToWorldTransform() const; 39 | void setGravity(cocos2d::Point& gravity); 40 | cocos2d::Point getGravity(); 41 | 42 | protected: 43 | bool initWithPhysics(); 44 | 45 | }; 46 | 47 | NS_CC_END 48 | 49 | #endif /* defined(__cocos2d_libs__CCPhysicsNode__) */ 50 | -------------------------------------------------------------------------------- /spritebuilder/CCTextFieldLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _SB_CCEDITBOXLOADER_H_ 2 | #define _SB_CCEDITBOXLOADER_H_ 3 | 4 | #include "CCControlLoader.h" 5 | #include "extensions//GUI/CCEditBox/CCEditBox.h" 6 | 7 | namespace spritebuilder { 8 | 9 | /* Forward declaration. */ 10 | class CCBReader; 11 | 12 | 13 | class EditBoxLoader : public spritebuilder::ControlLoader { 14 | public: 15 | //EditBoxLoader() {} 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | virtual ~EditBoxLoader() {}; 21 | /** 22 | * @js NA 23 | * @lua NA 24 | */ 25 | 26 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(EditBoxLoader, loader); 27 | 28 | protected: 29 | // virtual cocos2d::extension::ControlButton * createNode(cocos2d::Node * pParent, CCBReader * ccbReader); 30 | virtual cocos2d::extension::EditBox * createNode(cocos2d::Node * pParent, CCBReader * ccbReader); 31 | 32 | /** 33 | * @js NA 34 | * @lua NA 35 | */ 36 | 37 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 38 | /** 39 | * @js NA 40 | * @lua NA 41 | */ 42 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 43 | /** 44 | * @js NA 45 | * @lua NA 46 | */ 47 | virtual void onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloatScale, CCBReader * ccbReader); 48 | 49 | virtual void onHandlePropTypeBlockControl(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader); 50 | 51 | }; 52 | 53 | 54 | }; 55 | 56 | #endif 57 | -------------------------------------------------------------------------------- /spritebuilder/CCLayout.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCLayout__ 25 | #define __cocos2d_libs__CCLayout__ 26 | 27 | 28 | #include "cocos2d.h" 29 | 30 | NS_CC_BEGIN 31 | 32 | 33 | class CC_DLL Layout : public Node { 34 | public: 35 | Layout(); 36 | virtual void needLayout(); 37 | virtual void layout(); 38 | 39 | virtual void addChild(Node * child, int localZOrder); 40 | virtual void visit(Renderer *renderer, const kmMat4& parentTransform, bool parentTransformUpdated); 41 | virtual const Size& getContentSize(); 42 | protected: 43 | bool m_bNeedLayout; 44 | }; 45 | NS_CC_END 46 | #endif /* defined(__cocos2d_libs__CCLayout__) */ 47 | -------------------------------------------------------------------------------- /spritebuilder/CCPhysicsNodeLoader.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | #include "CCPhysicsNodeLoader.h" 24 | 25 | using namespace cocos2d; 26 | 27 | #define PROPERTY_GRAVITY "gravity" 28 | 29 | namespace spritebuilder { 30 | 31 | void PhysicsNodeLoader::onHandlePropTypePoint(Node * pNode, Node * pParent, const char* pPropertyName, Point pPoint, CCBReader * ccbReader) { 32 | if (strcmp(pPropertyName, PROPERTY_GRAVITY) == 0) { 33 | pPoint = pPoint; 34 | ((PhysicsNode*)pNode)->setGravity(pPoint); 35 | } else { 36 | NodeLoader::onHandlePropTypePoint(pNode, pParent, pPropertyName, pPoint, ccbReader); 37 | } 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCLayerLoader.h" 2 | 3 | 4 | using namespace cocos2d; 5 | 6 | #define PROPERTY_TOUCH_ENABLED "isTouchEnabled" 7 | #define PROPERTY_ACCELEROMETER_ENABLED "isAccelerometerEnabled" 8 | #define PROPERTY_MOUSE_ENABLED "isMouseEnabled" 9 | #define PROPERTY_KEYBOARD_ENABLED "isKeyboardEnabled" 10 | 11 | #if defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) 12 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 13 | #elif _MSC_VER >= 1400 //vs 2005 or higher 14 | #pragma warning (push) 15 | #pragma warning (disable: 4996) 16 | #endif 17 | 18 | using namespace cocos2d; 19 | 20 | namespace spritebuilder { 21 | 22 | void LayerLoader::onHandlePropTypeCheck(Node * pNode, Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader) { 23 | if(strcmp(pPropertyName, PROPERTY_TOUCH_ENABLED) == 0) { 24 | ((Layer *)pNode)->setTouchEnabled(pCheck); 25 | } else if(strcmp(pPropertyName, PROPERTY_ACCELEROMETER_ENABLED) == 0) { 26 | ((Layer *)pNode)->setAccelerometerEnabled(pCheck); 27 | } else if(strcmp(pPropertyName, PROPERTY_MOUSE_ENABLED) == 0) { 28 | // TODO XXX 29 | CCLOG("The property '%s' is not supported!", PROPERTY_MOUSE_ENABLED); 30 | } else if(strcmp(pPropertyName, PROPERTY_KEYBOARD_ENABLED) == 0) { 31 | // TODO XXX 32 | CCLOG("The property '%s' is not supported!", PROPERTY_KEYBOARD_ENABLED); 33 | // This comes closest: ((Layer *)pNode)->setKeypadEnabled(pCheck); 34 | } else { 35 | NodeLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader); 36 | } 37 | } 38 | 39 | } 40 | 41 | #if defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) 42 | #pragma GCC diagnostic warning "-Wdeprecated-declarations" 43 | #elif _MSC_VER >= 1400 //vs 2005 or higher 44 | #pragma warning (pop) 45 | #endif -------------------------------------------------------------------------------- /spritebuilder/CCBPhysicsBody.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCBPhysicsBody__ 25 | #define __cocos2d_libs__CCBPhysicsBody__ 26 | 27 | #include 28 | #include "cocos2d.h" 29 | 30 | namespace spritebuilder { 31 | 32 | 33 | class CCBPhysicsBody : public cocos2d::PhysicsBody { 34 | public: 35 | static CCBPhysicsBody* create(); 36 | 37 | //Nguyen Thai Duong: pure me because getPosition is non virtual method :(( 38 | cocos2d::Point getPosition() const; 39 | 40 | protected: 41 | virtual void setPosition(cocos2d::Point position); 42 | void update(float delta); 43 | 44 | friend class CCBPhysicsWorld; 45 | }; 46 | } 47 | #endif /* defined(__cocos2d_libs__CCBPhysicBody__) */ 48 | -------------------------------------------------------------------------------- /spritebuilder/CCBSequence.cpp: -------------------------------------------------------------------------------- 1 | #include "CCBSequence.h" 2 | 3 | using namespace cocos2d; 4 | using namespace std; 5 | 6 | 7 | namespace spritebuilder { 8 | 9 | CCBSequence::CCBSequence() 10 | : _duration(0.0f) 11 | , _name("") 12 | , mSequenceId(0) 13 | , mChainedSequenceId(0) 14 | , mCallbackChannel(NULL) 15 | , mSoundChannel(NULL) 16 | {} 17 | 18 | CCBSequence::~CCBSequence() { 19 | CC_SAFE_RELEASE(mCallbackChannel); 20 | CC_SAFE_RELEASE(mSoundChannel); 21 | } 22 | 23 | float CCBSequence::getDuration() 24 | { 25 | return _duration; 26 | } 27 | 28 | void CCBSequence::setDuration(float fDuration) 29 | { 30 | _duration = fDuration; 31 | } 32 | 33 | const char* CCBSequence::getName() 34 | { 35 | return _name.c_str(); 36 | } 37 | 38 | void CCBSequence::setName(const char *pName) 39 | { 40 | _name = pName; 41 | } 42 | 43 | int CCBSequence::getSequenceId() 44 | { 45 | return mSequenceId; 46 | 47 | } 48 | 49 | void CCBSequence::setSequenceId(int nSequenceId) 50 | { 51 | mSequenceId = nSequenceId; 52 | } 53 | 54 | CCBSequenceProperty* CCBSequence::getCallbackChannel() 55 | { 56 | return mCallbackChannel; 57 | } 58 | 59 | void CCBSequence::setCallbackChannel(CCBSequenceProperty* callbackChannel) 60 | { 61 | CC_SAFE_RELEASE(mCallbackChannel); 62 | mCallbackChannel = callbackChannel; 63 | CC_SAFE_RETAIN(mCallbackChannel); 64 | } 65 | 66 | 67 | CCBSequenceProperty* CCBSequence::getSoundChannel() 68 | { 69 | return mSoundChannel; 70 | } 71 | 72 | void CCBSequence::setSoundChannel(CCBSequenceProperty* soundChannel) 73 | { 74 | CC_SAFE_RELEASE(mSoundChannel); 75 | mSoundChannel = soundChannel; 76 | CC_SAFE_RETAIN(mSoundChannel); 77 | } 78 | 79 | 80 | int CCBSequence::getChainedSequenceId() 81 | { 82 | return mChainedSequenceId; 83 | } 84 | 85 | void CCBSequence::setChainedSequenceId(int nChainedSequenceId) 86 | { 87 | mChainedSequenceId = nChainedSequenceId; 88 | } 89 | 90 | } -------------------------------------------------------------------------------- /spritebuilder/CCBLocalizationManager.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | #ifndef __cocos2d_libs__CCBLocalizationManager__ 24 | #define __cocos2d_libs__CCBLocalizationManager__ 25 | 26 | #include 27 | #include "cocos2d.h" 28 | 29 | namespace spritebuilder { 30 | 31 | #define CCBLocalize(key) (CCBLocalizationManager::sharedManager()->localizedStringForKey(key)) 32 | 33 | class CCBLocalizationManager : public cocos2d::Ref { 34 | public: 35 | CCBLocalizationManager(); 36 | static CCBLocalizationManager* sharedManager(); 37 | std::string& localizedStringForKey(const char* key); 38 | private: 39 | void loadStringFile(const char* file); 40 | private: 41 | 42 | std::map mTranslation; 43 | }; 44 | } 45 | #endif /* defined(__cocos2d_libs__CCBLocalizationManager__) */ 46 | -------------------------------------------------------------------------------- /spritebuilder/CCLayout.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCLayout.h" 25 | 26 | NS_CC_BEGIN 27 | 28 | Layout::Layout(): 29 | m_bNeedLayout(true) 30 | { 31 | 32 | } 33 | void Layout::needLayout() { 34 | m_bNeedLayout = true; 35 | } 36 | void Layout::layout() { 37 | m_bNeedLayout = false; 38 | } 39 | 40 | void Layout::addChild(Node * child, int localZOrder) { 41 | Node::addChild(child, localZOrder); 42 | layout(); 43 | } 44 | 45 | void Layout::visit(Renderer *renderer, const kmMat4& parentTransform, bool parentTransformUpdated) { 46 | if (m_bNeedLayout) 47 | layout(); 48 | 49 | Node::visit(renderer, parentTransform, parentTransformUpdated); 50 | } 51 | 52 | const Size& Layout::getContentSize() { 53 | if (m_bNeedLayout) 54 | layout(); 55 | 56 | return Node::getContentSize(); 57 | } 58 | 59 | NS_CC_END -------------------------------------------------------------------------------- /spritebuilder/CCPhysicsNodeLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | #ifndef _CCB_CCPHYSICSNODELOADER_H_ 24 | #define _CCB_CCPHYSICSNODELOADER_H_ 25 | 26 | #include "CCNodeLoader.h" 27 | #include "CCPhysicsNode.h" 28 | 29 | namespace spritebuilder { 30 | 31 | /* Forward declaration. */ 32 | class CCBReader; 33 | 34 | class PhysicsNodeLoader : public NodeLoader { 35 | public: 36 | /** 37 | * @js NA 38 | * @lua NA 39 | */ 40 | virtual ~PhysicsNodeLoader() {}; 41 | /** 42 | * @js NA 43 | * @lua NA 44 | */ 45 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(PhysicsNodeLoader, loader); 46 | 47 | protected: 48 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::PhysicsNode); 49 | 50 | 51 | virtual void onHandlePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Point pPoint, CCBReader * ccbReader); 52 | }; 53 | 54 | } 55 | 56 | #endif 57 | -------------------------------------------------------------------------------- /spritebuilder/CCLayoutBox.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCLayoutBox__ 25 | #define __cocos2d_libs__CCLayoutBox__ 26 | 27 | #include "cocos2d.h" 28 | #include "CCLayout.h" 29 | NS_CC_BEGIN 30 | 31 | typedef enum { 32 | /// The children will be layout out in a horizontal line. 33 | CCLayoutBoxDirectionHorizontal, 34 | 35 | /// The children will be layout out in a vertical line. 36 | CCLayoutBoxDirectionVertical, 37 | } CCLayoutBoxDirection; 38 | 39 | class CC_DLL LayoutBox : public Layout { 40 | public: 41 | static LayoutBox* create(); 42 | LayoutBox(); 43 | void setDirection(CCLayoutBoxDirection direction); 44 | CCLayoutBoxDirection getDirection(); 45 | 46 | void setSpacing(float spacing); 47 | float getSpacing(); 48 | virtual void removeChild(Node* child, bool cleanup = true); 49 | virtual void layout(); 50 | protected: 51 | CCLayoutBoxDirection m_eDirection; 52 | float m_nSpacing; 53 | }; 54 | NS_CC_END 55 | #endif /* defined(__cocos2d_libs__CCLayoutBox__) */ 56 | -------------------------------------------------------------------------------- /spritebuilder/CCControlLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCControlLoader.h" 2 | 3 | using namespace cocos2d; 4 | using namespace cocos2d::extension; 5 | 6 | namespace spritebuilder { 7 | 8 | #define PROPERTY_ENABLED "enabled" 9 | #define PROPERTY_SELECTED "selected" 10 | #define PROPERTY_CCCONTROL "ccControl" 11 | #define PROPERTY_BLOCK "block" 12 | 13 | void ControlLoader::onHandlePropTypeCheck(Node * pNode, Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader) { 14 | if(strcmp(pPropertyName, PROPERTY_ENABLED) == 0) { 15 | ((Control *)pNode)->setEnabled(pCheck); 16 | } else if(strcmp(pPropertyName, PROPERTY_SELECTED) == 0) { 17 | ((Control *)pNode)->setSelected(pCheck); 18 | } else { 19 | NodeLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader); 20 | } 21 | } 22 | 23 | void ControlLoader::onHandlePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, BlockData * pBlockData, CCBReader * ccbReader) { 24 | if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 25 | if (pBlockData) 26 | ((Control *)pNode)->addTargetWithActionForControlEvents(pBlockData->_target, (Control::Handler)pBlockData->mSELMenuHandler, cocos2d::extension::Control::EventType::TOUCH_DOWN); 27 | } else { 28 | NodeLoader::onHandlePropTypeBlock(pNode, pParent, pPropertyName, pBlockData, ccbReader); 29 | } 30 | 31 | } 32 | 33 | void ControlLoader::onHandlePropTypeBlockControl(Node * pNode, Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader) { 34 | if(strcmp(pPropertyName, PROPERTY_CCCONTROL) == 0) { 35 | ((Control *)pNode)->addTargetWithActionForControlEvents(pBlockControlData->_target, pBlockControlData->mSELControlHandler, pBlockControlData->mControlEvents); 36 | } else if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 37 | ((Control *)pNode)->addTargetWithActionForControlEvents(pBlockControlData->_target, pBlockControlData->mSELControlHandler, cocos2d::extension::Control::EventType::TOUCH_UP_INSIDE); 38 | } else { 39 | NodeLoader::onHandlePropTypeBlockControl(pNode, pParent, pPropertyName, pBlockControlData, ccbReader); 40 | } 41 | } 42 | 43 | } -------------------------------------------------------------------------------- /spritebuilder/CCBPhysicsWorld.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCBPhysicsWorld__ 25 | #define __cocos2d_libs__CCBPhysicsWorld__ 26 | 27 | #include 28 | #include "cocos2d.h" 29 | #include "CCPhysicsNode.h" 30 | 31 | namespace spritebuilder { 32 | 33 | class CCBPhysicsWorld : public cocos2d::PhysicsWorld { 34 | public: 35 | 36 | protected: 37 | virtual void update(float delta); 38 | virtual void debugDraw(); 39 | static CCBPhysicsWorld* construct(cocos2d::PhysicsNode& scene); 40 | friend class cocos2d::PhysicsNode; 41 | }; 42 | 43 | class CCBPhysicsDebugDraw : public cocos2d::PhysicsDebugDraw 44 | { 45 | public: 46 | virtual void drawShape(cocos2d::PhysicsShape& shape); 47 | virtual void drawJoint(cocos2d::PhysicsJoint& joint); 48 | virtual void drawContact(); 49 | protected: 50 | CCBPhysicsDebugDraw(CCBPhysicsWorld& world); 51 | friend class CCBPhysicsWorld; 52 | }; 53 | extern const float PHYSICS_INFINITY; 54 | } 55 | 56 | #endif /* defined(__cocos2d_libs__CCBPhysicsWorld__) */ 57 | -------------------------------------------------------------------------------- /spritebuilder/CCLabelTTFLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCLABELTTFLOADER_H_ 2 | #define _CCB_CCLABELTTFLOADER_H_ 3 | 4 | #include "CCRef.h" 5 | #include "CCLabel.h" 6 | 7 | #include "CCNodeLoader.h" 8 | 9 | namespace spritebuilder { 10 | 11 | /* Forward declaration. */ 12 | class CCBReader; 13 | 14 | class LabelTTFLoader : public NodeLoader { 15 | public: 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | virtual ~LabelTTFLoader() {}; 21 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LabelTTFLoader, loader); 22 | 23 | protected: 24 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Label); 25 | 26 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 27 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 28 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 29 | virtual void onHandlePropTypeFontTTF(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char * pFontTTF, CCBReader * ccbReader); 30 | virtual void onHandlePropTypeText(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char * pText, CCBReader * ccbReader); 31 | virtual void onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float pFloatScale, CCBReader * ccbReader); 32 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 33 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 34 | virtual void onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader); 35 | virtual void onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 36 | private: 37 | cocos2d::Size _shadowOffset; 38 | float _shadowBlurRadius; 39 | cocos2d::Color4B _shadowColor; 40 | 41 | cocos2d::Color4B _outlineColor; 42 | float _outlineWidth; 43 | }; 44 | 45 | } 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /spritebuilder/CCLabelBMFontLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCLabelBMFontLoader.h" 2 | 3 | 4 | using namespace cocos2d; 5 | 6 | namespace spritebuilder { 7 | 8 | #define PROPERTY_COLOR "color" 9 | #define PROPERTY_OPACITY "opacity" 10 | #define PROPERTY_BLENDFUNC "blendFunc" 11 | #define PROPERTY_FNTFILE "fntFile" 12 | #define PROPERTY_STRING "string" 13 | 14 | 15 | void LabelBMFontLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 16 | if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) { 17 | ((Label *)pNode)->setColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 18 | ((Label *)pNode)->setOpacity(pColor4F.a * 255); 19 | } else { 20 | NodeLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 21 | } 22 | } 23 | 24 | void LabelBMFontLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 25 | if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) { 26 | ((Label *)pNode)->setOpacity(pByte); 27 | } else { 28 | NodeLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 29 | } 30 | } 31 | 32 | void LabelBMFontLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 33 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 34 | ((Label *)pNode)->setBlendFunc(pBlendFunc); 35 | } else { 36 | NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 37 | } 38 | } 39 | 40 | void LabelBMFontLoader::onHandlePropTypeFntFile(Node * pNode, Node * pParent, const char * pPropertyName, const char* pFntFile, CCBReader * ccbReader) { 41 | 42 | if(strcmp(pPropertyName, PROPERTY_FNTFILE) == 0) { 43 | ((Label *)pNode)->setBMFontFilePath(pFntFile); 44 | } else { 45 | NodeLoader::onHandlePropTypeFntFile(pNode, pParent, pPropertyName, pFntFile, ccbReader); 46 | } 47 | } 48 | 49 | void LabelBMFontLoader::onHandlePropTypeText(Node * pNode, Node * pParent, const char * pPropertyName, const char* pText, CCBReader * ccbReader) { 50 | if(strcmp(pPropertyName, PROPERTY_STRING) == 0) { 51 | ((Label *)pNode)->setString(pText); 52 | } else { 53 | NodeLoader::onHandlePropTypeText(pNode, pParent, pPropertyName, pText, ccbReader); 54 | } 55 | } 56 | 57 | } -------------------------------------------------------------------------------- /spritebuilder/CCBMemberVariableAssigner.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCBMEMBERVARIABLEASSIGNER_H_ 2 | #define _CCB_CCBMEMBERVARIABLEASSIGNER_H_ 3 | 4 | 5 | namespace spritebuilder { 6 | 7 | #define SB_MEMBERVARIABLEASSIGNER_GLUE(TARGET, MEMBERVARIABLENAME, MEMBERVARIABLETYPE, MEMBERVARIABLE) \ 8 | if (pTarget == TARGET && 0 == strcmp(pMemberVariableName, (MEMBERVARIABLENAME))) { \ 9 | MEMBERVARIABLETYPE pOldVar = MEMBERVARIABLE; \ 10 | MEMBERVARIABLE = dynamic_cast(pNode); \ 11 | CC_ASSERT(MEMBERVARIABLE); \ 12 | if (pOldVar != MEMBERVARIABLE) { \ 13 | CC_SAFE_RELEASE(pOldVar); \ 14 | MEMBERVARIABLE->retain(); \ 15 | } \ 16 | return true; \ 17 | } 18 | 19 | #define SB_MEMBERVARIABLEASSIGNER_GLUE_WEAK(TARGET, MEMBERVARIABLENAME, MEMBERVARIABLETYPE, MEMBERVARIABLE) \ 20 | if (pTarget == TARGET && 0 == strcmp(pMemberVariableName, MEMBERVARIABLENAME)) { \ 21 | MEMBERVARIABLE = dynamic_cast(pNode); \ 22 | CC_ASSERT(MEMBERVARIABLE); \ 23 | return true; \ 24 | } 25 | 26 | class CCBMemberVariableAssigner { 27 | public: 28 | /** 29 | * @js NA 30 | * @lua NA 31 | */ 32 | virtual ~CCBMemberVariableAssigner() {}; 33 | 34 | /** 35 | * The callback function of assigning member variable. 36 | * @note The member variable must be Node or its subclass. 37 | * @param target The custom class. 38 | * @param memberVariableName The name of the member variable. 39 | * @param node The member variable. 40 | * @return Whether the assignment was successful. 41 | */ 42 | virtual bool onAssignCCBMemberVariable(cocos2d::Ref* target, const char* memberVariableName, cocos2d::Node* node) = 0; 43 | 44 | /** 45 | * The callback function of assigning custom properties. 46 | * @note The member variable must be Integer, Float, Boolean or String. 47 | * @param target The custom class. 48 | * @param memberVariableName The name of the member variable. 49 | * @param value The value of the property. 50 | * @return Whether the assignment was successful. 51 | */ 52 | virtual bool onAssignCCBCustomProperty(cocos2d::Ref* target, const char* memberVariableName, const cocos2d::Value& value) { return false; }; 53 | }; 54 | 55 | } 56 | 57 | #endif 58 | -------------------------------------------------------------------------------- /spritebuilder/CCLayoutBoxLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCLayoutBoxLoader__ 25 | #define __cocos2d_libs__CCLayoutBoxLoader__ 26 | 27 | #include 28 | #include "CCNodeLoader.h" 29 | #include "CCLayoutBox.h" 30 | 31 | namespace spritebuilder { 32 | 33 | /* Forward declaration. */ 34 | class CCBReader; 35 | 36 | class LayoutBoxLoader : public NodeLoader { 37 | public: 38 | /** 39 | * @js NA 40 | * @lua NA 41 | */ 42 | virtual ~LayoutBoxLoader() {}; 43 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LayoutBoxLoader, loader); 44 | 45 | protected: 46 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::LayoutBox); 47 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 48 | virtual void onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloatScale, CCBReader * ccbReader); 49 | /* 50 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader);*/ 51 | }; 52 | 53 | } 54 | #endif /* defined(__cocos2d_libs__CCLayoutBoxLoader__) */ 55 | -------------------------------------------------------------------------------- /spritebuilder/CCLayoutBoxLoader.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCLayoutBoxLoader.h" 25 | 26 | using namespace cocos2d; 27 | 28 | #define PROPERTY_DIRECTION "direction" 29 | #define PROPERTY_SPACING "spacing" 30 | using namespace cocos2d; 31 | 32 | namespace spritebuilder { 33 | void LayoutBoxLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char* pPropertyName, int pIntegerLabeled, CCBReader * ccbReader) { 34 | if(strcmp(pPropertyName, PROPERTY_DIRECTION) == 0) { 35 | ((LayoutBox *)pNode)->setDirection((CCLayoutBoxDirection)pIntegerLabeled); 36 | } else 37 | NodeLoader::onHandlePropTypeIntegerLabeled(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader); 38 | } 39 | 40 | void LayoutBoxLoader::onHandlePropTypeFloatScale(Node * pNode, Node * pParent, const char* pPropertyName, float pFloatScale, CCBReader * ccbReader) { 41 | if(strcmp(pPropertyName, PROPERTY_SPACING) == 0) { 42 | ((LayoutBox *)pNode)->setSpacing(pFloatScale); 43 | } else 44 | NodeLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader); 45 | } 46 | 47 | } 48 | 49 | #if defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) 50 | #pragma GCC diagnostic warning "-Wdeprecated-declarations" 51 | #elif _MSC_VER >= 1400 //vs 2005 or higher 52 | #pragma warning (pop) 53 | #endif -------------------------------------------------------------------------------- /spritebuilder/CCSpriteLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCSpriteLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | #define PROPERTY_FLIP "flip" 6 | #define PROPERTY_DISPLAYFRAME "spriteFrame" 7 | #define PROPERTY_COLOR "color" 8 | #define PROPERTY_OPACITY "opacity" 9 | #define PROPERTY_BLENDFUNC "blendFunc" 10 | #define PROPERTY_CONTENTSIZE "contentSize" 11 | 12 | namespace spritebuilder { 13 | 14 | void SpriteLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 15 | if(strcmp(pPropertyName, PROPERTY_DISPLAYFRAME) == 0) { 16 | if(pSpriteFrame != NULL) { 17 | ((Sprite *)pNode)->setSpriteFrame(pSpriteFrame); 18 | } else { 19 | CCLOG("ERROR: SpriteFrame NULL"); 20 | } 21 | } else { 22 | NodeLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 23 | } 24 | } 25 | 26 | void SpriteLoader::onHandlePropTypeFlip(Node * pNode, Node * pParent, const char * pPropertyName, bool * pFlip, CCBReader * ccbReader) { 27 | if(strcmp(pPropertyName, PROPERTY_FLIP) == 0) { 28 | ((Sprite *)pNode)->setFlippedX(pFlip[0]); 29 | ((Sprite *)pNode)->setFlippedY(pFlip[1]); 30 | } else { 31 | NodeLoader::onHandlePropTypeFlip(pNode, pParent, pPropertyName, pFlip, ccbReader); 32 | } 33 | } 34 | 35 | void SpriteLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 36 | if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) { 37 | ((Sprite *)pNode)->setColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 38 | } else { 39 | NodeLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 40 | } 41 | } 42 | 43 | void SpriteLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 44 | if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) { 45 | ((Sprite *)pNode)->setOpacity(pByte); 46 | } else { 47 | NodeLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 48 | } 49 | } 50 | 51 | void SpriteLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 52 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 53 | ((Sprite *)pNode)->setBlendFunc(pBlendFunc); 54 | } else { 55 | NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 56 | } 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /spritebuilder/CCLayerGradientLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCLayerGradientLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | #define PROPERTY_STARTCOLOR "startColor" 6 | #define PROPERTY_ENDCOLOR "endColor" 7 | #define PROPERTY_STARTOPACITY "startOpacity" 8 | #define PROPERTY_ENDOPACITY "endOpacity" 9 | #define PROPERTY_VECTOR "vector" 10 | #define PROPERTY_BLENDFUNC "blendFunc" 11 | 12 | namespace spritebuilder { 13 | 14 | void LayerGradientLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 15 | if(strcmp(pPropertyName, PROPERTY_STARTCOLOR) == 0) { 16 | ((LayerGradient *)pNode)->setEndColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 17 | ((LayerGradient *)pNode)->setEndOpacity(pColor4F.a * 255); 18 | } else if(strcmp(pPropertyName, PROPERTY_ENDCOLOR) == 0) { 19 | ((LayerGradient *)pNode)->setStartColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 20 | ((LayerGradient *)pNode)->setStartOpacity(pColor4F.a * 255); 21 | 22 | } else { 23 | LayerLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 24 | } 25 | } 26 | 27 | void LayerGradientLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 28 | if(strcmp(pPropertyName, PROPERTY_STARTOPACITY) == 0) { 29 | ((LayerGradient *)pNode)->setStartOpacity(pByte); 30 | } else if(strcmp(pPropertyName, PROPERTY_ENDOPACITY) == 0) { 31 | ((LayerGradient *)pNode)->setEndOpacity(pByte); 32 | } else { 33 | LayerLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 34 | } 35 | } 36 | 37 | void LayerGradientLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 38 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 39 | ((LayerGradient *)pNode)->setBlendFunc(pBlendFunc); 40 | } else { 41 | LayerLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 42 | } 43 | } 44 | 45 | 46 | void LayerGradientLoader::onHandlePropTypePoint(Node * pNode, Node * pParent, const char * pPropertyName, Point pPoint, CCBReader * ccbReader) { 47 | if(strcmp(pPropertyName, PROPERTY_VECTOR) == 0) { 48 | ((LayerGradient *)pNode)->setVector(pPoint); 49 | 50 | // TODO Not passed along the ccbi file. 51 | // ((LayerGradient *)pNode)->setCompressedInterpolation(true); 52 | } else { 53 | LayerLoader::onHandlePropTypePoint(pNode, pParent, pPropertyName, pPoint, ccbReader); 54 | } 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /spritebuilder/CCPhysicsNode.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCPhysicsNode.h" 25 | #include "CCBPhysicsWorld.h" 26 | 27 | NS_CC_BEGIN 28 | 29 | 30 | PhysicsNode::PhysicsNode() { 31 | } 32 | 33 | PhysicsNode* PhysicsNode::create() { 34 | PhysicsNode* ret = new PhysicsNode(); 35 | 36 | if (ret->initWithPhysics()) { 37 | ret->autorelease(); 38 | return ret; 39 | } 40 | return NULL; 41 | } 42 | kmMat4 PhysicsNode::getNodeToWorldTransform() const 43 | { 44 | return this->getNodeToParentTransform(); 45 | } 46 | bool PhysicsNode::initWithPhysics() 47 | { 48 | bool ret = false; 49 | // ret = Scene::initWithPhysics(); 50 | 51 | do 52 | { 53 | Director * director; 54 | CC_BREAK_IF( ! (director = Director::getInstance()) ); 55 | this->setContentSize(director->getWinSize()); 56 | CC_BREAK_IF(! (_physicsWorld = spritebuilder::CCBPhysicsWorld::construct(*this))); 57 | 58 | this->scheduleUpdate(); 59 | // success 60 | ret = true; 61 | } while (0); 62 | return ret; 63 | 64 | this->setContentSize(Size(0, 0)); 65 | //this->getPhysicsWorld()->setDebugDrawMask(PhysicsWorld::DEBUGDRAW_ALL); 66 | 67 | return ret; 68 | } 69 | void PhysicsNode::setGravity(cocos2d::Point& gravity) { 70 | getPhysicsWorld()->setGravity(Vect(gravity.x, gravity.y)); 71 | } 72 | cocos2d::Point PhysicsNode::getGravity() { 73 | Vect gravity = getPhysicsWorld()->getGravity(); 74 | return cocos2d::Point(gravity.x, gravity.y); 75 | } 76 | 77 | 78 | NS_CC_END 79 | -------------------------------------------------------------------------------- /spritebuilder/CCScrollViewLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCScrollViewLoader.h" 2 | 3 | using namespace cocos2d; 4 | using namespace cocos2d::extension; 5 | 6 | #define PROPERTY_CONTAINER "container" 7 | #define PROPERTY_DIRECTION "direction" 8 | #define PROPERTY_CLIPSTOBOUNDS "clipsToBounds" 9 | #define PROPERTY_BOUNCES "bounces" 10 | #define PROPERTY_SCALE "scale" 11 | 12 | namespace spritebuilder { 13 | 14 | void ScrollViewLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char * pPropertyName, Size pSize, CCBReader * ccbReader) { 15 | if(strcmp(pPropertyName, PROPERTY_CONTENTSIZE) == 0) { 16 | ((ScrollView *)pNode)->setViewSize(pSize); 17 | } else { 18 | NodeLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, pSize, ccbReader); 19 | } 20 | } 21 | 22 | void ScrollViewLoader::onHandlePropTypeCheck(Node * pNode, Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader) { 23 | if(strcmp(pPropertyName, PROPERTY_CLIPSTOBOUNDS) == 0) { 24 | ((ScrollView *)pNode)->setClippingToBounds(pCheck); 25 | } else if(strcmp(pPropertyName, PROPERTY_BOUNCES) == 0) { 26 | ((ScrollView *)pNode)->setBounceable(pCheck); 27 | } else { 28 | NodeLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader); 29 | } 30 | } 31 | 32 | void ScrollViewLoader::onHandlePropTypeCCBFile(Node * pNode, Node * pParent, const char * pPropertyName, Node * pCCBFileNode, CCBReader * ccbReader) { 33 | if(strcmp(pPropertyName, PROPERTY_CONTAINER) == 0) { 34 | ((ScrollView *)pNode)->setContainer(pCCBFileNode); 35 | ((ScrollView *)pNode)->updateInset(); 36 | } else if (strcmp(pPropertyName, "contentNode") == 0) { 37 | //((ScrollView *)pNode)->addChild(pCCBFileNode); 38 | ((ScrollView *)pNode)->setContainer(pCCBFileNode); 39 | } else { 40 | NodeLoader::onHandlePropTypeCCBFile(pNode, pParent, pPropertyName, pCCBFileNode, ccbReader); 41 | } 42 | } 43 | 44 | void ScrollViewLoader::onHandlePropTypeFloat(Node * pNode, Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader) { 45 | if(strcmp(pPropertyName, PROPERTY_SCALE) == 0) { 46 | ((ScrollView *)pNode)->setScale(pFloat); 47 | } else { 48 | NodeLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader); 49 | } 50 | } 51 | 52 | void ScrollViewLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader) { 53 | if(strcmp(pPropertyName, PROPERTY_DIRECTION) == 0) { 54 | ((ScrollView *)pNode)->setDirection(ScrollView::Direction(pIntegerLabeled)); 55 | } else { 56 | NodeLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader); 57 | } 58 | } 59 | 60 | } -------------------------------------------------------------------------------- /spritebuilder/CCScale9SpriteLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCSCALE9SPRITELOADER_H_ 2 | #define _CCB_CCSCALE9SPRITELOADER_H_ 3 | 4 | #include "CCNodeLoader.h" 5 | #include "CCScale9SpriteLoader.h" 6 | #include "extensions/GUI/CCControlExtension/CCScale9Sprite.h" 7 | 8 | namespace spritebuilder { 9 | 10 | /* Forward declaration. */ 11 | class CCBReader; 12 | 13 | class Scale9SpriteLoader : public NodeLoader { 14 | public: 15 | /** 16 | * @js NA 17 | * @lua NA 18 | */ 19 | virtual ~Scale9SpriteLoader() {}; 20 | /** 21 | * @js NA 22 | * @lua NA 23 | */ 24 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(Scale9SpriteLoader, loader); 25 | 26 | protected: 27 | /** 28 | * @js NA 29 | * @lua NA 30 | */ 31 | virtual cocos2d::extension::Scale9Sprite * createNode(cocos2d::Node * pParent, spritebuilder::CCBReader * ccbReader) { 32 | cocos2d::extension::Scale9Sprite* pNode = cocos2d::extension::Scale9Sprite::create(); 33 | 34 | pNode->setAnchorPoint(cocos2d::Point(0,0)); 35 | 36 | return pNode; 37 | }; 38 | /** 39 | * @js NA 40 | * @lua NA 41 | */ 42 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 43 | /** 44 | * @js NA 45 | * @lua NA 46 | */ 47 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader); 48 | /** 49 | * @js NA 50 | * @lua NA 51 | */ 52 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 53 | /** 54 | * @js NA 55 | * @lua NA 56 | */ 57 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 58 | /** 59 | * @js NA 60 | * @lua NA 61 | */ 62 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 63 | /** 64 | * @js NA 65 | * @lua NA 66 | */ 67 | virtual void onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader); 68 | virtual void onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 69 | private: 70 | float _insetLeft; 71 | float _insetTop; 72 | float _insetRight; 73 | float _insetBottom; 74 | cocos2d::Size _contentSize; 75 | cocos2d::Size _preferedSize; 76 | cocos2d::SpriteFrame* _spriteFrame; 77 | }; 78 | 79 | } 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /spritebuilder/CCParticleSystemQuadLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCPARTICLESYSTEMQUADLOADER_H_ 2 | #define _CCB_CCPARTICLESYSTEMQUADLOADER_H_ 3 | 4 | #include "CCRef.h" 5 | #include "CCParticleSystemQuad.h" 6 | 7 | #include "CCNodeLoader.h" 8 | 9 | namespace spritebuilder { 10 | 11 | /* Forward declaration. */ 12 | class CCBReader; 13 | 14 | class ParticleSystemQuadLoader : public NodeLoader { 15 | public: 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | virtual ~ParticleSystemQuadLoader() {}; 21 | /** 22 | * @js NA 23 | * @lua NA 24 | */ 25 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(spritebuilder::ParticleSystemQuadLoader, loader); 26 | 27 | protected: 28 | /** 29 | * @js NA 30 | * @lua NA 31 | */ 32 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::ParticleSystemQuad); 33 | /** 34 | * @js NA 35 | * @lua NA 36 | */ 37 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 38 | /** 39 | * @js NA 40 | * @lua NA 41 | */ 42 | virtual void onHandlePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Point pPoint, CCBReader * ccbReader); 43 | /** 44 | * @js NA 45 | * @lua NA 46 | */ 47 | virtual void onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader); 48 | /** 49 | * @js NA 50 | * @lua NA 51 | */ 52 | virtual void onHandlePropTypeInteger(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, int pInteger, CCBReader * ccbReader); 53 | /** 54 | * @js NA 55 | * @lua NA 56 | */ 57 | virtual void onHandlePropTypeFloatVar(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float * pFloatVar, CCBReader * ccbReader); 58 | /** 59 | * @js NA 60 | * @lua NA 61 | */ 62 | virtual void onHandlePropTypeColor4FVar(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F * pColor4FVar, CCBReader * ccbReader); 63 | /** 64 | * @js NA 65 | * @lua NA 66 | */ 67 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 68 | /** 69 | * @js NA 70 | * @lua NA 71 | */ 72 | virtual void onHandlePropTypeTexture(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Texture2D * pTexture2D, CCBReader * ccbReader); 73 | 74 | virtual cocos2d::Texture2D * parsePropTypeTexture(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 75 | protected: 76 | cocos2d::Rect _textureRect; 77 | }; 78 | 79 | } 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /spritebuilder/CCControlButtonLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCCONTROLBUTTONLOADER_H_ 2 | #define _CCB_CCCONTROLBUTTONLOADER_H_ 3 | 4 | #include "CCControlLoader.h" 5 | #include "extensions//GUI/CCControlExtension/CCControlButton.h" 6 | 7 | namespace spritebuilder { 8 | 9 | /* Forward declaration. */ 10 | class CCBReader; 11 | 12 | class ControlButtonLoader : public ControlLoader { 13 | public: 14 | /** 15 | * @js NA 16 | * @lua NA 17 | */ 18 | virtual ~ControlButtonLoader() {}; 19 | /** 20 | * @js NA 21 | * @lua NA 22 | */ 23 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(ControlButtonLoader, loader); 24 | 25 | protected: 26 | 27 | virtual cocos2d::extension::ControlButton * createNode(cocos2d::Node * pParent, CCBReader * ccbReader); 28 | 29 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader); 30 | virtual void onHandlePropTypeString(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char * pString, CCBReader * ccbReader); 31 | virtual void onHandlePropTypeFontTTF(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const char * pFontTTF, CCBReader * ccbReader); 32 | virtual void onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, float pFloatScale, CCBReader * ccbReader); 33 | virtual void onHandlePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Point pPoint, CCBReader * ccbReader); 34 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 35 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 36 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, cocos2d::Color4F pColor4F, CCBReader * ccbReader); 37 | virtual void onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader); 38 | virtual void onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 39 | 40 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 41 | void updateForState(cocos2d::Node * pNode, cocos2d::extension::Control::State state); 42 | protected: 43 | float _outlineWidth; 44 | float _shadowBlurRadius; 45 | cocos2d::Point _shadowOffset; 46 | cocos2d::Color4F _outlineColor; 47 | cocos2d::Color4F _shadowColor; 48 | }; 49 | 50 | } 51 | 52 | #endif 53 | -------------------------------------------------------------------------------- /spritebuilder/CCNode+CCBRelativePositioning.cpp: -------------------------------------------------------------------------------- 1 | #include "CCNode+CCBRelativePositioning.h" 2 | #include "CCBReader.h" 3 | 4 | using namespace cocos2d; 5 | 6 | namespace spritebuilder { 7 | 8 | Point getAbsolutePosition(Point pt, CCBReader::PositionType type, CCBReader::PositionUnit xUnit, CCBReader::PositionUnit yUnit, const Size &containerSize, const std::string& propName) 9 | { 10 | Point absPt = Point(0,0); 11 | 12 | if (xUnit == CCBReader::PositionUnit::NORMALIZED) { 13 | pt.x = static_cast(containerSize.width * pt.x); 14 | } 15 | else if (xUnit == CCBReader::PositionUnit::SCALED) { 16 | float resolutionScale = CCBReader::getResolutionScale(); 17 | pt.x = pt.x * resolutionScale; 18 | } 19 | 20 | if (yUnit == CCBReader::PositionUnit::NORMALIZED) { 21 | pt.y = static_cast(containerSize.height * pt.y); 22 | } 23 | else if (yUnit == CCBReader::PositionUnit::SCALED) { 24 | float resolutionScale = CCBReader::getResolutionScale(); 25 | pt.y = pt.y * resolutionScale; 26 | } 27 | 28 | if (type == CCBReader::PositionType::RELATIVE_BOTTOM_LEFT) 29 | { 30 | absPt = pt; 31 | } 32 | else if (type == CCBReader::PositionType::RELATIVE_TOP_LEFT) 33 | { 34 | absPt.x = pt.x; 35 | absPt.y = containerSize.height - pt.y; 36 | } 37 | else if (type == CCBReader::PositionType::RELATIVE_TOP_RIGHT) 38 | { 39 | absPt.x = containerSize.width - pt.x; 40 | absPt.y = containerSize.height - pt.y; 41 | } 42 | else if (type == CCBReader::PositionType::RELATIVE_BOTTOM_RIGHT) 43 | { 44 | absPt.x = containerSize.width - pt.x; 45 | absPt.y = pt.y; 46 | } 47 | /* 48 | else if (type == CCBReader::PositionType::PERCENT) 49 | { 50 | absPt.x = (int)(containerSize.width * pt.x / 100.0f); 51 | absPt.y = (int)(containerSize.height * pt.y / 100.0f); 52 | } 53 | else if (type == CCBReader::PositionType::MULTIPLY_RESOLUTION) 54 | { 55 | float resolutionScale = CCBReader::getResolutionScale(); 56 | 57 | absPt.x = pt.x * resolutionScale; 58 | absPt.y = pt.y * resolutionScale; 59 | } 60 | */ 61 | 62 | return absPt; 63 | } 64 | 65 | 66 | void setRelativeScale(Node *pNode, float scaleX, float scaleY, CCBReader::ScaleType type, const std::string& propName) 67 | { 68 | CCASSERT(pNode, "pNode should not be null"); 69 | 70 | if (type == CCBReader::ScaleType::MULTIPLY_RESOLUTION) 71 | { 72 | float resolutionScale = CCBReader::getResolutionScale(); 73 | 74 | scaleX *= resolutionScale; 75 | scaleY *= resolutionScale; 76 | } 77 | 78 | pNode->setScaleX(scaleX); 79 | pNode->setScaleY(scaleY); 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /spritebuilder/CCBPhysicsBody.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCBPhysicsBody.h" 25 | #include "CCBReader.h" 26 | #include "CCPhysicsBodyInfo_chipmunk.h" 27 | 28 | using namespace cocos2d; 29 | namespace spritebuilder { 30 | 31 | 32 | 33 | CCBPhysicsBody* CCBPhysicsBody::create() { 34 | CCBPhysicsBody* body = new CCBPhysicsBody(); 35 | if (body && body->init()) 36 | { 37 | body->autorelease(); 38 | return body; 39 | } 40 | 41 | CC_SAFE_DELETE(body); 42 | return nullptr; 43 | 44 | } 45 | 46 | Point CCBPhysicsBody::getPosition() const { 47 | Point position = PhysicsBody::getPosition(); 48 | position = position * CCBReader::getPTMRatio(); 49 | return position; 50 | } 51 | 52 | void CCBPhysicsBody::setPosition(Point position) { 53 | position = position / CCBReader::getPTMRatio(); 54 | PhysicsBody::setPosition(position); 55 | } 56 | void CCBPhysicsBody::update(float delta) { 57 | 58 | if (_node != nullptr) 59 | { 60 | Node* parent = _node->getParent(); 61 | Point position = parent != nullptr ? parent->convertToNodeSpace(getPosition()) : getPosition(); 62 | 63 | _positionResetTag = true; 64 | _rotationResetTag = true; 65 | _node->setPosition(position); 66 | _node->setRotation(getRotation()); 67 | _positionResetTag = false; 68 | _rotationResetTag = false; 69 | 70 | // damping compute 71 | if (_isDamping && _dynamic && !isResting()) 72 | { 73 | _info->getBody()->v.x *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f); 74 | _info->getBody()->v.y *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f); 75 | _info->getBody()->w *= cpfclamp(1.0f - delta * _angularDamping, 0.0f, 1.0f); 76 | } 77 | } 78 | 79 | } 80 | } -------------------------------------------------------------------------------- /spritebuilder/CCNodeLoaderLibrary.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCNODELOADERLIBRARY_H_ 2 | #define _CCB_CCNODELOADERLIBRARY_H_ 3 | 4 | #include "CCBReader.h" 5 | 6 | namespace spritebuilder { 7 | 8 | class NodeLoader; 9 | 10 | typedef std::map NodeLoaderMap; 11 | typedef std::pair NodeLoaderMapEntry; 12 | 13 | class NodeLoaderLibrary : public cocos2d::Ref 14 | { 15 | public: 16 | /** 17 | * @js NA 18 | * @lua NA 19 | */ 20 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(NodeLoaderLibrary, library); 21 | /** 22 | * @js NA 23 | * @lua NA 24 | */ 25 | NodeLoaderLibrary(); 26 | /** 27 | * @js NA 28 | * @lua NA 29 | */ 30 | virtual ~NodeLoaderLibrary(); 31 | /** 32 | * @js NA 33 | * @lua NA 34 | */ 35 | void registerDefaultNodeLoaders(); 36 | /** 37 | * @js NA 38 | * @lua NA 39 | */ 40 | void registerNodeLoader(const char * pClassName, NodeLoader * pNodeLoader); 41 | //void registerNodeLoader(String * pClassName, NodeLoader * pNodeLoader); 42 | /** 43 | * @js NA 44 | * @lua NA 45 | */ 46 | void unregisterNodeLoader(const char * pClassName); 47 | //void unregisterNodeLoader(String * pClassName); 48 | /** 49 | * @js NA 50 | * @lua NA 51 | */ 52 | NodeLoader * getNodeLoader(const char * pClassName); 53 | //CCNodeLoader * getNodeLoader(String * pClassName); 54 | /** 55 | * @js NA 56 | * @lua NA 57 | */ 58 | void purge(bool pDelete); 59 | /** 60 | * @js NA 61 | * @lua NA 62 | */ 63 | CC_DEPRECATED_ATTRIBUTE void registerDefaultCCNodeLoaders() { registerDefaultNodeLoaders(); } 64 | /** 65 | * @js NA 66 | * @lua NA 67 | */ 68 | CC_DEPRECATED_ATTRIBUTE void registerCCNodeLoader(const char * pClassName, NodeLoader * pNodeLoader) { registerNodeLoader(pClassName, pNodeLoader); }; 69 | /** 70 | * @js NA 71 | * @lua NA 72 | */ 73 | CC_DEPRECATED_ATTRIBUTE void unregisterCCNodeLoader(const char * pClassName) { unregisterNodeLoader(pClassName); }; 74 | /** 75 | * @js NA 76 | * @lua NA 77 | */ 78 | CC_DEPRECATED_ATTRIBUTE NodeLoader * getCCNodeLoader(const char * pClassName) { return getNodeLoader(pClassName); }; 79 | 80 | public: 81 | /** 82 | * @js NA 83 | * @lua NA 84 | */ 85 | static NodeLoaderLibrary * getInstance(); 86 | /** 87 | * @js NA 88 | * @lua NA 89 | */ 90 | static void destroyInstance(); 91 | /** 92 | * @js NA 93 | * @lua NA 94 | */ 95 | static NodeLoaderLibrary * newDefaultNodeLoaderLibrary(); 96 | /** 97 | * @js NA 98 | * @lua NA 99 | */ 100 | CC_DEPRECATED_ATTRIBUTE static NodeLoaderLibrary * sharedNodeLoaderLibrary() { return NodeLoaderLibrary::getInstance(); }; 101 | /** 102 | * @js NA 103 | * @lua NA 104 | */ 105 | CC_DEPRECATED_ATTRIBUTE static void purgeSharedNodeLoaderLibrary() { NodeLoaderLibrary::destroyInstance(); }; 106 | /** 107 | * @js NA 108 | * @lua NA 109 | */ 110 | CC_DEPRECATED_ATTRIBUTE static NodeLoaderLibrary * newDefaultCCNodeLoaderLibrary() { return NodeLoaderLibrary::newDefaultNodeLoaderLibrary(); }; 111 | 112 | private: 113 | NodeLoaderMap _nodeLoaders; 114 | }; 115 | 116 | } 117 | 118 | #endif 119 | -------------------------------------------------------------------------------- /spritebuilder/CCSliderLoader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCSliderLoader__ 25 | #define __cocos2d_libs__CCSliderLoader__ 26 | 27 | #include "CCControlLoader.h" 28 | #include "extensions/cocos-ext.h" 29 | 30 | 31 | namespace spritebuilder { 32 | 33 | /* Forward declaration. */ 34 | class CCBReader; 35 | 36 | class SliderLoader : public ControlLoader{ 37 | public: 38 | /** 39 | * @js NA 40 | * @lua NA 41 | */ 42 | virtual ~SliderLoader() {}; 43 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(SliderLoader, loader); 44 | 45 | protected: 46 | virtual cocos2d::extension::ControlSlider * createNode(cocos2d::Node * pParent, CCBReader * ccbReader) { 47 | auto pRet = cocos2d::extension::ControlSlider::create(cocos2d::Sprite::create(), cocos2d::Sprite::create(), cocos2d::Sprite::create()); 48 | 49 | return pRet; 50 | } 51 | 52 | virtual void onHandlePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, BlockData * pBlockData, CCBReader * ccbReader); 53 | 54 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 55 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 56 | virtual void onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 57 | virtual void onHandlePropTypeBlockControl(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader); 58 | 59 | /* 60 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader);*/ 61 | protected: 62 | cocos2d::SpriteFrame* _progressSprite; 63 | cocos2d::SpriteFrame* _backgroundSprite; 64 | cocos2d::SpriteFrame* _handleSprite; 65 | cocos2d::SpriteFrame* _selectedHandleSprite; 66 | cocos2d::Size _contentSize; 67 | }; 68 | 69 | } 70 | #endif /* defined(__cocos2d_libs__CCSliderLoader__) */ 71 | -------------------------------------------------------------------------------- /spritebuilder/CCBLocalizationManager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCBLocalizationManager.h" 25 | 26 | USING_NS_CC; 27 | namespace spritebuilder { 28 | #define LOCALIZATION_FILE "Strings.ccbLang" 29 | 30 | std::string strEmpty = ""; 31 | 32 | static CCBLocalizationManager *_instance; 33 | 34 | CCBLocalizationManager::CCBLocalizationManager() { 35 | loadStringFile(LOCALIZATION_FILE); 36 | } 37 | 38 | CCBLocalizationManager* CCBLocalizationManager::sharedManager() { 39 | if (_instance == NULL) 40 | _instance = new CCBLocalizationManager(); 41 | 42 | return _instance; 43 | } 44 | 45 | std::string& CCBLocalizationManager::localizedStringForKey(const char* key) { 46 | std::map::iterator it = mTranslation.find(key); 47 | if (it != mTranslation.end()) 48 | return (*it).second; 49 | 50 | return strEmpty; 51 | } 52 | 53 | void CCBLocalizationManager::loadStringFile(const char* file) { 54 | 55 | ValueMap map = FileUtils::getInstance()->getValueMapFromFile(file); 56 | 57 | ValueMap::iterator it = map.find("fileType"); 58 | 59 | CCASSERT(it != map.end() && it->second.asString() == "SpriteBuilderTranslations", "Invalid file format for SpriteBuilder localizations"); 60 | 61 | it = map.find("fileVersion"); 62 | CCASSERT(it != map.end() && it->second.asInt() == 1, "Translation file version is incompatible with this reader"); 63 | 64 | ValueVector languages = map["activeLanguages"].asValueVector(); 65 | 66 | std::string userLanguage; 67 | std::string preferredLangs = Application::getInstance()->getCurrentLanguageCode(); 68 | 69 | for (ValueVector::iterator _it = languages.begin(); _it != languages.end(); _it++) { 70 | if (_it->asString() == preferredLangs) { 71 | userLanguage = _it->asString(); 72 | break; 73 | } 74 | } 75 | 76 | mTranslation.clear(); 77 | if (userLanguage != "") { 78 | ValueVector tranList = map["translations"].asValueVector(); 79 | for (ValueVector::iterator _it = tranList.begin(); _it != tranList.end(); _it++) { 80 | ValueMap dic = _it->asValueMap(); 81 | 82 | mTranslation[dic["key"].asString()] = dic["translations"].asValueMap()[userLanguage].asString(); 83 | } 84 | } 85 | } 86 | } -------------------------------------------------------------------------------- /spritebuilder/CCTextFieldLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCTextFieldLoader.h" 2 | 3 | using namespace cocos2d; 4 | using namespace cocos2d::extension; 5 | 6 | #define PROPERTY_PREFERREDSIZE "preferredSize" 7 | #define PROPERTY_SPRITEFRAME "backgroundSpriteFrame" 8 | #define PROPERTY_PADDING "padding" 9 | #define PROPERTY_BLOCK "block" 10 | 11 | namespace spritebuilder { 12 | 13 | class ExtTextField : public EditBox, public cocos2d::extension::EditBoxDelegate { 14 | 15 | public: 16 | ExtTextField():_target(NULL), mSELControlHandler(NULL) { 17 | 18 | } 19 | virtual void editBoxEditingDidBegin(cocos2d::extension::EditBox* editBox) { 20 | 21 | } 22 | virtual void editBoxEditingDidEnd(cocos2d::extension::EditBox* editBox) { 23 | 24 | } 25 | virtual void editBoxTextChanged(cocos2d::extension::EditBox* editBox, const std::string& text) { 26 | 27 | } 28 | virtual void editBoxReturn(cocos2d::extension::EditBox* editBox) { 29 | if (_target && mSELControlHandler) 30 | (_target->*mSELControlHandler)(this, cocos2d::extension::Control::EventType::DRAG_EXIT); 31 | } 32 | void setTargetSelector(Ref* target, cocos2d::extension::Control::Handler handler) { 33 | _target = target; 34 | mSELControlHandler = handler; 35 | } 36 | private: 37 | Ref* _target; 38 | cocos2d::extension::Control::Handler mSELControlHandler; 39 | 40 | }; 41 | 42 | 43 | cocos2d::extension::EditBox * EditBoxLoader::createNode(cocos2d::Node * pParent, CCBReader * ccbReader) { 44 | ExtTextField* pRet = new ExtTextField(); 45 | pRet->initWithSizeAndBackgroundSprite(cocos2d::Size(0,0), cocos2d::extension::Scale9Sprite::create()); 46 | pRet->autorelease(); 47 | pRet->setDelegate(pRet); 48 | pRet->setFontName("Helvetica"); 49 | pRet->setFontColor(cocos2d::Color3B::BLACK); 50 | 51 | return pRet; 52 | } 53 | 54 | 55 | void EditBoxLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char* pPropertyName, Size pSize, CCBReader * ccbReader) { 56 | if(strcmp(pPropertyName, PROPERTY_PREFERREDSIZE) == 0) { 57 | ((EditBox*)pNode)->setPreferredSize(pSize); 58 | ((EditBox*)pNode)->setFontSize(pSize.height*2/3); 59 | } else { 60 | ControlLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, pSize, ccbReader); 61 | } 62 | } 63 | 64 | void EditBoxLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 65 | if(strcmp(pPropertyName, PROPERTY_SPRITEFRAME) == 0) { 66 | ((EditBox*)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::NORMAL); 67 | } else { 68 | ControlLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 69 | } 70 | } 71 | 72 | void EditBoxLoader::onHandlePropTypeFloatScale(Node * pNode, Node * pParent, const char* pPropertyName, float pFloatScale, CCBReader * ccbReader) { 73 | if(strcmp(pPropertyName, PROPERTY_PADDING) == 0) { 74 | } else { 75 | ControlLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader); 76 | } 77 | } 78 | void EditBoxLoader::onHandlePropTypeBlockControl(Node * pNode, Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader) { 79 | if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 80 | ((ExtTextField*)pNode)->setTargetSelector(pBlockControlData->_target, pBlockControlData->mSELControlHandler); 81 | } else { 82 | ControlLoader::onHandlePropTypeBlockControl(pNode, pParent, pPropertyName, pBlockControlData, ccbReader); 83 | } 84 | } 85 | 86 | }; -------------------------------------------------------------------------------- /spritebuilder/CCScale9SpriteLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCScale9SpriteLoader.h" 2 | 3 | using namespace cocos2d; 4 | using namespace cocos2d::extension; 5 | 6 | #define PROPERTY_CONTENTSIZE "contentSize" 7 | #define PROPERTY_SPRITEFRAME "spriteFrame" 8 | #define PROPERTY_COLOR "color" 9 | #define PROPERTY_OPACITY "opacity" 10 | #define PROPERTY_BLENDFUNC "blendFunc" 11 | #define PROPERTY_PREFEREDSIZE "preferedSize" // TODO Should be "preferredSize". This is a typo in cocos2d-iphone, cocos2d-x and CocosBuilder! 12 | #define PROPERTY_INSETLEFT "insetLeft" 13 | #define PROPERTY_INSETTOP "insetTop" 14 | #define PROPERTY_INSETRIGHT "insetRight" 15 | #define PROPERTY_INSETBOTTOM "insetBottom" 16 | 17 | namespace spritebuilder { 18 | 19 | void Scale9SpriteLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 20 | if(strcmp(pPropertyName, PROPERTY_SPRITEFRAME) == 0) { 21 | // ((Scale9Sprite *)pNode)->setSpriteFrame(pSpriteFrame); 22 | if (pSpriteFrame) { 23 | _spriteFrame = pSpriteFrame; 24 | _spriteFrame->retain(); 25 | } 26 | 27 | } else { 28 | NodeLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 29 | } 30 | } 31 | 32 | void Scale9SpriteLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 33 | if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) { 34 | ((Scale9Sprite *)pNode)->setColor(Color3B(pColor4F.r * 255, pColor4F.g * 255, pColor4F.b * 255)); 35 | } else { 36 | NodeLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 37 | } 38 | } 39 | 40 | void Scale9SpriteLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 41 | if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) { 42 | ((Scale9Sprite *)pNode)->setOpacity(pByte); 43 | } else { 44 | NodeLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 45 | } 46 | } 47 | 48 | void Scale9SpriteLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 49 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 50 | // TODO Not exported by CocosBuilder yet! 51 | //((Scale9Sprite *)pNode)->setBlendFunc(pBlendFunc); 52 | } else { 53 | NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 54 | } 55 | } 56 | 57 | void Scale9SpriteLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char * pPropertyName, Size pSize, CCBReader * ccbReader) { 58 | if(strcmp(pPropertyName, PROPERTY_CONTENTSIZE) == 0) { 59 | _contentSize = pSize; 60 | } else if(strcmp(pPropertyName, PROPERTY_PREFEREDSIZE) == 0) { 61 | this->_preferedSize = pSize; 62 | } else { 63 | NodeLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, pSize, ccbReader); 64 | } 65 | } 66 | 67 | void Scale9SpriteLoader::onHandlePropTypeFloat(Node * pNode, Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader) { 68 | if(strcmp(pPropertyName, PROPERTY_INSETLEFT) == 0) { 69 | this->_insetLeft = pFloat; 70 | } else if(strcmp(pPropertyName, PROPERTY_INSETTOP) == 0) { 71 | this->_insetTop = pFloat; 72 | } else if(strcmp(pPropertyName, PROPERTY_INSETRIGHT) == 0) { 73 | this->_insetRight = pFloat; 74 | } else if(strcmp(pPropertyName, PROPERTY_INSETBOTTOM) == 0) { 75 | this->_insetBottom = pFloat; 76 | } else { 77 | NodeLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader); 78 | } 79 | } 80 | void Scale9SpriteLoader::onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader) { 81 | if (_spriteFrame) 82 | ((Scale9Sprite *)pNode)->setSpriteFrame(_spriteFrame); 83 | ((Scale9Sprite *)pNode)->setContentSize(_contentSize); 84 | ((Scale9Sprite *)pNode)->setPreferredSize(_contentSize); 85 | 86 | ((Scale9Sprite *)pNode)->setInsetLeft(_insetLeft); 87 | ((Scale9Sprite *)pNode)->setInsetTop(_insetTop); 88 | ((Scale9Sprite *)pNode)->setInsetRight(_insetRight); 89 | ((Scale9Sprite *)pNode)->setInsetBottom(_insetBottom); 90 | 91 | 92 | if (_spriteFrame) 93 | _spriteFrame->release(); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /spritebuilder/CCLayoutBox.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCLayoutBox.h" 25 | 26 | NS_CC_BEGIN 27 | 28 | static float roundUpToEven(float f) 29 | { 30 | return ceilf(f/2.0f) * 2.0f; 31 | } 32 | 33 | LayoutBox* LayoutBox::create() { 34 | LayoutBox* ret = new LayoutBox(); 35 | if (ret->init()) { 36 | ret->autorelease(); 37 | return ret; 38 | } else 39 | return NULL; 40 | } 41 | LayoutBox::LayoutBox() { 42 | m_eDirection = CCLayoutBoxDirectionHorizontal; 43 | m_nSpacing = 0; 44 | } 45 | void LayoutBox::layout() { 46 | Layout::layout(); 47 | if (m_eDirection == CCLayoutBoxDirectionHorizontal) 48 | { 49 | // Get the maximum height 50 | float maxHeight = 0; 51 | 52 | for(auto it = _children.cbegin(); it != _children.cend(); ++it) { 53 | float height = (*it)->getContentSize().height; 54 | if (height > maxHeight) maxHeight = height; 55 | } 56 | 57 | // Position the nodes 58 | float width = 0; 59 | for(auto it = _children.cbegin(); it != _children.cend(); ++it) { 60 | 61 | Size childSize = (*it)->getContentSize(); 62 | 63 | Point offset = (*it)->getAnchorPointInPoints(); 64 | Point localPos(roundf(width), roundf((maxHeight-childSize.height)/2.0f)); 65 | Point position = localPos + offset; 66 | 67 | (*it)->setPosition(position); 68 | // (*it)->setPositionType(CCPositionTypePoints); 69 | 70 | width += childSize.width; 71 | width += m_nSpacing; 72 | } 73 | 74 | // Account for last added increment 75 | width -= m_nSpacing; 76 | if (width < 0) width = 0; 77 | 78 | this->setContentSize(Size(roundUpToEven(width), roundUpToEven(maxHeight))); 79 | } 80 | else 81 | { 82 | // Get the maximum height 83 | float maxWidth = 0; 84 | 85 | for(auto it = _children.cbegin(); it != _children.cend(); ++it) { 86 | float width = (*it)->getContentSize().width; 87 | if (width > maxWidth) maxWidth = width; 88 | } 89 | 90 | // Position the nodes 91 | float height = 0; 92 | for(auto it = _children.cbegin(); it != _children.cend(); ++it) { 93 | 94 | Size childSize = (*it)->getContentSize(); 95 | 96 | Point offset = (*it)->getAnchorPointInPoints(); 97 | Point localPos(roundf((maxWidth-childSize.width)/2.0f), roundf(height)); 98 | Point position = localPos + offset; 99 | 100 | (*it)->setPosition(position); 101 | // (*it)->setPositionType(CCPositionTypePoints); 102 | 103 | height += childSize.height; 104 | height += m_nSpacing; 105 | } 106 | 107 | // Account for last added increment 108 | height -= m_nSpacing; 109 | if (height < 0) height = 0; 110 | 111 | 112 | this->setContentSize(Size(roundUpToEven(maxWidth), roundUpToEven(height))); 113 | } 114 | } 115 | 116 | void LayoutBox::setDirection(CCLayoutBoxDirection direction) { 117 | m_eDirection = direction; 118 | needLayout(); 119 | } 120 | CCLayoutBoxDirection LayoutBox::getDirection() { 121 | return m_eDirection; 122 | } 123 | 124 | void LayoutBox::setSpacing(float spacing) { 125 | m_nSpacing = spacing; 126 | needLayout(); 127 | } 128 | 129 | float LayoutBox::getSpacing() { 130 | return m_nSpacing; 131 | } 132 | 133 | void LayoutBox::removeChild(Node* child, bool cleanup) { 134 | Layout::removeChild(child, cleanup); 135 | needLayout(); 136 | } 137 | 138 | NS_CC_END -------------------------------------------------------------------------------- /spritebuilder/CCNodeLoaderLibrary.cpp: -------------------------------------------------------------------------------- 1 | #include "CCNodeLoaderLibrary.h" 2 | 3 | #include "CCLayerLoader.h" 4 | #include "CCLayerColorLoader.h" 5 | #include "CCLayerGradientLoader.h" 6 | #include "CCLabelBMFontLoader.h" 7 | #include "CCLabelTTFLoader.h" 8 | #include "CCSpriteLoader.h" 9 | #include "CCScale9SpriteLoader.h" 10 | #include "CCBFileLoader.h" 11 | #include "CCMenuLoader.h" 12 | #include "CCMenuItemLoader.h" 13 | #include "CCMenuItemImageLoader.h" 14 | #include "CCControlButtonLoader.h" 15 | #include "CCParticleSystemQuadLoader.h" 16 | #include "CCScrollViewLoader.h" 17 | #include "CCPhysicsNodeLoader.h" 18 | #include "CCLayoutBoxLoader.h" 19 | #include "CCSliderLoader.h" 20 | #include "CCTextFieldLoader.h" 21 | 22 | using namespace cocos2d; 23 | 24 | namespace spritebuilder { 25 | 26 | NodeLoaderLibrary::NodeLoaderLibrary() { 27 | 28 | } 29 | 30 | NodeLoaderLibrary::~NodeLoaderLibrary() { 31 | this->purge(true); 32 | } 33 | 34 | void NodeLoaderLibrary::registerDefaultNodeLoaders() { 35 | this->registerNodeLoader("CCNode", NodeLoader::loader()); 36 | this->registerNodeLoader("CCLayer", LayerLoader::loader()); 37 | this->registerNodeLoader("CCLayerColor", LayerColorLoader::loader()); 38 | this->registerNodeLoader("CCLayerGradient", LayerGradientLoader::loader()); 39 | 40 | this->registerNodeLoader("CCSprite", SpriteLoader::loader()); 41 | this->registerNodeLoader("CCLabelBMFont", LabelBMFontLoader::loader()); 42 | this->registerNodeLoader("CCLabelTTF", LabelTTFLoader::loader()); 43 | // this->registerNodeLoader("CCScale9Sprite", Scale9SpriteLoader::loader()); 44 | this->registerNodeLoader("CCSprite9Slice", Scale9SpriteLoader::loader()); 45 | 46 | this->registerNodeLoader("CCScrollView", ScrollViewLoader::loader()); 47 | this->registerNodeLoader("CCBFile", CCBFileLoader::loader()); 48 | this->registerNodeLoader("CCMenu", MenuLoader::loader()); 49 | this->registerNodeLoader("CCMenuItemImage", MenuItemImageLoader::loader()); 50 | this->registerNodeLoader("CCControlButton", ControlButtonLoader::loader()); 51 | this->registerNodeLoader("CCParticleSystemQuad", ParticleSystemQuadLoader::loader()); 52 | this->registerNodeLoader("CCParticleSystem", ParticleSystemQuadLoader::loader()); 53 | 54 | 55 | this->registerNodeLoader("CCNodeGradient", LayerGradientLoader::loader()); 56 | this->registerNodeLoader("CCNodeColor", LayerColorLoader::loader()); 57 | 58 | this->registerNodeLoader("CCButton", ControlButtonLoader::loader()); 59 | this->registerNodeLoader("CCPhysicsNode", PhysicsNodeLoader::loader()); 60 | 61 | this->registerNodeLoader("CCLayoutBox", LayoutBoxLoader::loader()); 62 | this->registerNodeLoader("CCSlider", SliderLoader::loader()); 63 | 64 | EditBoxLoader::loader(); 65 | this->registerNodeLoader("CCTextField", EditBoxLoader::loader()); 66 | 67 | 68 | } 69 | 70 | void NodeLoaderLibrary::registerNodeLoader(const char * pClassName, NodeLoader * pNodeLoader) { 71 | pNodeLoader->retain(); 72 | this->_nodeLoaders.insert(NodeLoaderMapEntry(pClassName, pNodeLoader)); 73 | } 74 | 75 | void NodeLoaderLibrary::unregisterNodeLoader(const char * pClassName) { 76 | NodeLoaderMap::iterator ccNodeLoadersIterator = this->_nodeLoaders.find(pClassName); 77 | if (ccNodeLoadersIterator != this->_nodeLoaders.end()) 78 | { 79 | ccNodeLoadersIterator->second->release(); 80 | _nodeLoaders.erase(ccNodeLoadersIterator); 81 | } 82 | else 83 | { 84 | CCLOG("The loader (%s) doesn't exist", pClassName); 85 | } 86 | } 87 | 88 | NodeLoader * NodeLoaderLibrary::getNodeLoader(const char* pClassName) { 89 | NodeLoaderMap::iterator ccNodeLoadersIterator = this->_nodeLoaders.find(pClassName); 90 | //if (ccNodeLoadersIterator == this->_nodeLoaders.end()) 91 | // return getNodeLoader("CCNode"); 92 | 93 | assert(ccNodeLoadersIterator != this->_nodeLoaders.end()); 94 | return ccNodeLoadersIterator->second; 95 | } 96 | 97 | void NodeLoaderLibrary::purge(bool pReleaseNodeLoaders) { 98 | if(pReleaseNodeLoaders) { 99 | for(NodeLoaderMap::iterator it = this->_nodeLoaders.begin(); it != this->_nodeLoaders.end(); it++) { 100 | it->second->release(); 101 | } 102 | } 103 | this->_nodeLoaders.clear(); 104 | } 105 | 106 | 107 | 108 | static NodeLoaderLibrary * sSharedNodeLoaderLibrary = NULL; 109 | 110 | NodeLoaderLibrary * NodeLoaderLibrary::getInstance() { 111 | if(sSharedNodeLoaderLibrary == NULL) { 112 | sSharedNodeLoaderLibrary = new NodeLoaderLibrary(); 113 | 114 | sSharedNodeLoaderLibrary->registerDefaultNodeLoaders(); 115 | } 116 | return sSharedNodeLoaderLibrary; 117 | } 118 | 119 | void NodeLoaderLibrary::destroyInstance() { 120 | CC_SAFE_DELETE(sSharedNodeLoaderLibrary); 121 | } 122 | 123 | NodeLoaderLibrary * NodeLoaderLibrary::newDefaultNodeLoaderLibrary() { 124 | NodeLoaderLibrary * ccNodeLoaderLibrary = NodeLoaderLibrary::library(); 125 | 126 | ccNodeLoaderLibrary->registerDefaultNodeLoaders(); 127 | 128 | return ccNodeLoaderLibrary; 129 | } 130 | 131 | } -------------------------------------------------------------------------------- /spritebuilder/CCLabelTTFLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCLabelTTFLoader.h" 2 | #include "ccMacros.h" 3 | #include "CCDirector.h" 4 | using namespace cocos2d; 5 | /* 6 | #define PROPERTY_COLOR "color" 7 | #define PROPERTY_OPACITY "opacity" 8 | #define PROPERTY_BLENDFUNC "blendFunc" 9 | #define PROPERTY_FONTNAME "fontName" 10 | #define PROPERTY_FONTSIZE "fontSize" 11 | #define PROPERTY_HORIZONTALALIGNMENT "horizontalAlignment" 12 | #define PROPERTY_VERTICALALIGNMENT "verticalAlignment" 13 | #define PROPERTY_STRING "string" 14 | #define PROPERTY_DIMENSIONS "dimensions" 15 | */ 16 | 17 | #define PROPERTY_BLENDFUNC "blendFunc" 18 | 19 | #define PROPERTY_STRING "string" 20 | #define PROPERTY_FONTNAME "fontName" 21 | #define PROPERTY_FONTSIZE "fontSize" 22 | #define PROPERTY_ADJUSTSFONTSIZETOFIT "adjustsFontSizeToFit" // TODO: 23 | #define PROPERTY_OPACITY "opacity" 24 | #define PROPERTY_COLOR "color" 25 | #define PROPERTY_DIMENSIONS "dimensions" 26 | #define PROPERTY_HORIZONTALALIGNMENT "horizontalAlignment" 27 | #define PROPERTY_VERTICALALIGNMENT "verticalAlignment" 28 | #define PROPERTY_FONTCOLOR "fontColor" 29 | #define PROPERTY_OUTLINECOLOR "outlineColor" 30 | #define PROPERTY_OUTLINEWIDTH "outlineWidth" 31 | #define PROPERTY_SHADOWCOLOR "shadowColor" 32 | #define PROPERTY_SHADOWBLURRADIUS "shadowBlurRadius" 33 | #define PROPERTY_SHADOWOFFSET "shadowOffset" 34 | namespace spritebuilder { 35 | 36 | 37 | void LabelTTFLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 38 | if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) { 39 | ((Label *)pNode)->setTextColor(COLOR4F_TO_COLOR4B(pColor4F)); 40 | } else if(strcmp(pPropertyName, PROPERTY_FONTCOLOR) == 0) { 41 | ((Label *)pNode)->setColor(COLOR4F_TO_COLOR3B(pColor4F)); 42 | ((Label *)pNode)->setOpacity(pColor4F.a * 255); 43 | } else if(strcmp(pPropertyName, PROPERTY_OUTLINECOLOR) == 0) { 44 | this->_outlineColor = COLOR4F_TO_COLOR4B(pColor4F); 45 | 46 | } else if(strcmp(pPropertyName, PROPERTY_SHADOWCOLOR) == 0) { 47 | this->_shadowColor = COLOR4F_TO_COLOR4B(pColor4F); 48 | ((Label *)pNode)->enableShadow(this->_shadowColor, this->_shadowOffset, this->_shadowBlurRadius); 49 | } else { 50 | NodeLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 51 | } 52 | } 53 | void LabelTTFLoader::onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader) { 54 | 55 | if(strcmp(pPropertyName, PROPERTY_SHADOWOFFSET) == 0) { 56 | auto contentScaleFactor = CC_CONTENT_SCALE_FACTOR(); 57 | this->_shadowOffset = Size(pPosition.x / contentScaleFactor, pPosition.y / contentScaleFactor); 58 | 59 | ((Label *)pNode)->enableShadow(this->_shadowColor, this->_shadowOffset, this->_shadowBlurRadius); 60 | 61 | } else { 62 | NodeLoader::onHandlePropTypePosition(pNode, pParent, pPropertyName, pPosition, ccbReader); 63 | } 64 | } 65 | void LabelTTFLoader::onHandlePropTypeByte(Node * pNode, Node * pParent, const char * pPropertyName, unsigned char pByte, CCBReader * ccbReader) { 66 | if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) { 67 | ((Label *)pNode)->setOpacity(pByte); 68 | } else { 69 | NodeLoader::onHandlePropTypeByte(pNode, pParent, pPropertyName, pByte, ccbReader); 70 | } 71 | } 72 | 73 | void LabelTTFLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 74 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 75 | ((Label *)pNode)->setBlendFunc(pBlendFunc); 76 | } else { 77 | NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 78 | } 79 | } 80 | 81 | void LabelTTFLoader::onHandlePropTypeFontTTF(Node * pNode, Node * pParent, const char * pPropertyName, const char * pFontTTF, CCBReader * ccbReader) { 82 | if(strcmp(pPropertyName, PROPERTY_FONTNAME) == 0) { 83 | #if COCOS2D_VERSION <= 0x030000 84 | ((Label *)pNode)->setFontName(pFontTTF); 85 | #else 86 | ((Label *)pNode)->setSystemFontName(pFontTTF); 87 | #endif 88 | } else { 89 | NodeLoader::onHandlePropTypeFontTTF(pNode, pParent, pPropertyName, pFontTTF, ccbReader); 90 | } 91 | } 92 | 93 | void LabelTTFLoader::onHandlePropTypeText(Node * pNode, Node * pParent, const char * pPropertyName, const char * pText, CCBReader * ccbReader) { 94 | if(strcmp(pPropertyName, PROPERTY_STRING) == 0) { 95 | ((Label *)pNode)->setString(pText); 96 | } else { 97 | NodeLoader::onHandlePropTypeText(pNode, pParent, pPropertyName, pText, ccbReader); 98 | } 99 | } 100 | 101 | void LabelTTFLoader::onHandlePropTypeFloatScale(Node * pNode, Node * pParent, const char * pPropertyName, float pFloatScale, CCBReader * ccbReader) { 102 | 103 | if(strcmp(pPropertyName, PROPERTY_FONTSIZE) == 0) { 104 | #if COCOS2D_VERSION <= 0x030000 105 | ((Label *)pNode)->setFontSize(pFloatScale); 106 | #else 107 | ((Label *)pNode)->setSystemFontSize(pFloatScale); 108 | #endif 109 | } else if(strcmp(pPropertyName, PROPERTY_OUTLINEWIDTH) == 0) { 110 | this->_outlineWidth = pFloatScale; 111 | } else if(strcmp(pPropertyName, PROPERTY_SHADOWBLURRADIUS) == 0) { 112 | this->_shadowBlurRadius = pFloatScale; 113 | 114 | ((Label *)pNode)->enableShadow(this->_shadowColor, this->_shadowOffset, this->_shadowBlurRadius); 115 | } else { 116 | NodeLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader); 117 | } 118 | 119 | } 120 | 121 | void LabelTTFLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader) { 122 | if(strcmp(pPropertyName, PROPERTY_HORIZONTALALIGNMENT) == 0) { 123 | ((Label *)pNode)->setHorizontalAlignment(TextHAlignment(pIntegerLabeled)); 124 | } else if(strcmp(pPropertyName, PROPERTY_VERTICALALIGNMENT) == 0) { 125 | ((Label *)pNode)->setVerticalAlignment(TextVAlignment(pIntegerLabeled)); 126 | } else { 127 | NodeLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader); 128 | } 129 | } 130 | 131 | void LabelTTFLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char * pPropertyName, Size size, CCBReader * ccbReader) { 132 | if(strcmp(pPropertyName, PROPERTY_DIMENSIONS) == 0) { 133 | ((Label *)pNode)->setDimensions(size.width,size.height); 134 | } else { 135 | NodeLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, size, ccbReader); 136 | } 137 | } 138 | void LabelTTFLoader::onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader) { 139 | if (this->_outlineColor.a > 0) 140 | ((Label *)pNode)->enableOutline(this->_outlineColor, this->_outlineWidth); 141 | else 142 | ((Label *)pNode)->enableOutline(this->_outlineColor, 0); 143 | } 144 | 145 | } -------------------------------------------------------------------------------- /spritebuilder/CCSliderLoader.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCSliderLoader.h" 25 | 26 | using namespace cocos2d; 27 | using namespace cocos2d::extension; 28 | 29 | #define PROPERTY_BACKGROUNDSPRITEFRAME_NORMAL "backgroundSpriteFrame|Normal" 30 | #define PROPERTY_BACKGROUNDSPRITEFRAME_HIGHLIGHTED "backgroundSpriteFrame|Highlighted" 31 | #define PROPERTY_BACKGROUNDSPRITEFRAME_DISABLED "backgroundSpriteFrame|Disabled" 32 | 33 | #define PROPERTY_HANDLESPRITEFRAME_NORMAL "handleSpriteFrame|Normal" 34 | #define PROPERTY_HANDLESPRITEFRAME_HIGHLIGHTED "handleSpriteFrame|Highlighted" 35 | #define PROPERTY_HANDLESPRITEFRAME_DISABLED "handleSpriteFrame|Disabled" 36 | #define PROPERTY_BLOCK "block" 37 | 38 | namespace spritebuilder { 39 | void SliderLoader::onHandlePropTypeBlockControl(Node * pNode, Node * pParent, const char * pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader) { 40 | 41 | if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 42 | ((Control *)pNode)->addTargetWithActionForControlEvents(pBlockControlData->_target, pBlockControlData->mSELControlHandler, Control::EventType::VALUE_CHANGED); 43 | } else { 44 | ControlLoader::onHandlePropTypeBlockControl(pNode, pParent, pPropertyName, pBlockControlData, ccbReader); 45 | } 46 | } 47 | void SliderLoader::onHandlePropTypeBlock(Node * pNode, Node * pParent, const char* pPropertyName, BlockData * pBlockData, CCBReader * ccbReader) { 48 | if(strcmp(pPropertyName, PROPERTY_BLOCK) == 0) { 49 | ((ControlSlider*)pNode)->addTargetWithActionForControlEvents(pBlockData->_target, (Control::Handler)pBlockData->mSELMenuHandler, Control::EventType::VALUE_CHANGED); 50 | } else { 51 | NodeLoader::onHandlePropTypeBlock(pNode, pParent, pPropertyName, pBlockData, ccbReader); 52 | } 53 | } 54 | void SliderLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char* pPropertyName, Size pSize, CCBReader * ccbReader) { 55 | if(strcmp(pPropertyName, "preferredSize") == 0) { 56 | _contentSize = pSize; 57 | } else { 58 | NodeLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, pSize, ccbReader); 59 | } 60 | } 61 | 62 | void SliderLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char* pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 63 | if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_NORMAL) == 0) { 64 | if(pSpriteFrame != NULL) { 65 | //((Slider *)pNode)->loadSlidBallTextureNormal(pSpriteFrame, Control::State::NORMAL); 66 | //((ControlSlider*)pNode)->setBackgroundSprite(CCSprite::createWithSpriteFrame(pSpriteFrame)); 67 | //((ControlSlider*)pNode)->setProgressSprite(CCSprite::createWithSpriteFrame(pSpriteFrame)); 68 | //this->_progressSprite = pSpriteFrame; 69 | this->_backgroundSprite = pSpriteFrame; 70 | _backgroundSprite->retain(); 71 | } 72 | } else if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_HIGHLIGHTED) == 0) { 73 | if(pSpriteFrame != NULL) { 74 | //((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::HIGH_LIGHTED); 75 | } 76 | } else if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_DISABLED) == 0) { 77 | if(pSpriteFrame != NULL) { 78 | //((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::DISABLED); 79 | } 80 | } else if(strcmp(pPropertyName, PROPERTY_HANDLESPRITEFRAME_NORMAL) == 0) { 81 | if(pSpriteFrame != NULL) { 82 | this->_handleSprite = pSpriteFrame; 83 | _handleSprite->retain(); 84 | } 85 | } else if(strcmp(pPropertyName, PROPERTY_HANDLESPRITEFRAME_HIGHLIGHTED) == 0) { 86 | if(pSpriteFrame != NULL) { 87 | this->_selectedHandleSprite = pSpriteFrame; 88 | _selectedHandleSprite->retain(); 89 | } 90 | } else if(strcmp(pPropertyName, PROPERTY_HANDLESPRITEFRAME_DISABLED) == 0) { 91 | if(pSpriteFrame != NULL) { 92 | //((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::DISABLED); 93 | } 94 | } else { 95 | NodeLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 96 | } 97 | } 98 | 99 | void SliderLoader::onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader) { 100 | Scale9Sprite* background = Scale9Sprite::createWithSpriteFrame(this->_backgroundSprite); 101 | background->setContentSize(_contentSize); 102 | 103 | Sprite* progressSprite = Sprite::create(); 104 | progressSprite->setContentSize(_contentSize); 105 | progressSprite->addChild(background); 106 | background->setAnchorPoint(Point(0.0, 0.5)); 107 | 108 | Sprite* sprite = Sprite::create(); 109 | sprite->setContentSize(_contentSize); 110 | sprite->setAnchorPoint(Point(0.0, 0.0)); 111 | 112 | ((ControlSlider*)pNode)->setContentSize(_contentSize); 113 | 114 | 115 | if (_selectedHandleSprite) 116 | ((ControlSlider *)pNode)->initWithSprites(sprite, 117 | progressSprite, 118 | Sprite::createWithSpriteFrame(this->_handleSprite), 119 | Sprite::createWithSpriteFrame(this->_selectedHandleSprite)); 120 | else 121 | ((ControlSlider *)pNode)->initWithSprites(sprite, 122 | progressSprite, 123 | Sprite::createWithSpriteFrame(this->_handleSprite)); 124 | 125 | 126 | ((ControlSlider*)pNode)->setAnchorPoint(Point(0.0, 0.25)); 127 | 128 | _backgroundSprite->release(); 129 | _handleSprite->release(); 130 | if (_selectedHandleSprite) 131 | _selectedHandleSprite->release(); 132 | 133 | } 134 | } 135 | 136 | #if defined(__GNUC__) && ((__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) 137 | #pragma GCC diagnostic warning "-Wdeprecated-declarations" 138 | #elif _MSC_VER >= 1400 //vs 2005 or higher 139 | #pragma warning (pop) 140 | #endif -------------------------------------------------------------------------------- /spritebuilder/CCParticleSystemQuadLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCParticleSystemQuadLoader.h" 2 | 3 | using namespace cocos2d; 4 | 5 | #define PROPERTY_EMITERMODE "emitterMode" 6 | #define PROPERTY_POSVAR "posVar" 7 | #define PROPERTY_EMISSIONRATE "emissionRate" 8 | #define PROPERTY_DURATION "duration" 9 | #define PROPERTY_TOTALPARTICLES "totalParticles" 10 | #define PROPERTY_LIFE "life" 11 | #define PROPERTY_STARTSIZE "startSize" 12 | #define PROPERTY_ENDSIZE "endSize" 13 | #define PROPERTY_STARTSPIN "startSpin" 14 | #define PROPERTY_ENDSPIN "endSpin" 15 | #define PROPERTY_ANGLE "angle" 16 | #define PROPERTY_STARTCOLOR "startColor" 17 | #define PROPERTY_ENDCOLOR "endColor" 18 | #define PROPERTY_BLENDFUNC "blendFunc" 19 | #define PROPERTY_GRAVITY "gravity" 20 | #define PROPERTY_SPEED "speed" 21 | #define PROPERTY_TANGENTIALACCEL "tangentialAccel" 22 | #define PROPERTY_RADIALACCEL "radialAccel" 23 | #define PROPERTY_TEXTURE "texture" 24 | #define PROPERTY_STARTRADIUS "startRadius" 25 | #define PROPERTY_ENDRADIUS "endRadius" 26 | #define PROPERTY_ROTATEPERSECOND "rotatePerSecond" 27 | 28 | namespace spritebuilder { 29 | 30 | void ParticleSystemQuadLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char * pPropertyName, int pIntegerLabeled, CCBReader * ccbReader) { 31 | if(strcmp(pPropertyName, PROPERTY_EMITERMODE) == 0) { 32 | ((ParticleSystemQuad *)pNode)->setEmitterMode((ParticleSystem::Mode)pIntegerLabeled); 33 | } else { 34 | NodeLoader::onHandlePropTypeIntegerLabeled(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader); 35 | } 36 | } 37 | 38 | void ParticleSystemQuadLoader::onHandlePropTypePoint(Node * pNode, Node * pParent, const char * pPropertyName, Point pPoint, CCBReader * ccbReader) { 39 | if(strcmp(pPropertyName, PROPERTY_POSVAR) == 0) { 40 | ((ParticleSystemQuad *)pNode)->setPosVar(pPoint); 41 | } else if(strcmp(pPropertyName, PROPERTY_GRAVITY) == 0) { 42 | ((ParticleSystemQuad *)pNode)->setGravity(pPoint); 43 | } else { 44 | NodeLoader::onHandlePropTypePoint(pNode, pParent, pPropertyName, pPoint, ccbReader); 45 | } 46 | } 47 | 48 | void ParticleSystemQuadLoader::onHandlePropTypeFloat(Node * pNode, Node * pParent, const char * pPropertyName, float pFloat, CCBReader * ccbReader) { 49 | if(strcmp(pPropertyName, PROPERTY_EMISSIONRATE) == 0) { 50 | ((ParticleSystemQuad *)pNode)->setEmissionRate(pFloat); 51 | } else if(strcmp(pPropertyName, PROPERTY_DURATION) == 0) { 52 | ((ParticleSystemQuad *)pNode)->setDuration(pFloat); 53 | } else { 54 | NodeLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader); 55 | } 56 | } 57 | 58 | void ParticleSystemQuadLoader::onHandlePropTypeInteger(Node * pNode, Node * pParent, const char * pPropertyName, int pInteger, CCBReader * ccbReader) { 59 | if(strcmp(pPropertyName, PROPERTY_TOTALPARTICLES) == 0) { 60 | ((ParticleSystemQuad *)pNode)->setTotalParticles(pInteger); 61 | } else { 62 | NodeLoader::onHandlePropTypeInteger(pNode, pParent, pPropertyName, pInteger, ccbReader); 63 | } 64 | } 65 | 66 | void ParticleSystemQuadLoader::onHandlePropTypeFloatVar(Node * pNode, Node * pParent, const char * pPropertyName, float * pFloatVar, CCBReader * ccbReader) { 67 | if(strcmp(pPropertyName, PROPERTY_LIFE) == 0) { 68 | ((ParticleSystemQuad *)pNode)->setLife(pFloatVar[0]); 69 | ((ParticleSystemQuad *)pNode)->setLifeVar(pFloatVar[1]); 70 | } else if(strcmp(pPropertyName, PROPERTY_STARTSIZE) == 0) { 71 | ((ParticleSystemQuad *)pNode)->setStartSize(pFloatVar[0]); 72 | ((ParticleSystemQuad *)pNode)->setStartSizeVar(pFloatVar[1]); 73 | } else if(strcmp(pPropertyName, PROPERTY_ENDSIZE) == 0) { 74 | ((ParticleSystemQuad *)pNode)->setEndSize(pFloatVar[0]); 75 | ((ParticleSystemQuad *)pNode)->setEndSizeVar(pFloatVar[1]); 76 | } else if(strcmp(pPropertyName, PROPERTY_STARTSPIN) == 0) { 77 | ((ParticleSystemQuad *)pNode)->setStartSpin(pFloatVar[0]); 78 | ((ParticleSystemQuad *)pNode)->setStartSpinVar(pFloatVar[1]); 79 | } else if(strcmp(pPropertyName, PROPERTY_ENDSPIN) == 0) { 80 | ((ParticleSystemQuad *)pNode)->setEndSpin(pFloatVar[0]); 81 | ((ParticleSystemQuad *)pNode)->setEndSpinVar(pFloatVar[1]); 82 | } else if(strcmp(pPropertyName, PROPERTY_ANGLE) == 0) { 83 | ((ParticleSystemQuad *)pNode)->setAngle(pFloatVar[0]); 84 | ((ParticleSystemQuad *)pNode)->setAngleVar(pFloatVar[1]); 85 | } else if(strcmp(pPropertyName, PROPERTY_SPEED) == 0) { 86 | ((ParticleSystemQuad *)pNode)->setSpeed(pFloatVar[0]); 87 | ((ParticleSystemQuad *)pNode)->setSpeedVar(pFloatVar[1]); 88 | } else if(strcmp(pPropertyName, PROPERTY_TANGENTIALACCEL) == 0) { 89 | ((ParticleSystemQuad *)pNode)->setTangentialAccel(pFloatVar[0]); 90 | ((ParticleSystemQuad *)pNode)->setTangentialAccelVar(pFloatVar[1]); 91 | } else if(strcmp(pPropertyName, PROPERTY_RADIALACCEL) == 0) { 92 | ((ParticleSystemQuad *)pNode)->setRadialAccel(pFloatVar[0]); 93 | ((ParticleSystemQuad *)pNode)->setRadialAccelVar(pFloatVar[1]); 94 | } else if(strcmp(pPropertyName, PROPERTY_STARTRADIUS) == 0) { 95 | ((ParticleSystemQuad *)pNode)->setStartRadius(pFloatVar[0]); 96 | ((ParticleSystemQuad *)pNode)->setStartRadiusVar(pFloatVar[1]); 97 | } else if(strcmp(pPropertyName, PROPERTY_ENDRADIUS) == 0) { 98 | ((ParticleSystemQuad *)pNode)->setEndRadius(pFloatVar[0]); 99 | ((ParticleSystemQuad *)pNode)->setEndRadiusVar(pFloatVar[1]); 100 | } else if(strcmp(pPropertyName, PROPERTY_ROTATEPERSECOND) == 0) { 101 | ((ParticleSystemQuad *)pNode)->setRotatePerSecond(pFloatVar[0]); 102 | ((ParticleSystemQuad *)pNode)->setRotatePerSecondVar(pFloatVar[1]); 103 | } else { 104 | NodeLoader::onHandlePropTypeFloatVar(pNode, pParent, pPropertyName, pFloatVar, ccbReader); 105 | } 106 | } 107 | 108 | void ParticleSystemQuadLoader::onHandlePropTypeColor4FVar(Node * pNode, Node * pParent, const char * pPropertyName, Color4F * pColor4FVar, CCBReader * ccbReader) { 109 | if(strcmp(pPropertyName, PROPERTY_STARTCOLOR) == 0) { 110 | ((ParticleSystemQuad *)pNode)->setStartColor(pColor4FVar[0]); 111 | ((ParticleSystemQuad *)pNode)->setStartColorVar(pColor4FVar[1]); 112 | } else if(strcmp(pPropertyName, PROPERTY_ENDCOLOR) == 0) { 113 | ((ParticleSystemQuad *)pNode)->setEndColor(pColor4FVar[0]); 114 | ((ParticleSystemQuad *)pNode)->setEndColorVar(pColor4FVar[1]); 115 | } else { 116 | NodeLoader::onHandlePropTypeColor4FVar(pNode, pParent, pPropertyName, pColor4FVar, ccbReader); 117 | } 118 | } 119 | 120 | void ParticleSystemQuadLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, CCBReader * ccbReader) { 121 | if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) { 122 | ((ParticleSystemQuad *)pNode)->setBlendFunc(pBlendFunc); 123 | } else { 124 | NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader); 125 | } 126 | } 127 | 128 | void ParticleSystemQuadLoader::onHandlePropTypeTexture(Node * pNode, Node * pParent, const char * pPropertyName, Texture2D * pTexture2D, CCBReader * ccbReader) { 129 | if(strcmp(pPropertyName, PROPERTY_TEXTURE) == 0) { 130 | 131 | if (_textureRect.size.width == 0 || _textureRect.size.height == 0) 132 | static_cast(pNode)->setTexture(pTexture2D); 133 | else 134 | static_cast(pNode)->setTextureWithRect(pTexture2D, _textureRect); 135 | 136 | if(pTexture2D) 137 | { 138 | static_cast(pNode)->setBlendAdditive(true); 139 | } 140 | } else { 141 | NodeLoader::onHandlePropTypeTexture(pNode, pParent, pPropertyName, pTexture2D, ccbReader); 142 | } 143 | } 144 | 145 | Texture2D * ParticleSystemQuadLoader::parsePropTypeTexture(Node * pNode, Node * pParent, CCBReader * ccbReader) { 146 | 147 | std::string spriteFile = ccbReader->readCachedString(); 148 | memset(&_textureRect, 0, sizeof(_textureRect)); 149 | 150 | if (spriteFile.length() > 0) 151 | { 152 | Texture2D* texture = Director::getInstance()->getTextureCache()->addImage(ccbReader->getCCBRootPath() + spriteFile.c_str()); 153 | if (texture == NULL) { 154 | 155 | SpriteFrame* spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName(spriteFile); 156 | texture = spriteFrame->getTexture(); 157 | _textureRect.origin = spriteFrame->getOffsetInPixels(); 158 | _textureRect.size = spriteFrame->getOriginalSizeInPixels(); 159 | } 160 | 161 | return texture; 162 | } 163 | else 164 | { 165 | return NULL; 166 | } 167 | } 168 | 169 | } -------------------------------------------------------------------------------- /spritebuilder/CCBAnimationManager.h: -------------------------------------------------------------------------------- 1 | #ifndef __CCB_CCBANIMATION_MANAGER_H__ 2 | #define __CCB_CCBANIMATION_MANAGER_H__ 3 | 4 | #include "CCMap.h" 5 | #include "CCActionInterval.h" 6 | #include "CCActionInstant.h" 7 | #include "CCActionEase.h" 8 | 9 | #include "extensions/ExtensionMacros.h" 10 | #include "CCBSequence.h" 11 | #include "CCBSequenceProperty.h" 12 | #include "extensions/GUI/CCControlExtension/CCControl.h" 13 | 14 | namespace spritebuilder { 15 | 16 | class CCBAnimationManagerDelegate 17 | { 18 | public: 19 | virtual ~CCBAnimationManagerDelegate() {} 20 | virtual void completedAnimationSequenceNamed(const char *name) = 0; 21 | }; 22 | 23 | class CCBAnimationManager : public cocos2d::Ref 24 | { 25 | public: 26 | bool _jsControlled; 27 | /** 28 | * @js ctor 29 | */ 30 | CCBAnimationManager(); 31 | /** 32 | * @js NA 33 | * @lua NA 34 | */ 35 | ~CCBAnimationManager(); 36 | 37 | 38 | cocos2d::Ref *_owner; 39 | 40 | virtual bool init(); 41 | 42 | cocos2d::Vector& getSequences(); 43 | void setSequences(const cocos2d::Vector& seq); 44 | 45 | 46 | int getAutoPlaySequenceId(); 47 | void setAutoPlaySequenceId(int autoPlaySequenceId); 48 | 49 | cocos2d::Node* getRootNode(); 50 | void setRootNode(cocos2d::Node* pRootNode); // weak reference 51 | 52 | 53 | void addDocumentCallbackNode(cocos2d::Node *node); 54 | void addDocumentCallbackName(std::string name); 55 | void addDocumentCallbackControlEvents(cocos2d::extension::Control::EventType eventType); 56 | 57 | void addDocumentOutletNode(cocos2d::Node *node); 58 | void addDocumentOutletName(std::string name); 59 | 60 | void setDocumentControllerName(const std::string &name); 61 | 62 | std::string getDocumentControllerName(); 63 | cocos2d::ValueVector& getDocumentCallbackNames(); 64 | cocos2d::Vector& getDocumentCallbackNodes(); 65 | cocos2d::ValueVector& getDocumentCallbackControlEvents(); 66 | 67 | cocos2d::ValueVector& getDocumentOutletNames(); 68 | cocos2d::Vector& getDocumentOutletNodes(); 69 | std::string getLastCompletedSequenceName(); 70 | 71 | cocos2d::ValueVector& getKeyframeCallbacks(); 72 | 73 | const cocos2d::Size& getRootContainerSize(); 74 | void setRootContainerSize(const cocos2d::Size &rootContainerSize); 75 | 76 | CCBAnimationManagerDelegate* getDelegate(); 77 | void setDelegate(CCBAnimationManagerDelegate* pDelegate); // retain 78 | 79 | const char* getRunningSequenceName(); 80 | 81 | const cocos2d::Size& getContainerSize(cocos2d::Node* pNode); 82 | 83 | void addNode(cocos2d::Node *pNode, const std::unordered_map>& seq); 84 | void setBaseValue(const cocos2d::Value& value, cocos2d::Node *pNode, const std::string& propName); 85 | void setObject(cocos2d::Ref* obj, cocos2d::Node *pNode, const std::string& propName); 86 | 87 | void moveAnimationsFromNode(cocos2d::Node* fromNode, cocos2d::Node* toNode); 88 | 89 | /** @deprecated This interface will be deprecated sooner or later.*/ 90 | CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName, float fTweenDuration); 91 | /** @deprecated This interface will be deprecated sooner or later.*/ 92 | CC_DEPRECATED_ATTRIBUTE void runAnimations(const char *pName); 93 | /** @deprecated This interface will be deprecated sooner or later.*/ 94 | CC_DEPRECATED_ATTRIBUTE void runAnimations(int nSeqId, float fTweenDuraiton); 95 | 96 | void runAnimationsForSequenceNamedTweenDuration(const char *pName, float fTweenDuration); 97 | void runAnimationsForSequenceNamed(const char *pName); 98 | void runAnimationsForSequenceIdTweenDuration(int nSeqId, float fTweenDuraiton); 99 | /** 100 | * when this function bound to js ,the second param are callfunc_selector 101 | * @lua NA 102 | */ 103 | void setAnimationCompletedCallback(cocos2d::Ref *target, cocos2d::SEL_CallFunc callbackFunc); 104 | 105 | void debug(); 106 | /** 107 | * @js setCallFuncForJSCallbackNamed 108 | */ 109 | void setCallFunc(cocos2d::CallFunc *callFunc, const std::string &callbackNamed); 110 | 111 | cocos2d::Sequence* actionForCallbackChannel(CCBSequenceProperty* channel); 112 | cocos2d::Sequence* actionForSoundChannel(CCBSequenceProperty* channel); 113 | 114 | // return -1 if timeline not exsit 115 | int getSequenceId(const char* pSequenceName); 116 | 117 | // get timeline duration 118 | float getSequenceDuration(const char* pSequenceName); 119 | 120 | private: 121 | const cocos2d::Value& getBaseValue(cocos2d::Node *pNode, const std::string& propName); 122 | Ref* getObject(cocos2d::Node *pNode, const std::string& propName); 123 | 124 | CCBSequence* getSequence(int nSequenceId); 125 | cocos2d::ActionInterval* getAction(CCBKeyframe *pKeyframe0, CCBKeyframe *pKeyframe1, const std::string& propName, cocos2d::Node *pNode); 126 | void setAnimatedProperty(const std::string& propName,cocos2d::Node *pNode, const cocos2d::Value& value, Ref* obj, float fTweenDuraion); 127 | void setFirstFrame(cocos2d::Node *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration); 128 | cocos2d::ActionInterval* getEaseAction(cocos2d::ActionInterval *pAction, CCBKeyframe::EasingType easingType, float fEasingOpt); 129 | void runAction(cocos2d::Node *pNode, CCBSequenceProperty *pSeqProp, float fTweenDuration); 130 | void sequenceCompleted(); 131 | 132 | private: 133 | cocos2d::Vector _sequences; 134 | std::unordered_map>> _nodeSequences; 135 | std::unordered_map> _baseValues; 136 | std::unordered_map> _objects; 137 | 138 | int _autoPlaySequenceId; 139 | 140 | cocos2d::Node *_rootNode; 141 | 142 | cocos2d::Size _rootContainerSize; 143 | 144 | CCBAnimationManagerDelegate *_delegate; 145 | CCBSequence *_runningSequence; 146 | 147 | cocos2d::ValueVector _documentOutletNames; 148 | cocos2d::Vector _documentOutletNodes; 149 | cocos2d::ValueVector _documentCallbackNames; 150 | cocos2d::Vector _documentCallbackNodes; 151 | cocos2d::ValueVector _documentCallbackControlEvents; 152 | cocos2d::ValueVector _keyframeCallbacks; 153 | cocos2d::Map _keyframeCallFuncs; 154 | 155 | std::string _documentControllerName; 156 | std::string _lastCompletedSequenceName; 157 | 158 | cocos2d::SEL_CallFunc _animationCompleteCallbackFunc; 159 | cocos2d::Ref *_target; 160 | 161 | }; 162 | 163 | class CCBSetSpriteFrame : public cocos2d::ActionInstant 164 | { 165 | public: 166 | /** creates a Place action with a position */ 167 | static CCBSetSpriteFrame* create(cocos2d::SpriteFrame *pSpriteFrame); 168 | /** 169 | * @js NA 170 | * @lua NA 171 | */ 172 | ~CCBSetSpriteFrame(); 173 | 174 | bool initWithSpriteFrame(cocos2d::SpriteFrame *pSpriteFrame); 175 | 176 | // Overrides 177 | virtual void update(float time) override; 178 | virtual CCBSetSpriteFrame* clone() const override; 179 | virtual CCBSetSpriteFrame* reverse() const override; 180 | 181 | private: 182 | cocos2d::SpriteFrame *_spriteFrame; 183 | }; 184 | 185 | 186 | class CCBSoundEffect : public cocos2d::ActionInstant 187 | { 188 | public: 189 | static CCBSoundEffect* actionWithSoundFile(const std::string &file, float pitch, float pan, float gain); 190 | /** 191 | * @js NA 192 | * @lua NA 193 | */ 194 | ~CCBSoundEffect(); 195 | bool initWithSoundFile(const std::string &file, float pitch, float pan, float gain); 196 | 197 | // Overrides 198 | virtual void update(float time) override; 199 | virtual CCBSoundEffect* clone() const override; 200 | virtual CCBSoundEffect* reverse() const override; 201 | 202 | private: 203 | std::string _soundFile; 204 | float _pitch, _pan, _gain; 205 | }; 206 | 207 | 208 | class CCBRotateTo : public cocos2d::ActionInterval 209 | { 210 | public: 211 | static CCBRotateTo* create(float fDuration, float fAngle); 212 | bool initWithDuration(float fDuration, float fAngle); 213 | 214 | // Override 215 | virtual void update(float time) override; 216 | virtual CCBRotateTo* clone() const override; 217 | virtual CCBRotateTo* reverse() const override; 218 | virtual void startWithTarget(cocos2d::Node *pNode) override; 219 | 220 | private: 221 | float _startAngle; 222 | float _dstAngle; 223 | float _diffAngle; 224 | }; 225 | 226 | 227 | class CCBRotateXTo: public cocos2d::ActionInterval 228 | { 229 | public: 230 | static CCBRotateXTo* create(float fDuration, float fAngle); 231 | bool initWithDuration(float fDuration, float fAngle); 232 | 233 | // Overrides 234 | virtual void startWithTarget(cocos2d::Node *pNode) override; 235 | virtual CCBRotateXTo* clone() const override; 236 | virtual CCBRotateXTo* reverse() const override; 237 | virtual void update(float time) override; 238 | 239 | private: 240 | float _startAngle; 241 | float _dstAngle; 242 | float _diffAngle; 243 | }; 244 | 245 | 246 | class CCBRotateYTo: public cocos2d::ActionInterval 247 | { 248 | public: 249 | static CCBRotateYTo* create(float fDuration, float fAngle); 250 | bool initWithDuration(float fDuration, float fAngle); 251 | 252 | // Override 253 | virtual void startWithTarget(cocos2d::Node *pNode) override; 254 | virtual CCBRotateYTo* clone() const override; 255 | virtual CCBRotateYTo* reverse() const override; 256 | virtual void update(float time) override; 257 | 258 | private: 259 | float _startAngle; 260 | float _dstAngle; 261 | float _diffAngle; 262 | }; 263 | 264 | 265 | class CCBEaseInstant : public cocos2d::ActionEase 266 | { 267 | public: 268 | static CCBEaseInstant* create(cocos2d::ActionInterval *pAction); 269 | 270 | virtual CCBEaseInstant* clone() const override; 271 | virtual CCBEaseInstant* reverse() const override; 272 | virtual void update(float dt) override; 273 | }; 274 | 275 | 276 | } 277 | 278 | #endif // __CCB_CCBANIMATION_MANAGER_H__ 279 | -------------------------------------------------------------------------------- /spritebuilder/CCBPhysicsJoints.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #ifndef __cocos2d_libs__CCBPhysicsJoints__ 25 | #define __cocos2d_libs__CCBPhysicsJoints__ 26 | 27 | #include 28 | #include "chipmunk.h" 29 | #include "CCPhysicsHelper_chipmunk.h" 30 | #include "CCPhysicsJointInfo_chipmunk.h" 31 | #include "CCPhysicsBodyInfo_chipmunk.h" 32 | #include "CCBPhysicsBody.h" 33 | 34 | namespace spritebuilder { 35 | 36 | //because _info field is a protected field in PhysicsJoint class 37 | class HackPhysicsJoint : public cocos2d::PhysicsJoint { 38 | public: 39 | cocos2d::PhysicsJointInfo* getPhysicsJointInfo() { 40 | return _info; 41 | } 42 | 43 | }; 44 | 45 | class ExternalJointsInfo { 46 | public: 47 | virtual ~ExternalJointsInfo() {} 48 | virtual float getBreakingForce() {return m_nBreakingForce;} 49 | virtual void setBreakingForce(float breakingForce) {m_nBreakingForce = breakingForce;} 50 | protected: 51 | float m_nBreakingForce; 52 | }; 53 | 54 | class CCBPhysicsJointMotor : public cocos2d::PhysicsJointMotor, public virtual ExternalJointsInfo { 55 | public: 56 | static CCBPhysicsJointMotor* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, float rate) { 57 | CCBPhysicsJointMotor* joint = new CCBPhysicsJointMotor(); 58 | 59 | if (joint && joint->init(a, b, rate)) 60 | { 61 | return joint; 62 | } 63 | 64 | CC_SAFE_DELETE(joint); 65 | return nullptr; 66 | } 67 | }; 68 | 69 | class CCBPhysicsJointRotarySpring : public cocos2d::PhysicsJointRotarySpring, public virtual ExternalJointsInfo { 70 | public: 71 | static CCBPhysicsJointRotarySpring* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, float stiffness, float damping) { 72 | CCBPhysicsJointRotarySpring* joint = new CCBPhysicsJointRotarySpring(); 73 | 74 | if (joint && joint->init(a, b, stiffness, damping)) 75 | { 76 | return joint; 77 | } 78 | 79 | CC_SAFE_DELETE(joint); 80 | return nullptr; 81 | } 82 | 83 | }; 84 | 85 | class CCBPhysicsJointRotaryLimit : public cocos2d::PhysicsJointRotaryLimit, public virtual ExternalJointsInfo { 86 | public: 87 | static CCBPhysicsJointRotaryLimit* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, float min, float max) { 88 | CCBPhysicsJointRotaryLimit* joint = new CCBPhysicsJointRotaryLimit(); 89 | 90 | if (joint && joint->init(a, b, min, max)) 91 | { 92 | return joint; 93 | } 94 | 95 | CC_SAFE_DELETE(joint); 96 | return nullptr; 97 | 98 | } 99 | static CCBPhysicsJointRotaryLimit* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b) { 100 | return construct(a, b, 0.0f, 0.0f); 101 | } 102 | }; 103 | 104 | class CCBPhysicsJointSpring : public cocos2d::PhysicsJointSpring, public virtual ExternalJointsInfo { 105 | public: 106 | static CCBPhysicsJointSpring* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2, float stiffness, float damping) { 107 | 108 | CCBPhysicsJointSpring* joint = new CCBPhysicsJointSpring(); 109 | 110 | if (joint && joint->init(a, b, anchr1, anchr2, stiffness, damping)) 111 | { 112 | return joint; 113 | } 114 | 115 | CC_SAFE_DELETE(joint); 116 | return nullptr; 117 | 118 | } 119 | }; 120 | 121 | class CCBPhysicsJointRatchet : public cocos2d::PhysicsJointRatchet, public virtual ExternalJointsInfo { 122 | public: 123 | static CCBPhysicsJointRatchet* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, float phase, float ratchet) { 124 | CCBPhysicsJointRatchet* joint = new CCBPhysicsJointRatchet(); 125 | 126 | if (joint && joint->init(a, b, phase, ratchet)) 127 | { 128 | return joint; 129 | } 130 | 131 | CC_SAFE_DELETE(joint); 132 | return nullptr; 133 | } 134 | }; 135 | 136 | class CCBPhysicsJointLimit : public cocos2d::PhysicsJointLimit, public virtual ExternalJointsInfo { 137 | public: 138 | static CCBPhysicsJointLimit* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2) { 139 | return construct(a, b, anchr1, anchr2, 0, b->local2World(anchr1).getDistance(a->local2World(anchr2))); 140 | } 141 | static CCBPhysicsJointLimit* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2, float min, float max) { 142 | CCBPhysicsJointLimit* joint = new CCBPhysicsJointLimit(); 143 | 144 | if (joint && joint->init(a, b, anchr1, anchr2, min, max)) 145 | { 146 | return joint; 147 | } 148 | 149 | CC_SAFE_DELETE(joint); 150 | return nullptr; 151 | } 152 | }; 153 | 154 | class CCBPhysicsJointDistance : public cocos2d::PhysicsJointDistance, public virtual ExternalJointsInfo { 155 | public: 156 | static CCBPhysicsJointDistance* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2, float min, float max) { 157 | CCBPhysicsJointDistance* joint = new CCBPhysicsJointDistance(); 158 | 159 | if (joint && joint->init(a, b, anchr1, anchr2, min, max)) 160 | { 161 | return joint; 162 | } 163 | 164 | CC_SAFE_DELETE(joint); 165 | return nullptr; 166 | } 167 | static CCBPhysicsJointDistance* construct(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2) { 168 | CCBPhysicsJointDistance* joint = new CCBPhysicsJointDistance(); 169 | 170 | if (joint && joint->init(a, b, anchr1, anchr2)) 171 | { 172 | return joint; 173 | } 174 | 175 | CC_SAFE_DELETE(joint); 176 | return nullptr; 177 | } 178 | /* 179 | float getDistance() const { 180 | if (m_bHasMinMax) { 181 | 182 | } else 183 | return cocos2d::PhysicsJointDistance::getDistance(); 184 | } 185 | void setDistance(float distance) { 186 | if (m_bHasMinMax) { 187 | 188 | } else 189 | return cocos2d::PhysicsJointDistance::setDistance(distance); 190 | }*/ 191 | protected: 192 | bool init(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2) 193 | { 194 | do 195 | { 196 | CC_BREAK_IF(!PhysicsJoint::init(a, b)); 197 | 198 | cpConstraint* joint = cpPinJointNew(getBodyInfo(a)->getBody(), 199 | getBodyInfo(b)->getBody(), 200 | cocos2d::PhysicsHelper::point2cpv(anchr1), 201 | cocos2d::PhysicsHelper::point2cpv(anchr2)); 202 | 203 | CC_BREAK_IF(joint == nullptr); 204 | 205 | _info->add(joint); 206 | m_bHasMinMax = false; 207 | return true; 208 | } while (false); 209 | 210 | return false; 211 | } 212 | bool init(cocos2d::PhysicsBody* a, cocos2d::PhysicsBody* b, const cocos2d::Point& anchr1, const cocos2d::Point& anchr2, float min, float max) { 213 | do 214 | { 215 | CC_BREAK_IF(!PhysicsJoint::init(a, b)); 216 | 217 | 218 | cpConstraint* joint = cpSlideJointNew(getBodyInfo(a)->getBody(), 219 | getBodyInfo(b)->getBody(), 220 | cocos2d::PhysicsHelper::point2cpv(anchr1), 221 | cocos2d::PhysicsHelper::point2cpv(anchr2), 222 | min, 223 | max 224 | ); 225 | 226 | 227 | CC_BREAK_IF(joint == nullptr); 228 | 229 | _info->add(joint); 230 | m_bHasMinMax = true; 231 | return true; 232 | } while (false); 233 | 234 | return false; 235 | 236 | } 237 | protected: 238 | bool m_bHasMinMax; 239 | }; 240 | } 241 | 242 | #endif /* defined(__cocos2d_libs__CCBPhysicsJoints__) */ 243 | -------------------------------------------------------------------------------- /spritebuilder/CCNodeLoader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCNODELOADER_H_ 2 | #define _CCB_CCNODELOADER_H_ 3 | 4 | #include "extensions/GUI/CCControlExtension/CCInvocation.h" 5 | #include "CCBReader.h" 6 | #include "extensions/GUI/CCControlExtension/CCControl.h" 7 | #include "cocos2d.h" 8 | 9 | namespace spritebuilder { 10 | 11 | #define PROPERTY_POSITION "position" 12 | #define PROPERTY_CONTENTSIZE "contentSize" 13 | #define PROPERTY_SKEW "skew" 14 | #define PROPERTY_ANCHORPOINT "anchorPoint" 15 | #define PROPERTY_SCALE "scale" 16 | #define PROPERTY_ROTATION "rotation" 17 | #define PROPERTY_ROTATIONX "rotationX" 18 | #define PROPERTY_ROTATIONY "rotationY" 19 | #define PROPERTY_TAG "tag" 20 | #define PROPERTY_IGNOREANCHORPOINTFORPOSITION "ignoreAnchorPointForPosition" 21 | #define PROPERTY_VISIBLE "visible" 22 | 23 | #define ASSERT_FAIL_UNEXPECTED_PROPERTY(PROPERTY) cocos2d::log("Unexpected property: '%s'!\n", PROPERTY); assert(false) 24 | #define ASSERT_FAIL_UNEXPECTED_PROPERTYTYPE(PROPERTYTYPE) cocos2d::log("Unexpected property type: '%d'!\n", PROPERTYTYPE); assert(false) 25 | 26 | #define SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(T) virtual T * createNode(cocos2d::Node * pParent, spritebuilder::CCBReader * ccbReader) { \ 27 | return T::create(); \ 28 | } 29 | 30 | #define SB_PURE_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(T) virtual T * createNode(cocos2d::Node * pParent, spritebuilder::CCBReader * ccbReader) = 0 31 | 32 | #define COLOR4F_TO_COLOR4B(X) (Color4B(X.r * 255, X.g * 255, X.b * 255, X.a * 255)) 33 | #define COLOR4F_TO_COLOR3B(X) (Color3B(X.r * 255, X.g * 255, X.b * 255)) 34 | struct BlockData { 35 | cocos2d::SEL_MenuHandler mSELMenuHandler; 36 | cocos2d::Ref * _target; 37 | }; 38 | 39 | struct BlockControlData { 40 | cocos2d::extension::Control::Handler mSELControlHandler; 41 | cocos2d::Ref * _target; 42 | cocos2d::extension::Control::EventType mControlEvents; 43 | }; 44 | 45 | /* Forward declaration. */ 46 | class CCBReader; 47 | 48 | class NodeLoader : public cocos2d::Ref { 49 | public: 50 | /** 51 | * @js NA 52 | * @lua NA 53 | */ 54 | NodeLoader(); 55 | /** 56 | * @js NA 57 | * @lua NA 58 | */ 59 | virtual ~NodeLoader(); 60 | /** 61 | * @js NA 62 | * @lua NA 63 | */ 64 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(NodeLoader, loader); 65 | /** 66 | * @js NA 67 | * @lua NA 68 | */ 69 | virtual cocos2d::Node * loadNode(cocos2d::Node *, CCBReader * ccbReader); 70 | /** 71 | * @js NA 72 | * @lua NA 73 | */ 74 | virtual void parseProperties(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 75 | /** 76 | * @js NA 77 | * @lua NA 78 | */ 79 | virtual cocos2d::ValueMap& getCustomProperties(); 80 | 81 | protected: 82 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(cocos2d::Node); 83 | 84 | virtual cocos2d::Point parsePropTypePosition(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 85 | virtual cocos2d::Point parsePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 86 | virtual cocos2d::Point parsePropTypePointLock(cocos2d::Node * pNode,cocos2d:: Node * pParent, CCBReader * ccbReader); 87 | virtual cocos2d::Size parsePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 88 | virtual float * parsePropTypeScaleLock(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 89 | virtual float parsePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 90 | virtual float parsePropTypeDegrees(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 91 | virtual float parsePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 92 | virtual int parsePropTypeInteger(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 93 | virtual int parsePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 94 | virtual float * parsePropTypeFloatVar(cocos2d::Node * pNode,cocos2d::Node * pParent, CCBReader * ccbReader); 95 | virtual bool parsePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 96 | virtual cocos2d::SpriteFrame * parsePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 97 | virtual cocos2d::Animation * parsePropTypeAnimation(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 98 | virtual cocos2d::Texture2D * parsePropTypeTexture(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 99 | virtual unsigned char parsePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 100 | virtual cocos2d::Color3B parsePropTypeColor3(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 101 | virtual cocos2d::Color4F parsePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader, const char *pPropertyName); 102 | virtual cocos2d::Color4F * parsePropTypeColor4FVar(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 103 | virtual bool * parsePropTypeFlip(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 104 | virtual cocos2d::BlendFunc parsePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 105 | virtual std::string parsePropTypeFntFile(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 106 | virtual std::string parsePropTypeString(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 107 | virtual std::string parsePropTypeText(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 108 | virtual std::string parsePropTypeFontTTF(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 109 | virtual BlockData * parsePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 110 | virtual BlockControlData * parsePropTypeBlockControl(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 111 | virtual cocos2d::Node * parsePropTypeCCBFile(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 112 | virtual float * parsePropTypeFloatXY(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 113 | 114 | 115 | virtual void onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader); 116 | virtual void onHandlePropTypePoint(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Point pPoint, CCBReader * ccbReader); 117 | virtual void onHandlePropTypePointLock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Point pPointLock, CCBReader * ccbReader); 118 | virtual void onHandlePropTypeSize(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Size pSize, CCBReader * ccbReader); 119 | virtual void onHandlePropTypeScaleLock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pScaleLock, CCBReader * ccbReader); 120 | virtual void onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloat, CCBReader * ccbReader); 121 | virtual void onHandlePropTypeDegrees(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pDegrees, CCBReader * ccbReader); 122 | virtual void onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloatScale, CCBReader * ccbReader); 123 | virtual void onHandlePropTypeInteger(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pInteger, CCBReader * ccbReader); 124 | virtual void onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pIntegerLabeled, CCBReader * ccbReader); 125 | virtual void onHandlePropTypeFloatVar(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pFoatVar, CCBReader * ccbReader); 126 | virtual void onHandlePropTypeFloatXY(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pFoatVar, CCBReader * ccbReader); 127 | 128 | virtual void onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool pCheck, CCBReader * ccbReader); 129 | virtual void onHandlePropTypeSpriteFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::SpriteFrame * pSpriteFrame, CCBReader * ccbReader); 130 | virtual void onHandlePropTypeAnimation(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Animation * pAnimation, CCBReader * ccbReader); 131 | virtual void onHandlePropTypeTexture(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Texture2D * pTexture2D, CCBReader * ccbReader); 132 | virtual void onHandlePropTypeByte(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, unsigned char pByte, CCBReader * ccbReader); 133 | virtual void onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Color4F pColor3B, CCBReader * ccbReader); 134 | virtual void onHandlePropTypeColor4FVar(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Color4F * pColor4FVar, CCBReader * ccbReader); 135 | virtual void onHandlePropTypeFlip(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool * pFlip, CCBReader * ccbReader); 136 | virtual void onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::BlendFunc pBlendFunc, CCBReader * ccbReader); 137 | virtual void onHandlePropTypeFntFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pFntFile, CCBReader * ccbReader); 138 | virtual void onHandlePropTypeString(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pString, CCBReader * ccbReader); 139 | virtual void onHandlePropTypeText(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pText, CCBReader * ccbReader); 140 | virtual void onHandlePropTypeFontTTF(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pFontTTF, CCBReader * ccbReader); 141 | virtual void onHandlePropTypeBlock(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, BlockData * pBlockData, CCBReader * ccbReader); 142 | virtual void onHandlePropTypeBlockControl(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, BlockControlData * pBlockControlData, CCBReader * ccbReader); 143 | virtual void onHandlePropTypeCCBFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Node * pCCBFileNode, CCBReader * ccbReader); 144 | 145 | virtual void onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader); 146 | protected: 147 | cocos2d::ValueMap _customProperties; 148 | }; 149 | 150 | } 151 | 152 | #endif 153 | -------------------------------------------------------------------------------- /spritebuilder/CCBPhysicsWorld.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright (c) 2014 Nguyen Thai Duong 4 | * 5 | * Permission is hereby granted, free of charge, to any person obtaining a copy 6 | * of this software and associated documentation files (the "Software"), to deal 7 | * in the Software without restriction, including without limitation the rights 8 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | * copies of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be included in 13 | * all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | * THE SOFTWARE. 22 | */ 23 | 24 | #include "CCBPhysicsWorld.h" 25 | #include "CCPhysicsWorldInfo_chipmunk.h" 26 | #include "CCPhysicsShapeInfo_chipmunk.h" 27 | #include "CCBPhysicsBody.h" 28 | #include "CCPhysicsHelper_chipmunk.h" 29 | #include "CCPhysicsJointInfo_chipmunk.h" 30 | #include "CCBReader.h" 31 | 32 | using namespace cocos2d; 33 | namespace spritebuilder { 34 | 35 | 36 | CCBPhysicsWorld* CCBPhysicsWorld::construct(cocos2d::PhysicsNode& scene) 37 | { 38 | CCBPhysicsWorld * world = new CCBPhysicsWorld(); 39 | if(world && world->init(scene)) 40 | { 41 | return world; 42 | } 43 | 44 | CC_SAFE_DELETE(world); 45 | return nullptr; 46 | } 47 | void CCBPhysicsWorld::update(float delta) 48 | { 49 | if (_delayDirty) 50 | { 51 | // the updateJoints must run before the updateBodies. 52 | updateJoints(); 53 | updateBodies(); 54 | _delayDirty = !(_delayAddBodies.size() == 0 && _delayRemoveBodies.size() == 0 && _delayAddJoints.size() == 0 && _delayRemoveJoints.size() == 0); 55 | } 56 | 57 | _updateTime += delta; 58 | if (++_updateRateCount >= _updateRate) 59 | { 60 | _info->step(_updateTime * _speed); 61 | for (auto& body : _bodies) 62 | { 63 | ((CCBPhysicsBody*)body)->update(_updateTime * _speed); 64 | } 65 | _updateRateCount = 0; 66 | _updateTime = 0.0f; 67 | } 68 | 69 | if (_debugDrawMask != DEBUGDRAW_NONE) 70 | { 71 | debugDraw(); 72 | } 73 | } 74 | void CCBPhysicsWorld::debugDraw() { 75 | if (_debugDraw == nullptr) 76 | { 77 | _debugDraw = new CCBPhysicsDebugDraw(*this); 78 | } 79 | PhysicsWorld::debugDraw(); 80 | } 81 | 82 | 83 | //Nguyen Thai Duong: Cheater classes 84 | 85 | class CCBPhysicsShape : public PhysicsShape { 86 | protected: 87 | inline PhysicsShapeInfo* getShapeInfor() {return _info;}; 88 | friend class CCBPhysicsDebugDraw; 89 | }; 90 | 91 | class CCBPhysicsJoint : public PhysicsJoint { 92 | protected: 93 | inline PhysicsJointInfo* getJointInfor() {return _info;}; 94 | friend class CCBPhysicsDebugDraw; 95 | }; 96 | 97 | 98 | CCBPhysicsDebugDraw::CCBPhysicsDebugDraw(CCBPhysicsWorld& world): PhysicsDebugDraw(world) 99 | { 100 | } 101 | 102 | void CCBPhysicsDebugDraw::drawShape(PhysicsShape& shape) 103 | { 104 | const Color4F fillColor(1.0f, 0.0f, 0.0f, 0.3f); 105 | const Color4F outlineColor(1.0f, 0.0f, 0.0f, 1.0f); 106 | float ptmRatio = CCBReader::getPTMRatio(); 107 | 108 | for (auto it = ((CCBPhysicsShape*)&shape)->getShapeInfor()->getShapes().begin(); it != ((CCBPhysicsShape*)&shape)->getShapeInfor()->getShapes().end(); ++it) 109 | { 110 | cpShape *subShape = *it; 111 | 112 | switch ((*it)->klass_private->type) 113 | { 114 | case CP_CIRCLE_SHAPE: 115 | { 116 | float radius = PhysicsHelper::cpfloat2float(cpCircleShapeGetRadius(subShape)) * ptmRatio; 117 | Point centre = PhysicsHelper::cpv2point(cpBodyGetPos(cpShapeGetBody(subShape))) 118 | + PhysicsHelper::cpv2point(cpCircleShapeGetOffset(subShape)); 119 | 120 | centre = centre * ptmRatio; 121 | 122 | static const int CIRCLE_SEG_NUM = 12; 123 | Point seg[CIRCLE_SEG_NUM] = {}; 124 | 125 | for (int i = 0; i < CIRCLE_SEG_NUM; ++i) 126 | { 127 | float angle = (float)i * M_PI / (float)CIRCLE_SEG_NUM * 2.0f; 128 | Point d(radius * cosf(angle), radius * sinf(angle)); 129 | seg[i] = centre + d; 130 | } 131 | _drawNode->drawPolygon(seg, CIRCLE_SEG_NUM, fillColor, 1, outlineColor); 132 | break; 133 | } 134 | case CP_SEGMENT_SHAPE: 135 | { 136 | cpSegmentShape *seg = (cpSegmentShape *)subShape; 137 | seg->ta.x *= ptmRatio; 138 | seg->ta.y *= ptmRatio; 139 | 140 | seg->tb.x *= ptmRatio; 141 | seg->tb.y *= ptmRatio; 142 | 143 | _drawNode->drawSegment(PhysicsHelper::cpv2point(seg->ta), 144 | PhysicsHelper::cpv2point(seg->tb), 145 | PhysicsHelper::cpfloat2float(seg->r==0 ? 1 : seg->r), outlineColor); 146 | break; 147 | } 148 | case CP_POLY_SHAPE: 149 | { 150 | cpPolyShape* poly = (cpPolyShape*)subShape; 151 | int num = poly->numVerts; 152 | Point* seg = new Point[num]; 153 | 154 | PhysicsHelper::cpvs2points(poly->tVerts, seg, num); 155 | 156 | for (int i = 0; i < num; i++) { 157 | seg[i] = seg[i] * ptmRatio; 158 | } 159 | 160 | _drawNode->drawPolygon(seg, num, fillColor, 1.0f, outlineColor); 161 | 162 | delete[] seg; 163 | break; 164 | } 165 | default: 166 | break; 167 | } 168 | } 169 | } 170 | 171 | void CCBPhysicsDebugDraw::drawJoint(PhysicsJoint& joint) 172 | { 173 | 174 | const Color4F lineColor(0.0f, 0.0f, 1.0f, 1.0f); 175 | const Color4F jointPointColor(0.0f, 1.0f, 0.0f, 1.0f); 176 | 177 | for (auto it = ((CCBPhysicsJoint*)&joint)->getJointInfor()->getJoints().begin(); it != ((CCBPhysicsJoint*)&joint)->getJointInfor()->getJoints().end(); ++it) 178 | { 179 | cpConstraint *constraint = *it; 180 | 181 | 182 | cpBody *body_a = constraint->a; 183 | cpBody *body_b = constraint->b; 184 | 185 | const cpConstraintClass *klass = constraint->klass_private; 186 | if(klass == cpPinJointGetClass()) 187 | { 188 | cpPinJoint *subJoint = (cpPinJoint *)constraint; 189 | 190 | cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot)); 191 | cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot)); 192 | 193 | a.x *= CCBReader::getPTMRatio(); 194 | a.y *= CCBReader::getPTMRatio(); 195 | b.x *= CCBReader::getPTMRatio(); 196 | b.y *= CCBReader::getPTMRatio(); 197 | 198 | _drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor); 199 | _drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor); 200 | _drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor); 201 | } 202 | else if(klass == cpSlideJointGetClass()) 203 | { 204 | cpSlideJoint *subJoint = (cpSlideJoint *)constraint; 205 | 206 | cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot)); 207 | 208 | cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot)); 209 | 210 | a.x *= CCBReader::getPTMRatio(); 211 | a.y *= CCBReader::getPTMRatio(); 212 | b.x *= CCBReader::getPTMRatio(); 213 | b.y *= CCBReader::getPTMRatio(); 214 | 215 | _drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor); 216 | _drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor); 217 | _drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor); 218 | } 219 | else if(klass == cpPivotJointGetClass()) 220 | { 221 | cpPivotJoint *subJoint = (cpPivotJoint *)constraint; 222 | 223 | cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot)); 224 | cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot)); 225 | 226 | 227 | a.x *= CCBReader::getPTMRatio(); 228 | a.y *= CCBReader::getPTMRatio(); 229 | b.x *= CCBReader::getPTMRatio(); 230 | b.y *= CCBReader::getPTMRatio(); 231 | 232 | _drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor); 233 | _drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor); 234 | } 235 | else if(klass == cpGrooveJointGetClass()) 236 | { 237 | cpGrooveJoint *subJoint = (cpGrooveJoint *)constraint; 238 | 239 | cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->grv_a, body_a->rot)); 240 | cpVect b = cpvadd(body_a->p, cpvrotate(subJoint->grv_b, body_a->rot)); 241 | cpVect c = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot)); 242 | 243 | a.x *= CCBReader::getPTMRatio(); 244 | a.y *= CCBReader::getPTMRatio(); 245 | b.x *= CCBReader::getPTMRatio(); 246 | b.y *= CCBReader::getPTMRatio(); 247 | c.x *= CCBReader::getPTMRatio(); 248 | c.y *= CCBReader::getPTMRatio(); 249 | 250 | _drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor); 251 | _drawNode->drawDot(PhysicsHelper::cpv2point(c), 2, jointPointColor); 252 | } 253 | else if(klass == cpDampedSpringGetClass()) 254 | { 255 | cpDampedSpring *subJoint = (cpDampedSpring *)constraint; 256 | 257 | cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot)); 258 | cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot)); 259 | 260 | a.x *= CCBReader::getPTMRatio(); 261 | a.y *= CCBReader::getPTMRatio(); 262 | b.x *= CCBReader::getPTMRatio(); 263 | b.y *= CCBReader::getPTMRatio(); 264 | 265 | _drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor); 266 | _drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor); 267 | _drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor); 268 | } 269 | 270 | } 271 | } 272 | 273 | void CCBPhysicsDebugDraw::drawContact() 274 | { 275 | 276 | } 277 | 278 | 279 | } -------------------------------------------------------------------------------- /spritebuilder/CCBReader.h: -------------------------------------------------------------------------------- 1 | #ifndef _CCB_CCBREADER_H_ 2 | #define _CCB_CCBREADER_H_ 3 | 4 | #include 5 | #include 6 | #include "CCNode.h" 7 | #include "CCData.h" 8 | #include "CCMap.h" 9 | #include "CCBSequence.h" 10 | #include "extensions/GUI/CCControlExtension/CCControl.h" 11 | 12 | #define CREATE_SPRITEBUILDER_LOADER_CLASS(LOADER_CLASS_NAME, UI_CLASS_NAME) \ 13 | class LOADER_CLASS_NAME : public spritebuilder::LayerLoader { \ 14 | public: \ 15 | SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(LOADER_CLASS_NAME, loader); \ 16 | protected: \ 17 | SB_VIRTUAL_NEW_AUTORELEASE_CREATECCNODE_METHOD(UI_CLASS_NAME); \ 18 | }; 19 | 20 | #define SB_STATIC_NEW_AUTORELEASE_OBJECT_METHOD(T, METHOD) static T * METHOD() { \ 21 | T * ptr = new T(); \ 22 | if(ptr != NULL) { \ 23 | ptr->autorelease(); \ 24 | return ptr; \ 25 | } \ 26 | CC_SAFE_DELETE(ptr); \ 27 | return NULL; \ 28 | } 29 | 30 | #define SB_STATIC_NEW_AUTORELEASE_OBJECT_WITH_INIT_METHOD(T, METHOD) static T * METHOD() { \ 31 | T * ptr = new T(); \ 32 | if(ptr != NULL && ptr->init()) { \ 33 | ptr->autorelease(); \ 34 | return ptr; \ 35 | } \ 36 | CC_SAFE_DELETE(ptr); \ 37 | return NULL; \ 38 | } 39 | 40 | #define CCB_VERSION 10 41 | 42 | #define DEFAULT_PTM_RATIO 32.0f 43 | 44 | 45 | namespace spritebuilder { 46 | 47 | /** 48 | * @addtogroup spritebuilder 49 | * @{ 50 | */ 51 | 52 | class CCBFile : public cocos2d::Node 53 | { 54 | private: 55 | cocos2d::Node *_CCBFileNode; 56 | 57 | public: 58 | CCBFile(); 59 | 60 | static CCBFile* create(); 61 | 62 | cocos2d::Node* getCCBFileNode(); 63 | void setCCBFileNode(Node *pNode); // retain 64 | }; 65 | 66 | /* Forward declaration. */ 67 | class NodeLoader; 68 | class NodeLoaderLibrary; 69 | class NodeLoaderListener; 70 | class CCBMemberVariableAssigner; 71 | class CCBSelectorResolver; 72 | class CCBAnimationManager; 73 | class CCBKeyframe; 74 | 75 | 76 | 77 | /** 78 | * @brief Parse CCBI file which is generated by CocosBuilder 79 | */ 80 | class CCBReader : public cocos2d::Ref 81 | { 82 | public: 83 | 84 | enum class PropertyType { 85 | POSITION = 0, 86 | SIZE, 87 | POINT, 88 | POINT_LOCK, 89 | SCALE_LOCK, 90 | DEGREES, 91 | INTEGER, 92 | FLOAT, 93 | FLOAT_VAR, 94 | CHECK, 95 | SPRITEFRAME, 96 | TEXTURE, 97 | BYTE, 98 | COLOR3, 99 | COLOR4F_VAR, 100 | FLIP, 101 | BLEND_MODE, 102 | FNT_FILE, 103 | TEXT, 104 | FONT_TTF, 105 | INTEGER_LABELED, 106 | BLOCK, 107 | ANIMATION, 108 | CCB_FILE, 109 | STRING, 110 | BLOCK_CONTROL, 111 | FLOAT_SCALE, 112 | FLOAT_XY, 113 | COLOR4, 114 | NODE_REFERENCE, 115 | FLOAT_CHECK 116 | }; 117 | enum class FloatType { 118 | _0 = 0, 119 | _1, 120 | MINUS1, 121 | _05, 122 | INTEGER, 123 | FULL 124 | }; 125 | 126 | enum class PlatformType { 127 | ALL = 0, 128 | IOS, 129 | MAC 130 | }; 131 | 132 | enum class TargetType { 133 | NONE = 0, 134 | DOCUMENT_ROOT = 1, 135 | OWNER = 2, 136 | }; 137 | 138 | enum class PositionType 139 | { 140 | RELATIVE_BOTTOM_LEFT, 141 | RELATIVE_TOP_LEFT, 142 | RELATIVE_TOP_RIGHT, 143 | RELATIVE_BOTTOM_RIGHT, 144 | PERCENT, 145 | MULTIPLY_RESOLUTION, 146 | }; 147 | enum class PositionUnit 148 | { 149 | POINTS, 150 | SCALED, 151 | NORMALIZED 152 | }; 153 | 154 | #if CC_TARGET_PLATFORM == CC_PLATFORM_WP8 155 | #ifdef ABSOLUTE 156 | #undef ABSOLUTE 157 | #endif 158 | #endif 159 | enum class SizeType 160 | { 161 | ABSOLUTE, 162 | PERCENT, 163 | RELATIVE_CONTAINER, 164 | HORIZONTAL_PERCENT, 165 | VERTICAL_PERCENT, 166 | MULTIPLY_RESOLUTION, 167 | }; 168 | enum class SizeUnit 169 | { 170 | POINTS, 171 | SCALED, 172 | NORMALIZED, 173 | INSETPOINTS, 174 | INSETSCALED 175 | }; 176 | enum class ScaleType 177 | { 178 | ABSOLUTE, 179 | MULTIPLY_RESOLUTION 180 | }; 181 | 182 | /** 183 | * @js NA 184 | * @lua NA 185 | */ 186 | CCBReader(NodeLoaderLibrary *pNodeLoaderLibrary, CCBMemberVariableAssigner *pCCBMemberVariableAssigner = NULL, CCBSelectorResolver *pCCBSelectorResolver = NULL, NodeLoaderListener *pNodeLoaderListener = NULL); 187 | /** 188 | * @js NA 189 | * @lua NA 190 | */ 191 | CCBReader(CCBReader *ccbReader); 192 | /** 193 | * @js NA 194 | * @lua NA 195 | */ 196 | virtual ~CCBReader(); 197 | /** 198 | * @js NA 199 | * @lua NA 200 | */ 201 | CCBReader(); 202 | 203 | void setCCBRootPath(const char* ccbRootPath); 204 | const std::string& getCCBRootPath() const; 205 | 206 | cocos2d::Node* readNodeGraphFromFile(const char *pCCBFileName); 207 | cocos2d::Node* readNodeGraphFromFile(const char *pCCBFileName, cocos2d::Ref *pOwner); 208 | cocos2d::Node* readNodeGraphFromFile(const char *pCCBFileName, cocos2d::Ref *pOwner, const cocos2d::Size &parentSize); 209 | /** 210 | * @js NA 211 | * @lua NA 212 | */ 213 | cocos2d::Node* readNodeGraphFromData(std::shared_ptr data, cocos2d::Ref *pOwner, const cocos2d::Size &parentSize); 214 | 215 | /** 216 | @lua NA 217 | */ 218 | cocos2d::Scene* createSceneWithNodeGraphFromFile(const char *pCCBFileName); 219 | /** 220 | @lua NA 221 | */ 222 | cocos2d::Scene* createSceneWithNodeGraphFromFile(const char *pCCBFileName, cocos2d::Ref *pOwner); 223 | /** 224 | @lua NA 225 | */ 226 | cocos2d::Scene* createSceneWithNodeGraphFromFile(const char *pCCBFileName, cocos2d::Ref *pOwner, const cocos2d::Size &parentSize); 227 | 228 | /** 229 | * @js NA 230 | * @lua NA 231 | */ 232 | CCBMemberVariableAssigner* getCCBMemberVariableAssigner(); 233 | /** 234 | * @js NA 235 | * @lua NA 236 | */ 237 | CCBSelectorResolver* getCCBSelectorResolver(); 238 | 239 | /** 240 | * @js getActionManager 241 | * @lua getActionManager 242 | */ 243 | CCBAnimationManager* getAnimationManager(); 244 | /** 245 | * @js setActionManager 246 | * @lua setActionManager 247 | */ 248 | void setAnimationManager(CCBAnimationManager *pAnimationManager); 249 | 250 | /** Used in NodeLoader::parseProperties() 251 | * @js NA 252 | * @lua NA 253 | */ 254 | std::set* getAnimatedProperties(); 255 | /** 256 | * @js NA 257 | * @lua NA 258 | */ 259 | std::set& getLoadedSpriteSheet(); 260 | /** 261 | * @js NA 262 | * @lua NA 263 | */ 264 | cocos2d::Ref* getOwner(); 265 | 266 | /* Utility methods. 267 | * @js NA 268 | * @lua NA 269 | */ 270 | static std::string lastPathComponent(const char* pString); 271 | /** 272 | * @js NA 273 | * @lua NA 274 | */ 275 | static std::string deletePathExtension(const char* pString); 276 | /** 277 | * @js NA 278 | * @lua NA 279 | */ 280 | static std::string toLowerCase(const char* pString); 281 | /** 282 | * @js NA 283 | * @lua NA 284 | */ 285 | static bool endsWith(const char* pString, const char* pEnding); 286 | 287 | /* Parse methods. 288 | * @js NA 289 | * @lua NA 290 | */ 291 | int readInt(bool pSigned); 292 | /** 293 | * @js NA 294 | * @lua NA 295 | */ 296 | unsigned char readByte(); 297 | /** 298 | * @js NA 299 | * @lua NA 300 | */ 301 | bool readBool(); 302 | std::string readUTF8(); 303 | /** 304 | * @js NA 305 | * @lua NA 306 | */ 307 | float readFloat(); 308 | /** 309 | * @js NA 310 | * @lua NA 311 | */ 312 | std::string readCachedString(); 313 | /** 314 | * @js NA 315 | * @lua NA 316 | */ 317 | bool isJSControlled(); 318 | 319 | bool readCallbackKeyframesForSeq(CCBSequence* seq); 320 | bool readSoundKeyframesForSeq(CCBSequence* seq); 321 | 322 | cocos2d::ValueVector getOwnerCallbackNames(); 323 | cocos2d::Vector& getOwnerCallbackNodes(); 324 | cocos2d::ValueVector& getOwnerCallbackControlEvents(); 325 | 326 | cocos2d::ValueVector getOwnerOutletNames(); 327 | cocos2d::Vector& getOwnerOutletNodes(); 328 | cocos2d::Vector& getNodesWithAnimationManagers(); 329 | cocos2d::Vector& getAnimationManagersForNodes(); 330 | 331 | typedef cocos2d::Map CCBAnimationManagerMap; 332 | typedef std::shared_ptr CCBAnimationManagerMapPtr; 333 | 334 | /** 335 | * @js NA 336 | * @lua NA 337 | */ 338 | CCBAnimationManagerMapPtr getAnimationManagers(); 339 | /** 340 | * @js NA 341 | * @lua NA 342 | */ 343 | void setAnimationManagers(CCBAnimationManagerMapPtr x); 344 | /** 345 | * @js NA 346 | * @lua NA 347 | */ 348 | void addOwnerCallbackName(const std::string& name); 349 | /** 350 | * @js NA 351 | * @lua NA 352 | */ 353 | void addOwnerCallbackNode(cocos2d::Node *node); 354 | void addOwnerCallbackControlEvents(cocos2d::extension::Control::EventType type); 355 | /** 356 | * @js NA 357 | * @lua NA 358 | */ 359 | void addDocumentCallbackName(const std::string& name); 360 | /** 361 | * @js NA 362 | * @lua NA 363 | */ 364 | void addDocumentCallbackNode(cocos2d::Node *node); 365 | void addDocumentCallbackControlEvents(cocos2d::extension::Control::EventType eventType); 366 | /** 367 | * @js NA 368 | * @lua NA 369 | */ 370 | static float getResolutionScale(); 371 | static void setResolutionScale(float scale); 372 | /** 373 | * @js NA 374 | * @lua NA 375 | */ 376 | cocos2d::Node* readFileWithCleanUp(bool bCleanUp, CCBAnimationManagerMapPtr am); 377 | 378 | void addOwnerOutletName(std::string name); 379 | void addOwnerOutletNode(cocos2d::Node *node); 380 | 381 | static void setupSpriteBuilder(const char* resourcePath, float ptmRatio = DEFAULT_PTM_RATIO); 382 | static float getPTMRatio(); 383 | void setNodeRef(int uuid, cocos2d::Node* node); 384 | cocos2d::Node* getNodeByRef(int uuid); 385 | private: 386 | void cleanUpNodeGraph(cocos2d::Node *pNode); 387 | bool readSequences(); 388 | CCBKeyframe* readKeyframe(PropertyType type); 389 | 390 | bool readHeader(); 391 | bool readStringCache(); 392 | //void readStringCacheEntry(); 393 | cocos2d::Node* readNodeGraph(); 394 | cocos2d::Node* readNodeGraph(cocos2d::Node * pParent); 395 | void readJoints(); 396 | void readJoint(); 397 | void parseProperties(cocos2d::ValueMap& map); 398 | bool getBit(); 399 | void alignBits(); 400 | 401 | bool init(); 402 | int readIntWithSign(bool pSigned); 403 | friend class NodeLoader; 404 | 405 | void readPropertyPosition(const std::string& propertyName, cocos2d::ValueMap& map); 406 | 407 | private: 408 | std::shared_ptr _data; 409 | unsigned char *_bytes; 410 | int _currentByte; 411 | int _currentBit; 412 | 413 | std::vector _stringCache; 414 | std::set _loadedSpriteSheets; 415 | 416 | cocos2d::Ref *_owner; 417 | 418 | CCBAnimationManager* _animationManager; //retain 419 | CCBAnimationManagerMapPtr _animationManagers; 420 | 421 | std::set *_animatedProps; 422 | 423 | NodeLoaderLibrary *_nodeLoaderLibrary; 424 | NodeLoaderListener *_nodeLoaderListener; 425 | CCBMemberVariableAssigner *_CCBMemberVariableAssigner; 426 | CCBSelectorResolver *_CCBSelectorResolver; 427 | 428 | std::vector _ownerOutletNames; 429 | cocos2d::Vector _ownerOutletNodes; 430 | cocos2d::Vector _nodesWithAnimationManagers; 431 | cocos2d::Vector _animationManagersForNodes; 432 | 433 | std::vector _ownerCallbackNames; 434 | cocos2d::Vector _ownerCallbackNodes; 435 | cocos2d::ValueVector _ownerOwnerCallbackControlEvents; 436 | std::string _CCBRootPath; 437 | static float _ptmRatio; 438 | 439 | bool _jsControlled; 440 | std::map m_oNodeMap; 441 | 442 | }; 443 | 444 | // end of effects group 445 | /// @} 446 | 447 | } 448 | 449 | #endif 450 | -------------------------------------------------------------------------------- /spritebuilder/CCControlButtonLoader.cpp: -------------------------------------------------------------------------------- 1 | #include "CCControlButtonLoader.h" 2 | #include "CCLabel.h" 3 | #include "CCDirector.h" 4 | 5 | using namespace cocos2d; 6 | using namespace cocos2d::extension; 7 | 8 | namespace spritebuilder {; 9 | 10 | #define PROPERTY_ZOOMONTOUCHDOWN "zoomOnTouchDown" 11 | #define PROPERTY_TITLE_NORMAL "title|1" 12 | #define PROPERTY_TITLE_HIGHLIGHTED "title|2" 13 | #define PROPERTY_TITLE_DISABLED "title|3" 14 | #define PROPERTY_TITLECOLOR_NORMAL "titleColor|1" 15 | #define PROPERTY_TITLECOLOR_HIGHLIGHTED "titleColor|2" 16 | #define PROPERTY_TITLECOLOR_DISABLED "titleColor|3" 17 | #define PROPERTY_TITLETTF_NORMAL "titleTTF|1" 18 | #define PROPERTY_TITLETTF_HIGHLIGHTED "titleTTF|2" 19 | #define PROPERTY_TITLETTF_DISABLED "titleTTF|3" 20 | #define PROPERTY_TITLETTFSIZE_NORMAL "titleTTFSize|1" 21 | #define PROPERTY_TITLETTFSIZE_HIGHLIGHTED "titleTTFSize|2" 22 | #define PROPERTY_TITLETTFSIZE_DISABLED "titleTTFSize|3" 23 | #define PROPERTY_LABELANCHORPOINT "labelAnchorPoint" 24 | #define PROPERTY_PREFEREDSIZE "preferredSize" // TODO Should be "preferredSize". This is a typo in cocos2d-iphone, cocos2d-x and CocosBuilder! 25 | #define PROPERTY_TITLE_FONTNAME "fontName" 26 | #define PROPERTY_TITLE_FONTSIZE "fontSize" 27 | #define PROPERTY_HORIZONTAL_PADDING "horizontalPadding" 28 | #define PROPERTY_VERTICAL_PADDING "verticalPadding" 29 | 30 | #define PROPERTY_BACKGROUNDSPRITEFRAME_NORMAL "backgroundSpriteFrame|Normal" 31 | #define PROPERTY_BACKGROUNDSPRITEFRAME_HIGHLIGHTED "backgroundSpriteFrame|Highlighted" 32 | #define PROPERTY_BACKGROUNDSPRITEFRAME_DISABLED "backgroundSpriteFrame|Disabled" 33 | #define PROPERTY_BACKGROUNDSPRITEFRAME_SELECTED "backgroundSpriteFrame|Selected" 34 | 35 | #define PROPERTY_LABELCOLOR_NORMAL "labelColor|Normal" 36 | #define PROPERTY_LABELCOLOR_HIGHLIGHTED "labelColor|Highlighted" 37 | #define PROPERTY_LABELCOLOR_DISABLED "labelColor|Disabled" 38 | 39 | #define PROPERTY_LABELCOLOR "labelColor" 40 | #define PROPERTY_OUTLINE_COLOR "outlineColor" 41 | #define PROPERTY_FONT_COLOR "fontColor" 42 | #define PROPERTY_OUTLINE_WIDTH "outlineWidth" 43 | #define PROPERTY_SHADOW_COLOR "shadowColor" 44 | 45 | #define PROPERTY_SHADOW_BLUR_RADIUS "shadowBlurRadius" 46 | 47 | #define PROPERTY_SHADOW_OFFSET "shadowOffset" 48 | #define PROPERTY_TITLE "title" 49 | 50 | #define PROPERTY_MAXSIZE "maxSize" 51 | 52 | class SpriteBuilderButtonControl : public ControlButton { 53 | private: 54 | Size _maxSize; 55 | float _horizonPadding; 56 | float _verticalPadding; 57 | public: 58 | static SpriteBuilderButtonControl* create() { 59 | SpriteBuilderButtonControl *ret = new SpriteBuilderButtonControl(); 60 | if (ret->init()) { 61 | ret->autorelease(); 62 | return ret; 63 | } else 64 | return nullptr; 65 | } 66 | void setMaxSize(Size& size) { 67 | _maxSize = size; 68 | needsLayout(); 69 | } 70 | void setHorizonPadding(float padding) { 71 | _horizonPadding = padding; 72 | } 73 | void setVerticalPadding(float padding) { 74 | _verticalPadding = padding; 75 | } 76 | void setTitleOutlineColor(Color4B color) { 77 | Label *titleLabel = dynamic_cast(getTitleLabel()); 78 | if (titleLabel) { 79 | titleLabel->enableOutline(color); 80 | } 81 | } 82 | virtual void needsLayout(void) 83 | { 84 | if (!_parentInited) { 85 | return; 86 | } 87 | // Hide the background and the label 88 | if (getTitleLabel() != nullptr) { 89 | getTitleLabel()->setVisible(false); 90 | } 91 | if (getBackgroundSprite()) { 92 | getBackgroundSprite()->setVisible(false); 93 | } 94 | // Update anchor of all labels 95 | this->setLabelAnchorPoint(this->_labelAnchorPoint); 96 | 97 | // Update the label to match with the current state 98 | _currentTitle = getTitleForState(_state); 99 | 100 | _currentTitleColor = getTitleColorForState(_state); 101 | 102 | this->setTitleLabel(getTitleLabelForState(_state)); 103 | 104 | LabelProtocol* label = dynamic_cast(getTitleLabel()); 105 | if (label && !_currentTitle.empty()) 106 | { 107 | label->setString(_currentTitle); 108 | } 109 | 110 | if (getTitleLabel()) 111 | { 112 | getTitleLabel()->setColor(_currentTitleColor); 113 | } 114 | if (getTitleLabel() != nullptr) 115 | { 116 | getTitleLabel()->setPosition(Point (getContentSize().width / 2, getContentSize().height / 2)); 117 | } 118 | 119 | // Update the background sprite 120 | this->setBackgroundSprite(this->getBackgroundSpriteForState(_state)); 121 | if (getBackgroundSprite() != nullptr) 122 | { 123 | getBackgroundSprite()->setPosition(Point (getContentSize().width / 2, getContentSize().height / 2)); 124 | } 125 | 126 | // Get the title label size 127 | Size titleLabelSize; 128 | if (getTitleLabel() != nullptr) 129 | { 130 | titleLabelSize = getTitleLabel()->getBoundingBox().size; 131 | } 132 | 133 | // Adjust the background image if necessary 134 | if (_doesAdjustBackgroundImage) 135 | { 136 | // Add the margins 137 | if (getBackgroundSprite() != nullptr) 138 | { 139 | getBackgroundSprite()->setContentSize(Size(titleLabelSize.width + _marginH * 2, titleLabelSize.height + _marginV * 2)); 140 | } 141 | } 142 | else 143 | { 144 | //TODO: should this also have margins if one of the preferred sizes is relaxed? 145 | if (getBackgroundSprite() != nullptr) 146 | { 147 | Size preferredSize = getBackgroundSprite()->getPreferredSize(); 148 | if (preferredSize.width <= 0) 149 | { 150 | preferredSize.width = titleLabelSize.width; 151 | } 152 | if (preferredSize.height <= 0) 153 | { 154 | preferredSize.height = titleLabelSize.height; 155 | } 156 | 157 | getBackgroundSprite()->setContentSize(preferredSize); 158 | } 159 | } 160 | 161 | // Set the content size 162 | Rect rectTitle; 163 | if (getTitleLabel() != nullptr) 164 | { 165 | rectTitle = getTitleLabel()->getBoundingBox(); 166 | } 167 | Rect rectBackground; 168 | if (getBackgroundSprite() != nullptr) 169 | { 170 | rectBackground = getBackgroundSprite()->getBoundingBox(); 171 | } 172 | 173 | Rect maxRect = ControlUtils::RectUnion(rectTitle, rectBackground); 174 | if (_maxSize.width > 0 && maxRect.size.width > _maxSize.width) 175 | maxRect.size.width = _maxSize.width; 176 | 177 | if (_maxSize.height > 0 && maxRect.size.height > _maxSize.height) 178 | maxRect.size.height = _maxSize.height; 179 | 180 | if (titleLabelSize.width > maxRect.size.width - _horizonPadding * 2) 181 | maxRect.size.width += _horizonPadding * 2; 182 | 183 | if (titleLabelSize.height > maxRect.size.height - _verticalPadding * 2) 184 | maxRect.size.height += _verticalPadding * 2; 185 | 186 | setContentSize(Size(maxRect.size.width, maxRect.size.height)); 187 | 188 | if (getTitleLabel() != nullptr) 189 | { 190 | getTitleLabel()->setPosition(Point(getContentSize().width/2, getContentSize().height/2)); 191 | // Make visible the background and the label 192 | getTitleLabel()->setVisible(true); 193 | } 194 | 195 | if (getBackgroundSprite() != nullptr) 196 | { 197 | getBackgroundSprite()->setPosition(Point(getContentSize().width/2, getContentSize().height/2)); 198 | getBackgroundSprite()->setVisible(true); 199 | getBackgroundSprite()->setContentSize(maxRect.size); 200 | } 201 | } 202 | 203 | }; 204 | 205 | cocos2d::extension::ControlButton * ControlButtonLoader::createNode(cocos2d::Node * pParent, CCBReader * ccbReader) { 206 | auto pRet = SpriteBuilderButtonControl::create(); 207 | return pRet; 208 | } 209 | void ControlButtonLoader::onHandlePropTypeCheck(Node * pNode, Node * pParent, const char * pPropertyName, bool pCheck, CCBReader * ccbReader) { 210 | if(strcmp(pPropertyName, PROPERTY_ZOOMONTOUCHDOWN) == 0) { 211 | ((ControlButton *)pNode)->setZoomOnTouchDown(pCheck); 212 | } else { 213 | ControlLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader); 214 | } 215 | } 216 | 217 | void ControlButtonLoader::onHandlePropTypeString(Node * pNode, Node * pParent, const char * pPropertyName, const char * pString, CCBReader * ccbReader) { 218 | if(strcmp(pPropertyName, PROPERTY_TITLE_NORMAL) == 0) { 219 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::NORMAL); 220 | } else if(strcmp(pPropertyName, PROPERTY_TITLE_HIGHLIGHTED) == 0) { 221 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::HIGH_LIGHTED); 222 | } else if(strcmp(pPropertyName, PROPERTY_TITLE_DISABLED) == 0) { 223 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::DISABLED); 224 | } else if(strcmp(pPropertyName, PROPERTY_TITLE) == 0) { 225 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::NORMAL); 226 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::HIGH_LIGHTED); 227 | ((ControlButton *)pNode)->setTitleForState(pString, Control::State::DISABLED); 228 | } else { 229 | ControlLoader::onHandlePropTypeString(pNode, pParent, pPropertyName, pString, ccbReader); 230 | } 231 | } 232 | 233 | void ControlButtonLoader::onHandlePropTypeFontTTF(Node * pNode, Node * pParent, const char * pPropertyName, const char * pFontTTF, CCBReader * ccbReader) { 234 | if(strcmp(pPropertyName, PROPERTY_TITLETTF_NORMAL) == 0) { 235 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::NORMAL); 236 | } else if(strcmp(pPropertyName, PROPERTY_TITLETTF_HIGHLIGHTED) == 0) { 237 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::HIGH_LIGHTED); 238 | } else if(strcmp(pPropertyName, PROPERTY_TITLETTF_DISABLED) == 0) { 239 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::DISABLED); 240 | 241 | } else if(strcmp(pPropertyName, PROPERTY_TITLE_FONTNAME) == 0) { 242 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::NORMAL); 243 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::HIGH_LIGHTED); 244 | ((ControlButton *)pNode)->setTitleTTFForState(pFontTTF, Control::State::DISABLED); 245 | } else { 246 | ControlLoader::onHandlePropTypeFontTTF(pNode, pParent, pPropertyName, pFontTTF, ccbReader); 247 | } 248 | } 249 | 250 | void ControlButtonLoader::onHandlePropTypeFloatScale(Node * pNode, Node * pParent, const char * pPropertyName, float pFloatScale, CCBReader * ccbReader) { 251 | if(strcmp(pPropertyName, PROPERTY_TITLETTFSIZE_NORMAL) == 0) { 252 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::NORMAL); 253 | } else if(strcmp(pPropertyName, PROPERTY_TITLETTFSIZE_HIGHLIGHTED) == 0) { 254 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::HIGH_LIGHTED); 255 | } else if(strcmp(pPropertyName, PROPERTY_TITLETTFSIZE_DISABLED) == 0) { 256 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::DISABLED); 257 | } else if(strcmp(pPropertyName, PROPERTY_TITLE_FONTSIZE) == 0) { 258 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::NORMAL); 259 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::HIGH_LIGHTED); 260 | ((ControlButton *)pNode)->setTitleTTFSizeForState(pFloatScale, Control::State::DISABLED); 261 | } else if(strcmp(pPropertyName, PROPERTY_HORIZONTAL_PADDING) == 0) { 262 | ((SpriteBuilderButtonControl *)pNode)->setHorizonPadding(pFloatScale); 263 | } else if(strcmp(pPropertyName, PROPERTY_VERTICAL_PADDING) == 0) { 264 | ((SpriteBuilderButtonControl *)pNode)->setVerticalPadding(pFloatScale); 265 | } else if(strcmp(pPropertyName, PROPERTY_OUTLINE_WIDTH) == 0) { 266 | _outlineWidth = pFloatScale; 267 | } else if(strcmp(pPropertyName, PROPERTY_SHADOW_BLUR_RADIUS) == 0) { 268 | _shadowBlurRadius = pFloatScale; 269 | } else {// 270 | ControlLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader); 271 | } 272 | } 273 | 274 | void ControlButtonLoader::onHandlePropTypePosition(cocos2d::Node * pNode,cocos2d:: Node * pParent, const char* pPropertyName, cocos2d::Point pPosition, CCBReader * ccbReader) { 275 | if(strcmp(pPropertyName, PROPERTY_SHADOW_OFFSET) == 0) { 276 | _shadowOffset = pPosition; 277 | } else { 278 | ControlLoader::onHandlePropTypePosition(pNode, pParent, pPropertyName, pPosition, ccbReader); 279 | } 280 | } 281 | void ControlButtonLoader::onHandlePropTypePoint(Node * pNode, Node * pParent, const char * pPropertyName, Point pPoint, CCBReader * ccbReader) { 282 | if(strcmp(pPropertyName, PROPERTY_LABELANCHORPOINT) == 0) { 283 | ((ControlButton *)pNode)->setLabelAnchorPoint(pPoint); 284 | } else { 285 | ControlLoader::onHandlePropTypePoint(pNode, pParent, pPropertyName, pPoint, ccbReader); 286 | } 287 | } 288 | 289 | void ControlButtonLoader::onHandlePropTypeSize(Node * pNode, Node * pParent, const char * pPropertyName, Size pSize, CCBReader * ccbReader) { 290 | 291 | 292 | if(strcmp(pPropertyName, PROPERTY_PREFEREDSIZE) == 0) { 293 | ((ControlButton *)pNode)->setPreferredSize(pSize); 294 | } else if(strcmp(pPropertyName, PROPERTY_MAXSIZE) == 0) { 295 | ((SpriteBuilderButtonControl *)pNode)->setMaxSize(pSize); 296 | 297 | } else { 298 | ControlLoader::onHandlePropTypeSize(pNode, pParent, pPropertyName, pSize, ccbReader); 299 | } 300 | } 301 | 302 | void ControlButtonLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pSpriteFrame, CCBReader * ccbReader) { 303 | if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_NORMAL) == 0) { 304 | if(pSpriteFrame != NULL) { 305 | 306 | ((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::NORMAL); 307 | } 308 | } else if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_HIGHLIGHTED) == 0) { 309 | if(pSpriteFrame != NULL) { 310 | ((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::HIGH_LIGHTED); 311 | } 312 | } else if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_DISABLED) == 0) { 313 | if(pSpriteFrame != NULL) { 314 | ((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::DISABLED); 315 | } 316 | } else if(strcmp(pPropertyName, PROPERTY_BACKGROUNDSPRITEFRAME_SELECTED) == 0) { 317 | if(pSpriteFrame != NULL) { 318 | ((ControlButton *)pNode)->setBackgroundSpriteFrameForState(pSpriteFrame, Control::State::SELECTED); 319 | } 320 | } else { 321 | ControlLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pSpriteFrame, ccbReader); 322 | } 323 | } 324 | 325 | void ControlButtonLoader::onHandlePropTypeColor4(Node * pNode, Node * pParent, const char * pPropertyName, Color4F pColor4F, CCBReader * ccbReader) { 326 | if(strcmp(pPropertyName, PROPERTY_TITLECOLOR_NORMAL) == 0) { 327 | ((ControlButton *)pNode)->setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::NORMAL); 328 | } else if(strcmp(pPropertyName, PROPERTY_TITLECOLOR_HIGHLIGHTED) == 0) { 329 | ((ControlButton *)pNode)->setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::HIGH_LIGHTED); 330 | } else if(strcmp(pPropertyName, PROPERTY_TITLECOLOR_DISABLED) == 0) { 331 | ((ControlButton *)pNode)->setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::DISABLED); 332 | 333 | } else if(strcmp(pPropertyName, PROPERTY_LABELCOLOR_NORMAL) == 0) { 334 | ((ControlButton *)pNode)-> setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::NORMAL); 335 | } else if(strcmp(pPropertyName, PROPERTY_LABELCOLOR_HIGHLIGHTED) == 0) { 336 | ((ControlButton *)pNode)-> setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::HIGH_LIGHTED); 337 | } else if(strcmp(pPropertyName, PROPERTY_LABELCOLOR_DISABLED) == 0) { 338 | ((ControlButton *)pNode)-> setTitleColorForState(COLOR4F_TO_COLOR3B(pColor4F), Control::State::DISABLED); 339 | } else if(strcmp(pPropertyName, PROPERTY_LABELCOLOR) == 0) { 340 | ((SpriteBuilderButtonControl *)pNode)->getTitleLabel()->setColor(COLOR4F_TO_COLOR3B(pColor4F)); 341 | } else if(strcmp(pPropertyName, PROPERTY_OUTLINE_COLOR) == 0) { 342 | _outlineColor = pColor4F; 343 | } else if(strcmp(pPropertyName, PROPERTY_FONT_COLOR) == 0) { 344 | ((ControlButton *)pNode)->setTitleColorForState(Color3B(pColor4F.r, pColor4F.g, pColor4F.b), Control::State::NORMAL); 345 | ((ControlButton *)pNode)->setTitleColorForState(Color3B(pColor4F.r, pColor4F.g, pColor4F.b), Control::State::HIGH_LIGHTED); 346 | ((ControlButton *)pNode)->setTitleColorForState(Color3B(pColor4F.r, pColor4F.g, pColor4F.b), Control::State::DISABLED); 347 | } else if(strcmp(pPropertyName, PROPERTY_SHADOW_COLOR) == 0) { 348 | _shadowColor = pColor4F; 349 | } else { 350 | ControlLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4F, ccbReader); 351 | } 352 | } 353 | 354 | void ControlButtonLoader::updateForState(cocos2d::Node * pNode, cocos2d::extension::Control::State state) { 355 | Label *label = dynamic_cast(((SpriteBuilderButtonControl *)pNode)->getTitleLabelForState(state)); 356 | if (label) { 357 | float factor = Director::getInstance()->getContentScaleFactor(); 358 | label->enableOutline(Color4B(_outlineColor.r * 255, _outlineColor.g * 255, _outlineColor.b * 255, _outlineColor.a * 255), _outlineWidth / factor); 359 | 360 | label->enableShadow(Color4B(_shadowColor.r, _shadowColor.g, _shadowColor.b, _shadowColor.a), 361 | Size(_shadowOffset.x, _shadowOffset.y / factor), _shadowBlurRadius / factor); 362 | } 363 | } 364 | void ControlButtonLoader::onDone(cocos2d::Node * pNode, cocos2d::Node * pParent, CCBReader * ccbReader) { 365 | updateForState(pNode, Control::State::NORMAL); 366 | updateForState(pNode, Control::State::HIGH_LIGHTED); 367 | updateForState(pNode, Control::State::DISABLED); 368 | 369 | } 370 | 371 | void ControlButtonLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char* pPropertyName, int pIntegerLabeled, CCBReader * ccbReader) { 372 | if (strcmp(pPropertyName, "horizontalAlignment") == 0) { 373 | 374 | } else if (strcmp(pPropertyName, "verticalAlignment") == 0) { 375 | 376 | } else 377 | 378 | NodeLoader::onHandlePropTypeIntegerLabeled(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader); 379 | } 380 | }; --------------------------------------------------------------------------------