From 9cd57b731ab1c666d4a1cb725538fdc137763d12 Mon Sep 17 00:00:00 2001 From: Starla Insigna Date: Sat, 30 Jul 2011 11:19:14 -0400 Subject: Initial commit (version 0.2.1) --- libs/cocos2d/CCTransition.m | 1059 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1059 insertions(+) create mode 100755 libs/cocos2d/CCTransition.m (limited to 'libs/cocos2d/CCTransition.m') diff --git a/libs/cocos2d/CCTransition.m b/libs/cocos2d/CCTransition.m new file mode 100755 index 0000000..22eed50 --- /dev/null +++ b/libs/cocos2d/CCTransition.m @@ -0,0 +1,1059 @@ +/* + * cocos2d for iPhone: http://www.cocos2d-iphone.org + * + * Copyright (c) 2008-2010 Ricardo Quesada + * Copyright (c) 2011 Zynga Inc. + * + * 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. + * + */ + + + +#import "CCTransition.h" +#import "CCNode.h" +#import "CCDirector.h" +#import "CCActionInterval.h" +#import "CCActionInstant.h" +#import "CCActionCamera.h" +#import "CCLayer.h" +#import "CCCamera.h" +#import "CCActionTiledGrid.h" +#import "CCActionEase.h" +#import "CCRenderTexture.h" +#import "Support/CGPointExtension.h" + +#import +#ifdef __IPHONE_OS_VERSION_MAX_ALLOWED +#import "Platforms/iOS/CCTouchDispatcher.h" +#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) +#import "Platforms/Mac/CCEventDispatcher.h" +#endif + +const uint32_t kSceneFade = 0xFADEFADE; + + +@interface CCTransitionScene (Private) +-(void) sceneOrder; +- (void)setNewScene:(ccTime)dt; +@end + +@implementation CCTransitionScene ++(id) transitionWithDuration:(ccTime) t scene:(CCScene*)s +{ + return [[[self alloc] initWithDuration:t scene:s] autorelease]; +} + +-(id) initWithDuration:(ccTime) t scene:(CCScene*)s +{ + NSAssert( s != nil, @"Argument scene must be non-nil"); + + if( (self=[super init]) ) { + + duration_ = t; + + // retain + inScene_ = [s retain]; + outScene_ = [[CCDirector sharedDirector] runningScene]; + [outScene_ retain]; + + NSAssert( inScene_ != outScene_, @"Incoming scene must be different from the outgoing scene" ); + + // disable events while transitions +#ifdef __IPHONE_OS_VERSION_MAX_ALLOWED + [[CCTouchDispatcher sharedDispatcher] setDispatchEvents: NO]; +#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) + [[CCEventDispatcher sharedDispatcher] setDispatchEvents: NO]; +#endif + + [self sceneOrder]; + } + return self; +} +-(void) sceneOrder +{ + inSceneOnTop_ = YES; +} + +-(void) draw +{ + [super draw]; + + if( inSceneOnTop_ ) { + [outScene_ visit]; + [inScene_ visit]; + } else { + [inScene_ visit]; + [outScene_ visit]; + } +} + +-(void) finish +{ + /* clean up */ + [inScene_ setVisible:YES]; + [inScene_ setPosition:ccp(0,0)]; + [inScene_ setScale:1.0f]; + [inScene_ setRotation:0.0f]; + [inScene_.camera restore]; + + [outScene_ setVisible:NO]; + [outScene_ setPosition:ccp(0,0)]; + [outScene_ setScale:1.0f]; + [outScene_ setRotation:0.0f]; + [outScene_.camera restore]; + + [self schedule:@selector(setNewScene:) interval:0]; +} + +-(void) setNewScene: (ccTime) dt +{ + [self unschedule:_cmd]; + + CCDirector *director = [CCDirector sharedDirector]; + + // Before replacing, save the "send cleanup to scene" + sendCleanupToScene_ = [director sendCleanupToScene]; + + [director replaceScene: inScene_]; + + // enable events while transitions +#ifdef __IPHONE_OS_VERSION_MAX_ALLOWED + [[CCTouchDispatcher sharedDispatcher] setDispatchEvents: YES]; +#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) + [[CCEventDispatcher sharedDispatcher] setDispatchEvents: YES]; +#endif + + // issue #267 + [outScene_ setVisible:YES]; +} + +-(void) hideOutShowIn +{ + [inScene_ setVisible:YES]; + [outScene_ setVisible:NO]; +} + +// custom onEnter +-(void) onEnter +{ + [super onEnter]; + [inScene_ onEnter]; + // outScene_ should not receive the onEnter callback +} + +// custom onExit +-(void) onExit +{ + [super onExit]; + [outScene_ onExit]; + + // inScene_ should not receive the onExit callback + // only the onEnterTransitionDidFinish + [inScene_ onEnterTransitionDidFinish]; +} + +// custom cleanup +-(void) cleanup +{ + [super cleanup]; + + if( sendCleanupToScene_ ) + [outScene_ cleanup]; +} + +-(void) dealloc +{ + [inScene_ release]; + [outScene_ release]; + [super dealloc]; +} +@end + +// +// Oriented Transition +// +@implementation CCTransitionSceneOriented ++(id) transitionWithDuration:(ccTime) t scene:(CCScene*)s orientation:(tOrientation)o +{ + return [[[self alloc] initWithDuration:t scene:s orientation:o] autorelease]; +} + +-(id) initWithDuration:(ccTime) t scene:(CCScene*)s orientation:(tOrientation)o +{ + if( (self=[super initWithDuration:t scene:s]) ) + orientation = o; + return self; +} +@end + + +// +// RotoZoom +// +@implementation CCTransitionRotoZoom +-(void) onEnter +{ + [super onEnter]; + + [inScene_ setScale:0.001f]; + [outScene_ setScale:1.0f]; + + [inScene_ setAnchorPoint:ccp(0.5f, 0.5f)]; + [outScene_ setAnchorPoint:ccp(0.5f, 0.5f)]; + + CCActionInterval *rotozoom = [CCSequence actions: [CCSpawn actions: + [CCScaleBy actionWithDuration:duration_/2 scale:0.001f], + [CCRotateBy actionWithDuration:duration_/2 angle:360 *2], + nil], + [CCDelayTime actionWithDuration:duration_/2], + nil]; + + + [outScene_ runAction: rotozoom]; + [inScene_ runAction: [CCSequence actions: + [rotozoom reverse], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil]]; +} +@end + +// +// JumpZoom +// +@implementation CCTransitionJumpZoom +-(void) onEnter +{ + [super onEnter]; + CGSize s = [[CCDirector sharedDirector] winSize]; + + [inScene_ setScale:0.5f]; + [inScene_ setPosition:ccp( s.width,0 )]; + + [inScene_ setAnchorPoint:ccp(0.5f, 0.5f)]; + [outScene_ setAnchorPoint:ccp(0.5f, 0.5f)]; + + CCActionInterval *jump = [CCJumpBy actionWithDuration:duration_/4 position:ccp(-s.width,0) height:s.width/4 jumps:2]; + CCActionInterval *scaleIn = [CCScaleTo actionWithDuration:duration_/4 scale:1.0f]; + CCActionInterval *scaleOut = [CCScaleTo actionWithDuration:duration_/4 scale:0.5f]; + + CCActionInterval *jumpZoomOut = [CCSequence actions: scaleOut, jump, nil]; + CCActionInterval *jumpZoomIn = [CCSequence actions: jump, scaleIn, nil]; + + CCActionInterval *delay = [CCDelayTime actionWithDuration:duration_/2]; + + [outScene_ runAction: jumpZoomOut]; + [inScene_ runAction: [CCSequence actions: delay, + jumpZoomIn, + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil] ]; +} +@end + +// +// MoveInL +// +@implementation CCTransitionMoveInL +-(void) onEnter +{ + [super onEnter]; + + [self initScenes]; + + CCActionInterval *a = [self action]; + + [inScene_ runAction: [CCSequence actions: + [self easeActionWithAction:a], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil] + ]; + +} +-(CCActionInterval*) action +{ + return [CCMoveTo actionWithDuration:duration_ position:ccp(0,0)]; +} + +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return [CCEaseOut actionWithAction:action rate:2.0f]; +// return [EaseElasticOut actionWithAction:action period:0.4f]; +} + +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( -s.width,0) ]; +} +@end + +// +// MoveInR +// +@implementation CCTransitionMoveInR +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( s.width,0) ]; +} +@end + +// +// MoveInT +// +@implementation CCTransitionMoveInT +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( 0, s.height) ]; +} +@end + +// +// MoveInB +// +@implementation CCTransitionMoveInB +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( 0, -s.height) ]; +} +@end + +// +// 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 +@implementation CCTransitionSlideInL +-(void) onEnter +{ + [super onEnter]; + + [self initScenes]; + + CCActionInterval *in = [self action]; + CCActionInterval *out = [self action]; + + id inAction = [self easeActionWithAction:in]; + id outAction = [CCSequence actions: + [self easeActionWithAction:out], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil]; + + [inScene_ runAction: inAction]; + [outScene_ runAction: outAction]; +} +-(void) sceneOrder +{ + inSceneOnTop_ = NO; +} +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( -(s.width-ADJUST_FACTOR),0) ]; +} +-(CCActionInterval*) action +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + return [CCMoveBy actionWithDuration:duration_ position:ccp(s.width-ADJUST_FACTOR,0)]; +} + +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return [CCEaseOut actionWithAction:action rate:2.0f]; +// return [EaseElasticOut actionWithAction:action period:0.4f]; +} + +@end + +// +// SlideInR +// +@implementation CCTransitionSlideInR +-(void) sceneOrder +{ + inSceneOnTop_ = YES; +} +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp( s.width-ADJUST_FACTOR,0) ]; +} + +-(CCActionInterval*) action +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + return [CCMoveBy actionWithDuration:duration_ position:ccp(-(s.width-ADJUST_FACTOR),0)]; +} + +@end + +// +// SlideInT +// +@implementation CCTransitionSlideInT +-(void) sceneOrder +{ + inSceneOnTop_ = NO; +} +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp(0,s.height-ADJUST_FACTOR) ]; +} + +-(CCActionInterval*) action +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + return [CCMoveBy actionWithDuration:duration_ position:ccp(0,-(s.height-ADJUST_FACTOR))]; +} + +@end + +// +// SlideInB +// +@implementation CCTransitionSlideInB +-(void) sceneOrder +{ + inSceneOnTop_ = YES; +} + +-(void) initScenes +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + [inScene_ setPosition: ccp(0,-(s.height-ADJUST_FACTOR)) ]; +} + +-(CCActionInterval*) action +{ + CGSize s = [[CCDirector sharedDirector] winSize]; + return [CCMoveBy actionWithDuration:duration_ position:ccp(0,s.height-ADJUST_FACTOR)]; +} +@end + +// +// ShrinkGrow Transition +// +@implementation CCTransitionShrinkGrow +-(void) onEnter +{ + [super onEnter]; + + [inScene_ setScale:0.001f]; + [outScene_ setScale:1.0f]; + + [inScene_ setAnchorPoint:ccp(2/3.0f,0.5f)]; + [outScene_ setAnchorPoint:ccp(1/3.0f,0.5f)]; + + CCActionInterval *scaleOut = [CCScaleTo actionWithDuration:duration_ scale:0.01f]; + CCActionInterval *scaleIn = [CCScaleTo actionWithDuration:duration_ scale:1.0f]; + + [inScene_ runAction: [self easeActionWithAction:scaleIn]]; + [outScene_ runAction: [CCSequence actions: + [self easeActionWithAction:scaleOut], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil] ]; +} +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return [CCEaseOut actionWithAction:action rate:2.0f]; +// return [EaseElasticOut actionWithAction:action period:0.3f]; +} +@end + +// +// FlipX Transition +// +@implementation CCTransitionFlipX +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCShow action], + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:0 deltaAngleX:0], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:0 deltaAngleX:0], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; + +} +@end + +// +// FlipY Transition +// +@implementation CCTransitionFlipY +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationUpOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCShow action], + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:90 deltaAngleX:0], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:90 deltaAngleX:0], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; + +} +@end + +// +// FlipAngular Transition +// +@implementation CCTransitionFlipAngular +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCShow action], + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:-45 deltaAngleX:0], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:45 deltaAngleX:0], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; +} +@end + +// +// ZoomFlipX Transition +// +@implementation CCTransitionZoomFlipX +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:0 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:1], + [CCShow action], + nil], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:0 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:0.5f], + nil], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + inScene_.scale = 0.5f; + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; +} +@end + +// +// ZoomFlipY Transition +// +@implementation CCTransitionZoomFlipY +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationUpOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:90 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:1], + [CCShow action], + nil], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:90 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:0.5f], + nil], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + inScene_.scale = 0.5f; + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; +} +@end + +// +// ZoomFlipAngular Transition +// +@implementation CCTransitionZoomFlipAngular +-(void) onEnter +{ + [super onEnter]; + + CCActionInterval *inA, *outA; + [inScene_ setVisible: NO]; + + float inDeltaZ, inAngleZ; + float outDeltaZ, outAngleZ; + + if( orientation == kOrientationRightOver ) { + inDeltaZ = 90; + inAngleZ = 270; + outDeltaZ = 90; + outAngleZ = 0; + } else { + inDeltaZ = -90; + inAngleZ = 90; + outDeltaZ = -90; + outAngleZ = 0; + } + + inA = [CCSequence actions: + [CCDelayTime actionWithDuration:duration_/2], + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:inAngleZ deltaAngleZ:inDeltaZ angleX:-45 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:1], + [CCShow action], + nil], + [CCShow action], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + outA = [CCSequence actions: + [CCSpawn actions: + [CCOrbitCamera actionWithDuration: duration_/2 radius: 1 deltaRadius:0 angleZ:outAngleZ deltaAngleZ:outDeltaZ angleX:45 deltaAngleX:0], + [CCScaleTo actionWithDuration:duration_/2 scale:0.5f], + nil], + [CCHide action], + [CCDelayTime actionWithDuration:duration_/2], + nil ]; + + inScene_.scale = 0.5f; + [inScene_ runAction: inA]; + [outScene_ runAction: outA]; +} +@end + + +// +// Fade Transition +// +@implementation CCTransitionFade ++(id) transitionWithDuration:(ccTime)d scene:(CCScene*)s withColor:(ccColor3B)color +{ + return [[[self alloc] initWithDuration:d scene:s withColor:color] autorelease]; +} + +-(id) initWithDuration:(ccTime)d scene:(CCScene*)s withColor:(ccColor3B)aColor +{ + if( (self=[super initWithDuration:d scene:s]) ) { + color.r = aColor.r; + color.g = aColor.g; + color.b = aColor.b; + } + + return self; +} + +-(id) initWithDuration:(ccTime)d scene:(CCScene*)s +{ + return [self initWithDuration:d scene:s withColor:ccBLACK]; +} + +-(void) onEnter +{ + [super onEnter]; + + CCLayerColor *l = [CCLayerColor layerWithColor:color]; + [inScene_ setVisible: NO]; + + [self addChild: l z:2 tag:kSceneFade]; + + + CCNode *f = [self getChildByTag:kSceneFade]; + + CCActionInterval *a = [CCSequence actions: + [CCFadeIn actionWithDuration:duration_/2], + [CCCallFunc actionWithTarget:self selector:@selector(hideOutShowIn)], + [CCFadeOut actionWithDuration:duration_/2], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + [f runAction: a]; +} + +-(void) onExit +{ + [super onExit]; + [self removeChildByTag:kSceneFade cleanup:NO]; +} +@end + + +// +// Cross Fade Transition +// +@implementation CCTransitionCrossFade + +-(void) draw +{ + // override draw since both scenes (textures) are rendered in 1 scene +} + +-(void) onEnter +{ + [super 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] winSize]; + CCLayerColor * layer = [CCLayerColor layerWithColor:color]; + + // create the first render texture for inScene_ + CCRenderTexture *inTexture = [CCRenderTexture renderTextureWithWidth:size.width height:size.height]; + inTexture.sprite.anchorPoint= ccp(0.5f,0.5f); + inTexture.position = ccp(size.width/2, size.height/2); + inTexture.anchorPoint = ccp(0.5f,0.5f); + + // render inScene_ to its texturebuffer + [inTexture begin]; + [inScene_ visit]; + [inTexture end]; + + // create the second render texture for outScene_ + CCRenderTexture *outTexture = [CCRenderTexture renderTextureWithWidth:size.width height:size.height]; + outTexture.sprite.anchorPoint= ccp(0.5f,0.5f); + outTexture.position = ccp(size.width/2, size.height/2); + outTexture.anchorPoint = ccp(0.5f,0.5f); + + // render outScene_ to its texturebuffer + [outTexture begin]; + [outScene_ 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.sprite setBlendFunc:blend1]; + [outTexture.sprite setBlendFunc:blend2]; + + // add render textures to the layer + [layer addChild:inTexture]; + [layer addChild:outTexture]; + + // initial opacity: + [inTexture.sprite setOpacity:255]; + [outTexture.sprite setOpacity:255]; + + // create the blend action + CCActionInterval * layerAction = [CCSequence actions: + [CCFadeTo actionWithDuration:duration_ opacity:0], + [CCCallFunc actionWithTarget:self selector:@selector(hideOutShowIn)], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + nil ]; + + + // run the blend action + [outTexture.sprite runAction: layerAction]; + + // add the layer (which contains our two rendertextures) to the scene + [self addChild: layer z:2 tag:kSceneFade]; +} + +// clean up on exit +-(void) onExit +{ + // remove our layer and release all containing objects + [self removeChildByTag:kSceneFade cleanup:NO]; + + [super onExit]; +} +@end + +// +// TurnOffTilesTransition +// +@implementation CCTransitionTurnOffTiles + +// override addScenes, and change the order +-(void) sceneOrder +{ + inSceneOnTop_ = NO; +} + +-(void) onEnter +{ + [super onEnter]; + CGSize s = [[CCDirector sharedDirector] winSize]; + float aspect = s.width / s.height; + int x = 12 * aspect; + int y = 12; + + id toff = [CCTurnOffTiles actionWithSize: ccg(x,y) duration:duration_]; + id action = [self easeActionWithAction:toff]; + [outScene_ runAction: [CCSequence actions: action, + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + [CCStopGrid action], + nil] + ]; + +} +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return action; +// return [EaseIn actionWithAction:action rate:2.0f]; +} +@end + +#pragma mark Split Transitions + +// +// SplitCols Transition +// +@implementation CCTransitionSplitCols + +-(void) onEnter +{ + [super onEnter]; + + inScene_.visible = NO; + + id split = [self action]; + id seq = [CCSequence actions: + split, + [CCCallFunc actionWithTarget:self selector:@selector(hideOutShowIn)], + [split reverse], + nil + ]; + [self runAction: [CCSequence actions: + [self easeActionWithAction:seq], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + [CCStopGrid action], + nil] + ]; +} + +-(CCActionInterval*) action +{ + return [CCSplitCols actionWithCols:3 duration:duration_/2.0f]; +} + +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return [CCEaseInOut actionWithAction:action rate:3.0f]; +} +@end + +// +// SplitRows Transition +// +@implementation CCTransitionSplitRows +-(CCActionInterval*) action +{ + return [CCSplitRows actionWithRows:3 duration:duration_/2.0f]; +} +@end + + +#pragma mark Fade Grid Transitions + +// +// FadeTR Transition +// +@implementation CCTransitionFadeTR +-(void) sceneOrder +{ + inSceneOnTop_ = NO; +} + +-(void) onEnter +{ + [super onEnter]; + + CGSize s = [[CCDirector sharedDirector] winSize]; + float aspect = s.width / s.height; + int x = 12 * aspect; + int y = 12; + + id action = [self actionWithSize:ccg(x,y)]; + + [outScene_ runAction: [CCSequence actions: + [self easeActionWithAction:action], + [CCCallFunc actionWithTarget:self selector:@selector(finish)], + [CCStopGrid action], + nil] + ]; +} + +-(CCActionInterval*) actionWithSize: (ccGridSize) v +{ + return [CCFadeOutTRTiles actionWithSize:v duration:duration_]; +} + +-(CCActionInterval*) easeActionWithAction:(CCActionInterval*)action +{ + return action; +// return [EaseIn actionWithAction:action rate:2.0f]; +} +@end + +// +// FadeBL Transition +// +@implementation CCTransitionFadeBL +-(CCActionInterval*) actionWithSize: (ccGridSize) v +{ + return [CCFadeOutBLTiles actionWithSize:v duration:duration_]; +} +@end + +// +// FadeUp Transition +// +@implementation CCTransitionFadeUp +-(CCActionInterval*) actionWithSize: (ccGridSize) v +{ + return [CCFadeOutUpTiles actionWithSize:v duration:duration_]; +} +@end + +// +// FadeDown Transition +// +@implementation CCTransitionFadeDown +-(CCActionInterval*) actionWithSize: (ccGridSize) v +{ + return [CCFadeOutDownTiles actionWithSize:v duration:duration_]; +} +@end -- cgit 1.4.1