From 46e78ab7a14aa40cb838310f724e5cc04183303e Mon Sep 17 00:00:00 2001 From: natural-law Date: Sat, 25 Dec 2010 18:07:34 +0800 Subject: [PATCH] update layers_scenes_transition_nodes to 0.99.5. --- cocos2dx/Android.mk | 6 +- cocos2dx/include/CCLayer.h | 123 +- cocos2dx/include/CCTransition.h | 266 ++-- ...urnTransition.h => CCTransitionPageTurn.h} | 8 +- ...adialTransition.h => CCTransitionRadial.h} | 16 +- cocos2dx/include/cocos2d.h | 4 +- ...ransition.cpp => CCTransitionPageTurn.cpp} | 24 +- ...lTransition.cpp => CCTransitionRadial.cpp} | 20 +- .../CCLayer_mobile.cpp} | 241 ++- cocos2dx/platform/CCMenu_mobile.cpp | 30 + .../CCTransition_mobile.cpp} | 302 ++-- cocos2dx/platform/mac/CCLayer_mac.cpp | 658 ++++++++ cocos2dx/platform/mac/CCMenu_mac.cpp | 70 +- cocos2dx/platform/mac/CCTransition_mac.cpp | 1408 +++++++++++++++++ cocos2dx/proj.uphone/cocos2d-uphone.vcproj | 42 +- cocos2dx/proj.win32/cocos2d-win32.vcproj | 42 +- tests/tests/AtlasTest/AtlasTest.cpp | 2 +- .../ClickAndMoveTest/ClickAndMoveTest.cpp | 2 +- .../EffectsAdvancedTest.cpp | 4 +- tests/tests/EffectsTest/EffectsTest.h | 2 +- tests/tests/LayerTest/LayerTest.cpp | 12 +- tests/tests/ParticleTest/ParticleTest.h | 2 +- .../tests/RotateWorldTest/RotateWorldTest.cpp | 8 +- tests/tests/SceneTest/SceneTest.cpp | 4 +- tests/tests/SceneTest/SceneTest.h | 2 +- tests/tests/TileMapTest/TileMapTest.cpp | 12 +- .../tests/TransitionsTest/TransitionsTest.cpp | 110 +- 27 files changed, 2889 insertions(+), 531 deletions(-) rename cocos2dx/include/{CCPageTurnTransition.h => CCTransitionPageTurn.h} (91%) rename cocos2dx/include/{CCRadialTransition.h => CCTransitionRadial.h} (81%) rename cocos2dx/layers_scenes_transitions_nodes/{CCPageTurnTransition.cpp => CCTransitionPageTurn.cpp} (84%) rename cocos2dx/layers_scenes_transitions_nodes/{CCRadialTransition.cpp => CCTransitionRadial.cpp} (87%) rename cocos2dx/{layers_scenes_transitions_nodes/CCLayer.cpp => platform/CCLayer_mobile.cpp} (61%) rename cocos2dx/{layers_scenes_transitions_nodes/CCTransition.cpp => platform/CCTransition_mobile.cpp} (76%) create mode 100644 cocos2dx/platform/mac/CCLayer_mac.cpp create mode 100644 cocos2dx/platform/mac/CCTransition_mac.cpp diff --git a/cocos2dx/Android.mk b/cocos2dx/Android.mk index a8b61e9e6d..e8e5563546 100644 --- a/cocos2dx/Android.mk +++ b/cocos2dx/Android.mk @@ -35,9 +35,8 @@ effects/CCGrid.cpp \ label_nodes/CCLabelBMFont.cpp \ label_nodes/CCLabelTTF.cpp \ label_nodes/CCLabelAtlas.cpp \ -layers_scenes_transitions_nodes/CCLayer.cpp \ -layers_scenes_transitions_nodes/CCPageTurnTransition.cpp \ -layers_scenes_transitions_nodes/CCRadialTransition.cpp \ +layers_scenes_transitions_nodes/CCTransitionPageTurn.cpp \ +layers_scenes_transitions_nodes/CCTransitionRadial.cpp \ layers_scenes_transitions_nodes/CCScene.cpp \ layers_scenes_transitions_nodes/CCTransition.cpp \ menu_nodes/CCMenuItem.cpp \ @@ -49,6 +48,7 @@ particle_nodes/CCParticleExamples.cpp \ particle_nodes/CCParticleSystem.cpp \ particle_nodes/CCPointParticleSystem.cpp \ particle_nodes/CCQuadParticleSystem.cpp \ +platform/CCLayer_mobile.cpp \ platform/CCMenu_mobile.cpp \ platform/CCNode_mobile.cpp \ platform/android/CCTime.cpp \ diff --git a/cocos2dx/include/CCLayer.h b/cocos2dx/include/CCLayer.h index 80e4b2c6bd..46bb9a5932 100644 --- a/cocos2dx/include/CCLayer.h +++ b/cocos2dx/include/CCLayer.h @@ -44,7 +44,7 @@ All features from CCNode are valid, plus the following new features: - It can receive iPhone Touches - It can receive Accelerometer input */ -class CCX_DLL CCLayer : public CCNode, public CCTouchDelegate, public UIAccelerometerDelegate, public CCKeypadDelegate +class CCX_DLL CCLayer : public CCNode, public CCTouchDelegate, public UIAccelerometerDelegate, public CCKeypadDelegate, public CCKeyboardEventDelegate, public CCMouseEventDelegate { public: CCLayer(); @@ -54,6 +54,7 @@ public: virtual void onEnter(); virtual void onExit(); + virtual void onEnterTransitionDidFinish(); virtual bool ccTouchBegan(CCTouch *pTouch, UIEvent *pEvent); virtual void destroy(void); virtual void keep(void); @@ -77,6 +78,20 @@ public: */ virtual void registerWithTouchDispatcher(void); + /** priority of the mouse event delegate. + Default 0. + Override this method to set another priority. + @since v0.99.5 + */ + virtual int mouseDelegatePriority() { return 0; } + + /** priority of the keyboard event delegate. + Default 0. + Override this method to set another priority. + @since v0.99.5 + */ + virtual int keyboardDelegatePriority() { return 0; } + /** whether or not it will receive Touch events. You can enable / disable touch events with this property. Only the touches of this node will be affected. This "method" is not propagated to it's children. @@ -88,6 +103,16 @@ public: @since v0.8.1 */ CCX_PROPERTY(bool, m_bIsAccelerometerEnabled, IsAccelerometerEnabled) + /** whether or not it will receive Keyboard events + You can enable / disable Keyboard events with this property. + @since v0.99.5 + */ + CCX_PROPERTY(bool, m_bIsKeyboardEnabled, IsKeyboardEnabled) + /** whether or not it will receive mouse events + You can enable / disable mouse events with this property. + @since v0.99.5 + */ + CCX_PROPERTY(bool, m_bIsMouseEnabled, IsMouseEnabled) /** whether or not it will receive keypad events You can enable / disable accelerometer events with this property. it's new in cocos2d-x @@ -96,15 +121,15 @@ public: }; // -// CCColorLayer +// CCLayerColor // -/** @brief CCColorLayer is a subclass of CCLayer that implements the CCRGBAProtocol protocol. +/** @brief CCLayerColor is a subclass of CCLayer that implements the CCRGBAProtocol protocol. All features from CCLayer are valid, plus the following new features: - opacity - RGB colors */ -class CCX_DLL CCColorLayer : public CCLayer , public CCRGBAProtocol, public CCBlendProtocol +class CCX_DLL CCLayerColor : public CCLayer , public CCRGBAProtocol, public CCBlendProtocol { protected: GLfloat m_pSquareVertices[4 * 2]; @@ -112,27 +137,27 @@ protected: public: - CCColorLayer(); - virtual ~CCColorLayer(); + CCLayerColor(); + virtual ~CCLayerColor(); virtual void draw(); virtual void setContentSize(CGSize var); - /** creates a CCLayer with color, width and height */ - static CCColorLayer * layerWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height); + /** creates a CCLayer with color, width and height in Points */ + static CCLayerColor * layerWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height); /** creates a CCLayer with color. Width and height are the window size. */ - static CCColorLayer * layerWithColor(ccColor4B color); + static CCLayerColor * layerWithColor(ccColor4B color); - /** initializes a CCLayer with color, width and height */ - bool initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height); + /** initializes a CCLayer with color, width and height in Points */ + virtual bool initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height); /** initializes a CCLayer with color. Width and height are the window size. */ - bool initWithColor(ccColor4B color); + virtual bool initWithColor(ccColor4B color); - /** change width */ + /** change width in Points*/ void changeWidth(GLfloat w); - /** change height */ + /** change height in Points*/ void changeHeight(GLfloat h); - /** change width and height + /** change width and height in Points @since v0.8 */ void changeWidthAndHeight(GLfloat w ,GLfloat h); @@ -146,8 +171,72 @@ public: virtual CCRGBAProtocol* convertToRGBAProtocol() { return (CCRGBAProtocol*)this; } -private : - void updateColor(); +protected: + virtual void updateColor(); +}; + +/** CCColorLayer +It is the same as CCLayerColor. + +@deprecated Use CCLayerColor instead. This class will be removed in v1.0.1 +*/ +class CCColorLayer : public CCLayerColor +{ + +}; + +// +// CCLayerGradient +// +/** CCLayerGradient is a subclass of CCLayerColor that draws gradients across +the background. + +All features from CCLayerColor are valid, plus the following new features: +- direction +- final color + +Color is interpolated between the startColor and endColor along the given +vector (starting at the origin, ending at the terminus). If no vector is +supplied, it defaults to (0, -1) -- a fade from top to bottom. + +Given the nature of +the interpolation, you will not see either the start or end color for +non-cardinal vectors; a smooth gradient implying both end points will be still +be drawn, however. + +@since v0.99.5 +*/ +class CCLayerGradient : public CCLayerColor +{ +public: + /** Creates a full-screen CCLayer with a gradient between start and end. */ + static CCLayerGradient* layerWithColor(ccColor4B start, ccColor4B end); + + /** Creates a full-screen CCLayer with a gradient between start and end in the direction of v. */ + static CCLayerGradient* layerWithColor(ccColor4B start, ccColor4B end, CGPoint v); + + /** Initializes the CCLayer with a gradient between start and end. */ + virtual bool initWithColor(ccColor4B start, ccColor4B end); + + /** Initializes the CCLayer with a gradient between start and end in the direction of v. */ + virtual bool initWithColor(ccColor4B start, ccColor4B end, CGPoint v); + + ccColor3B getStartColor(); + void setStartColor(ccColor3B colors); + + CCX_PROPERTY(ccColor3B, m_endColor, EndColor) + CCX_PROPERTY(GLubyte, m_cStartOpacity, StartOpacity) + CCX_PROPERTY(GLubyte, m_cEndOpacity, EndOpacity) + CCX_PROPERTY(CGPoint, m_AlongVector, AlongVector) + +protected: + virtual void updateColor(); + +protected: + ccColor3B m_endColor; + GLubyte m_cStartOpacity; + GLubyte m_cEndOpacity; + CGPoint m_AlongVector; }; /** @brief CCMultipleLayer is a CCLayer with the ability to multiplex it's children. diff --git a/cocos2dx/include/CCTransition.h b/cocos2dx/include/CCTransition.h index 4474e98b39..914229279e 100644 --- a/cocos2dx/include/CCTransition.h +++ b/cocos2dx/include/CCTransition.h @@ -105,55 +105,55 @@ private: /** @brief A CCTransition that supports orientation like. * Possible orientation: LeftOver, RightOver, UpOver, DownOver */ -class CCX_DLL CCOrientedTransitionScene : public CCTransitionScene +class CCX_DLL CCTransitionSceneOriented : public CCTransitionScene { protected: tOrientation m_eOrientation; public: - CCOrientedTransitionScene(); - virtual ~CCOrientedTransitionScene(); + CCTransitionSceneOriented(); + virtual ~CCTransitionSceneOriented(); /** creates a base transition with duration and incoming scene */ - static CCOrientedTransitionScene * transitionWithDuration(ccTime t,CCScene* scene, tOrientation orientation); + static CCTransitionSceneOriented * transitionWithDuration(ccTime t,CCScene* scene, tOrientation orientation); /** initializes a transition with duration and incoming scene */ virtual bool initWithDuration(ccTime t,CCScene* scene,tOrientation orientation); }; -/** @brief CCRotoZoomTransition: +/** @brief CCTransitionRotoZoom: Rotate and zoom out the outgoing scene, and then rotate and zoom in the incoming */ -class CCX_DLL CCRotoZoomTransition : public CCTransitionScene +class CCX_DLL CCTransitionRotoZoom : public CCTransitionScene { public: - CCRotoZoomTransition(); - virtual ~CCRotoZoomTransition(); + CCTransitionRotoZoom(); + virtual ~CCTransitionRotoZoom(); virtual void onEnter(); - DECLEAR_TRANSITIONWITHDURATION(CCRotoZoomTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionRotoZoom); }; -/** @brief CCJumpZoomTransition: +/** @brief CCTransitionJumpZoom: Zoom out and jump the outgoing scene, and then jump and zoom in the incoming */ -class CCX_DLL CCJumpZoomTransition : public CCTransitionScene +class CCX_DLL CCTransitionJumpZoom : public CCTransitionScene { public: - CCJumpZoomTransition(); - virtual ~CCJumpZoomTransition(); + CCTransitionJumpZoom(); + virtual ~CCTransitionJumpZoom(); virtual void onEnter(); - DECLEAR_TRANSITIONWITHDURATION(CCJumpZoomTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionJumpZoom); }; -/** @brief CCMoveInLTransition: +/** @brief CCTransitionMoveInL: Move in from to the left the incoming scene. */ -class CCX_DLL CCMoveInLTransition : public CCTransitionScene, public CCTransitionEaseScene +class CCX_DLL CCTransitionMoveInL : public CCTransitionScene, public CCTransitionEaseScene { public: - CCMoveInLTransition(); - virtual ~CCMoveInLTransition(); + CCTransitionMoveInL(); + virtual ~CCTransitionMoveInL(); /** initializes the scenes */ virtual void initScenes(void); /** returns the action that will be performed */ @@ -163,56 +163,56 @@ public: virtual void onEnter(); - DECLEAR_TRANSITIONWITHDURATION(CCMoveInLTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionMoveInL); }; -/** @brief CCMoveInRTransition: +/** @brief CCTransitionMoveInR: Move in from to the right the incoming scene. */ -class CCX_DLL CCMoveInRTransition : public CCMoveInLTransition +class CCX_DLL CCTransitionMoveInR : public CCTransitionMoveInL { public: - CCMoveInRTransition(); - virtual ~CCMoveInRTransition(); + CCTransitionMoveInR(); + virtual ~CCTransitionMoveInR(); virtual void initScenes(); - DECLEAR_TRANSITIONWITHDURATION(CCMoveInRTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionMoveInR); }; -/** @brief CCMoveInTTransition: +/** @brief CCTransitionMoveInT: Move in from to the top the incoming scene. */ -class CCX_DLL CCMoveInTTransition : public CCMoveInLTransition +class CCX_DLL CCTransitionMoveInT : public CCTransitionMoveInL { public: - CCMoveInTTransition(); - virtual ~CCMoveInTTransition(); + CCTransitionMoveInT(); + virtual ~CCTransitionMoveInT(); virtual void initScenes(); - DECLEAR_TRANSITIONWITHDURATION(CCMoveInTTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionMoveInT); }; -/** @brief CCMoveInBTransition: +/** @brief CCTransitionMoveInB: Move in from to the bottom the incoming scene. */ -class CCX_DLL CCMoveInBTransition : public CCMoveInLTransition +class CCX_DLL CCTransitionMoveInB : public CCTransitionMoveInL { public: - CCMoveInBTransition(); - virtual ~CCMoveInBTransition(); + CCTransitionMoveInB(); + virtual ~CCTransitionMoveInB(); virtual void initScenes(); - DECLEAR_TRANSITIONWITHDURATION(CCMoveInBTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionMoveInB); }; -/** @brief CCSlideInLTransition: +/** @brief CCTransitionSlideInL: Slide in the incoming scene from the left border. */ -class CCX_DLL CCSlideInLTransition : public CCTransitionScene, public CCTransitionEaseScene +class CCX_DLL CCTransitionSlideInL : public CCTransitionScene, public CCTransitionEaseScene { public: - CCSlideInLTransition(); - virtual ~CCSlideInLTransition(); + CCTransitionSlideInL(); + virtual ~CCTransitionSlideInL(); /** initializes the scenes */ virtual void initScenes(void); @@ -223,64 +223,64 @@ public: virtual CCActionInterval* easeActionWithAction(CCActionInterval * action); - DECLEAR_TRANSITIONWITHDURATION(CCSlideInLTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSlideInL); protected: virtual void sceneOrder(); }; -/** @brief CCSlideInRTransition: +/** @brief CCTransitionSlideInR: Slide in the incoming scene from the right border. */ -class CCX_DLL CCSlideInRTransition : public CCSlideInLTransition +class CCX_DLL CCTransitionSlideInR : public CCTransitionSlideInL { public: - CCSlideInRTransition(); - virtual ~CCSlideInRTransition(); + CCTransitionSlideInR(); + virtual ~CCTransitionSlideInR(); /** initializes the scenes */ virtual void initScenes(void); /** returns the action that will be performed by the incomming and outgoing scene */ virtual CCActionInterval* action(void); - DECLEAR_TRANSITIONWITHDURATION(CCSlideInRTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSlideInR); protected: virtual void sceneOrder(); }; -/** @brief CCSlideInBTransition: +/** @brief CCTransitionSlideInB: Slide in the incoming scene from the bottom border. */ -class CCX_DLL CCSlideInBTransition : public CCSlideInLTransition +class CCX_DLL CCTransitionSlideInB : public CCTransitionSlideInL { public: - CCSlideInBTransition(); - virtual ~CCSlideInBTransition(); + CCTransitionSlideInB(); + virtual ~CCTransitionSlideInB(); /** initializes the scenes */ virtual void initScenes(void); /** returns the action that will be performed by the incomming and outgoing scene */ virtual CCActionInterval* action(void); - DECLEAR_TRANSITIONWITHDURATION(CCSlideInBTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSlideInB); protected: virtual void sceneOrder(); }; -/** @brief CCSlideInTTransition: +/** @brief CCTransitionSlideInT: Slide in the incoming scene from the top border. */ -class CCX_DLL CCSlideInTTransition : public CCSlideInLTransition +class CCX_DLL CCTransitionSlideInT : public CCTransitionSlideInL { public: - CCSlideInTTransition(); - virtual ~CCSlideInTTransition(); + CCTransitionSlideInT(); + virtual ~CCTransitionSlideInT(); /** initializes the scenes */ virtual void initScenes(void); /** returns the action that will be performed by the incomming and outgoing scene */ virtual CCActionInterval* action(void); - DECLEAR_TRANSITIONWITHDURATION(CCSlideInTTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSlideInT); protected: virtual void sceneOrder(); }; @@ -288,125 +288,125 @@ protected: /** @brief Shrink the outgoing scene while grow the incoming scene */ -class CCX_DLL CCShrinkGrowTransition : public CCTransitionScene , public CCTransitionEaseScene +class CCX_DLL CCTransitionShrinkGrow : public CCTransitionScene , public CCTransitionEaseScene { public: - CCShrinkGrowTransition(); - virtual ~CCShrinkGrowTransition(); + CCTransitionShrinkGrow(); + virtual ~CCTransitionShrinkGrow(); virtual void onEnter(); virtual CCActionInterval* easeActionWithAction(CCActionInterval * action); - DECLEAR_TRANSITIONWITHDURATION(CCShrinkGrowTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionShrinkGrow); }; -/** @brief CCFlipXTransition: +/** @brief CCTransitionFlipX: Flips the screen horizontally. The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCFlipXTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionFlipX : public CCTransitionSceneOriented { public: - CCFlipXTransition(); - virtual ~CCFlipXTransition(); + CCTransitionFlipX(); + virtual ~CCTransitionFlipX(); virtual void onEnter(); - static CCFlipXTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); + static CCTransitionFlipX* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); }; -/** @brief CCFlipYTransition: +/** @brief CCTransitionFlipY: Flips the screen vertically. The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCFlipYTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionFlipY : public CCTransitionSceneOriented { public: - CCFlipYTransition(); - virtual ~CCFlipYTransition(); + CCTransitionFlipY(); + virtual ~CCTransitionFlipY(); virtual void onEnter(); - static CCFlipYTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationUpOver); + static CCTransitionFlipY* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationUpOver); }; -/** @brief CCFlipAngularTransition: +/** @brief CCTransitionFlipAngular: Flips the screen half horizontally and half vertically. The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCFlipAngularTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionFlipAngular : public CCTransitionSceneOriented { public: - CCFlipAngularTransition(); - virtual ~CCFlipAngularTransition(); + CCTransitionFlipAngular(); + virtual ~CCTransitionFlipAngular(); virtual void onEnter(); - static CCFlipAngularTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); + static CCTransitionFlipAngular* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); }; -/** @brief CCZoomFlipXTransition: +/** @brief CCTransitionZoomFlipX: Flips the screen horizontally doing a zoom out/in The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCZoomFlipXTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionZoomFlipX : public CCTransitionSceneOriented { public: - CCZoomFlipXTransition(); - virtual ~CCZoomFlipXTransition(); + CCTransitionZoomFlipX(); + virtual ~CCTransitionZoomFlipX(); virtual void onEnter(); - static CCZoomFlipXTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); + static CCTransitionZoomFlipX* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); }; -/** @brief CCZoomFlipYTransition: +/** @brief CCTransitionZoomFlipY: Flips the screen vertically doing a little zooming out/in The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCZoomFlipYTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionZoomFlipY : public CCTransitionSceneOriented { public: - CCZoomFlipYTransition(); - virtual ~CCZoomFlipYTransition(); + CCTransitionZoomFlipY(); + virtual ~CCTransitionZoomFlipY(); virtual void onEnter(); - static CCZoomFlipYTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationUpOver); + static CCTransitionZoomFlipY* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationUpOver); }; -/** @brief CCZoomFlipAngularTransition: +/** @brief CCTransitionZoomFlipAngular: Flips the screen half horizontally and half vertically doing a little zooming out/in. The front face is the outgoing scene and the back face is the incoming scene. */ -class CCX_DLL CCZoomFlipAngularTransition : public CCOrientedTransitionScene +class CCX_DLL CCTransitionZoomFlipAngular : public CCTransitionSceneOriented { public: - CCZoomFlipAngularTransition(); - virtual ~CCZoomFlipAngularTransition(); + CCTransitionZoomFlipAngular(); + virtual ~CCTransitionZoomFlipAngular(); virtual void onEnter(); - static CCZoomFlipAngularTransition* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); + static CCTransitionZoomFlipAngular* transitionWithDuration(ccTime t, CCScene* s, tOrientation o = kOrientationRightOver); }; -/** @brief CCFadeTransition: +/** @brief CCTransitionFade: Fade out the outgoing scene and then fade in the incoming scene.''' */ -class CCX_DLL CCFadeTransition : public CCTransitionScene +class CCX_DLL CCTransitionFade : public CCTransitionScene { protected: ccColor4B m_tColor; public: - CCFadeTransition(); - virtual ~CCFadeTransition(); + CCTransitionFade(); + virtual ~CCTransitionFade(); /** creates the transition with a duration and with an RGB color * Example: FadeTransition::transitionWithDuration(2, scene, ccc3(255,0,0); // red color */ - static CCFadeTransition* transitionWithDuration(ccTime duration,CCScene* scene, ccColor3B color = ccBLACK); + static CCTransitionFade* transitionWithDuration(ccTime duration,CCScene* scene, ccColor3B color = ccBLACK); /** initializes the transition with a duration and with an RGB color */ virtual bool initWithDuration(ccTime t, CCScene*scene ,ccColor3B color); @@ -417,132 +417,132 @@ public: class CCRenderTexture; /** -@brief CCCrossFadeTransition: +@brief CCTransitionCrossFade: Cross fades two scenes using the CCRenderTexture object. */ -class CCX_DLL CCCrossFadeTransition : public CCTransitionScene +class CCX_DLL CCTransitionCrossFade : public CCTransitionScene { public : - CCCrossFadeTransition(); - virtual ~CCCrossFadeTransition(); + CCTransitionCrossFade(); + virtual ~CCTransitionCrossFade(); virtual void draw(); virtual void onEnter(); virtual void onExit(); public: - DECLEAR_TRANSITIONWITHDURATION(CCCrossFadeTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionCrossFade); }; -/** @brief CCTurnOffTilesTransition: +/** @brief CCTransitionTurnOffTiles: Turn off the tiles of the outgoing scene in random order */ -class CCX_DLL CCTurnOffTilesTransition : public CCTransitionScene ,public CCTransitionEaseScene +class CCX_DLL CCTransitionTurnOffTiles : public CCTransitionScene ,public CCTransitionEaseScene { public : - CCTurnOffTilesTransition(); - virtual ~CCTurnOffTilesTransition(); + CCTransitionTurnOffTiles(); + virtual ~CCTransitionTurnOffTiles(); virtual void onEnter(); virtual CCActionInterval * easeActionWithAction(CCActionInterval * action); public: - DECLEAR_TRANSITIONWITHDURATION(CCTurnOffTilesTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionTurnOffTiles); protected: virtual void sceneOrder(); }; -/** @brief CCSplitColsTransition: +/** @brief CCTransitionSplitCols: The odd columns goes upwards while the even columns goes downwards. */ -class CCX_DLL CCSplitColsTransition : public CCTransitionScene , public CCTransitionEaseScene +class CCX_DLL CCTransitionSplitCols : public CCTransitionScene , public CCTransitionEaseScene { public: - CCSplitColsTransition(); - virtual ~CCSplitColsTransition(); + CCTransitionSplitCols(); + virtual ~CCTransitionSplitCols(); virtual CCActionInterval* action(void); virtual void onEnter(); virtual CCActionInterval * easeActionWithAction(CCActionInterval * action); public: - DECLEAR_TRANSITIONWITHDURATION(CCSplitColsTransition); + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSplitCols); }; -/** @brief CCSplitRowsTransition: +/** @brief CCTransitionSplitRows: The odd rows goes to the left while the even rows goes to the right. */ -class CCX_DLL CCSplitRowsTransition : public CCSplitColsTransition +class CCX_DLL CCTransitionSplitRows : public CCTransitionSplitCols { public: - CCSplitRowsTransition(); - virtual ~CCSplitRowsTransition(); + CCTransitionSplitRows(); + virtual ~CCTransitionSplitRows(); virtual CCActionInterval* action(void); public: - DECLEAR_TRANSITIONWITHDURATION(CCSplitRowsTransition) + DECLEAR_TRANSITIONWITHDURATION(CCTransitionSplitRows) }; -/** @brief CCFadeTRTransition: +/** @brief CCTransitionFadeTR: Fade the tiles of the outgoing scene from the left-bottom corner the to top-right corner. */ -class CCX_DLL CCFadeTRTransition : public CCTransitionScene , public CCTransitionEaseScene +class CCX_DLL CCTransitionFadeTR : public CCTransitionScene , public CCTransitionEaseScene { public: - CCFadeTRTransition(); - virtual ~CCFadeTRTransition(); + CCTransitionFadeTR(); + virtual ~CCTransitionFadeTR(); virtual CCActionInterval* actionWithSize(ccGridSize size); virtual void onEnter(); virtual CCActionInterval* easeActionWithAction(CCActionInterval * action); public: - DECLEAR_TRANSITIONWITHDURATION(CCFadeTRTransition) + DECLEAR_TRANSITIONWITHDURATION(CCTransitionFadeTR) protected: virtual void sceneOrder(); }; -/** @brief CCFadeBLTransition: +/** @brief CCTransitionFadeBL: Fade the tiles of the outgoing scene from the top-right corner to the bottom-left corner. */ -class CCX_DLL CCFadeBLTransition : public CCFadeTRTransition +class CCX_DLL CCTransitionFadeBL : public CCTransitionFadeTR { public: - CCFadeBLTransition(); - virtual ~CCFadeBLTransition(); + CCTransitionFadeBL(); + virtual ~CCTransitionFadeBL(); virtual CCActionInterval* actionWithSize(ccGridSize size); public: - DECLEAR_TRANSITIONWITHDURATION(CCFadeBLTransition) + DECLEAR_TRANSITIONWITHDURATION(CCTransitionFadeBL) }; -/** @brief CCFadeUpTransition: +/** @brief CCTransitionFadeUp: * Fade the tiles of the outgoing scene from the bottom to the top. */ -class CCX_DLL CCFadeUpTransition : public CCFadeTRTransition +class CCX_DLL CCTransitionFadeUp : public CCTransitionFadeTR { public: - CCFadeUpTransition(); - virtual ~CCFadeUpTransition(); + CCTransitionFadeUp(); + virtual ~CCTransitionFadeUp(); virtual CCActionInterval* actionWithSize(ccGridSize size); public: - DECLEAR_TRANSITIONWITHDURATION(CCFadeUpTransition) + DECLEAR_TRANSITIONWITHDURATION(CCTransitionFadeUp) }; -/** @brief CCFadeDownTransition: +/** @brief CCTransitionFadeDown: * Fade the tiles of the outgoing scene from the top to the bottom. */ -class CCX_DLL CCFadeDownTransition : public CCFadeTRTransition +class CCX_DLL CCTransitionFadeDown : public CCTransitionFadeTR { public: - CCFadeDownTransition(); - virtual ~CCFadeDownTransition(); + CCTransitionFadeDown(); + virtual ~CCTransitionFadeDown(); virtual CCActionInterval* actionWithSize(ccGridSize size); public: - DECLEAR_TRANSITIONWITHDURATION(CCFadeDownTransition) + DECLEAR_TRANSITIONWITHDURATION(CCTransitionFadeDown) }; }//namespace cocos2d diff --git a/cocos2dx/include/CCPageTurnTransition.h b/cocos2dx/include/CCTransitionPageTurn.h similarity index 91% rename from cocos2dx/include/CCPageTurnTransition.h rename to cocos2dx/include/CCTransitionPageTurn.h index 850f46fc5f..efeff5ee98 100644 --- a/cocos2dx/include/CCPageTurnTransition.h +++ b/cocos2dx/include/CCTransitionPageTurn.h @@ -39,21 +39,21 @@ is turned on in CCDirector using: @since v0.8.2 */ -class CCX_DLL CCPageTurnTransition : public CCTransitionScene +class CCX_DLL CCTransitionPageTurn : public CCTransitionScene { protected: bool m_bBack; public: - CCPageTurnTransition(); - virtual ~CCPageTurnTransition(); + CCTransitionPageTurn(); + virtual ~CCTransitionPageTurn(); /** * Creates a base transition with duration and incoming scene. * If back is true then the effect is reversed to appear as if the incoming * scene is being turned from left over the outgoing scene. */ - static CCPageTurnTransition* transitionWithDuration(ccTime t,CCScene* scene,bool backwards); + static CCTransitionPageTurn* transitionWithDuration(ccTime t,CCScene* scene,bool backwards); /** * Creates a base transition with duration and incoming scene. diff --git a/cocos2dx/include/CCRadialTransition.h b/cocos2dx/include/CCTransitionRadial.h similarity index 81% rename from cocos2dx/include/CCRadialTransition.h rename to cocos2dx/include/CCTransitionRadial.h index ff6cd52165..c171081970 100644 --- a/cocos2dx/include/CCRadialTransition.h +++ b/cocos2dx/include/CCTransitionRadial.h @@ -32,16 +32,16 @@ namespace cocos2d { /** @brief A counter colock-wise radial transition to the next scene */ -class CCX_DLL CCRadialCCWTransition : public CCTransitionScene +class CCX_DLL CCTransitionRadialCCW : public CCTransitionScene { public: - CCRadialCCWTransition(){} - virtual ~CCRadialCCWTransition(){} + CCTransitionRadialCCW(){} + virtual ~CCTransitionRadialCCW(){} virtual void onEnter(); virtual void onExit(); - static CCRadialCCWTransition* transitionWithDuration(ccTime t, CCScene* scene); + static CCTransitionRadialCCW* transitionWithDuration(ccTime t, CCScene* scene); protected: virtual void sceneOrder(); @@ -51,12 +51,12 @@ protected: /** @brief A counter colock-wise radial transition to the next scene */ -class CCX_DLL CCRadialCWTransition : public CCRadialCCWTransition +class CCX_DLL CCTransitionRadialCW : public CCTransitionRadialCCW { public: - CCRadialCWTransition(){} - virtual ~CCRadialCWTransition(){} - static CCRadialCWTransition* transitionWithDuration(ccTime t, CCScene* scene); + CCTransitionRadialCW(){} + virtual ~CCTransitionRadialCW(){} + static CCTransitionRadialCW* transitionWithDuration(ccTime t, CCScene* scene); protected: virtual CCProgressTimerType radialType(); diff --git a/cocos2dx/include/cocos2d.h b/cocos2dx/include/cocos2d.h index 51830ddc27..0f0684a386 100644 --- a/cocos2dx/include/cocos2d.h +++ b/cocos2dx/include/cocos2d.h @@ -72,10 +72,10 @@ THE SOFTWARE. #include "CCRenderTexture.h" #include "CCMotionStreak.h" #include "CCActionPageTurn3D.h" -#include "CCPageTurnTransition.h" +#include "CCTransitionPageTurn.h" #include "CCTexture2D.h" #include "CCPVRTexture.h" -#include "CCRadialTransition.h" +#include "CCTransitionRadial.h" #include "CCActionProgressTimer.h" #include "CCTouchDispatcher.h" #include "CCDrawingPrimitives.h" diff --git a/cocos2dx/layers_scenes_transitions_nodes/CCPageTurnTransition.cpp b/cocos2dx/layers_scenes_transitions_nodes/CCTransitionPageTurn.cpp similarity index 84% rename from cocos2dx/layers_scenes_transitions_nodes/CCPageTurnTransition.cpp rename to cocos2dx/layers_scenes_transitions_nodes/CCTransitionPageTurn.cpp index 26285190b2..d6c5b1601e 100644 --- a/cocos2dx/layers_scenes_transitions_nodes/CCPageTurnTransition.cpp +++ b/cocos2dx/layers_scenes_transitions_nodes/CCTransitionPageTurn.cpp @@ -22,7 +22,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ -#include "CCPageTurnTransition.h" +#include "CCTransitionPageTurn.h" #include "CCDirector.h" #include "CCActionInterval.h" #include "CCActionInstant.h" @@ -31,24 +31,24 @@ THE SOFTWARE. namespace cocos2d { -CCPageTurnTransition::CCPageTurnTransition() +CCTransitionPageTurn::CCTransitionPageTurn() { } -CCPageTurnTransition::~CCPageTurnTransition() +CCTransitionPageTurn::~CCTransitionPageTurn() { } /** creates a base transition with duration and incoming scene */ -CCPageTurnTransition * CCPageTurnTransition::transitionWithDuration(ccTime t, CCScene *scene, bool backwards) +CCTransitionPageTurn * CCTransitionPageTurn::transitionWithDuration(ccTime t, CCScene *scene, bool backwards) { - CCPageTurnTransition * pTransition = new CCPageTurnTransition(); + CCTransitionPageTurn * pTransition = new CCTransitionPageTurn(); pTransition->initWithDuration(t,scene,backwards); pTransition->autorelease(); return pTransition; } /** initializes a transition with duration and incoming scene */ -bool CCPageTurnTransition::initWithDuration(ccTime t, CCScene *scene, bool backwards) +bool CCTransitionPageTurn::initWithDuration(ccTime t, CCScene *scene, bool backwards) { // XXX: needed before [super init] m_bBack = backwards; @@ -60,23 +60,25 @@ bool CCPageTurnTransition::initWithDuration(ccTime t, CCScene *scene, bool backw return true; } -void CCPageTurnTransition::sceneOrder() +void CCTransitionPageTurn::sceneOrder() { m_bIsInSceneOnTop = m_bBack; } -void CCPageTurnTransition::onEnter() +void CCTransitionPageTurn::onEnter() { CCTransitionScene::onEnter(); CGSize s = CCDirector::sharedDirector()->getWinSize(); int x,y; if( s.width > s.height) { - x=16;y=12; + x=16; + y=12; } else { - x=12;y=16; + x=12; + y=16; } CCActionInterval *action = this->actionWithSize(ccg(x,y)); @@ -113,7 +115,7 @@ void CCPageTurnTransition::onEnter() } -CCActionInterval* CCPageTurnTransition:: actionWithSize(ccGridSize vector) +CCActionInterval* CCTransitionPageTurn:: actionWithSize(ccGridSize vector) { if( m_bBack ) { diff --git a/cocos2dx/layers_scenes_transitions_nodes/CCRadialTransition.cpp b/cocos2dx/layers_scenes_transitions_nodes/CCTransitionRadial.cpp similarity index 87% rename from cocos2dx/layers_scenes_transitions_nodes/CCRadialTransition.cpp rename to cocos2dx/layers_scenes_transitions_nodes/CCTransitionRadial.cpp index 42a4cb0492..e206ef42a0 100644 --- a/cocos2dx/layers_scenes_transitions_nodes/CCRadialTransition.cpp +++ b/cocos2dx/layers_scenes_transitions_nodes/CCTransitionRadial.cpp @@ -22,7 +22,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ -#include "CCRadialTransition.h" +#include "CCTransitionRadial.h" #include "CCDirector.h" #include "CCRenderTexture.h" #include "CCActionInstant.h" @@ -42,17 +42,17 @@ enum { kSceneRadial = 0xc001, }; -void CCRadialCCWTransition::sceneOrder() +void CCTransitionRadialCCW::sceneOrder() { m_bIsInSceneOnTop = false; } -CCProgressTimerType CCRadialCCWTransition::radialType() +CCProgressTimerType CCTransitionRadialCCW::radialType() { return kCCProgressTimerTypeRadialCCW; } -void CCRadialCCWTransition::onEnter() +void CCTransitionRadialCCW::onEnter() { CCTransitionScene::onEnter(); // create a transparent color layer @@ -100,30 +100,30 @@ void CCRadialCCWTransition::onEnter() // clean up on exit -void CCRadialCCWTransition::onExit() +void CCTransitionRadialCCW::onExit() { // remove our layer and release all containing objects this->removeChildByTag(kSceneRadial, false); CCTransitionScene::onExit(); } -CCRadialCCWTransition* CCRadialCCWTransition::transitionWithDuration(ccTime t, CCScene* scene) +CCTransitionRadialCCW* CCTransitionRadialCCW::transitionWithDuration(ccTime t, CCScene* scene) { - CCRadialCCWTransition* pScene = new CCRadialCCWTransition(); + CCTransitionRadialCCW* pScene = new CCTransitionRadialCCW(); pScene->initWithDuration(t, scene); pScene->autorelease(); return pScene; } -CCProgressTimerType CCRadialCWTransition::radialType() +CCProgressTimerType CCTransitionRadialCW::radialType() { return kCCProgressTimerTypeRadialCW; } -CCRadialCWTransition* CCRadialCWTransition::transitionWithDuration(ccTime t, CCScene* scene) +CCTransitionRadialCW* CCTransitionRadialCW::transitionWithDuration(ccTime t, CCScene* scene) { - CCRadialCWTransition* pScene = new CCRadialCWTransition(); + CCTransitionRadialCW* pScene = new CCTransitionRadialCW(); pScene->initWithDuration(t, scene); pScene->autorelease(); diff --git a/cocos2dx/layers_scenes_transitions_nodes/CCLayer.cpp b/cocos2dx/platform/CCLayer_mobile.cpp similarity index 61% rename from cocos2dx/layers_scenes_transitions_nodes/CCLayer.cpp rename to cocos2dx/platform/CCLayer_mobile.cpp index 3dee544e66..17f823ef2e 100644 --- a/cocos2dx/layers_scenes_transitions_nodes/CCLayer.cpp +++ b/cocos2dx/platform/CCLayer_mobile.cpp @@ -35,6 +35,8 @@ CCLayer::CCLayer() :m_bIsTouchEnabled(false) ,m_bIsAccelerometerEnabled(false) ,m_bIsKeypadEnabled(false) +,m_bIsMouseEnabled(false) +,m_bIsKeyboardEnabled(false) { m_eTouchDelegateType = ccTouchDeletateAllBit; m_tAnchorPoint = ccp(0.5f, 0.5f); @@ -111,6 +113,25 @@ void CCLayer::KeypadKeep() this->retain(); } +bool CCLayer::getIsMouseEnabled() +{ + return m_bIsMouseEnabled; +} + +void CCLayer::setIsMouseEnabled(bool enabled) +{ + CCLOG("cocos2d: CCLayer: unsupportted!"); +} + +bool CCLayer::getIsKeyboardEnabled() +{ + return m_bIsKeyboardEnabled; +} + +void CCLayer::setIsKeyboardEnabled(bool enabled) +{ + CCLOG("cocos2d: CCLayer: unsupportted!"); +} /// isTouchEnabled getter bool CCLayer::getIsTouchEnabled() @@ -239,6 +260,16 @@ void CCLayer::onExit() CCNode::onExit(); } +void CCLayer::onEnterTransitionDidFinish() +{ + if (m_bIsAccelerometerEnabled) + { + UIAccelerometer::sharedAccelerometer()->addDelegate(this); + } + + CCNode::onEnterTransitionDidFinish(); +} + bool CCLayer::ccTouchBegan(CCTouch *pTouch, UIEvent *pEvent) { NSAssert(false, "Layer#ccTouchBegan override me"); @@ -248,34 +279,34 @@ bool CCLayer::ccTouchBegan(CCTouch *pTouch, UIEvent *pEvent) /// ColorLayer -CCColorLayer::CCColorLayer() +CCLayerColor::CCLayerColor() { } -CCColorLayer::~CCColorLayer() +CCLayerColor::~CCLayerColor() { } // Opacity and RGB color protocol /// opacity getter -GLubyte CCColorLayer::getOpacity() +GLubyte CCLayerColor::getOpacity() { return m_cOpacity; } /// opacity setter -void CCColorLayer::setOpacity(GLubyte var) +void CCLayerColor::setOpacity(GLubyte var) { m_cOpacity = var; updateColor(); } /// color getter -ccColor3B CCColorLayer::getColor() +ccColor3B CCLayerColor::getColor() { return m_tColor; } /// color setter -void CCColorLayer::setColor(ccColor3B var) +void CCLayerColor::setColor(ccColor3B var) { m_tColor = var; updateColor(); @@ -283,20 +314,20 @@ void CCColorLayer::setColor(ccColor3B var) /// blendFunc getter -ccBlendFunc CCColorLayer::getBlendFunc() +ccBlendFunc CCLayerColor::getBlendFunc() { return m_tBlendFunc; } /// blendFunc setter -void CCColorLayer::setBlendFunc(ccBlendFunc var) +void CCLayerColor::setBlendFunc(ccBlendFunc var) { m_tBlendFunc = var; } -CCColorLayer * CCColorLayer::layerWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) +CCLayerColor * CCLayerColor::layerWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) { - CCColorLayer * pLayer = new CCColorLayer(); + CCLayerColor * pLayer = new CCLayerColor(); if( pLayer && pLayer->initWithColorWidthHeight(color,width,height)) { pLayer->autorelease(); @@ -305,9 +336,9 @@ CCColorLayer * CCColorLayer::layerWithColorWidthHeight(ccColor4B color, GLfloat CCX_SAFE_DELETE(pLayer); return NULL; } -CCColorLayer * CCColorLayer::layerWithColor(ccColor4B color) +CCLayerColor * CCLayerColor::layerWithColor(ccColor4B color) { - CCColorLayer * pLayer = new CCColorLayer(); + CCLayerColor * pLayer = new CCLayerColor(); if(pLayer && pLayer->initWithColor(color)) { pLayer->autorelease(); @@ -317,7 +348,7 @@ CCColorLayer * CCColorLayer::layerWithColor(ccColor4B color) return NULL; } -bool CCColorLayer::initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) +bool CCLayerColor::initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) { // default blend function m_tBlendFunc.src = CC_BLEND_SRC; @@ -338,7 +369,7 @@ bool CCColorLayer::initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfl return true; } -bool CCColorLayer::initWithColor(ccColor4B color) +bool CCLayerColor::initWithColor(ccColor4B color) { CGSize s = CCDirector::sharedDirector()->getWinSize(); this->initWithColorWidthHeight(color, s.width, s.height); @@ -346,47 +377,43 @@ bool CCColorLayer::initWithColor(ccColor4B color) } /// override contentSize -void CCColorLayer::setContentSize(CGSize size) +void CCLayerColor::setContentSize(CGSize size) { - m_pSquareVertices[2] = size.width; - m_pSquareVertices[5] = size.height; - m_pSquareVertices[6] = size.width; - m_pSquareVertices[7] = size.height; + m_pSquareVertices[2] = size.width * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[5] = size.height * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[6] = size.width * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[7] = size.height * CC_CONTENT_SCALE_FACTOR(); CCLayer::setContentSize(size); } -void CCColorLayer::changeWidthAndHeight(GLfloat w ,GLfloat h) +void CCLayerColor::changeWidthAndHeight(GLfloat w ,GLfloat h) { this->setContentSize(CGSizeMake(w, h)); } -void CCColorLayer::changeWidth(GLfloat w) +void CCLayerColor::changeWidth(GLfloat w) { this->setContentSize(CGSizeMake(w, m_tContentSize.height)); } -void CCColorLayer::changeHeight(GLfloat h) +void CCLayerColor::changeHeight(GLfloat h) { this->setContentSize(CGSizeMake(m_tContentSize.width, h)); } -void CCColorLayer::updateColor() +void CCLayerColor::updateColor() { - for( unsigned int i=0; i < sizeof(m_pSquareColors) / sizeof(m_pSquareColors[0]); i++ ) + for( unsigned int i=0; i < 4; i++ ) { - if( i % 4 == 0 ) - m_pSquareColors[i] = m_tColor.r; - else if( i % 4 == 1) - m_pSquareColors[i] = m_tColor.g; - else if( i % 4 ==2 ) - m_pSquareColors[i] = m_tColor.b; - else - m_pSquareColors[i] = m_cOpacity; + m_pSquareColors[i * 4] = m_tColor.r; + m_pSquareColors[i * 4 + 1] = m_tColor.g; + m_pSquareColors[i * 4 + 2] = m_tColor.b; + m_pSquareColors[i * 4 + 3] = m_cOpacity; } } -void CCColorLayer::draw() +void CCLayerColor::draw() { // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY // Needed states: GL_VERTEX_ARRAY, GL_COLOR_ARRAY @@ -417,6 +444,154 @@ void CCColorLayer::draw() glEnable(GL_TEXTURE_2D); } +// +// CCLayerGradient +// +CCLayerGradient* CCLayerGradient::layerWithColor(ccColor4B start, ccColor4B end) +{ + CCLayerGradient * pLayer = new CCLayerGradient(); + if( pLayer && pLayer->initWithColor(start, end)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} + +CCLayerGradient* CCLayerGradient::layerWithColor(ccColor4B start, ccColor4B end, CGPoint v) +{ + CCLayerGradient * pLayer = new CCLayerGradient(); + if( pLayer && pLayer->initWithColor(start, end, v)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} + +bool CCLayerGradient::initWithColor(ccColor4B start, ccColor4B end) +{ + return initWithColor(start, end, ccp(0, -1)); +} + +bool CCLayerGradient::initWithColor(ccColor4B start, ccColor4B end, CGPoint v) +{ + m_endColor.r = end.r; + m_endColor.g = end.g; + m_endColor.b = end.b; + + m_cEndOpacity = end.a; + m_cStartOpacity = start.a; + m_AlongVector = v; + + start.a = 255; + return this->initWithColor(start); +} + +void CCLayerGradient::updateColor() +{ + CCLayerColor::updateColor(); + + float h = sqrtf(m_AlongVector.x * m_AlongVector.x + m_AlongVector.y * m_AlongVector.y); + if (h == 0) + return; + + double c = sqrt(2); + CGPoint u = ccp(m_AlongVector.x / h, m_AlongVector.y / h); + + float opacityf = (float)m_cOpacity / 255.0f; + + ccColor4B S = { + m_tColor.r, + m_tColor.g, + m_tColor.b, + m_cStartOpacity * opacityf + }; + + ccColor4B E = { + m_endColor.r, + m_endColor.g, + m_endColor.b, + m_cEndOpacity * opacityf + }; + + // (-1, -1) + m_pSquareColors[0] = E.r + (S.r - E.r) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[1] = E.g + (S.g - E.g) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[2] = E.b + (S.b - E.b) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[3] = E.a + (S.a - E.a) * ((c + u.x + u.y) / (2.0f * c)); + // (1, -1) + m_pSquareColors[4] = E.r + (S.r - E.r) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[5] = E.g + (S.g - E.g) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[6] = E.b + (S.b - E.b) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[7] = E.a + (S.a - E.a) * ((c - u.x + u.y) / (2.0f * c)); + // (-1, 1) + m_pSquareColors[8] = E.r + (S.r - E.r) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[9] = E.g + (S.g - E.g) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[10] = E.b + (S.b - E.b) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[11] = E.a + (S.a - E.a) * ((c + u.x - u.y) / (2.0f * c)); + // (1, 1) + m_pSquareColors[12] = E.r + (S.r - E.r) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[13] = E.g + (S.g - E.g) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[14] = E.b + (S.b - E.b) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[15] = E.a + (S.a - E.a) * ((c - u.x - u.y) / (2.0f * c)); +} + +ccColor3B CCLayerGradient::getStartColor() +{ + return m_tColor; +} + +void CCLayerGradient::setStartColor(ccColor3B colors) +{ + setColor(colors); +} + +void CCLayerGradient::setEndColor(ccColor3B colors) +{ + m_endColor = colors; + updateColor(); +} + +ccColor3B CCLayerGradient::getEndColor() +{ + return m_endColor; +} + +void CCLayerGradient::setStartOpacity(GLubyte o) +{ + m_cStartOpacity = o; + updateColor(); +} + +GLubyte CCLayerGradient::getStartOpacity() +{ + return m_cStartOpacity; +} + +void CCLayerGradient::setEndOpacity(GLubyte o) +{ + m_cEndOpacity = o; + updateColor(); +} + +GLubyte CCLayerGradient::getEndOpacity() +{ + return m_cEndOpacity; +} + +void CCLayerGradient::setAlongVector(CGPoint var) +{ + m_AlongVector = var; + updateColor(); +} + +CGPoint CCLayerGradient::getAlongVector() +{ + return m_AlongVector; +} /// MultiplexLayer diff --git a/cocos2dx/platform/CCMenu_mobile.cpp b/cocos2dx/platform/CCMenu_mobile.cpp index 0146bbb49d..d99a40b618 100644 --- a/cocos2dx/platform/CCMenu_mobile.cpp +++ b/cocos2dx/platform/CCMenu_mobile.cpp @@ -197,6 +197,36 @@ namespace cocos2d{ } } + int CCMenu::mouseDelegatePriority() + { + CCLOG("cocos2d: CCMenu: unsupported"); + return -1;/** @todo upto-0.99.5 use NSIntegerMin+1 instead*/ + } + + CCMenuItem* CCMenu::itemForMouseEvent(NSEvent * pEvent) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NULL; + } + + bool CCMenu::ccMouseUp(NSEvent * pEvent) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NO; + } + + bool CCMenu::ccMouseDown(NSEvent * pEvent) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NO; + } + + bool CCMenu::ccMouseDragged(NSEvent * pEvent) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NO; + } + void CCMenu::destroy(void) { release(); diff --git a/cocos2dx/layers_scenes_transitions_nodes/CCTransition.cpp b/cocos2dx/platform/CCTransition_mobile.cpp similarity index 76% rename from cocos2dx/layers_scenes_transitions_nodes/CCTransition.cpp rename to cocos2dx/platform/CCTransition_mobile.cpp index 74a8869668..4b148cf814 100644 --- a/cocos2dx/layers_scenes_transitions_nodes/CCTransition.cpp +++ b/cocos2dx/platform/CCTransition_mobile.cpp @@ -194,22 +194,22 @@ void CCTransitionScene::cleanup() // // Oriented Transition // -CCOrientedTransitionScene::CCOrientedTransitionScene() +CCTransitionSceneOriented::CCTransitionSceneOriented() { } -CCOrientedTransitionScene::~CCOrientedTransitionScene() +CCTransitionSceneOriented::~CCTransitionSceneOriented() { } -CCOrientedTransitionScene * CCOrientedTransitionScene::transitionWithDuration(ccTime t, CCScene *scene, tOrientation orientation) +CCTransitionSceneOriented * CCTransitionSceneOriented::transitionWithDuration(ccTime t, CCScene *scene, tOrientation orientation) { - CCOrientedTransitionScene * pScene = new CCOrientedTransitionScene(); + CCTransitionSceneOriented * pScene = new CCTransitionSceneOriented(); pScene->initWithDuration(t,scene,orientation); pScene->autorelease(); return pScene; } -bool CCOrientedTransitionScene::initWithDuration(ccTime t, CCScene *scene, tOrientation orientation) +bool CCTransitionSceneOriented::initWithDuration(ccTime t, CCScene *scene, tOrientation orientation) { if ( CCTransitionScene::initWithDuration(t, scene) ) { @@ -221,14 +221,14 @@ bool CCOrientedTransitionScene::initWithDuration(ccTime t, CCScene *scene, tOrie // // RotoZoom // -CCRotoZoomTransition::CCRotoZoomTransition() +CCTransitionRotoZoom::CCTransitionRotoZoom() { } -CCRotoZoomTransition::~CCRotoZoomTransition() +CCTransitionRotoZoom::~CCTransitionRotoZoom() { } -void CCRotoZoomTransition:: onEnter() +void CCTransitionRotoZoom:: onEnter() { CCTransitionScene::onEnter(); @@ -262,20 +262,20 @@ void CCRotoZoomTransition:: onEnter() ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCRotoZoomTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionRotoZoom) // // JumpZoom // -CCJumpZoomTransition::CCJumpZoomTransition() +CCTransitionJumpZoom::CCTransitionJumpZoom() { } -CCJumpZoomTransition::~CCJumpZoomTransition() +CCTransitionJumpZoom::~CCTransitionJumpZoom() { } -void CCJumpZoomTransition::onEnter() +void CCTransitionJumpZoom::onEnter() { CCTransitionScene::onEnter(); CGSize s = CCDirector::sharedDirector()->getWinSize(); @@ -307,19 +307,19 @@ void CCJumpZoomTransition::onEnter() ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCJumpZoomTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionJumpZoom) // // MoveInL // -CCMoveInLTransition::CCMoveInLTransition() +CCTransitionMoveInL::CCTransitionMoveInL() { } -CCMoveInLTransition::~CCMoveInLTransition() +CCTransitionMoveInL::~CCTransitionMoveInL() { } -void CCMoveInLTransition::onEnter() +void CCTransitionMoveInL::onEnter() { CCTransitionScene::onEnter(); this->initScenes(); @@ -337,78 +337,78 @@ void CCMoveInLTransition::onEnter() ); } -CCActionInterval* CCMoveInLTransition::action() +CCActionInterval* CCTransitionMoveInL::action() { return CCMoveTo::actionWithDuration(m_fDuration, ccp(0,0)); } -CCActionInterval* CCMoveInLTransition::easeActionWithAction(CCActionInterval* action) +CCActionInterval* CCTransitionMoveInL::easeActionWithAction(CCActionInterval* action) { return CCEaseOut::actionWithAction(action, 2.0f); // return [EaseElasticOut actionWithAction:action period:0.4f]; } -void CCMoveInLTransition::initScenes() +void CCTransitionMoveInL::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(-s.width,0) ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCMoveInLTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInL) // // MoveInR // -CCMoveInRTransition::CCMoveInRTransition() +CCTransitionMoveInR::CCTransitionMoveInR() { } -CCMoveInRTransition::~CCMoveInRTransition() +CCTransitionMoveInR::~CCTransitionMoveInR() { } -void CCMoveInRTransition::initScenes() +void CCTransitionMoveInR::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(s.width,0) ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCMoveInRTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInR) // // MoveInT // -CCMoveInTTransition::CCMoveInTTransition() +CCTransitionMoveInT::CCTransitionMoveInT() { } -CCMoveInTTransition::~CCMoveInTTransition() +CCTransitionMoveInT::~CCTransitionMoveInT() { } -void CCMoveInTTransition::initScenes() +void CCTransitionMoveInT::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(0,s.height) ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCMoveInTTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInT) // // MoveInB // -CCMoveInBTransition::CCMoveInBTransition() +CCTransitionMoveInB::CCTransitionMoveInB() { } -CCMoveInBTransition::~CCMoveInBTransition() +CCTransitionMoveInB::~CCTransitionMoveInB() { } -void CCMoveInBTransition::initScenes() +void CCTransitionMoveInB::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(0,-s.height) ); } -IMPLEMENT_TRANSITIONWITHDURATION(CCMoveInBTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInB) // @@ -420,14 +420,14 @@ IMPLEMENT_TRANSITIONWITHDURATION(CCMoveInBTransition) // The other issue is that in some transitions (and I don't know why) // the order should be reversed (In in top of Out or vice-versa). #define ADJUST_FACTOR 0.5f -CCSlideInLTransition::CCSlideInLTransition() +CCTransitionSlideInL::CCTransitionSlideInL() { } -CCSlideInLTransition::~CCSlideInLTransition() +CCTransitionSlideInL::~CCTransitionSlideInL() { } -void CCSlideInLTransition::onEnter() +void CCTransitionSlideInL::onEnter() { CCTransitionScene::onEnter(); this->initScenes(); @@ -446,134 +446,134 @@ void CCSlideInLTransition::onEnter() m_pOutScene->runAction(outAction); } -void CCSlideInLTransition::sceneOrder() +void CCTransitionSlideInL::sceneOrder() { m_bIsInSceneOnTop = false; } -void CCSlideInLTransition:: initScenes() +void CCTransitionSlideInL:: initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(-(s.width-ADJUST_FACTOR),0) ); } -CCActionInterval* CCSlideInLTransition::action() +CCActionInterval* CCTransitionSlideInL::action() { CGSize s = CCDirector::sharedDirector()->getWinSize(); return CCMoveBy::actionWithDuration(m_fDuration, ccp(s.width-ADJUST_FACTOR,0)); } -CCActionInterval* CCSlideInLTransition::easeActionWithAction(CCActionInterval* action) +CCActionInterval* CCTransitionSlideInL::easeActionWithAction(CCActionInterval* action) { return CCEaseOut::actionWithAction(action, 2.0f); // return [EaseElasticOut actionWithAction:action period:0.4f]; } -IMPLEMENT_TRANSITIONWITHDURATION(CCSlideInLTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInL) // // SlideInR // -CCSlideInRTransition::CCSlideInRTransition() +CCTransitionSlideInR::CCTransitionSlideInR() { } -CCSlideInRTransition::~CCSlideInRTransition() +CCTransitionSlideInR::~CCTransitionSlideInR() { } -void CCSlideInRTransition::sceneOrder() +void CCTransitionSlideInR::sceneOrder() { m_bIsInSceneOnTop = true; } -void CCSlideInRTransition::initScenes() +void CCTransitionSlideInR::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(s.width-ADJUST_FACTOR,0) ); } -CCActionInterval* CCSlideInRTransition:: action() +CCActionInterval* CCTransitionSlideInR:: action() { CGSize s = CCDirector::sharedDirector()->getWinSize(); return CCMoveBy::actionWithDuration(m_fDuration, ccp(-(s.width-ADJUST_FACTOR),0)); } -IMPLEMENT_TRANSITIONWITHDURATION(CCSlideInRTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInR) // // SlideInT // -CCSlideInTTransition::CCSlideInTTransition() +CCTransitionSlideInT::CCTransitionSlideInT() { } -CCSlideInTTransition::~CCSlideInTTransition() +CCTransitionSlideInT::~CCTransitionSlideInT() { } -void CCSlideInTTransition::sceneOrder() +void CCTransitionSlideInT::sceneOrder() { m_bIsInSceneOnTop = false; } -void CCSlideInTTransition::initScenes() +void CCTransitionSlideInT::initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(0,s.height-ADJUST_FACTOR) ); } -CCActionInterval* CCSlideInTTransition::action() +CCActionInterval* CCTransitionSlideInT::action() { CGSize s = CCDirector::sharedDirector()->getWinSize(); return CCMoveBy::actionWithDuration(m_fDuration, ccp(0,-(s.height-ADJUST_FACTOR))); } -IMPLEMENT_TRANSITIONWITHDURATION(CCSlideInTTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInT) // // SlideInB // -CCSlideInBTransition::CCSlideInBTransition() +CCTransitionSlideInB::CCTransitionSlideInB() { } -CCSlideInBTransition::~CCSlideInBTransition() +CCTransitionSlideInB::~CCTransitionSlideInB() { } -void CCSlideInBTransition::sceneOrder() +void CCTransitionSlideInB::sceneOrder() { m_bIsInSceneOnTop = true; } -void CCSlideInBTransition:: initScenes() +void CCTransitionSlideInB:: initScenes() { CGSize s = CCDirector::sharedDirector()->getWinSize(); m_pInScene->setPosition( ccp(0,-(s.height-ADJUST_FACTOR)) ); } -CCActionInterval* CCSlideInBTransition:: action() +CCActionInterval* CCTransitionSlideInB:: action() { CGSize s = CCDirector::sharedDirector()->getWinSize(); return CCMoveBy::actionWithDuration(m_fDuration, ccp(0,s.height-ADJUST_FACTOR)); } -IMPLEMENT_TRANSITIONWITHDURATION(CCSlideInBTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInB) // // ShrinkGrow Transition // -CCShrinkGrowTransition::CCShrinkGrowTransition() +CCTransitionShrinkGrow::CCTransitionShrinkGrow() { } -CCShrinkGrowTransition::~CCShrinkGrowTransition() +CCTransitionShrinkGrow::~CCTransitionShrinkGrow() { } -void CCShrinkGrowTransition::onEnter() +void CCTransitionShrinkGrow::onEnter() { CCTransitionScene::onEnter(); @@ -597,27 +597,27 @@ void CCShrinkGrowTransition::onEnter() ) ); } -CCActionInterval* CCShrinkGrowTransition:: easeActionWithAction(CCActionInterval* action) +CCActionInterval* CCTransitionShrinkGrow:: easeActionWithAction(CCActionInterval* action) { return CCEaseOut::actionWithAction(action, 2.0f); // return [EaseElasticOut actionWithAction:action period:0.3f]; } -IMPLEMENT_TRANSITIONWITHDURATION(CCShrinkGrowTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionShrinkGrow) // // FlipX Transition // -CCFlipXTransition::CCFlipXTransition() +CCTransitionFlipX::CCTransitionFlipX() { } -CCFlipXTransition::~CCFlipXTransition() +CCTransitionFlipX::~CCTransitionFlipX() { } -void CCFlipXTransition::onEnter() +void CCTransitionFlipX::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -661,9 +661,9 @@ void CCFlipXTransition::onEnter() m_pOutScene->runAction(outA); } -CCFlipXTransition* CCFlipXTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionFlipX* CCTransitionFlipX::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCFlipXTransition* pScene = new CCFlipXTransition(); + CCTransitionFlipX* pScene = new CCTransitionFlipX(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -673,16 +673,16 @@ CCFlipXTransition* CCFlipXTransition::transitionWithDuration(ccTime t, CCScene* // // FlipY Transition // -CCFlipYTransition::CCFlipYTransition() +CCTransitionFlipY::CCTransitionFlipY() { } -CCFlipYTransition::~CCFlipYTransition() +CCTransitionFlipY::~CCTransitionFlipY() { } -void CCFlipYTransition::onEnter() +void CCTransitionFlipY::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -726,9 +726,9 @@ void CCFlipYTransition::onEnter() } -CCFlipYTransition* CCFlipYTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionFlipY* CCTransitionFlipY::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCFlipYTransition* pScene = new CCFlipYTransition(); + CCTransitionFlipY* pScene = new CCTransitionFlipY(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -738,16 +738,16 @@ CCFlipYTransition* CCFlipYTransition::transitionWithDuration(ccTime t, CCScene* // // FlipAngular Transition // -CCFlipAngularTransition::CCFlipAngularTransition() +CCTransitionFlipAngular::CCTransitionFlipAngular() { } -CCFlipAngularTransition::~CCFlipAngularTransition() +CCTransitionFlipAngular::~CCTransitionFlipAngular() { } -void CCFlipAngularTransition::onEnter() +void CCTransitionFlipAngular::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -790,9 +790,9 @@ void CCFlipAngularTransition::onEnter() m_pOutScene->runAction(outA); } -CCFlipAngularTransition* CCFlipAngularTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionFlipAngular* CCTransitionFlipAngular::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCFlipAngularTransition* pScene = new CCFlipAngularTransition(); + CCTransitionFlipAngular* pScene = new CCTransitionFlipAngular(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -802,16 +802,16 @@ CCFlipAngularTransition* CCFlipAngularTransition::transitionWithDuration(ccTime // // ZoomFlipX Transition // -CCZoomFlipXTransition::CCZoomFlipXTransition() +CCTransitionZoomFlipX::CCTransitionZoomFlipX() { } -CCZoomFlipXTransition::~CCZoomFlipXTransition() +CCTransitionZoomFlipX::~CCTransitionZoomFlipX() { } -void CCZoomFlipXTransition::onEnter() +void CCTransitionZoomFlipX::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -863,9 +863,9 @@ void CCZoomFlipXTransition::onEnter() m_pOutScene->runAction(outA); } -CCZoomFlipXTransition* CCZoomFlipXTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionZoomFlipX* CCTransitionZoomFlipX::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCZoomFlipXTransition* pScene = new CCZoomFlipXTransition(); + CCTransitionZoomFlipX* pScene = new CCTransitionZoomFlipX(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -875,16 +875,16 @@ CCZoomFlipXTransition* CCZoomFlipXTransition::transitionWithDuration(ccTime t, C // // ZoomFlipY Transition // -CCZoomFlipYTransition::CCZoomFlipYTransition() +CCTransitionZoomFlipY::CCTransitionZoomFlipY() { } -CCZoomFlipYTransition::~CCZoomFlipYTransition() +CCTransitionZoomFlipY::~CCTransitionZoomFlipY() { } -void CCZoomFlipYTransition::onEnter() +void CCTransitionZoomFlipY::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -936,9 +936,9 @@ void CCZoomFlipYTransition::onEnter() m_pOutScene->runAction(outA); } -CCZoomFlipYTransition* CCZoomFlipYTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionZoomFlipY* CCTransitionZoomFlipY::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCZoomFlipYTransition* pScene = new CCZoomFlipYTransition(); + CCTransitionZoomFlipY* pScene = new CCTransitionZoomFlipY(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -948,17 +948,17 @@ CCZoomFlipYTransition* CCZoomFlipYTransition::transitionWithDuration(ccTime t, C // // ZoomFlipAngular Transition // -CCZoomFlipAngularTransition::CCZoomFlipAngularTransition() +CCTransitionZoomFlipAngular::CCTransitionZoomFlipAngular() { } -CCZoomFlipAngularTransition::~CCZoomFlipAngularTransition() +CCTransitionZoomFlipAngular::~CCTransitionZoomFlipAngular() { } -void CCZoomFlipAngularTransition::onEnter() +void CCTransitionZoomFlipAngular::onEnter() { - CCOrientedTransitionScene::onEnter(); + CCTransitionSceneOriented::onEnter(); CCActionInterval *inA, *outA; m_pInScene->setIsVisible(false); @@ -1012,9 +1012,9 @@ void CCZoomFlipAngularTransition::onEnter() m_pOutScene->runAction(outA); } -CCZoomFlipAngularTransition* CCZoomFlipAngularTransition::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +CCTransitionZoomFlipAngular* CCTransitionZoomFlipAngular::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) { - CCZoomFlipAngularTransition* pScene = new CCZoomFlipAngularTransition(); + CCTransitionZoomFlipAngular* pScene = new CCTransitionZoomFlipAngular(); pScene->initWithDuration(t, s, o); pScene->autorelease(); @@ -1024,23 +1024,23 @@ CCZoomFlipAngularTransition* CCZoomFlipAngularTransition::transitionWithDuration // // Fade Transition // -CCFadeTransition::CCFadeTransition() +CCTransitionFade::CCTransitionFade() { } -CCFadeTransition::~CCFadeTransition() +CCTransitionFade::~CCTransitionFade() { } -CCFadeTransition * CCFadeTransition::transitionWithDuration(ccTime duration, CCScene *scene, ccColor3B color) +CCTransitionFade * CCTransitionFade::transitionWithDuration(ccTime duration, CCScene *scene, ccColor3B color) { - CCFadeTransition * pTransition = new CCFadeTransition(); + CCTransitionFade * pTransition = new CCTransitionFade(); pTransition->initWithDuration(duration, scene, color); pTransition->autorelease(); return pTransition; } -bool CCFadeTransition::initWithDuration(ccTime duration, CCScene *scene, ccColor3B color) +bool CCTransitionFade::initWithDuration(ccTime duration, CCScene *scene, ccColor3B color) { if (CCTransitionScene::initWithDuration(duration, scene)) { @@ -1051,17 +1051,17 @@ bool CCFadeTransition::initWithDuration(ccTime duration, CCScene *scene, ccColor return true; } -bool CCFadeTransition::initWithDuration(ccTime t, CCScene *scene) +bool CCTransitionFade::initWithDuration(ccTime t, CCScene *scene) { this->initWithDuration(t, scene, ccBLACK); return true; } -void CCFadeTransition :: onEnter() +void CCTransitionFade :: onEnter() { CCTransitionScene::onEnter(); - CCColorLayer* l = CCColorLayer::layerWithColor(m_tColor); + CCLayerColor* l = CCLayerColor::layerWithColor(m_tColor); m_pInScene->setIsVisible(false); addChild(l, 2, kSceneFade); @@ -1078,7 +1078,7 @@ void CCFadeTransition :: onEnter() f->runAction(a); } -void CCFadeTransition::onExit() +void CCTransitionFade::onExit() { CCTransitionScene::onExit(); this->removeChildByTag(kSceneFade, false); @@ -1087,20 +1087,20 @@ void CCFadeTransition::onExit() // // Cross Fade Transition // -CCCrossFadeTransition::CCCrossFadeTransition() +CCTransitionCrossFade::CCTransitionCrossFade() { } -CCCrossFadeTransition::~CCCrossFadeTransition() +CCTransitionCrossFade::~CCTransitionCrossFade() { } -void CCCrossFadeTransition:: draw() +void CCTransitionCrossFade:: draw() { // override draw since both scenes (textures) are rendered in 1 scene } -void CCCrossFadeTransition::onEnter() +void CCTransitionCrossFade::onEnter() { CCTransitionScene::onEnter(); @@ -1108,7 +1108,7 @@ void CCCrossFadeTransition::onEnter() // in which we are going to add our rendertextures ccColor4B color = {0,0,0,0}; CGSize size = CCDirector::sharedDirector()->getWinSize(); - CCColorLayer* layer = CCColorLayer::layerWithColor(color); + CCLayerColor* layer = CCLayerColor::layerWithColor(color); // create the first render texture for inScene CCRenderTexture* inTexture = CCRenderTexture::renderTextureWithWidthAndHeight((int)size.width, (int)size.height); @@ -1167,16 +1167,16 @@ void CCCrossFadeTransition::onEnter() } // clean up on exit -void CCCrossFadeTransition::onExit() +void CCTransitionCrossFade::onExit() { // remove our layer and release all containing objects this->removeChildByTag(kSceneFade, false); CCTransitionScene::onExit(); } -CCCrossFadeTransition* CCCrossFadeTransition::transitionWithDuration(ccTime d, CCScene* s) +CCTransitionCrossFade* CCTransitionCrossFade::transitionWithDuration(ccTime d, CCScene* s) { - CCCrossFadeTransition* Transition = new CCCrossFadeTransition(); + CCTransitionCrossFade* Transition = new CCTransitionCrossFade(); Transition->initWithDuration(d, s); Transition->autorelease(); @@ -1186,21 +1186,21 @@ CCCrossFadeTransition* CCCrossFadeTransition::transitionWithDuration(ccTime d, C // // TurnOffTilesTransition // -CCTurnOffTilesTransition::CCTurnOffTilesTransition() +CCTransitionTurnOffTiles::CCTransitionTurnOffTiles() { } -CCTurnOffTilesTransition::~CCTurnOffTilesTransition() +CCTransitionTurnOffTiles::~CCTransitionTurnOffTiles() { } // override addScenes, and change the order -void CCTurnOffTilesTransition::sceneOrder() +void CCTransitionTurnOffTiles::sceneOrder() { m_bIsInSceneOnTop = false; } -void CCTurnOffTilesTransition::onEnter() +void CCTransitionTurnOffTiles::onEnter() { CCTransitionScene::onEnter(); CGSize s = CCDirector::sharedDirector()->getWinSize(); @@ -1223,25 +1223,25 @@ void CCTurnOffTilesTransition::onEnter() } -CCActionInterval* CCTurnOffTilesTransition:: easeActionWithAction(CCActionInterval* action) +CCActionInterval* CCTransitionTurnOffTiles:: easeActionWithAction(CCActionInterval* action) { return action; } -IMPLEMENT_TRANSITIONWITHDURATION(CCTurnOffTilesTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionTurnOffTiles) // // SplitCols Transition // -CCSplitColsTransition::CCSplitColsTransition() +CCTransitionSplitCols::CCTransitionSplitCols() { } -CCSplitColsTransition::~CCSplitColsTransition() +CCTransitionSplitCols::~CCTransitionSplitCols() { } -void CCSplitColsTransition::onEnter() +void CCTransitionSplitCols::onEnter() { CCTransitionScene::onEnter(); m_pInScene->setIsVisible(false); @@ -1268,55 +1268,55 @@ void CCSplitColsTransition::onEnter() } -CCActionInterval* CCSplitColsTransition:: action() +CCActionInterval* CCTransitionSplitCols:: action() { return CCSplitCols::actionWithCols(3, m_fDuration/2.0f); } -CCActionInterval* CCSplitColsTransition::easeActionWithAction(CCActionInterval * action) +CCActionInterval* CCTransitionSplitCols::easeActionWithAction(CCActionInterval * action) { return CCEaseInOut::actionWithAction(action, 3.0f); } -IMPLEMENT_TRANSITIONWITHDURATION(CCSplitColsTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSplitCols) // // SplitRows Transition // -CCSplitRowsTransition::CCSplitRowsTransition() +CCTransitionSplitRows::CCTransitionSplitRows() { } -CCSplitRowsTransition::~CCSplitRowsTransition() +CCTransitionSplitRows::~CCTransitionSplitRows() { } -CCActionInterval* CCSplitRowsTransition::action() +CCActionInterval* CCTransitionSplitRows::action() { return CCSplitRows::actionWithRows(3, m_fDuration/2.0f); } -IMPLEMENT_TRANSITIONWITHDURATION(CCSplitRowsTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSplitRows) // // FadeTR Transition // -CCFadeTRTransition::CCFadeTRTransition() +CCTransitionFadeTR::CCTransitionFadeTR() { } -CCFadeTRTransition::~CCFadeTRTransition() +CCTransitionFadeTR::~CCTransitionFadeTR() { } -void CCFadeTRTransition::sceneOrder() +void CCTransitionFadeTR::sceneOrder() { m_bIsInSceneOnTop = false; } -void CCFadeTRTransition::onEnter() +void CCTransitionFadeTR::onEnter() { CCTransitionScene::onEnter(); @@ -1340,69 +1340,69 @@ void CCFadeTRTransition::onEnter() } -CCActionInterval* CCFadeTRTransition::actionWithSize(ccGridSize size) +CCActionInterval* CCTransitionFadeTR::actionWithSize(ccGridSize size) { return CCFadeOutTRTiles::actionWithSize(size, m_fDuration); } -CCActionInterval* CCFadeTRTransition:: easeActionWithAction(CCActionInterval* action) +CCActionInterval* CCTransitionFadeTR:: easeActionWithAction(CCActionInterval* action) { return action; } -IMPLEMENT_TRANSITIONWITHDURATION(CCFadeTRTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeTR) // // FadeBL Transition // -CCFadeBLTransition::CCFadeBLTransition() +CCTransitionFadeBL::CCTransitionFadeBL() { } -CCFadeBLTransition::~CCFadeBLTransition() +CCTransitionFadeBL::~CCTransitionFadeBL() { } -CCActionInterval* CCFadeBLTransition::actionWithSize(ccGridSize size) +CCActionInterval* CCTransitionFadeBL::actionWithSize(ccGridSize size) { return CCFadeOutBLTiles::actionWithSize(size, m_fDuration); } -IMPLEMENT_TRANSITIONWITHDURATION(CCFadeBLTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeBL) // // FadeUp Transition // -CCFadeUpTransition::CCFadeUpTransition() +CCTransitionFadeUp::CCTransitionFadeUp() { } -CCFadeUpTransition::~CCFadeUpTransition() +CCTransitionFadeUp::~CCTransitionFadeUp() { } -CCActionInterval* CCFadeUpTransition::actionWithSize(ccGridSize size) +CCActionInterval* CCTransitionFadeUp::actionWithSize(ccGridSize size) { return CCFadeOutUpTiles::actionWithSize(size, m_fDuration); } -IMPLEMENT_TRANSITIONWITHDURATION(CCFadeUpTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeUp) // // FadeDown Transition // -CCFadeDownTransition::CCFadeDownTransition() +CCTransitionFadeDown::CCTransitionFadeDown() { } -CCFadeDownTransition::~CCFadeDownTransition() +CCTransitionFadeDown::~CCTransitionFadeDown() { } -CCActionInterval* CCFadeDownTransition::actionWithSize(ccGridSize size) +CCActionInterval* CCTransitionFadeDown::actionWithSize(ccGridSize size) { return CCFadeOutDownTiles::actionWithSize(size, m_fDuration); } -IMPLEMENT_TRANSITIONWITHDURATION(CCFadeDownTransition) +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeDown) }//namespace cocos2d diff --git a/cocos2dx/platform/mac/CCLayer_mac.cpp b/cocos2dx/platform/mac/CCLayer_mac.cpp new file mode 100644 index 0000000000..9e9a2d45ea --- /dev/null +++ b/cocos2dx/platform/mac/CCLayer_mac.cpp @@ -0,0 +1,658 @@ +/**************************************************************************** +Copyright (c) 2010 cocos2d-x.org + +http://www.cocos2d-x.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +****************************************************************************/ + +#include +#include "CCLayer.h" +#include "CCTouchDispatcher.h" +#include "CCKeypadDispatcher.h" +#include "CCDirector.h" +#include "CGPointExtension.h" +namespace cocos2d { + +// CCLayer +CCLayer::CCLayer() +:m_bIsTouchEnabled(false) +,m_bIsAccelerometerEnabled(false) +,m_bIsKeypadEnabled(false) +,m_bIsMouseEnabled(false) +,m_bIsKeyboardEnabled(false) +{ + m_eTouchDelegateType = ccTouchDeletateAllBit; + m_tAnchorPoint = ccp(0.5f, 0.5f); + m_bIsRelativeAnchorPoint = false; +} + +CCLayer::~CCLayer() +{ +} + +bool CCLayer::init() +{ + bool bRet = false; + do + { + CCDirector * pDirector; + CCX_BREAK_IF( ! (pDirector = CCDirector::sharedDirector()) ); + this->setContentSize(pDirector->getWinSize()); + // success + bRet = true; + } while (0); + return bRet; +} + +CCLayer *CCLayer::node() +{ + CCLayer *pRet = new CCLayer(); + if (pRet && pRet->init()) + { + pRet->autorelease(); + return pRet; + } + else + { + CCX_SAFE_DELETE(pRet) + return NULL; + } +} + +/// Touch and Accelerometer related + +void CCLayer::registerWithTouchDispatcher() +{ + CCLOG("cocos2d: CCLayer: unsupported!"); +} + +void CCLayer::destroy(void) +{ + this->release(); +} + +void CCLayer::keep(void) +{ + this->retain(); +} + +void CCLayer::AccelerometerDestroy(void) +{ + this->release(); +} + +void CCLayer::AccelerometerKeep(void) +{ + this->retain(); +} + +void CCLayer::KeypadDestroy() +{ + this->release(); +} + +void CCLayer::KeypadKeep() +{ + this->retain(); +} + +bool CCLayer::getIsMouseEnabled() +{ + return m_bIsMouseEnabled; +} + +void CCLayer::setIsMouseEnabled(bool enabled) +{ + if( m_bIsMouseEnabled != enabled ) + { + m_bIsMouseEnabled = enabled; + + if( m_bIsRunning ) + { + if( enabled ) + { + CCEventDispatcher::sharedDispatcher()->addMouseDelegate(this, mouseDelegatePriority()); + } + else + { + CCEventDispatcher::sharedDispatcher()->removeMouseDelegate(this); + } + } + } +} + +bool CCLayer::getIsKeyboardEnabled() +{ + return m_bIsKeyboardEnabled; +} + +void CCLayer::setIsKeyboardEnabled(bool enabled) +{ + if( m_bIsKeyboardEnabled != enabled ) + { + m_bIsKeyboardEnabled = enabled; + + if( m_bIsRunning ) + { + if( enabled ) + { + CCEventDispatcher::sharedDispatcher()->addKeyboardDelegate(this, keyboardDelegatePriority()); + } + else + { + CCEventDispatcher::sharedDispatcher()->removeKeyboardDelegate(this); + } + } + } +} + +/// isTouchEnabled getter +bool CCLayer::getIsTouchEnabled() +{ + return m_bIsTouchEnabled; +} +/// isTouchEnabled setter +void CCLayer::setIsTouchEnabled(bool enabled) +{ + CCLOG("cocos2d: CCLayer: unsupported!"); +} + +/// isAccelerometerEnabled getter +bool CCLayer::getIsAccelerometerEnabled() +{ + return m_bIsAccelerometerEnabled; +} +/// isAccelerometerEnabled setter +void CCLayer::setIsAccelerometerEnabled(bool enabled) +{ + CCLOG("cocos2d: CCLayer: unsupported!"); +} + +/// isKeypadEnabled getter +bool CCLayer::getIsKeypadEnabled() +{ + return m_bIsKeypadEnabled; +} +/// isKeypadEnabled setter +void CCLayer::setIsKeypadEnabled(bool enabled) +{ + if (enabled != m_bIsKeypadEnabled) + { + m_bIsKeypadEnabled = enabled; + + if (m_bIsRunning) + { + if (enabled) + { + CCKeypadDispatcher::sharedDispatcher()->addDelegate(this); + } + else + { + CCKeypadDispatcher::sharedDispatcher()->removeDelegate(this); + } + } + } +} + + +/// Callbacks +void CCLayer::onEnter() +{ + if(m_bIsMouseEnabled) + { + CCEventDispatcher::sharedDispatcher()->addMouseDelegate(this, mouseDelegatePriority()); + } + + if( m_bIsKeyboardEnabled) + { + CCEventDispatcher::sharedDispatcher()->addKeyboardDelegate(this, keyboardDelegatePriority()); + } + + // then iterate over all the children + CCNode::onEnter(); + + // add this layer to concern the kaypad msg + if (m_bIsKeypadEnabled) + { + CCKeypadDispatcher::sharedDispatcher()->addDelegate(this); + } +} + +void CCLayer::onExit() +{ + if(m_bIsMouseEnabled) + { + CCEventDispatcher::sharedDispatcher()->removeMouseDelegate(this, mouseDelegatePriority()); + } + + if( m_bIsKeyboardEnabled) + { + CCEventDispatcher::sharedDispatcher()->removeKeyboardDelegate(this, keyboardDelegatePriority()); + } + + // remove this layer from the delegates who concern the kaypad msg + if (m_bIsKeypadEnabled) + { + CCKeypadDispatcher::sharedDispatcher()->removeDelegate(this); + } + + CCNode::onExit(); +} + +void CCLayer::onEnterTransitionDidFinish() +{ + CCNode::onEnterTransitionDidFinish(); +} + +bool CCLayer::ccTouchBegan(CCTouch *pTouch, UIEvent *pEvent) +{ + CCLOG("cocos2d: CCLayer: unsupported!"); + return false; +} + +// +// ColorLayer +// +CCLayerColor::CCLayerColor() +{ +} +CCLayerColor::~CCLayerColor() +{ +} + +// Opacity and RGB color protocol +/// opacity getter +GLubyte CCLayerColor::getOpacity() +{ + return m_cOpacity; +} +/// opacity setter +void CCLayerColor::setOpacity(GLubyte var) +{ + m_cOpacity = var; + updateColor(); +} + +/// color getter +ccColor3B CCLayerColor::getColor() +{ + return m_tColor; +} + +/// color setter +void CCLayerColor::setColor(ccColor3B var) +{ + m_tColor = var; + updateColor(); +} + + +/// blendFunc getter +ccBlendFunc CCLayerColor::getBlendFunc() +{ + return m_tBlendFunc; +} +/// blendFunc setter +void CCLayerColor::setBlendFunc(ccBlendFunc var) +{ + m_tBlendFunc = var; +} + + +CCLayerColor * CCLayerColor::layerWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) +{ + CCLayerColor * pLayer = new CCLayerColor(); + if( pLayer && pLayer->initWithColorWidthHeight(color,width,height)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} +CCLayerColor * CCLayerColor::layerWithColor(ccColor4B color) +{ + CCLayerColor * pLayer = new CCLayerColor(); + if(pLayer && pLayer->initWithColor(color)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} + +bool CCLayerColor::initWithColorWidthHeight(ccColor4B color, GLfloat width, GLfloat height) +{ + // default blend function + m_tBlendFunc.src = CC_BLEND_SRC; + m_tBlendFunc.dst = CC_BLEND_DST; + + m_tColor.r = color.r; + m_tColor.g = color.g; + m_tColor.b = color.b; + m_cOpacity = color.a; + + for (unsigned int i=0; iupdateColor(); + this->setContentSize(CGSizeMake(width,height)); + return true; +} + +bool CCLayerColor::initWithColor(ccColor4B color) +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + this->initWithColorWidthHeight(color, s.width, s.height); + return true; +} + +/// override contentSize +void CCLayerColor::setContentSize(CGSize size) +{ + m_pSquareVertices[2] = size.width * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[5] = size.height * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[6] = size.width * CC_CONTENT_SCALE_FACTOR(); + m_pSquareVertices[7] = size.height * CC_CONTENT_SCALE_FACTOR(); + + CCLayer::setContentSize(size); +} + +void CCLayerColor::changeWidthAndHeight(GLfloat w ,GLfloat h) +{ + this->setContentSize(CGSizeMake(w, h)); +} + +void CCLayerColor::changeWidth(GLfloat w) +{ + this->setContentSize(CGSizeMake(w, m_tContentSize.height)); +} + +void CCLayerColor::changeHeight(GLfloat h) +{ + this->setContentSize(CGSizeMake(m_tContentSize.width, h)); +} + +void CCLayerColor::updateColor() +{ + for( unsigned int i=0; i < 4; i++ ) + { + m_pSquareColors[i * 4] = m_tColor.r; + m_pSquareColors[i * 4 + 1] = m_tColor.g; + m_pSquareColors[i * 4 + 2] = m_tColor.b; + m_pSquareColors[i * 4 + 3] = m_cOpacity; + } +} + +void CCLayerColor::draw() +{ + // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY + // Needed states: GL_VERTEX_ARRAY, GL_COLOR_ARRAY + // Unneeded states: GL_TEXTURE_2D, GL_TEXTURE_COORD_ARRAY + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisable(GL_TEXTURE_2D); + + glVertexPointer(2, GL_FLOAT, 0, m_pSquareVertices); + glColorPointer(4, GL_UNSIGNED_BYTE, 0, m_pSquareColors); + + bool newBlend = false; + if( m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST ) { + newBlend = true; + glBlendFunc(m_tBlendFunc.src, m_tBlendFunc.dst); + } + else if( m_cOpacity != 255 ) { + newBlend = true; + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + + if( newBlend ) + glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST); + + // restore default GL state + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glEnable(GL_TEXTURE_2D); +} + +// +// CCLayerGradient +// +CCLayerGradient* CCLayerGradient::layerWithColor(ccColor4B start, ccColor4B end) +{ + CCLayerGradient * pLayer = new CCLayerGradient(); + if( pLayer && pLayer->initWithColor(start, end)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} + +CCLayerGradient* CCLayerGradient::layerWithColor(ccColor4B start, ccColor4B end, CGPoint v) +{ + CCLayerGradient * pLayer = new CCLayerGradient(); + if( pLayer && pLayer->initWithColor(start, end, v)) + { + pLayer->autorelease(); + return pLayer; + } + CCX_SAFE_DELETE(pLayer); + return NULL; +} + +bool CCLayerGradient::initWithColor(ccColor4B start, ccColor4B end) +{ + return initWithColor(start, end, ccp(0, -1)); +} + +bool CCLayerGradient::initWithColor(ccColor4B start, ccColor4B end, CGPoint v) +{ + m_endColor.r = end.r; + m_endColor.g = end.g; + m_endColor.b = end.b; + + m_cEndOpacity = end.a; + m_cStartOpacity = start.a; + m_AlongVector = v; + + start.a = 255; + return this->initWithColor(start); +} + +void CCLayerGradient::updateColor() +{ + CCLayerColor::updateColor(); + + float h = sqrtf(m_AlongVector.x * m_AlongVector.x + m_AlongVector.y * m_AlongVector.y); + if (h == 0) + return; + + double c = sqrt(2); + CGPoint u = ccp(m_AlongVector.x / h, m_AlongVector.y / h); + + float opacityf = (float)m_cOpacity / 255.0f; + + ccColor4B S = { + m_tColor.r, + m_tColor.g, + m_tColor.b, + m_cStartOpacity * opacityf + }; + + ccColor4B E = { + m_endColor.r, + m_endColor.g, + m_endColor.b, + m_cEndOpacity * opacityf + }; + + // (-1, -1) + m_pSquareColors[0] = E.r + (S.r - E.r) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[1] = E.g + (S.g - E.g) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[2] = E.b + (S.b - E.b) * ((c + u.x + u.y) / (2.0f * c)); + m_pSquareColors[3] = E.a + (S.a - E.a) * ((c + u.x + u.y) / (2.0f * c)); + // (1, -1) + m_pSquareColors[4] = E.r + (S.r - E.r) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[5] = E.g + (S.g - E.g) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[6] = E.b + (S.b - E.b) * ((c - u.x + u.y) / (2.0f * c)); + m_pSquareColors[7] = E.a + (S.a - E.a) * ((c - u.x + u.y) / (2.0f * c)); + // (-1, 1) + m_pSquareColors[8] = E.r + (S.r - E.r) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[9] = E.g + (S.g - E.g) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[10] = E.b + (S.b - E.b) * ((c + u.x - u.y) / (2.0f * c)); + m_pSquareColors[11] = E.a + (S.a - E.a) * ((c + u.x - u.y) / (2.0f * c)); + // (1, 1) + m_pSquareColors[12] = E.r + (S.r - E.r) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[13] = E.g + (S.g - E.g) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[14] = E.b + (S.b - E.b) * ((c - u.x - u.y) / (2.0f * c)); + m_pSquareColors[15] = E.a + (S.a - E.a) * ((c - u.x - u.y) / (2.0f * c)); +} + +ccColor3B CCLayerGradient::getStartColor() +{ + return m_tColor; +} + +void CCLayerGradient::setStartColor(ccColor3B colors) +{ + setColor(colors); +} + +void CCLayerGradient::setEndColor(ccColor3B colors) +{ + m_endColor = colors; + updateColor(); +} + +ccColor3B CCLayerGradient::getEndColor() +{ + return m_endColor; +} + +void CCLayerGradient::setStartOpacity(GLubyte o) +{ + m_cStartOpacity = o; + updateColor(); +} + +GLubyte CCLayerGradient::getStartOpacity() +{ + return m_cStartOpacity; +} + +void CCLayerGradient::setEndOpacity(GLubyte o) +{ + m_cEndOpacity = o; + updateColor(); +} + +GLubyte CCLayerGradient::getEndOpacity() +{ + return m_cEndOpacity; +} + +void CCLayerGradient::setAlongVector(CGPoint var) +{ + m_AlongVector = var; + updateColor(); +} + +CGPoint CCLayerGradient::getAlongVector() +{ + return m_AlongVector; +} + +/// MultiplexLayer + +CCMultiplexLayer::CCMultiplexLayer() +{ +} +CCMultiplexLayer::~CCMultiplexLayer() +{ + m_pLayers->release(); +} + +CCMultiplexLayer * CCMultiplexLayer::layerWithLayers(CCLayer * layer, ...) +{ + va_list args; + va_start(args,layer); + + CCMultiplexLayer * pMultiplexLayer = new CCMultiplexLayer(); + if(pMultiplexLayer && pMultiplexLayer->initWithLayers(layer, args)) + { + pMultiplexLayer->autorelease(); + va_end(args); + return pMultiplexLayer; + } + va_end(args); + CCX_SAFE_DELETE(pMultiplexLayer); + return NULL; +} + +bool CCMultiplexLayer::initWithLayers(CCLayer *layer, va_list params) +{ + m_pLayers = new NSMutableArray(5); + //m_pLayers->retain(); + + m_pLayers->addObject(layer); + + CCLayer *l = va_arg(params,CCLayer*); + while( l ) { + m_pLayers->addObject(l); + l = va_arg(params,CCLayer*); + } + + m_nEnabledLayer = 0; + this->addChild(m_pLayers->getObjectAtIndex(m_nEnabledLayer)); + + return true; +} + + +void CCMultiplexLayer::switchTo(unsigned int n) +{ + NSAssert( n < m_pLayers->count(), "Invalid index in MultiplexLayer switchTo message" ); + + this->removeChild(m_pLayers->getObjectAtIndex(m_nEnabledLayer), true); + + m_nEnabledLayer = n; + + this->addChild(m_pLayers->getObjectAtIndex(n)); +} + +void CCMultiplexLayer::switchToAndReleaseMe(unsigned int n) +{ + NSAssert( n < m_pLayers->count(), "Invalid index in MultiplexLayer switchTo message" ); + + this->removeChild(m_pLayers->getObjectAtIndex(m_nEnabledLayer), true); + + //[layers replaceObjectAtIndex:enabledLayer withObject:[NSNull null]]; + m_pLayers->replaceObjectAtIndex(m_nEnabledLayer, NULL); + + m_nEnabledLayer = n; + + this->addChild(m_pLayers->getObjectAtIndex(n)); +} +}//namespace cocos2d diff --git a/cocos2dx/platform/mac/CCMenu_mac.cpp b/cocos2dx/platform/mac/CCMenu_mac.cpp index bfc8c23acd..55c0543ea6 100644 --- a/cocos2dx/platform/mac/CCMenu_mac.cpp +++ b/cocos2dx/platform/mac/CCMenu_mac.cpp @@ -126,6 +126,38 @@ namespace cocos2d{ CCLayer::onExit(); } + void CCMenu::registerWithTouchDispatcher() + { + CCLOG("cocos2d: CCMenu: unsupported"); + } + + CCMenuItem* CCMenu::itemForTouch(CCTouch * touch) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NULL; + } + + bool CCMenu::ccTouchBegan(CCTouch* touch, UIEvent* event) + { + CCLOG("cocos2d: CCMenu: unsupported"); + return NO; + } + + void CCMenu::ccTouchEnded(CCTouch* touch, UIEvent* event) + { + CCLOG("cocos2d: CCMenu: unsupported"); + } + + void CCMenu::ccTouchCancelled(CCTouch *touch, UIEvent* event) + { + CCLOG("cocos2d: CCMenu: unsupported"); + } + + void CCMenu::ccTouchMoved(CCTouch* touch, UIEvent* event) + { + CCLOG("cocos2d: CCMenu: unsupported"); + } + //Menu - Events int CCMenu::mouseDelegatePriority() { @@ -591,41 +623,5 @@ namespace cocos2d{ ccColor3B CCMenu::getColor(void) { return m_tColor; - } - - CCMenuItem* CCMenu::itemForTouch(cocos2d::CCTouch *touch) - { - CGPoint touchLocation = touch->locationInView(touch->view()); - touchLocation = CCDirector::sharedDirector()->convertToGL(touchLocation); - - if (m_pChildren && m_pChildren->count() > 0) - { - NSMutableArray::NSMutableArrayIterator it; - for (it = m_pChildren->begin(); it != m_pChildren->end(); ++it) - { - if (! *it) - { - break; - } - - // ignore invisible and disabled items: issue #779, #866 - if ((*it)->getIsVisible() && ((CCMenuItem*)(*it))->getIsEnabled()) - { - CGPoint local = (*it)->convertToNodeSpace(touchLocation); - - CGRect r = ((CCMenuItem*)(*it))->rect(); - r.origin = CGPointZero; - - if (CGRect::CGRectContainsPoint(r, local)) - { - return (CCMenuItem*)(*it); - } - } - } - - } - - return NULL; - } - + } } diff --git a/cocos2dx/platform/mac/CCTransition_mac.cpp b/cocos2dx/platform/mac/CCTransition_mac.cpp new file mode 100644 index 0000000000..923f2ee0fd --- /dev/null +++ b/cocos2dx/platform/mac/CCTransition_mac.cpp @@ -0,0 +1,1408 @@ +/**************************************************************************** +Copyright (c) 2010 cocos2d-x.org + +http://www.cocos2d-x.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +****************************************************************************/ + +#include "CCTransition.h" +#include "CCCamera.h" +#include "CGPointExtension.h" +#include "CCDirector.h" +#include "CCTouchDispatcher.h" +#include "CCActionInterval.h" +#include "CCActionInstant.h" +#include "CCActionEase.h" +#include "CCActionCamera.h" +#include "CCLayer.h" +#include "CCActionGrid.h" +#include "CCRenderTexture.h" +#include "CCActionTiledGrid.h" +namespace cocos2d { + +enum { + kSceneFade = 0xFADEFADE, +}; + +#define IMPLEMENT_TRANSITIONWITHDURATION(_Type)\ + _Type* _Type::transitionWithDuration(ccTime t, CCScene* scene)\ +{\ + _Type* pScene = new _Type();\ + if(pScene && pScene->initWithDuration(t, scene)){\ + pScene->autorelease();\ + return pScene;}\ + CCX_SAFE_DELETE(pScene);\ + return NULL;\ +} + + + +CCTransitionScene::CCTransitionScene() +{ +} +CCTransitionScene::~CCTransitionScene() +{ + m_pInScene->release(); + m_pOutScene->release(); +} + +CCTransitionScene * CCTransitionScene::transitionWithDuration(ccTime t, CCScene *scene) +{ + CCTransitionScene * pScene = new CCTransitionScene(); + if(pScene && pScene->initWithDuration(t,scene)) + { + pScene->autorelease(); + return pScene; + } + CCX_SAFE_DELETE(pScene); + return NULL; +} + +bool CCTransitionScene::initWithDuration(ccTime t, CCScene *scene) +{ + NSAssert( scene != NULL, "Argument scene must be non-nil"); + + if (CCScene::init()) + { + m_fDuration = t; + + // retain + m_pInScene = scene; + m_pInScene->retain(); + m_pOutScene = CCDirector::sharedDirector()->getRunningScene(); + m_pOutScene->retain(); + m_eSceneType = ccTransitionScene; + + NSAssert( m_pInScene != m_pOutScene, "Incoming scene must be different from the outgoing scene" ); + + // disable events while transitions + CCEventDispatcher::sharedDispatcher()->setDispatchEvents(false); + this->sceneOrder(); + + return true; + } + else + { + return false; + } +} + +void CCTransitionScene::sceneOrder() +{ + m_bIsInSceneOnTop = true; +} + +void CCTransitionScene::draw() +{ + if( m_bIsInSceneOnTop ) { + m_pOutScene->visit(); + m_pInScene->visit(); + } else { + m_pInScene->visit(); + m_pOutScene->visit(); + } +} + +void CCTransitionScene::finish() +{ + // clean up + m_pInScene->setIsVisible(true); + m_pInScene->setPosition(ccp(0,0)); + m_pInScene->setScale(1.0f); + m_pInScene->setRotation(0.0f); + m_pInScene->getCamera()->restore(); + + m_pOutScene->setIsVisible(false); + m_pOutScene->setPosition(ccp(0,0)); + m_pOutScene->setScale(1.0f); + m_pOutScene->setRotation(0.0f); + m_pOutScene->getCamera()->restore(); + + //[self schedule:@selector(setNewScene:) interval:0]; + this->schedule(schedule_selector(CCTransitionScene::setNewScene), 0); + +} + +void CCTransitionScene::setNewScene(ccTime dt) +{ + // [self unschedule:_cmd]; + // "_cmd" is a local variable automatically defined in a method + // that contains the selector for the method + this->unschedule(schedule_selector(CCTransitionScene::setNewScene)); + CCDirector *director = CCDirector::sharedDirector(); + // Before replacing, save the "send cleanup to scene" + m_bIsSendCleanupToScene = director->isSendCleanupToScene(); + director->replaceScene(m_pInScene); + // enable events while transitions + CCEventDispatcher::sharedDispatcher()->setDispatchEvents(true); + // issue #267 + m_pOutScene->setIsVisible(true); +} + +void CCTransitionScene::hideOutShowIn() +{ + m_pInScene->setIsVisible(true); + m_pOutScene->setIsVisible(false); +} + + +// custom onEnter +void CCTransitionScene::onEnter() +{ + CCScene::onEnter(); + m_pInScene->onEnter(); + // outScene should not receive the onEnter callback +} + +// custom onExit +void CCTransitionScene::onExit() +{ + CCScene::onExit(); + m_pOutScene->onExit(); + + // inScene should not receive the onExit callback + // only the onEnterTransitionDidFinish + m_pInScene->onEnterTransitionDidFinish(); +} + +// custom cleanup +void CCTransitionScene::cleanup() +{ + CCScene::cleanup(); + + if( m_bIsSendCleanupToScene ) + m_pOutScene->cleanup(); +} + +// +// Oriented Transition +// +CCTransitionSceneOriented::CCTransitionSceneOriented() +{ +} +CCTransitionSceneOriented::~CCTransitionSceneOriented() +{ +} + +CCTransitionSceneOriented * CCTransitionSceneOriented::transitionWithDuration(ccTime t, CCScene *scene, tOrientation orientation) +{ + CCTransitionSceneOriented * pScene = new CCTransitionSceneOriented(); + pScene->initWithDuration(t,scene,orientation); + pScene->autorelease(); + return pScene; +} + +bool CCTransitionSceneOriented::initWithDuration(ccTime t, CCScene *scene, tOrientation orientation) +{ + if ( CCTransitionScene::initWithDuration(t, scene) ) + { + m_eOrientation = orientation; + } + return true; +} + +// +// RotoZoom +// +CCTransitionRotoZoom::CCTransitionRotoZoom() +{ +} +CCTransitionRotoZoom::~CCTransitionRotoZoom() +{ +} + +void CCTransitionRotoZoom:: onEnter() +{ + CCTransitionScene::onEnter(); + + m_pInScene->setScale(0.001f); + m_pOutScene->setScale(1.0f); + + m_pInScene->setAnchorPoint(ccp(0.5f, 0.5f)); + m_pOutScene->setAnchorPoint(ccp(0.5f, 0.5f)); + + CCActionInterval *rotozoom = (CCActionInterval*)(CCSequence::actions + ( + CCSpawn::actions + ( + CCScaleBy::actionWithDuration(m_fDuration/2, 0.001f), + CCRotateBy::actionWithDuration(m_fDuration/2, 360 * 2), + NULL + ), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + )); + + m_pOutScene->runAction(rotozoom); + m_pInScene->runAction + ( + CCSequence::actions + ( + rotozoom->reverse(), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ) + ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionRotoZoom) + + +// +// JumpZoom +// +CCTransitionJumpZoom::CCTransitionJumpZoom() +{ +} +CCTransitionJumpZoom::~CCTransitionJumpZoom() +{ +} + +void CCTransitionJumpZoom::onEnter() +{ + CCTransitionScene::onEnter(); + CGSize s = CCDirector::sharedDirector()->getWinSize(); + + m_pInScene->setScale(0.5f); + m_pInScene->setPosition(ccp(s.width, 0)); + m_pInScene->setAnchorPoint(ccp(0.5f, 0.5f)); + m_pOutScene->setAnchorPoint(ccp(0.5f, 0.5f)); + + CCActionInterval *jump = CCJumpBy::actionWithDuration(m_fDuration/4, ccp(-s.width,0), s.width/4, 2); + CCActionInterval *scaleIn = CCScaleTo::actionWithDuration(m_fDuration/4, 1.0f); + CCActionInterval *scaleOut = CCScaleTo::actionWithDuration(m_fDuration/4, 0.5f); + + CCActionInterval *jumpZoomOut = (CCActionInterval*)(CCSequence::actions(scaleOut, jump, NULL)); + CCActionInterval *jumpZoomIn = (CCActionInterval*)(CCSequence::actions(jump, scaleIn, NULL)); + + CCActionInterval *delay = CCDelayTime::actionWithDuration(m_fDuration/2); + + m_pOutScene->runAction(jumpZoomOut); + m_pInScene->runAction + ( + CCSequence::actions + ( + delay, + jumpZoomIn, + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ) + ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionJumpZoom) + +// +// MoveInL +// +CCTransitionMoveInL::CCTransitionMoveInL() +{ +} +CCTransitionMoveInL::~CCTransitionMoveInL() +{ +} + +void CCTransitionMoveInL::onEnter() +{ + CCTransitionScene::onEnter(); + this->initScenes(); + + CCActionInterval *a = this->action(); + + m_pInScene->runAction + ( + CCSequence::actions + ( + this->easeActionWithAction(a), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ) + ); +} + +CCActionInterval* CCTransitionMoveInL::action() +{ + return CCMoveTo::actionWithDuration(m_fDuration, ccp(0,0)); +} + +CCActionInterval* CCTransitionMoveInL::easeActionWithAction(CCActionInterval* action) +{ + return CCEaseOut::actionWithAction(action, 2.0f); +// return [EaseElasticOut actionWithAction:action period:0.4f]; +} + +void CCTransitionMoveInL::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(-s.width,0) ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInL) + +// +// MoveInR +// +CCTransitionMoveInR::CCTransitionMoveInR() +{ +} +CCTransitionMoveInR::~CCTransitionMoveInR() +{ +} + +void CCTransitionMoveInR::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(s.width,0) ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInR) + +// +// MoveInT +// +CCTransitionMoveInT::CCTransitionMoveInT() +{ +} +CCTransitionMoveInT::~CCTransitionMoveInT() +{ +} + +void CCTransitionMoveInT::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(0,s.height) ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInT) + +// +// MoveInB +// +CCTransitionMoveInB::CCTransitionMoveInB() +{ +} +CCTransitionMoveInB::~CCTransitionMoveInB() +{ +} + +void CCTransitionMoveInB::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(0,-s.height) ); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionMoveInB) + + +// +// SlideInL +// + +// The adjust factor is needed to prevent issue #442 +// One solution is to use DONT_RENDER_IN_SUBPIXELS images, but NO +// The other issue is that in some transitions (and I don't know why) +// the order should be reversed (In in top of Out or vice-versa). +#define ADJUST_FACTOR 0.5f +CCTransitionSlideInL::CCTransitionSlideInL() +{ +} +CCTransitionSlideInL::~CCTransitionSlideInL() +{ +} + +void CCTransitionSlideInL::onEnter() +{ + CCTransitionScene::onEnter(); + this->initScenes(); + + CCActionInterval *in = this->action(); + CCActionInterval *out = this->action(); + + CCActionInterval* inAction = easeActionWithAction(in); + CCActionInterval* outAction = (CCActionInterval*)CCSequence::actions + ( + easeActionWithAction(out), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + m_pInScene->runAction(inAction); + m_pOutScene->runAction(outAction); +} + +void CCTransitionSlideInL::sceneOrder() +{ + m_bIsInSceneOnTop = false; +} + +void CCTransitionSlideInL:: initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(-(s.width-ADJUST_FACTOR),0) ); +} + +CCActionInterval* CCTransitionSlideInL::action() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + return CCMoveBy::actionWithDuration(m_fDuration, ccp(s.width-ADJUST_FACTOR,0)); +} + +CCActionInterval* CCTransitionSlideInL::easeActionWithAction(CCActionInterval* action) +{ + return CCEaseOut::actionWithAction(action, 2.0f); +// return [EaseElasticOut actionWithAction:action period:0.4f]; +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInL) + + +// +// SlideInR +// +CCTransitionSlideInR::CCTransitionSlideInR() +{ +} +CCTransitionSlideInR::~CCTransitionSlideInR() +{ +} + +void CCTransitionSlideInR::sceneOrder() +{ + m_bIsInSceneOnTop = true; +} + +void CCTransitionSlideInR::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(s.width-ADJUST_FACTOR,0) ); +} + + +CCActionInterval* CCTransitionSlideInR:: action() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + return CCMoveBy::actionWithDuration(m_fDuration, ccp(-(s.width-ADJUST_FACTOR),0)); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInR) + + +// +// SlideInT +// +CCTransitionSlideInT::CCTransitionSlideInT() +{ +} +CCTransitionSlideInT::~CCTransitionSlideInT() +{ +} + +void CCTransitionSlideInT::sceneOrder() +{ + m_bIsInSceneOnTop = false; +} + +void CCTransitionSlideInT::initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(0,s.height-ADJUST_FACTOR) ); +} + + +CCActionInterval* CCTransitionSlideInT::action() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + return CCMoveBy::actionWithDuration(m_fDuration, ccp(0,-(s.height-ADJUST_FACTOR))); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInT) + +// +// SlideInB +// +CCTransitionSlideInB::CCTransitionSlideInB() +{ +} +CCTransitionSlideInB::~CCTransitionSlideInB() +{ +} + +void CCTransitionSlideInB::sceneOrder() +{ + m_bIsInSceneOnTop = true; +} + +void CCTransitionSlideInB:: initScenes() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + m_pInScene->setPosition( ccp(0,-(s.height-ADJUST_FACTOR)) ); +} + + +CCActionInterval* CCTransitionSlideInB:: action() +{ + CGSize s = CCDirector::sharedDirector()->getWinSize(); + return CCMoveBy::actionWithDuration(m_fDuration, ccp(0,s.height-ADJUST_FACTOR)); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSlideInB) + +// +// ShrinkGrow Transition +// +CCTransitionShrinkGrow::CCTransitionShrinkGrow() +{ +} +CCTransitionShrinkGrow::~CCTransitionShrinkGrow() +{ +} + +void CCTransitionShrinkGrow::onEnter() +{ + CCTransitionScene::onEnter(); + + m_pInScene->setScale(0.001f); + m_pOutScene->setScale(1.0f); + + m_pInScene->setAnchorPoint(ccp(2/3.0f,0.5f)); + m_pOutScene->setAnchorPoint(ccp(1/3.0f,0.5f)); + + CCActionInterval* scaleOut = CCScaleTo::actionWithDuration(m_fDuration, 0.01f); + CCActionInterval* scaleIn = CCScaleTo::actionWithDuration(m_fDuration, 1.0f); + + m_pInScene->runAction(this->easeActionWithAction(scaleIn)); + m_pOutScene->runAction + ( + CCSequence::actions + ( + this->easeActionWithAction(scaleOut), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ) + ); +} +CCActionInterval* CCTransitionShrinkGrow:: easeActionWithAction(CCActionInterval* action) +{ + return CCEaseOut::actionWithAction(action, 2.0f); +// return [EaseElasticOut actionWithAction:action period:0.3f]; +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionShrinkGrow) + +// +// FlipX Transition +// +CCTransitionFlipX::CCTransitionFlipX() +{ +} +CCTransitionFlipX::~CCTransitionFlipX() +{ +} + +void CCTransitionFlipX::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation == kOrientationRightOver ) + { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } + else + { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = (CCActionInterval*)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCShow::action(), + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 0, 0), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + + outA = (CCActionInterval *)CCSequence::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 0, 0), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); +} + +CCTransitionFlipX* CCTransitionFlipX::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionFlipX* pScene = new CCTransitionFlipX(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// FlipY Transition +// +CCTransitionFlipY::CCTransitionFlipY() +{ +} +CCTransitionFlipY::~CCTransitionFlipY() +{ +} + +void CCTransitionFlipY::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation == kOrientationUpOver ) + { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } + else + { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = (CCActionInterval*)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCShow::action(), + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 90, 0), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + outA = (CCActionInterval*)CCSequence::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 90, 0), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); + +} + +CCTransitionFlipY* CCTransitionFlipY::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionFlipY* pScene = new CCTransitionFlipY(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// FlipAngular Transition +// +CCTransitionFlipAngular::CCTransitionFlipAngular() +{ +} +CCTransitionFlipAngular::~CCTransitionFlipAngular() +{ +} + +void CCTransitionFlipAngular::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation == kOrientationRightOver ) + { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } + else + { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = (CCActionInterval *)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCShow::action(), + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, -45, 0), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + outA = (CCActionInterval *)CCSequence::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 45, 0), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); +} + +CCTransitionFlipAngular* CCTransitionFlipAngular::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionFlipAngular* pScene = new CCTransitionFlipAngular(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// ZoomFlipX Transition +// +CCTransitionZoomFlipX::CCTransitionZoomFlipX() +{ +} +CCTransitionZoomFlipX::~CCTransitionZoomFlipX() +{ +} + +void CCTransitionZoomFlipX::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } + else + { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + inA = (CCActionInterval *)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 0, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 1), + CCShow::action(), + NULL + ), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + outA = (CCActionInterval *)CCSequence::actions + ( + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 0, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 0.5f), + NULL + ), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->setScale(0.5f); + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); +} + +CCTransitionZoomFlipX* CCTransitionZoomFlipX::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionZoomFlipX* pScene = new CCTransitionZoomFlipX(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// ZoomFlipY Transition +// +CCTransitionZoomFlipY::CCTransitionZoomFlipY() +{ +} +CCTransitionZoomFlipY::~CCTransitionZoomFlipY() +{ +} + +void CCTransitionZoomFlipY::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation== kOrientationUpOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = (CCActionInterval *)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 90, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 1), + CCShow::action(), + NULL + ), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + + outA = (CCActionInterval *)CCSequence::actions + ( + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 90, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 0.5f), + NULL + ), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->setScale(0.5f); + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); +} + +CCTransitionZoomFlipY* CCTransitionZoomFlipY::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionZoomFlipY* pScene = new CCTransitionZoomFlipY(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// ZoomFlipAngular Transition +// +CCTransitionZoomFlipAngular::CCTransitionZoomFlipAngular() +{ +} +CCTransitionZoomFlipAngular::~CCTransitionZoomFlipAngular() +{ +} + + +void CCTransitionZoomFlipAngular::onEnter() +{ + CCTransitionSceneOriented::onEnter(); + + CCActionInterval *inA, *outA; + m_pInScene->setIsVisible(false); + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( m_eOrientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } + else + { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = (CCActionInterval *)CCSequence::actions + ( + CCDelayTime::actionWithDuration(m_fDuration/2), + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, -45, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 1), + CCShow::action(), + NULL + ), + CCShow::action(), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + outA = (CCActionInterval *)CCSequence::actions + ( + CCSpawn::actions + ( + CCOrbitCamera::actionWithDuration(m_fDuration/2, 1, 0 , outAngleZ, outDeltaZ, 45, 0), + CCScaleTo::actionWithDuration(m_fDuration/2, 0.5f), + NULL + ), + CCHide::action(), + CCDelayTime::actionWithDuration(m_fDuration/2), + NULL + ); + + m_pInScene->setScale(0.5f); + m_pInScene->runAction(inA); + m_pOutScene->runAction(outA); +} + +CCTransitionZoomFlipAngular* CCTransitionZoomFlipAngular::transitionWithDuration(ccTime t, CCScene* s, tOrientation o) +{ + CCTransitionZoomFlipAngular* pScene = new CCTransitionZoomFlipAngular(); + pScene->initWithDuration(t, s, o); + pScene->autorelease(); + + return pScene; +} + +// +// Fade Transition +// +CCTransitionFade::CCTransitionFade() +{ +} +CCTransitionFade::~CCTransitionFade() +{ +} + + +CCTransitionFade * CCTransitionFade::transitionWithDuration(ccTime duration, CCScene *scene, ccColor3B color) +{ + CCTransitionFade * pTransition = new CCTransitionFade(); + pTransition->initWithDuration(duration, scene, color); + pTransition->autorelease(); + return pTransition; +} + +bool CCTransitionFade::initWithDuration(ccTime duration, CCScene *scene, ccColor3B color) +{ + if (CCTransitionScene::initWithDuration(duration, scene)) + { + m_tColor.r = color.r; + m_tColor.g = color.g; + m_tColor.b = color.b; + } + return true; +} + +bool CCTransitionFade::initWithDuration(ccTime t, CCScene *scene) +{ + this->initWithDuration(t, scene, ccBLACK); + return true; +} + +void CCTransitionFade :: onEnter() +{ + CCTransitionScene::onEnter(); + + CCColorLayer* l = CCColorLayer::layerWithColor(m_tColor); + m_pInScene->setIsVisible(false); + + addChild(l, 2, kSceneFade); + CCNode* f = getChildByTag(kSceneFade); + + CCActionInterval* a = (CCActionInterval *)CCSequence::actions + ( + CCFadeIn::actionWithDuration(m_fDuration/2), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::hideOutShowIn)),//CCCallFunc::actionWithTarget:self selector:@selector(hideOutShowIn)], + CCFadeOut::actionWithDuration(m_fDuration/2), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), //:self selector:@selector(finish)], + NULL + ); + f->runAction(a); +} + +void CCTransitionFade::onExit() +{ + CCTransitionScene::onExit(); + this->removeChildByTag(kSceneFade, false); +} + +// +// Cross Fade Transition +// +CCTransitionCrossFade::CCTransitionCrossFade() +{ +} +CCTransitionCrossFade::~CCTransitionCrossFade() +{ +} + + +void CCTransitionCrossFade:: draw() +{ + // override draw since both scenes (textures) are rendered in 1 scene +} + +void CCTransitionCrossFade::onEnter() +{ + CCTransitionScene::onEnter(); + + // create a transparent color layer + // in which we are going to add our rendertextures + ccColor4B color = {0,0,0,0}; + CGSize size = CCDirector::sharedDirector()->getWinSize(); + CCColorLayer* layer = CCColorLayer::layerWithColor(color); + + // create the first render texture for inScene + CCRenderTexture* inTexture = CCRenderTexture::renderTextureWithWidthAndHeight((int)size.width, (int)size.height); + inTexture->getSprite()->setAnchorPoint( ccp(0.5f,0.5f) ); + inTexture->setPosition( ccp(size.width/2, size.height/2) ); + inTexture->setAnchorPoint( ccp(0.5f,0.5f) ); + + // render inScene to its texturebuffer + inTexture->begin(); + m_pInScene->visit(); + inTexture->end(); + + // create the second render texture for outScene + CCRenderTexture* outTexture = CCRenderTexture::renderTextureWithWidthAndHeight((int)size.width, (int)size.height); + outTexture->getSprite()->setAnchorPoint( ccp(0.5f,0.5f) ); + outTexture->setPosition( ccp(size.width/2, size.height/2) ); + outTexture->setAnchorPoint( ccp(0.5f,0.5f) ); + + // render outScene to its texturebuffer + outTexture->begin(); + m_pOutScene->visit(); + outTexture->end(); + + // create blend functions + + ccBlendFunc blend1 = {GL_ONE, GL_ONE}; // inScene will lay on background and will not be used with alpha + ccBlendFunc blend2 = {GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}; // we are going to blend outScene via alpha + + // set blendfunctions + inTexture->getSprite()->setBlendFunc(blend1); + outTexture->getSprite()->setBlendFunc(blend2); + + // add render textures to the layer + layer->addChild(inTexture); + layer->addChild(outTexture); + + // initial opacity: + inTexture->getSprite()->setOpacity(255); + outTexture->getSprite()->setOpacity(255); + + // create the blend action + CCAction* layerAction = CCSequence::actions + ( + CCFadeTo::actionWithDuration(m_fDuration, 0), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::hideOutShowIn)), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + NULL + ); + + + // run the blend action + outTexture->getSprite()->runAction( layerAction ); + + // add the layer (which contains our two rendertextures) to the scene + addChild(layer, 2, kSceneFade); +} + +// clean up on exit +void CCTransitionCrossFade::onExit() +{ + // remove our layer and release all containing objects + this->removeChildByTag(kSceneFade, false); + CCTransitionScene::onExit(); +} + +CCTransitionCrossFade* CCTransitionCrossFade::transitionWithDuration(ccTime d, CCScene* s) +{ + CCTransitionCrossFade* Transition = new CCTransitionCrossFade(); + Transition->initWithDuration(d, s); + Transition->autorelease(); + + return Transition; +} + +// +// TurnOffTilesTransition +// +CCTransitionTurnOffTiles::CCTransitionTurnOffTiles() +{ +} +CCTransitionTurnOffTiles::~CCTransitionTurnOffTiles() +{ +} + + +// override addScenes, and change the order +void CCTransitionTurnOffTiles::sceneOrder() +{ + m_bIsInSceneOnTop = false; +} + +void CCTransitionTurnOffTiles::onEnter() +{ + CCTransitionScene::onEnter(); + CGSize s = CCDirector::sharedDirector()->getWinSize(); + float aspect = s.width / s.height; + int x = (int)(12 * aspect); + int y = 12; + + CCTurnOffTiles* toff = CCTurnOffTiles::actionWithSize( ccg(x,y), m_fDuration); + CCActionInterval* action = easeActionWithAction(toff); + m_pOutScene->runAction + ( + CCSequence::actions + ( + action, + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + CCStopGrid::action(), + NULL + ) + ); +} + + +CCActionInterval* CCTransitionTurnOffTiles:: easeActionWithAction(CCActionInterval* action) +{ + return action; +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionTurnOffTiles) + +// +// SplitCols Transition +// +CCTransitionSplitCols::CCTransitionSplitCols() +{ +} +CCTransitionSplitCols::~CCTransitionSplitCols() +{ +} + + +void CCTransitionSplitCols::onEnter() +{ + CCTransitionScene::onEnter(); + m_pInScene->setIsVisible(false); + + CCActionInterval* split = action(); + CCActionInterval* seq = (CCActionInterval*)CCSequence::actions + ( + split, + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::hideOutShowIn)), + split->reverse(), + NULL + ); + + this->runAction + ( + CCSequence::actions + ( + easeActionWithAction(seq), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + CCStopGrid::action(), + NULL + ) + ); +} + + +CCActionInterval* CCTransitionSplitCols:: action() +{ + return CCSplitCols::actionWithCols(3, m_fDuration/2.0f); +} + + +CCActionInterval* CCTransitionSplitCols::easeActionWithAction(CCActionInterval * action) +{ + return CCEaseInOut::actionWithAction(action, 3.0f); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSplitCols) + + +// +// SplitRows Transition +// +CCTransitionSplitRows::CCTransitionSplitRows() +{ +} +CCTransitionSplitRows::~CCTransitionSplitRows() +{ +} + + +CCActionInterval* CCTransitionSplitRows::action() +{ + return CCSplitRows::actionWithRows(3, m_fDuration/2.0f); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionSplitRows) + +// +// FadeTR Transition +// +CCTransitionFadeTR::CCTransitionFadeTR() +{ +} +CCTransitionFadeTR::~CCTransitionFadeTR() +{ +} + + +void CCTransitionFadeTR::sceneOrder() +{ + m_bIsInSceneOnTop = false; +} + +void CCTransitionFadeTR::onEnter() +{ + CCTransitionScene::onEnter(); + + CGSize s = CCDirector::sharedDirector()->getWinSize(); + float aspect = s.width / s.height; + int x = (int)(12 * aspect); + int y = 12; + + CCActionInterval* action = actionWithSize(ccg(x,y)); + + m_pOutScene->runAction + ( + CCSequence::actions + ( + easeActionWithAction(action), + CCCallFunc::actionWithTarget(this, callfunc_selector(CCTransitionScene::finish)), + CCStopGrid::action(), + NULL + ) + ); +} + + +CCActionInterval* CCTransitionFadeTR::actionWithSize(ccGridSize size) +{ + return CCFadeOutTRTiles::actionWithSize(size, m_fDuration); +} + +CCActionInterval* CCTransitionFadeTR:: easeActionWithAction(CCActionInterval* action) +{ + return action; +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeTR) + + +// +// FadeBL Transition +// + +CCTransitionFadeBL::CCTransitionFadeBL() +{ +} +CCTransitionFadeBL::~CCTransitionFadeBL() +{ +} + +CCActionInterval* CCTransitionFadeBL::actionWithSize(ccGridSize size) +{ + return CCFadeOutBLTiles::actionWithSize(size, m_fDuration); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeBL) + +// +// FadeUp Transition +// +CCTransitionFadeUp::CCTransitionFadeUp() +{ +} +CCTransitionFadeUp::~CCTransitionFadeUp() +{ +} + +CCActionInterval* CCTransitionFadeUp::actionWithSize(ccGridSize size) +{ + return CCFadeOutUpTiles::actionWithSize(size, m_fDuration); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeUp) + +// +// FadeDown Transition +// +CCTransitionFadeDown::CCTransitionFadeDown() +{ +} +CCTransitionFadeDown::~CCTransitionFadeDown() +{ +} + +CCActionInterval* CCTransitionFadeDown::actionWithSize(ccGridSize size) +{ + return CCFadeOutDownTiles::actionWithSize(size, m_fDuration); +} + +IMPLEMENT_TRANSITIONWITHDURATION(CCTransitionFadeDown) + +}//namespace cocos2d diff --git a/cocos2dx/proj.uphone/cocos2d-uphone.vcproj b/cocos2dx/proj.uphone/cocos2d-uphone.vcproj index 4955739c7f..d05301de19 100644 --- a/cocos2dx/proj.uphone/cocos2d-uphone.vcproj +++ b/cocos2dx/proj.uphone/cocos2d-uphone.vcproj @@ -372,10 +372,6 @@ RelativePath="..\include\CCNode.h" > - - @@ -404,10 +400,6 @@ RelativePath="..\include\CCQuadParticleSystem.h" > - - @@ -488,6 +480,14 @@ RelativePath="..\include\CCTransition.h" > + + + + @@ -592,24 +592,16 @@ - - - - - - + + @@ -888,6 +880,10 @@ RelativePath="..\platform\CCFileUtils_platform.h" > + + @@ -896,6 +892,10 @@ RelativePath="..\platform\CCNode_mobile.cpp" > + + diff --git a/cocos2dx/proj.win32/cocos2d-win32.vcproj b/cocos2dx/proj.win32/cocos2d-win32.vcproj index 1b5e54af18..727b83266e 100644 --- a/cocos2dx/proj.win32/cocos2d-win32.vcproj +++ b/cocos2dx/proj.win32/cocos2d-win32.vcproj @@ -398,10 +398,6 @@ RelativePath="..\include\CCNode.h" > - - @@ -434,10 +430,6 @@ RelativePath="..\include\CCQuadParticleSystem.h" > - - @@ -518,6 +510,14 @@ RelativePath="..\include\CCTransition.h" > + + + + @@ -630,24 +630,16 @@ - - - - - - + + @@ -706,6 +698,10 @@ RelativePath="..\platform\CCFileUtils_platform.h" > + + @@ -714,6 +710,10 @@ RelativePath="..\platform\CCNode_mobile.cpp" > + + diff --git a/tests/tests/AtlasTest/AtlasTest.cpp b/tests/tests/AtlasTest/AtlasTest.cpp index e727764f07..854c342a80 100644 --- a/tests/tests/AtlasTest/AtlasTest.cpp +++ b/tests/tests/AtlasTest/AtlasTest.cpp @@ -348,7 +348,7 @@ Atlas3::Atlas3() { m_time = 0; - CCColorLayer* col = CCColorLayer::layerWithColor( ccc4(128,128,128,255) ); + CCLayerColor* col = CCLayerColor::layerWithColor( ccc4(128,128,128,255) ); addChild(col, -10); CCLabelBMFont* label1 = CCLabelBMFont::bitmapFontAtlasWithString("Test", "fonts/bitmapFontTest2.fnt"); diff --git a/tests/tests/ClickAndMoveTest/ClickAndMoveTest.cpp b/tests/tests/ClickAndMoveTest/ClickAndMoveTest.cpp index a169dffdd4..49d3621430 100644 --- a/tests/tests/ClickAndMoveTest/ClickAndMoveTest.cpp +++ b/tests/tests/ClickAndMoveTest/ClickAndMoveTest.cpp @@ -21,7 +21,7 @@ MainLayer::MainLayer() CCSprite* sprite = CCSprite::spriteWithFile(s_pPathGrossini); - CCLayer* layer = CCColorLayer::layerWithColor(ccc4(255,255,0,255)); + CCLayer* layer = CCLayerColor::layerWithColor(ccc4(255,255,0,255)); addChild(layer, -1); addChild(sprite, 0, kTagSprite); diff --git a/tests/tests/EffectsAdvancedTest/EffectsAdvancedTest.cpp b/tests/tests/EffectsAdvancedTest/EffectsAdvancedTest.cpp index 89e0c45968..3cfb1eaa52 100644 --- a/tests/tests/EffectsAdvancedTest/EffectsAdvancedTest.cpp +++ b/tests/tests/EffectsAdvancedTest/EffectsAdvancedTest.cpp @@ -199,14 +199,14 @@ void Issue631::onEnter() removeChild(bg, true); // background - CCColorLayer* layer = CCColorLayer::layerWithColor( ccc4(255,0,0,255) ); + CCLayerColor* layer = CCLayerColor::layerWithColor( ccc4(255,0,0,255) ); addChild(layer, -10); CCSprite* sprite = CCSprite::spriteWithFile("Images/grossini.png"); sprite->setPosition( ccp(50,80) ); layer->addChild(sprite, 10); // foreground - CCColorLayer* layer2 = CCColorLayer::layerWithColor(ccc4( 0, 255,0,255 ) ); + CCLayerColor* layer2 = CCLayerColor::layerWithColor(ccc4( 0, 255,0,255 ) ); CCSprite* fog = CCSprite::spriteWithFile("Images/Fog.png"); ccBlendFunc bf = {GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}; diff --git a/tests/tests/EffectsTest/EffectsTest.h b/tests/tests/EffectsTest/EffectsTest.h index 684c41374f..631df8d304 100644 --- a/tests/tests/EffectsTest/EffectsTest.h +++ b/tests/tests/EffectsTest/EffectsTest.h @@ -9,7 +9,7 @@ public: virtual void runThisTest(); }; -class TextLayer : public CCColorLayer +class TextLayer : public CCLayerColor { protected: //UxString m_strTitle; diff --git a/tests/tests/LayerTest/LayerTest.cpp b/tests/tests/LayerTest/LayerTest.cpp index d25c14337b..a31f39d4e0 100644 --- a/tests/tests/LayerTest/LayerTest.cpp +++ b/tests/tests/LayerTest/LayerTest.cpp @@ -134,7 +134,7 @@ void LayerTest1::onEnter() setIsTouchEnabled(true); CGSize s = CCDirector::sharedDirector()->getWinSize(); - CCColorLayer* layer = CCColorLayer::layerWithColorWidthHeight( ccc4(0xFF, 0x00, 0x00, 0x80), 200, 200); + CCLayerColor* layer = CCLayerColor::layerWithColorWidthHeight( ccc4(0xFF, 0x00, 0x00, 0x80), 200, 200); layer->setIsRelativeAnchorPoint(true); layer->setPosition( CGPointMake(s.width/2, s.height/2) ); @@ -155,7 +155,7 @@ void LayerTest1::updateSize(CCTouch*touch) CGSize newSize = CGSizeMake( fabs(touchLocation.x - s.width/2)*2, fabs(touchLocation.y - s.height/2)*2); - CCColorLayer* l = (CCColorLayer*) getChildByTag(kTagLayer); + CCLayerColor* l = (CCLayerColor*) getChildByTag(kTagLayer); l->setContentSize( newSize ); } @@ -192,12 +192,12 @@ void LayerTest2::onEnter() LayerTest::onEnter(); CGSize s = CCDirector::sharedDirector()->getWinSize(); - CCColorLayer* layer1 = CCColorLayer::layerWithColorWidthHeight( ccc4(255, 255, 0, 80), 100, 300); + CCLayerColor* layer1 = CCLayerColor::layerWithColorWidthHeight( ccc4(255, 255, 0, 80), 100, 300); layer1->setPosition(CGPointMake(s.width/3, s.height/2)); layer1->setIsRelativeAnchorPoint(true); addChild(layer1, 1); - CCColorLayer* layer2 = CCColorLayer::layerWithColorWidthHeight( ccc4(0, 0, 255, 255), 100, 300); + CCLayerColor* layer2 = CCLayerColor::layerWithColorWidthHeight( ccc4(0, 0, 255, 255), 100, 300); layer2->setPosition(CGPointMake((s.width/3)*2, s.height/2)); layer2->setIsRelativeAnchorPoint(true); addChild(layer2, 1); @@ -227,7 +227,7 @@ std::string LayerTest2::title() LayerTestBlend::LayerTestBlend() { CGSize s = CCDirector::sharedDirector()->getWinSize(); - CCColorLayer* layer1 = CCColorLayer::layerWithColor( ccc4(255, 255, 255, 80) ); + CCLayerColor* layer1 = CCLayerColor::layerWithColor( ccc4(255, 255, 255, 80) ); CCSprite* sister1 = CCSprite::spriteWithFile(s_pPathSister1); CCSprite* sister2 = CCSprite::spriteWithFile(s_pPathSister2); @@ -244,7 +244,7 @@ LayerTestBlend::LayerTestBlend() void LayerTestBlend::newBlend(ccTime dt) { - CCColorLayer *layer = (CCColorLayer*)getChildByTag(kTagLayer); + CCLayerColor *layer = (CCLayerColor*)getChildByTag(kTagLayer); GLenum src; GLenum dst; diff --git a/tests/tests/ParticleTest/ParticleTest.h b/tests/tests/ParticleTest/ParticleTest.h index 0c3aa43c0c..4be4ff149e 100644 --- a/tests/tests/ParticleTest/ParticleTest.h +++ b/tests/tests/ParticleTest/ParticleTest.h @@ -12,7 +12,7 @@ public: virtual void runThisTest(); }; -class ParticleDemo : public CCColorLayer +class ParticleDemo : public CCLayerColor { protected: CCParticleSystem* m_emitter; diff --git a/tests/tests/RotateWorldTest/RotateWorldTest.cpp b/tests/tests/RotateWorldTest/RotateWorldTest.cpp index 2867ca2721..5798b63a9f 100644 --- a/tests/tests/RotateWorldTest/RotateWorldTest.cpp +++ b/tests/tests/RotateWorldTest/RotateWorldTest.cpp @@ -90,10 +90,10 @@ void RotateWorldMainLayer::onEnter() x = size.width; y = size.height; - CCNode* blue = CCColorLayer::layerWithColor(ccc4(0,0,255,255)); - CCNode* red = CCColorLayer::layerWithColor(ccc4(255,0,0,255)); - CCNode* green = CCColorLayer::layerWithColor(ccc4(0,255,0,255)); - CCNode* white = CCColorLayer::layerWithColor(ccc4(255,255,255,255)); + CCNode* blue = CCLayerColor::layerWithColor(ccc4(0,0,255,255)); + CCNode* red = CCLayerColor::layerWithColor(ccc4(255,0,0,255)); + CCNode* green = CCLayerColor::layerWithColor(ccc4(0,255,0,255)); + CCNode* white = CCLayerColor::layerWithColor(ccc4(255,255,255,255)); blue->setScale(0.5f); blue->setPosition(CGPointMake(-x/4,-y/4)); diff --git a/tests/tests/SceneTest/SceneTest.cpp b/tests/tests/SceneTest/SceneTest.cpp index c067cc09ca..3a0536f693 100644 --- a/tests/tests/SceneTest/SceneTest.cpp +++ b/tests/tests/SceneTest/SceneTest.cpp @@ -64,7 +64,7 @@ void SceneTestLayer1::onPushSceneTran(NSObject* pSender) CCLayer* pLayer = new SceneTestLayer2(); scene->addChild( pLayer, 0 ); - CCDirector::sharedDirector()->pushScene( CCSlideInTTransition::transitionWithDuration(1, scene) ); + CCDirector::sharedDirector()->pushScene( CCTransitionSlideInT::transitionWithDuration(1, scene) ); scene->release(); pLayer->release(); } @@ -139,7 +139,7 @@ void SceneTestLayer2::onReplaceSceneTran(NSObject* pSender) CCScene* pScene = new SceneTestScene(); CCLayer* pLayer = new SceneTestLayer3(); pScene->addChild( pLayer, 0 ); - CCDirector::sharedDirector()->replaceScene( CCFlipXTransition::transitionWithDuration(2, pScene) ); + CCDirector::sharedDirector()->replaceScene( CCTransitionFlipX::transitionWithDuration(2, pScene) ); pScene->release(); pLayer->release(); } diff --git a/tests/tests/SceneTest/SceneTest.h b/tests/tests/SceneTest/SceneTest.h index b6c3bb9573..ebf7acfb03 100644 --- a/tests/tests/SceneTest/SceneTest.h +++ b/tests/tests/SceneTest/SceneTest.h @@ -32,7 +32,7 @@ public: //CREATE_NODE(SceneTestLayer2); } ; -class SceneTestLayer3 : public CCColorLayer +class SceneTestLayer3 : public CCLayerColor { public: SceneTestLayer3(); diff --git a/tests/tests/TileMapTest/TileMapTest.cpp b/tests/tests/TileMapTest/TileMapTest.cpp index 71ff93e470..ce4d6ed3e0 100644 --- a/tests/tests/TileMapTest/TileMapTest.cpp +++ b/tests/tests/TileMapTest/TileMapTest.cpp @@ -108,7 +108,7 @@ TMXOrthoTest::TMXOrthoTest() // // it should not flicker. No artifacts should appear // - //CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + //CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); //addChild(color, -1); CCTMXTiledMap* map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/orthogonal-test2.tmx"); @@ -428,7 +428,7 @@ std::string TMXReadWriteTest::title() //------------------------------------------------------------------ TMXHexTest::TMXHexTest() { - CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); addChild(color, -1); CCTMXTiledMap* map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/hexa-test.tmx"); @@ -450,7 +450,7 @@ std::string TMXHexTest::title() //------------------------------------------------------------------ TMXIsoTest::TMXIsoTest() { - CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); addChild(color, -1); CCTMXTiledMap* map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/iso-test.tmx"); @@ -474,7 +474,7 @@ std::string TMXIsoTest::title() //------------------------------------------------------------------ TMXIsoTest1::TMXIsoTest1() { - CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); addChild(color, -1); CCTMXTiledMap *map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/iso-test1.tmx"); @@ -498,7 +498,7 @@ std::string TMXIsoTest1::title() //------------------------------------------------------------------ TMXIsoTest2::TMXIsoTest2() { - CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); addChild(color, -1); CCTMXTiledMap *map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/iso-test2.tmx"); @@ -525,7 +525,7 @@ std::string TMXIsoTest2::title() //------------------------------------------------------------------ TMXUncompressedTest::TMXUncompressedTest() { - CCColorLayer* color = CCColorLayer::layerWithColor( ccc4(64,64,64,255) ); + CCLayerColor* color = CCLayerColor::layerWithColor( ccc4(64,64,64,255) ); addChild(color, -1); CCTMXTiledMap *map = CCTMXTiledMap::tiledMapWithTMXFile("TileMaps/iso-test2-uncompressed.tmx"); diff --git a/tests/tests/TransitionsTest/TransitionsTest.cpp b/tests/tests/TransitionsTest/TransitionsTest.cpp index 3976e69694..44f703179f 100644 --- a/tests/tests/TransitionsTest/TransitionsTest.cpp +++ b/tests/tests/TransitionsTest/TransitionsTest.cpp @@ -3,139 +3,139 @@ #define TRANSITION_DURATION (1.2f) -class FadeWhiteTransition : public CCFadeTransition +class FadeWhiteTransition : public CCTransitionFade { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFadeTransition::transitionWithDuration(t, s, ccWHITE); + return CCTransitionFade::transitionWithDuration(t, s, ccWHITE); } }; -class FlipXLeftOver : public CCFlipXTransition +class FlipXLeftOver : public CCTransitionFlipX { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipXTransition::transitionWithDuration(t, s, kOrientationLeftOver); + return CCTransitionFlipX::transitionWithDuration(t, s, kOrientationLeftOver); } }; -class FlipXRightOver : public CCFlipXTransition +class FlipXRightOver : public CCTransitionFlipX { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipXTransition::transitionWithDuration(t, s, kOrientationRightOver); + return CCTransitionFlipX::transitionWithDuration(t, s, kOrientationRightOver); } }; -class FlipYUpOver : public CCFlipYTransition +class FlipYUpOver : public CCTransitionFlipY { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipYTransition::transitionWithDuration(t, s, kOrientationUpOver); + return CCTransitionFlipY::transitionWithDuration(t, s, kOrientationUpOver); } }; -class FlipYDownOver : public CCFlipYTransition +class FlipYDownOver : public CCTransitionFlipY { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipYTransition::transitionWithDuration(t, s, kOrientationDownOver); + return CCTransitionFlipY::transitionWithDuration(t, s, kOrientationDownOver); } }; -class FlipAngularLeftOver : public CCFlipAngularTransition +class FlipAngularLeftOver : public CCTransitionFlipAngular { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipAngularTransition::transitionWithDuration(t, s, kOrientationLeftOver); + return CCTransitionFlipAngular::transitionWithDuration(t, s, kOrientationLeftOver); } }; -class FlipAngularRightOver : public CCFlipAngularTransition +class FlipAngularRightOver : public CCTransitionFlipAngular { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCFlipAngularTransition::transitionWithDuration(t, s, kOrientationRightOver); + return CCTransitionFlipAngular::transitionWithDuration(t, s, kOrientationRightOver); } }; -class ZoomFlipXLeftOver : public CCZoomFlipXTransition +class ZoomFlipXLeftOver : public CCTransitionZoomFlipX { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipXTransition::transitionWithDuration(t, s, kOrientationLeftOver); + return CCTransitionZoomFlipX::transitionWithDuration(t, s, kOrientationLeftOver); } }; -class ZoomFlipXRightOver : public CCZoomFlipXTransition +class ZoomFlipXRightOver : public CCTransitionZoomFlipX { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipXTransition::transitionWithDuration(t, s, kOrientationRightOver); + return CCTransitionZoomFlipX::transitionWithDuration(t, s, kOrientationRightOver); } }; -class ZoomFlipYUpOver : public CCZoomFlipYTransition +class ZoomFlipYUpOver : public CCTransitionZoomFlipY { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipYTransition::transitionWithDuration(t, s, kOrientationUpOver); + return CCTransitionZoomFlipY::transitionWithDuration(t, s, kOrientationUpOver); } }; -class ZoomFlipYDownOver : public CCZoomFlipYTransition +class ZoomFlipYDownOver : public CCTransitionZoomFlipY { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipYTransition::transitionWithDuration(t, s, kOrientationDownOver); + return CCTransitionZoomFlipY::transitionWithDuration(t, s, kOrientationDownOver); } }; -class ZoomFlipAngularLeftOver : public CCZoomFlipAngularTransition +class ZoomFlipAngularLeftOver : public CCTransitionZoomFlipAngular { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipAngularTransition::transitionWithDuration(t, s, kOrientationLeftOver); + return CCTransitionZoomFlipAngular::transitionWithDuration(t, s, kOrientationLeftOver); } }; -class ZoomFlipAngularRightOver : public CCZoomFlipAngularTransition +class ZoomFlipAngularRightOver : public CCTransitionZoomFlipAngular { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCZoomFlipAngularTransition::transitionWithDuration(t, s, kOrientationRightOver); + return CCTransitionZoomFlipAngular::transitionWithDuration(t, s, kOrientationRightOver); } }; -class PageTransitionForward : public CCPageTurnTransition +class PageTransitionForward : public CCTransitionPageTurn { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCPageTurnTransition::transitionWithDuration(t, s, false); + return CCTransitionPageTurn::transitionWithDuration(t, s, false); } }; -class PageTransitionBackward : public CCPageTurnTransition +class PageTransitionBackward : public CCTransitionPageTurn { public: static CCTransitionScene* transitionWithDuration(ccTime t, CCScene* s) { - return CCPageTurnTransition::transitionWithDuration(t, s, true); + return CCTransitionPageTurn::transitionWithDuration(t, s, true); } }; @@ -168,9 +168,9 @@ static std::string transitions[MAX_LAYER] = { "SlideInTTransition", "SlideInBTransition", - "CCCrossFadeTransition", - "CCRadialCCWTransition", - "CCRadialCWTransition", + "CCTransitionCrossFade", + "CCTransitionRadialCCW", + "CCTransitionRadialCW", "PageTransitionForward", "PageTransitionBackward", "FadeTRTransition", @@ -187,8 +187,8 @@ CCTransitionScene* createTransition(int nIndex, ccTime t, CCScene* s) { switch(nIndex) { - case 0: return CCJumpZoomTransition::transitionWithDuration(t, s); - case 1: return CCFadeTransition::transitionWithDuration(t, s); + case 0: return CCTransitionJumpZoom::transitionWithDuration(t, s); + case 1: return CCTransitionFade::transitionWithDuration(t, s); case 2: return FadeWhiteTransition::transitionWithDuration(t, s); case 3: return FlipXLeftOver::transitionWithDuration(t, s); case 4: return FlipXRightOver::transitionWithDuration(t, s); @@ -202,29 +202,29 @@ CCTransitionScene* createTransition(int nIndex, ccTime t, CCScene* s) case 12: return ZoomFlipYDownOver::transitionWithDuration(t, s); case 13: return ZoomFlipAngularLeftOver::transitionWithDuration(t, s); case 14: return ZoomFlipAngularRightOver::transitionWithDuration(t, s); - case 15: return CCShrinkGrowTransition::transitionWithDuration(t, s); - case 16: return CCRotoZoomTransition::transitionWithDuration(t, s); - case 17: return CCMoveInLTransition::transitionWithDuration(t, s); - case 18: return CCMoveInRTransition::transitionWithDuration(t, s); - case 19: return CCMoveInTTransition::transitionWithDuration(t, s); - case 20: return CCMoveInBTransition::transitionWithDuration(t, s); - case 21: return CCSlideInLTransition::transitionWithDuration(t, s); - case 22: return CCSlideInRTransition::transitionWithDuration(t, s); - case 23: return CCSlideInTTransition::transitionWithDuration(t, s); - case 24: return CCSlideInBTransition::transitionWithDuration(t, s); + case 15: return CCTransitionShrinkGrow::transitionWithDuration(t, s); + case 16: return CCTransitionRotoZoom::transitionWithDuration(t, s); + case 17: return CCTransitionMoveInL::transitionWithDuration(t, s); + case 18: return CCTransitionMoveInR::transitionWithDuration(t, s); + case 19: return CCTransitionMoveInT::transitionWithDuration(t, s); + case 20: return CCTransitionMoveInB::transitionWithDuration(t, s); + case 21: return CCTransitionSlideInL::transitionWithDuration(t, s); + case 22: return CCTransitionSlideInR::transitionWithDuration(t, s); + case 23: return CCTransitionSlideInT::transitionWithDuration(t, s); + case 24: return CCTransitionSlideInB::transitionWithDuration(t, s); - case 25: return CCCrossFadeTransition::transitionWithDuration(t,s); - case 26: return CCRadialCCWTransition::transitionWithDuration(t,s); - case 27: return CCRadialCWTransition::transitionWithDuration(t,s); + case 25: return CCTransitionCrossFade::transitionWithDuration(t,s); + case 26: return CCTransitionRadialCCW::transitionWithDuration(t,s); + case 27: return CCTransitionRadialCW::transitionWithDuration(t,s); case 28: return PageTransitionForward::transitionWithDuration(t, s); case 29: return PageTransitionBackward::transitionWithDuration(t, s); - case 30: return CCFadeTRTransition::transitionWithDuration(t, s); - case 31: return CCFadeBLTransition::transitionWithDuration(t, s); - case 32: return CCFadeUpTransition::transitionWithDuration(t, s); - case 33: return CCFadeDownTransition::transitionWithDuration(t, s); - case 34: return CCTurnOffTilesTransition::transitionWithDuration(t, s); - case 35: return CCSplitRowsTransition::transitionWithDuration(t, s); - case 36: return CCSplitColsTransition::transitionWithDuration(t, s); + case 30: return CCTransitionFadeTR::transitionWithDuration(t, s); + case 31: return CCTransitionFadeBL::transitionWithDuration(t, s); + case 32: return CCTransitionFadeUp::transitionWithDuration(t, s); + case 33: return CCTransitionFadeDown::transitionWithDuration(t, s); + case 34: return CCTransitionTurnOffTiles::transitionWithDuration(t, s); + case 35: return CCTransitionSplitRows::transitionWithDuration(t, s); + case 36: return CCTransitionSplitCols::transitionWithDuration(t, s); default: break; }