2019-11-23 20:27:39 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2009-2010 Ricardo Quesada
|
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2011 Zynga Inc.
|
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
|
|
|
|
|
|
|
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 "2d/CCTransition.h"
|
|
|
|
#include "2d/CCActionInterval.h"
|
|
|
|
#include "2d/CCActionInstant.h"
|
|
|
|
#include "2d/CCActionEase.h"
|
|
|
|
#include "2d/CCActionCamera.h"
|
|
|
|
#include "2d/CCActionTiledGrid.h"
|
|
|
|
#include "2d/CCActionGrid.h"
|
|
|
|
#include "2d/CCLayer.h"
|
|
|
|
#include "2d/CCRenderTexture.h"
|
|
|
|
#include "2d/CCNodeGrid.h"
|
|
|
|
#include "base/CCDirector.h"
|
|
|
|
#include "base/CCEventDispatcher.h"
|
|
|
|
|
|
|
|
NS_CC_BEGIN
|
|
|
|
|
|
|
|
const unsigned int kSceneFade = 0xFADEFADE;
|
|
|
|
|
|
|
|
TransitionScene::TransitionScene()
|
2021-12-25 10:04:45 +08:00
|
|
|
: _inScene(nullptr), _outScene(nullptr), _duration(0.0f), _isInSceneOnTop(false), _isSendCleanupToScene(false)
|
|
|
|
{}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionScene::~TransitionScene()
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE(_inScene);
|
|
|
|
CC_SAFE_RELEASE(_outScene);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionScene* TransitionScene::create(float t, Scene* scene)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionScene* pScene = new TransitionScene();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (pScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
pScene->autorelease();
|
|
|
|
return pScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(pScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool TransitionScene::initWithDuration(float t, Scene* scene)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
CCASSERT(scene != nullptr, "Argument scene must be non-nil");
|
|
|
|
|
|
|
|
if (Scene::init())
|
|
|
|
{
|
|
|
|
_duration = t;
|
|
|
|
|
|
|
|
// retain
|
|
|
|
#if CC_ENABLE_GC_FOR_NATIVE_OBJECTS
|
|
|
|
auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine();
|
|
|
|
if (sEngine)
|
|
|
|
{
|
|
|
|
sEngine->retainScriptObject(this, scene);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS
|
2019-11-23 20:27:39 +08:00
|
|
|
_inScene = scene;
|
|
|
|
_inScene->retain();
|
2021-04-22 22:01:47 +08:00
|
|
|
_outScene = _director->getRunningScene();
|
2019-11-23 20:27:39 +08:00
|
|
|
if (_outScene == nullptr)
|
|
|
|
{
|
|
|
|
_outScene = Scene::create();
|
|
|
|
// just change its state is running that can run actions later
|
|
|
|
// issue: https://github.com/cocos2d/cocos2d-x/issues/17442
|
|
|
|
_outScene->onEnter();
|
|
|
|
}
|
|
|
|
_outScene->retain();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
CCASSERT(_inScene != _outScene, "Incoming scene must be different from the outgoing scene");
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
sceneOrder();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionScene::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionScene::draw(Renderer* renderer, const Mat4& transform, uint32_t flags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
Scene::draw(renderer, transform, flags);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_isInSceneOnTop)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_outScene->visit(renderer, transform, flags);
|
|
|
|
_inScene->visit(renderer, transform, flags);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
_inScene->visit(renderer, transform, flags);
|
|
|
|
_outScene->visit(renderer, transform, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionScene::finish()
|
|
|
|
{
|
|
|
|
// clean up
|
|
|
|
_inScene->setVisible(true);
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(0, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
_inScene->setScale(1.0f);
|
|
|
|
_inScene->setRotation(0.0f);
|
|
|
|
_inScene->setAdditionalTransform(nullptr);
|
|
|
|
|
|
|
|
_outScene->setVisible(false);
|
2021-12-25 10:04:45 +08:00
|
|
|
_outScene->setPosition(0, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
_outScene->setScale(1.0f);
|
|
|
|
_outScene->setRotation(0.0f);
|
|
|
|
_outScene->setAdditionalTransform(nullptr);
|
|
|
|
|
|
|
|
//[self schedule:@selector(setNewScene:) interval:0];
|
|
|
|
this->schedule(CC_SCHEDULE_SELECTOR(TransitionScene::setNewScene), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionScene::setNewScene(float /*dt*/)
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
this->unschedule(CC_SCHEDULE_SELECTOR(TransitionScene::setNewScene));
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// Before replacing, save the "send cleanup to scene"
|
2021-04-22 22:01:47 +08:00
|
|
|
_isSendCleanupToScene = _director->isSendCleanupToScene();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2021-04-22 22:01:47 +08:00
|
|
|
_director->replaceScene(_inScene);
|
2019-11-23 20:27:39 +08:00
|
|
|
#if CC_ENABLE_GC_FOR_NATIVE_OBJECTS
|
|
|
|
auto sEngine = ScriptEngineManager::getInstance()->getScriptEngine();
|
|
|
|
if (sEngine)
|
|
|
|
{
|
|
|
|
sEngine->releaseScriptObject(this, _inScene);
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
#endif // CC_ENABLE_GC_FOR_NATIVE_OBJECTS
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// issue #267
|
|
|
|
_outScene->setVisible(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionScene::hideOutShowIn()
|
|
|
|
{
|
|
|
|
_inScene->setVisible(true);
|
|
|
|
_outScene->setVisible(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
// custom onEnter
|
|
|
|
void TransitionScene::onEnter()
|
|
|
|
{
|
|
|
|
Scene::onEnter();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// disable events while transitions
|
|
|
|
_eventDispatcher->setEnabled(false);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// outScene should not receive the onEnter callback
|
|
|
|
// only the onExitTransitionDidStart
|
|
|
|
_outScene->onExitTransitionDidStart();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
_inScene->onEnter();
|
|
|
|
}
|
|
|
|
|
|
|
|
// custom onExit
|
|
|
|
void TransitionScene::onExit()
|
|
|
|
{
|
|
|
|
Scene::onExit();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// enable events while transitions
|
|
|
|
_eventDispatcher->setEnabled(true);
|
|
|
|
_outScene->onExit();
|
|
|
|
|
|
|
|
// _inScene should not receive the onEnter callback
|
|
|
|
// only the onEnterTransitionDidFinish
|
|
|
|
_inScene->onEnterTransitionDidFinish();
|
|
|
|
|
|
|
|
#if CC_ENABLE_SCRIPT_BINDING
|
|
|
|
if (ScriptEngineManager::getInstance()->getScriptEngine())
|
|
|
|
ScriptEngineManager::getInstance()->getScriptEngine()->garbageCollect();
|
2021-12-25 10:04:45 +08:00
|
|
|
#endif // CC_ENABLE_SCRIPT_BINDING
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// custom cleanup
|
|
|
|
void TransitionScene::cleanup()
|
|
|
|
{
|
|
|
|
Scene::cleanup();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_isSendCleanupToScene)
|
2019-11-23 20:27:39 +08:00
|
|
|
_outScene->cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Oriented Transition
|
|
|
|
//
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSceneOriented::TransitionSceneOriented() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSceneOriented::~TransitionSceneOriented() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSceneOriented* TransitionSceneOriented::create(float t, Scene* scene, Orientation orientation)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSceneOriented* newScene = new TransitionSceneOriented();
|
|
|
|
newScene->initWithDuration(t, scene, orientation);
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool TransitionSceneOriented::initWithDuration(float t, Scene* scene, Orientation orientation)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (TransitionScene::initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_orientation = orientation;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// RotoZoom
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionRotoZoom::TransitionRotoZoom() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionRotoZoom* TransitionRotoZoom::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionRotoZoom* newScene = new TransitionRotoZoom();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionRotoZoom::~TransitionRotoZoom() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionRotoZoom::onEnter()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
_inScene->setScale(0.001f);
|
|
|
|
_outScene->setScale(1.0f);
|
|
|
|
|
|
|
|
_inScene->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
_outScene->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto rotozoom = Sequence::create(
|
|
|
|
Spawn::create(ScaleBy::create(_duration / 2, 0.001f), RotateBy::create(_duration / 2, 360 * 2), nullptr),
|
|
|
|
DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_outScene->runAction(rotozoom);
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->runAction(
|
|
|
|
Sequence::create(rotozoom->reverse(), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// JumpZoom
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionJumpZoom::TransitionJumpZoom() {}
|
|
|
|
TransitionJumpZoom::~TransitionJumpZoom() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionJumpZoom* TransitionJumpZoom::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionJumpZoom* newScene = new TransitionJumpZoom();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionJumpZoom::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->setScale(0.5f);
|
|
|
|
_inScene->setPosition(s.width, 0);
|
|
|
|
_inScene->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
_outScene->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* jump = JumpBy::create(_duration / 4, Vec2(-s.width, 0.0f), s.width / 4, 2);
|
|
|
|
ActionInterval* scaleIn = ScaleTo::create(_duration / 4, 1.0f);
|
|
|
|
ActionInterval* scaleOut = ScaleTo::create(_duration / 4, 0.5f);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
auto jumpZoomOut = Sequence::create(scaleOut, jump, nullptr);
|
2021-12-25 10:04:45 +08:00
|
|
|
auto jumpZoomIn = Sequence::create(jump, scaleIn, nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* delay = DelayTime::create(_duration / 2);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_outScene->runAction(jumpZoomOut);
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->runAction(
|
|
|
|
Sequence::create(delay, jumpZoomIn, CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// MoveInL
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionMoveInL::TransitionMoveInL() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionMoveInL::~TransitionMoveInL() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionMoveInL* TransitionMoveInL::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionMoveInL* newScene = new TransitionMoveInL();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionMoveInL::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
this->initScenes();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* a = this->action();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->runAction(Sequence::create(this->easeActionWithAction(a),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
ActionInterval* TransitionMoveInL::action()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return MoveTo::create(_duration, Vec2(0.0f, 0.0f));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ActionInterval* TransitionMoveInL::easeActionWithAction(ActionInterval* action)
|
|
|
|
{
|
|
|
|
return EaseOut::create(action, 2.0f);
|
2021-12-25 10:04:45 +08:00
|
|
|
// return [EaseElasticOut actionWithAction:action period:0.4f];
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionMoveInL::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(-s.width, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// MoveInR
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionMoveInR::TransitionMoveInR() {}
|
|
|
|
TransitionMoveInR::~TransitionMoveInR() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionMoveInR* TransitionMoveInR::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionMoveInR* newScene = new TransitionMoveInR();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionMoveInR::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(s.width, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// MoveInT
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionMoveInT::TransitionMoveInT() {}
|
|
|
|
TransitionMoveInT::~TransitionMoveInT() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionMoveInT* TransitionMoveInT::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionMoveInT* newScene = new TransitionMoveInT();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionMoveInT::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(0, s.height);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// MoveInB
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionMoveInB::TransitionMoveInB() {}
|
|
|
|
TransitionMoveInB::~TransitionMoveInB() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionMoveInB* TransitionMoveInB::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionMoveInB* newScene = new TransitionMoveInB();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionMoveInB::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(0, -s.height);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// 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
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSlideInL::TransitionSlideInL() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSlideInL::~TransitionSlideInL() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionSlideInL::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
this->initScenes();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* in = this->action();
|
|
|
|
ActionInterval* out = this->action();
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* inAction = easeActionWithAction(in);
|
|
|
|
ActionInterval* outAction = Sequence::create(
|
|
|
|
easeActionWithAction(out), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
_inScene->runAction(inAction);
|
|
|
|
_outScene->runAction(outAction);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInL::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionSlideInL::initScenes()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(-(s.width - ADJUST_FACTOR), 0.0f);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ActionInterval* TransitionSlideInL::action()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
return MoveBy::create(_duration, Vec2(s.width - ADJUST_FACTOR, 0.0f));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ActionInterval* TransitionSlideInL::easeActionWithAction(ActionInterval* action)
|
|
|
|
{
|
|
|
|
return EaseOut::create(action, 2.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionSlideInL* TransitionSlideInL::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSlideInL* newScene = new TransitionSlideInL();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// SlideInR
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSlideInR::TransitionSlideInR() {}
|
|
|
|
TransitionSlideInR::~TransitionSlideInR() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionSlideInR* TransitionSlideInR::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSlideInR* newScene = new TransitionSlideInR();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInR::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInR::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(s.width - ADJUST_FACTOR, 0);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionSlideInR::action()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
return MoveBy::create(_duration, Vec2(-(s.width - ADJUST_FACTOR), 0.0f));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// SlideInT
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSlideInT::TransitionSlideInT() {}
|
|
|
|
TransitionSlideInT::~TransitionSlideInT() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionSlideInT* TransitionSlideInT::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSlideInT* newScene = new TransitionSlideInT();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInT::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInT::initScenes()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(0, s.height - ADJUST_FACTOR);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ActionInterval* TransitionSlideInT::action()
|
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
return MoveBy::create(_duration, Vec2(0.0f, -(s.height - ADJUST_FACTOR)));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// SlideInB
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSlideInB::TransitionSlideInB() {}
|
|
|
|
TransitionSlideInB::~TransitionSlideInB() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionSlideInB* TransitionSlideInB::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSlideInB* newScene = new TransitionSlideInB();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSlideInB::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionSlideInB::initScenes()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setPosition(0, -(s.height - ADJUST_FACTOR));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionSlideInB::action()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-10-23 23:27:14 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2021-12-25 10:04:45 +08:00
|
|
|
return MoveBy::create(_duration, Vec2(0.0f, s.height - ADJUST_FACTOR));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// ShrinkGrow Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionShrinkGrow::TransitionShrinkGrow() {}
|
|
|
|
TransitionShrinkGrow::~TransitionShrinkGrow() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionShrinkGrow* TransitionShrinkGrow::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionShrinkGrow* newScene = new TransitionShrinkGrow();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionShrinkGrow::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
_inScene->setScale(0.001f);
|
|
|
|
_outScene->setScale(1.0f);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_inScene->setAnchorPoint(Vec2(2 / 3.0f, 0.5f));
|
|
|
|
_outScene->setAnchorPoint(Vec2(1 / 3.0f, 0.5f));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
ActionInterval* scaleOut = ScaleTo::create(_duration, 0.01f);
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* scaleIn = ScaleTo::create(_duration, 1.0f);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->runAction(this->easeActionWithAction(scaleIn));
|
2021-12-25 10:04:45 +08:00
|
|
|
_outScene->runAction(Sequence::create(this->easeActionWithAction(scaleOut),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr));
|
|
|
|
}
|
|
|
|
ActionInterval* TransitionShrinkGrow::easeActionWithAction(ActionInterval* action)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return EaseOut::create(action, 2.0f);
|
2021-12-25 10:04:45 +08:00
|
|
|
// return [EaseElasticOut actionWithAction:action period:0.3f];
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FlipX Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFlipX::TransitionFlipX() {}
|
|
|
|
TransitionFlipX::~TransitionFlipX() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionFlipX::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::RIGHT_OVER)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA = Sequence::create(DelayTime::create(_duration / 2), Show::create(),
|
|
|
|
OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, 0, 0),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
|
|
|
|
auto outA = Sequence::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 0, 0), Hide::create(),
|
|
|
|
DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipX* TransitionFlipX::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFlipX* newScene = new TransitionFlipX();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipX* TransitionFlipX::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionFlipX::create(t, s, TransitionScene::Orientation::RIGHT_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FlipY Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFlipY::TransitionFlipY() {}
|
|
|
|
TransitionFlipY::~TransitionFlipY() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionFlipY::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::UP_OVER)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA = Sequence::create(DelayTime::create(_duration / 2), Show::create(),
|
|
|
|
OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, 90, 0),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
auto outA = Sequence::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 90, 0), Hide::create(),
|
|
|
|
DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipY* TransitionFlipY::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFlipY* newScene = new TransitionFlipY();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipY* TransitionFlipY::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionFlipY::create(t, s, TransitionScene::Orientation::UP_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FlipAngular Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFlipAngular::TransitionFlipAngular() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFlipAngular::~TransitionFlipAngular() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionFlipAngular::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::RIGHT_OVER)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA = Sequence::create(DelayTime::create(_duration / 2), Show::create(),
|
|
|
|
OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, -45, 0),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
auto outA = Sequence::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 45, 0), Hide::create(),
|
|
|
|
DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipAngular* TransitionFlipAngular::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFlipAngular* newScene = new TransitionFlipAngular();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFlipAngular* TransitionFlipAngular::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionFlipAngular::create(t, s, TransitionScene::Orientation::RIGHT_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// ZoomFlipX Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionZoomFlipX::TransitionZoomFlipX() {}
|
|
|
|
TransitionZoomFlipX::~TransitionZoomFlipX() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionZoomFlipX::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::RIGHT_OVER)
|
|
|
|
{
|
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA = Sequence::create(DelayTime::create(_duration / 2),
|
|
|
|
Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, 0, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 1), Show::create(), nullptr),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
auto outA = Sequence::create(Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 0, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 0.5f), nullptr),
|
|
|
|
Hide::create(), DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->setScale(0.5f);
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipX* TransitionZoomFlipX::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionZoomFlipX* newScene = new TransitionZoomFlipX();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipX* TransitionZoomFlipX::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionZoomFlipX::create(t, s, TransitionScene::Orientation::RIGHT_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// ZoomFlipY Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionZoomFlipY::TransitionZoomFlipY() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionZoomFlipY::~TransitionZoomFlipY() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionZoomFlipY::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::UP_OVER)
|
|
|
|
{
|
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA = Sequence::create(DelayTime::create(_duration / 2),
|
|
|
|
Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, 90, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 1), Show::create(), nullptr),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
|
|
|
|
auto outA = Sequence::create(Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 90, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 0.5f), nullptr),
|
|
|
|
Hide::create(), DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->setScale(0.5f);
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipY* TransitionZoomFlipY::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionZoomFlipY* newScene = new TransitionZoomFlipY();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipY* TransitionZoomFlipY::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionZoomFlipY::create(t, s, TransitionScene::Orientation::UP_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// ZoomFlipAngular Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionZoomFlipAngular::TransitionZoomFlipAngular() {}
|
|
|
|
TransitionZoomFlipAngular::~TransitionZoomFlipAngular() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
void TransitionZoomFlipAngular::onEnter()
|
|
|
|
{
|
|
|
|
TransitionSceneOriented::onEnter();
|
|
|
|
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
float inDeltaZ, inAngleZ;
|
|
|
|
float outDeltaZ, outAngleZ;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_orientation == TransitionScene::Orientation::RIGHT_OVER)
|
|
|
|
{
|
|
|
|
inDeltaZ = 90;
|
|
|
|
inAngleZ = 270;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = 90;
|
|
|
|
outAngleZ = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
inDeltaZ = -90;
|
|
|
|
inAngleZ = 90;
|
2019-11-23 20:27:39 +08:00
|
|
|
outDeltaZ = -90;
|
|
|
|
outAngleZ = 0;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto inA =
|
|
|
|
Sequence::create(DelayTime::create(_duration / 2),
|
|
|
|
Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, inAngleZ, inDeltaZ, -45, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 1), Show::create(), nullptr),
|
|
|
|
Show::create(), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
|
|
|
auto outA = Sequence::create(Spawn::create(OrbitCamera::create(_duration / 2, 1, 0, outAngleZ, outDeltaZ, 45, 0),
|
|
|
|
ScaleTo::create(_duration / 2, 0.5f), nullptr),
|
|
|
|
Hide::create(), DelayTime::create(_duration / 2), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
_inScene->setScale(0.5f);
|
|
|
|
_inScene->runAction(inA);
|
|
|
|
_outScene->runAction(outA);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipAngular* TransitionZoomFlipAngular::create(float t, Scene* s, Orientation o)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionZoomFlipAngular* newScene = new TransitionZoomFlipAngular();
|
2019-11-23 20:27:39 +08:00
|
|
|
newScene->initWithDuration(t, s, o);
|
|
|
|
newScene->autorelease();
|
|
|
|
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionZoomFlipAngular* TransitionZoomFlipAngular::create(float t, Scene* s)
|
|
|
|
{
|
|
|
|
return TransitionZoomFlipAngular::create(t, s, TransitionScene::Orientation::RIGHT_OVER);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Fade Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFade::TransitionFade() {}
|
|
|
|
TransitionFade::~TransitionFade() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFade* TransitionFade::create(float duration, Scene* scene, const Color3B& color)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFade* transition = new TransitionFade();
|
2019-11-23 20:27:39 +08:00
|
|
|
transition->initWithDuration(duration, scene, color);
|
|
|
|
transition->autorelease();
|
|
|
|
return transition;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFade* TransitionFade::create(float duration, Scene* scene)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return TransitionFade::create(duration, scene, Color3B::BLACK);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool TransitionFade::initWithDuration(float duration, Scene* scene, const Color3B& color)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (TransitionScene::initWithDuration(duration, scene))
|
|
|
|
{
|
|
|
|
_color.r = color.r;
|
|
|
|
_color.g = color.g;
|
|
|
|
_color.b = color.b;
|
|
|
|
_color.a = 0;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool TransitionFade::initWithDuration(float t, Scene* scene)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
this->initWithDuration(t, scene, Color3B::BLACK);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionFade ::onEnter()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
LayerColor* l = LayerColor::create(_color);
|
|
|
|
_inScene->setVisible(false);
|
|
|
|
|
|
|
|
addChild(l, 2, kSceneFade);
|
|
|
|
Node* f = getChildByTag(kSceneFade);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto a = Sequence::create(
|
|
|
|
FadeIn::create(_duration / 2), CallFunc::create(CC_CALLBACK_0(TransitionScene::hideOutShowIn, this)),
|
|
|
|
FadeOut::create(_duration / 2), CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)),
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
f->runAction(a);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionFade::onExit()
|
|
|
|
{
|
|
|
|
TransitionScene::onExit();
|
|
|
|
this->removeChildByTag(kSceneFade, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Cross Fade Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionCrossFade::TransitionCrossFade() {}
|
|
|
|
TransitionCrossFade::~TransitionCrossFade() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionCrossFade* TransitionCrossFade::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionCrossFade* newScene = new TransitionCrossFade();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionCrossFade::draw(Renderer* /*renderer*/, const Mat4& /*transform*/, uint32_t /*flags*/)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// override draw since both scenes (textures) are rendered in 1 scene
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionCrossFade::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
// create a transparent color layer
|
|
|
|
// in which we are going to add our rendertextures
|
2021-12-25 10:04:45 +08:00
|
|
|
Color4B color(0, 0, 0, 0);
|
|
|
|
Vec2 size = _director->getWinSize();
|
2019-11-23 20:27:39 +08:00
|
|
|
LayerColor* layer = LayerColor::create(color);
|
|
|
|
|
|
|
|
// create the first render texture for inScene
|
2021-12-25 10:04:45 +08:00
|
|
|
RenderTexture* inTexture =
|
|
|
|
RenderTexture::create((int)size.width, (int)size.height, backend::PixelFormat::RGBA8, PixelFormat::D24S8);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
if (nullptr == inTexture)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
inTexture->getSprite()->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
inTexture->setPosition(size.width / 2, size.height / 2);
|
|
|
|
inTexture->setAnchorPoint(Vec2(0.5f, 0.5f));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// render inScene to its texturebuffer
|
|
|
|
inTexture->begin();
|
|
|
|
_inScene->visit();
|
|
|
|
inTexture->end();
|
|
|
|
|
|
|
|
// create the second render texture for outScene
|
2021-12-25 10:04:45 +08:00
|
|
|
RenderTexture* outTexture =
|
|
|
|
RenderTexture::create((int)size.width, (int)size.height, backend::PixelFormat::RGBA8, PixelFormat::D24S8);
|
|
|
|
outTexture->getSprite()->setAnchorPoint(Vec2(0.5f, 0.5f));
|
|
|
|
outTexture->setPosition(size.width / 2, size.height / 2);
|
|
|
|
outTexture->setAnchorPoint(Vec2(0.5f, 0.5f));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// render outScene to its texturebuffer
|
|
|
|
outTexture->begin();
|
|
|
|
_outScene->visit();
|
|
|
|
outTexture->end();
|
|
|
|
|
|
|
|
// create blend functions
|
|
|
|
|
|
|
|
// set blendfunctions
|
|
|
|
inTexture->getSprite()->setBlendFunc(BlendFunc::DISABLE);
|
2021-12-25 10:04:45 +08:00
|
|
|
outTexture->getSprite()->setBlendFunc(BlendFunc::ALPHA_PREMULTIPLIED);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// 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
|
2021-12-25 10:04:45 +08:00
|
|
|
Action* layerAction = Sequence::create(FadeTo::create(_duration, 0),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::hideOutShowIn, this)),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)), nullptr);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// run the blend action
|
2021-12-25 10:04:45 +08:00
|
|
|
outTexture->getSprite()->runAction(layerAction);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// add the layer (which contains our two rendertextures) to the scene
|
|
|
|
addChild(layer, 2, kSceneFade);
|
|
|
|
}
|
|
|
|
|
|
|
|
// clean up on exit
|
|
|
|
void TransitionCrossFade::onExit()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
// remove our layer and release all containing objects
|
2019-11-23 20:27:39 +08:00
|
|
|
this->removeChildByTag(kSceneFade, false);
|
|
|
|
TransitionScene::onExit();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// TurnOffTilesTransition
|
|
|
|
//
|
|
|
|
TransitionTurnOffTiles::TransitionTurnOffTiles()
|
|
|
|
{
|
|
|
|
_outSceneProxy = NodeGrid::create();
|
|
|
|
_outSceneProxy->retain();
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionTurnOffTiles::~TransitionTurnOffTiles()
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE(_outSceneProxy);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionTurnOffTiles* TransitionTurnOffTiles::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionTurnOffTiles* newScene = new TransitionTurnOffTiles();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// override addScenes, and change the order
|
|
|
|
void TransitionTurnOffTiles::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionTurnOffTiles::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
_outSceneProxy->setTarget(_outScene);
|
|
|
|
_outSceneProxy->onEnter();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2019-11-23 20:27:39 +08:00
|
|
|
float aspect = s.width / s.height;
|
2021-12-25 10:04:45 +08:00
|
|
|
int x = (int)(12 * aspect);
|
|
|
|
int y = 12;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TurnOffTiles* toff = TurnOffTiles::create(_duration, Vec2(x, y));
|
2019-11-23 20:27:39 +08:00
|
|
|
ActionInterval* action = easeActionWithAction(toff);
|
2021-12-25 10:04:45 +08:00
|
|
|
_outSceneProxy->runAction(Sequence::create(action, CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)),
|
|
|
|
StopGrid::create(), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionTurnOffTiles::onExit()
|
|
|
|
{
|
|
|
|
_outSceneProxy->setTarget(nullptr);
|
|
|
|
_outSceneProxy->onExit();
|
|
|
|
TransitionScene::onExit();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionTurnOffTiles::draw(Renderer* renderer, const Mat4& transform, uint32_t flags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
Scene::draw(renderer, transform, flags);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (_isInSceneOnTop)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_outSceneProxy->visit(renderer, transform, flags);
|
|
|
|
_inScene->visit(renderer, transform, flags);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_inScene->visit(renderer, transform, flags);
|
|
|
|
_outSceneProxy->visit(renderer, transform, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionTurnOffTiles::easeActionWithAction(ActionInterval* action)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return action;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// SplitCols Transition
|
|
|
|
//
|
|
|
|
TransitionSplitCols::TransitionSplitCols()
|
|
|
|
{
|
|
|
|
_gridProxy = NodeGrid::create();
|
|
|
|
_gridProxy->retain();
|
|
|
|
}
|
|
|
|
TransitionSplitCols::~TransitionSplitCols()
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE(_gridProxy);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionSplitCols* TransitionSplitCols::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSplitCols* newScene = new TransitionSplitCols();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSplitCols::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
_gridProxy->setTarget(_outScene);
|
|
|
|
_gridProxy->onEnter();
|
|
|
|
|
|
|
|
ActionInterval* split = action();
|
2021-12-25 10:04:45 +08:00
|
|
|
auto seq =
|
|
|
|
Sequence::create(split, CallFunc::create(CC_CALLBACK_0(TransitionSplitCols::switchTargetToInscene, this)),
|
|
|
|
split->reverse(), nullptr);
|
|
|
|
|
|
|
|
_gridProxy->runAction(Sequence::create(easeActionWithAction(seq),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)),
|
|
|
|
StopGrid::create(), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSplitCols::switchTargetToInscene()
|
|
|
|
{
|
|
|
|
_gridProxy->setTarget(_inScene);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionSplitCols::draw(Renderer* renderer, const Mat4& transform, uint32_t flags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
Scene::draw(renderer, transform, flags);
|
|
|
|
_gridProxy->visit(renderer, transform, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionSplitCols::onExit()
|
|
|
|
{
|
|
|
|
_gridProxy->setTarget(nullptr);
|
|
|
|
_gridProxy->onExit();
|
|
|
|
TransitionScene::onExit();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionSplitCols::action()
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return SplitCols::create(_duration / 2.0f, 3);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionSplitCols::easeActionWithAction(ActionInterval* action)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return EaseInOut::create(action, 3.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// SplitRows Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSplitRows::TransitionSplitRows() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionSplitRows::~TransitionSplitRows() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
ActionInterval* TransitionSplitRows::action()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return SplitRows::create(_duration / 2.0f, 3);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
TransitionSplitRows* TransitionSplitRows::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionSplitRows* newScene = new TransitionSplitRows();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FadeTR Transition
|
|
|
|
//
|
|
|
|
TransitionFadeTR::TransitionFadeTR()
|
|
|
|
{
|
|
|
|
_outSceneProxy = NodeGrid::create();
|
|
|
|
_outSceneProxy->retain();
|
|
|
|
}
|
|
|
|
TransitionFadeTR::~TransitionFadeTR()
|
|
|
|
{
|
|
|
|
CC_SAFE_RELEASE(_outSceneProxy);
|
|
|
|
}
|
|
|
|
|
|
|
|
TransitionFadeTR* TransitionFadeTR::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFadeTR* newScene = new TransitionFadeTR();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionFadeTR::sceneOrder()
|
|
|
|
{
|
|
|
|
_isInSceneOnTop = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionFadeTR::onEnter()
|
|
|
|
{
|
|
|
|
TransitionScene::onEnter();
|
|
|
|
|
|
|
|
_outSceneProxy->setTarget(_outScene);
|
|
|
|
_outSceneProxy->onEnter();
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
Vec2 s = _director->getWinSize();
|
2019-11-23 20:27:39 +08:00
|
|
|
float aspect = s.width / s.height;
|
2021-12-25 10:04:45 +08:00
|
|
|
int x = (int)(12 * aspect);
|
|
|
|
int y = 12;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* action = actionWithSize(Vec2(x, y));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
_outSceneProxy->runAction(Sequence::create(easeActionWithAction(action),
|
|
|
|
CallFunc::create(CC_CALLBACK_0(TransitionScene::finish, this)),
|
|
|
|
StopGrid::create(), nullptr));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TransitionFadeTR::onExit()
|
|
|
|
{
|
|
|
|
_outSceneProxy->setTarget(nullptr);
|
|
|
|
_outSceneProxy->onExit();
|
|
|
|
TransitionScene::onExit();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void TransitionFadeTR::draw(Renderer* renderer, const Mat4& transform, uint32_t flags)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
Scene::draw(renderer, transform, flags);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (_isInSceneOnTop)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_outSceneProxy->visit(renderer, transform, flags);
|
|
|
|
_inScene->visit(renderer, transform, flags);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_inScene->visit(renderer, transform, flags);
|
|
|
|
_outSceneProxy->visit(renderer, transform, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionFadeTR::actionWithSize(const Vec2& size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return FadeOutTRTiles::create(_duration, size);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionFadeTR::easeActionWithAction(ActionInterval* action)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return action;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FadeBL Transition
|
|
|
|
//
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFadeBL::TransitionFadeBL() {}
|
|
|
|
TransitionFadeBL::~TransitionFadeBL() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionFadeBL* TransitionFadeBL::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFadeBL* newScene = new TransitionFadeBL();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ActionInterval* TransitionFadeBL::actionWithSize(const Vec2& size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return FadeOutBLTiles::create(_duration, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FadeUp Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFadeUp::TransitionFadeUp() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFadeUp::~TransitionFadeUp() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionFadeUp* TransitionFadeUp::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFadeUp* newScene = new TransitionFadeUp();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-10-23 23:27:14 +08:00
|
|
|
ActionInterval* TransitionFadeUp::actionWithSize(const Vec2& size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return FadeOutUpTiles::create(_duration, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// FadeDown Transition
|
|
|
|
//
|
2021-12-25 10:04:45 +08:00
|
|
|
TransitionFadeDown::TransitionFadeDown() {}
|
|
|
|
TransitionFadeDown::~TransitionFadeDown() {}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
TransitionFadeDown* TransitionFadeDown::create(float t, Scene* scene)
|
|
|
|
{
|
2021-12-08 00:11:53 +08:00
|
|
|
TransitionFadeDown* newScene = new TransitionFadeDown();
|
2021-12-25 10:04:45 +08:00
|
|
|
if (newScene->initWithDuration(t, scene))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
newScene->autorelease();
|
|
|
|
return newScene;
|
|
|
|
}
|
|
|
|
CC_SAFE_DELETE(newScene);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2021-10-23 23:27:14 +08:00
|
|
|
ActionInterval* TransitionFadeDown::actionWithSize(const Vec2& size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
return FadeOutDownTiles::create(_duration, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_CC_END
|