axmol/samples/Cpp/TestCpp/Classes/EffectsTest/EffectsTest.cpp

435 lines
9.9 KiB
C++
Raw Normal View History

#include "EffectsTest.h"
#include "../testResource.h"
2010-08-23 10:17:29 +08:00
enum {
kTagTextLayer = 1,
kTagBackground = 1,
kTagLabel = 2,
};
static int actionIdx=0;
2010-08-23 10:17:29 +08:00
static std::string effectsList[] =
{
"Shaky3D",
"Waves3D",
"FlipX3D",
"FlipY3D",
"Lens3D",
"Ripple3D",
"Liquid",
"Waves",
"Twirl",
"ShakyTiles3D",
"ShatteredTiles3D",
"ShuffleTiles",
"FadeOutTRTiles",
"FadeOutBLTiles",
"FadeOutUpTiles",
"FadeOutDownTiles",
"TurnOffTiles",
"WavesTiles3D",
"JumpTiles3D",
"SplitRows",
"SplitCols",
"PageTurn3D",
};
class Shaky3DDemo : public Shaky3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return Shaky3D::create(t, Size(15,10), 5, false);
}
};
class Waves3DDemo : public Waves3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return Waves3D::create(t, Size(15,10), 5, 40);
}
};
class FlipX3DDemo : public FlipX3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FlipX3D* flipx = FlipX3D::create(t);
ActionInterval* flipx_back = flipx->reverse();
DelayTime* delay = DelayTime::create(2);
return Sequence::create(flipx, delay, flipx_back, NULL);
}
};
class FlipY3DDemo : public FlipY3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FlipY3D* flipy = FlipY3D::create(t);
ActionInterval* flipy_back = flipy->reverse();
DelayTime* delay = DelayTime::create(2);
return Sequence::create(flipy, delay, flipy_back, NULL);
}
};
class Lens3DDemo : public Lens3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
Size size = Director::getInstance()->getWinSize();
return Lens3D::create(t, Size(15,10), Point(size.width/2,size.height/2), 240);
}
};
class Ripple3DDemo : public Ripple3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
Size size = Director::getInstance()->getWinSize();
return Ripple3D::create(t, Size(32,24), Point(size.width/2,size.height/2), 240, 4, 160);
}
};
class LiquidDemo : public Liquid
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return Liquid::create(t, Size(16,12), 4, 20);
}
};
class WavesDemo : public Waves
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return Waves::create(t, Size(16,12), 4, 20, true, true);
}
};
class TwirlDemo : public Twirl
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
Size size = Director::getInstance()->getWinSize();
return Twirl::create(t, Size(12,8), Point(size.width/2, size.height/2), 1, 2.5f);
}
};
class ShakyTiles3DDemo : public ShakyTiles3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return ShakyTiles3D::create(t, Size(16,12), 5, false) ;
}
};
class ShatteredTiles3DDemo : public ShatteredTiles3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return ShatteredTiles3D::create(t, Size(16,12), 5, false);
}
};
class ShuffleTilesDemo : public ShuffleTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
ShuffleTiles* shuffle = ShuffleTiles::create(t, Size(16,12), 25);
ActionInterval* shuffle_back = shuffle->reverse();
DelayTime* delay = DelayTime::create(2);
return Sequence::create(shuffle, delay, shuffle_back, NULL);
}
};
class FadeOutTRTilesDemo : public FadeOutTRTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FadeOutTRTiles* fadeout = FadeOutTRTiles::create(t, Size(16,12));
ActionInterval* back = fadeout->reverse();
DelayTime* delay = DelayTime::create(0.5f);
return Sequence::create(fadeout, delay, back, NULL);
}
};
class FadeOutBLTilesDemo : public FadeOutBLTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FadeOutBLTiles* fadeout = FadeOutBLTiles::create(t, Size(16,12));
ActionInterval* back = fadeout->reverse();
DelayTime* delay = DelayTime::create(0.5f);
return Sequence::create(fadeout, delay, back, NULL);
}
};
class FadeOutUpTilesDemo : public FadeOutUpTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FadeOutUpTiles* fadeout = FadeOutUpTiles::create(t, Size(16,12));
ActionInterval* back = fadeout->reverse();
DelayTime* delay = DelayTime::create(0.5f);
return Sequence::create(fadeout, delay, back, NULL);
}
};
class FadeOutDownTilesDemo : public FadeOutDownTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
FadeOutDownTiles* fadeout = FadeOutDownTiles::create(t, Size(16,12));
ActionInterval* back = fadeout->reverse();
DelayTime* delay = DelayTime::create(0.5f);
return Sequence::create(fadeout, delay, back, NULL);
}
};
class TurnOffTilesDemo : public TurnOffTiles
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
TurnOffTiles* fadeout = TurnOffTiles::create(t, Size(48,32), 25);
ActionInterval* back = fadeout->reverse();
DelayTime* delay = DelayTime::create(0.5f);
return Sequence::create(fadeout, delay, back, NULL);
}
};
2010-08-23 10:17:29 +08:00
class WavesTiles3DDemo : public WavesTiles3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return WavesTiles3D::create(t, Size(15,10), 4, 120);
}
};
2010-08-23 10:17:29 +08:00
class JumpTiles3DDemo : public JumpTiles3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return JumpTiles3D::create(t, Size(15,10), 2, 30);
}
};
2010-08-23 10:17:29 +08:00
class SplitRowsDemo : public SplitRows
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return SplitRows::create(t, 9);
}
};
class SplitColsDemo : public SplitCols
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
return SplitCols::create(t, 9);
}
};
class PageTurn3DDemo : public PageTurn3D
2010-08-23 10:17:29 +08:00
{
public:
static ActionInterval* create(float t)
{
Director::getInstance()->setDepthTest(true);
return PageTurn3D::create(t, Size(15,10));
}
};
2010-08-23 10:17:29 +08:00
//------------------------------------------------------------------
//
// TextLayer
//
//------------------------------------------------------------------
#define MAX_LAYER 22
2010-08-23 10:17:29 +08:00
ActionInterval* createEffect(int nIndex, float t)
2010-08-23 10:17:29 +08:00
{
Director::getInstance()->setDepthTest(false);
switch(nIndex)
{
case 0: return Shaky3DDemo::create(t);
case 1: return Waves3DDemo::create(t);
case 2: return FlipX3DDemo::create(t);
case 3: return FlipY3DDemo::create(t);
case 4: return Lens3DDemo::create(t);
case 5: return Ripple3DDemo::create(t);
case 6: return LiquidDemo::create(t);
case 7: return WavesDemo::create(t);
case 8: return TwirlDemo::create(t);
case 9: return ShakyTiles3DDemo::create(t);
case 10: return ShatteredTiles3DDemo::create(t);
case 11: return ShuffleTilesDemo::create(t);
case 12: return FadeOutTRTilesDemo::create(t);
case 13: return FadeOutBLTilesDemo::create(t);
case 14: return FadeOutUpTilesDemo::create(t);
case 15: return FadeOutDownTilesDemo::create(t);
case 16: return TurnOffTilesDemo::create(t);
case 17: return WavesTiles3DDemo::create(t);
case 18: return JumpTiles3DDemo::create(t);
case 19: return SplitRowsDemo::create(t);
case 20: return SplitColsDemo::create(t);
case 21: return PageTurn3DDemo::create(t);
}
return NULL;
2010-08-23 10:17:29 +08:00
}
ActionInterval* getAction()
2010-08-23 10:17:29 +08:00
{
ActionInterval* pEffect = createEffect(actionIdx, 3);
2010-08-23 10:17:29 +08:00
return pEffect;
}
void EffectTestScene::runThisTest()
{
addChild(TextLayer::create());
Director::getInstance()->replaceScene(this);
}
#define SID_RESTART 1
TextLayer::TextLayer(void)
2013-06-07 14:31:15 +08:00
: BaseTest()
{
LayerColor *background = LayerColor::create( Color4B(32,128,32,255) );
this->addChild(background,-20);
Node* node = Node::create();
ActionInterval* effect = getAction();
2012-06-12 16:56:34 +08:00
node->runAction(effect);
addChild(node, 0, kTagBackground);
Sprite *bg = Sprite::create(s_back3);
node->addChild(bg, 0);
// bg->setAnchorPoint( Point::ZERO );
bg->setPosition(VisibleRect::center());
Sprite* grossini = Sprite::create(s_pathSister2);
node->addChild(grossini, 1);
2013-07-12 14:11:55 +08:00
grossini->setPosition( Point(VisibleRect::left().x+VisibleRect::getVisibleRect().size.width/3,VisibleRect::center().y) );
ActionInterval* sc = ScaleBy::create(2, 5);
ActionInterval* sc_back = sc->reverse();
grossini->runAction( RepeatForever::create(Sequence::create(sc, sc_back, NULL) ) );
Sprite* tamara = Sprite::create(s_pathSister1);
node->addChild(tamara, 1);
2013-07-12 14:11:55 +08:00
tamara->setPosition( Point(VisibleRect::left().x+2*VisibleRect::getVisibleRect().size.width/3,VisibleRect::center().y) );
ActionInterval* sc2 = ScaleBy::create(2, 5);
ActionInterval* sc2_back = sc2->reverse();
tamara->runAction( RepeatForever::create(Sequence::create(sc2, sc2_back, NULL)) );
schedule( schedule_selector(TextLayer::checkAnim) );
}
2012-06-08 13:55:28 +08:00
void TextLayer::checkAnim(float dt)
2010-08-23 10:17:29 +08:00
{
Node* s2 = getChildByTag(kTagBackground);
if ( s2->getNumberOfRunningActions() == 0 && s2->getGrid() != NULL)
s2->setGrid(NULL);;
2010-08-23 10:17:29 +08:00
}
TextLayer::~TextLayer(void)
{
}
// TextLayer* TextLayer::node()
// {
// return TextLayer::create();
// }
TextLayer* TextLayer::create()
2010-08-23 10:17:29 +08:00
{
TextLayer* layer = new TextLayer();
layer->autorelease();
return layer;
2010-08-23 10:17:29 +08:00
}
void TextLayer::onEnter()
{
BaseTest::onEnter();
2010-08-23 10:17:29 +08:00
}
void TextLayer::newScene()
{
Scene* s = new EffectTestScene();
Node* child = TextLayer::create();
s->addChild(child);
Director::getInstance()->replaceScene(s);
s->release();
}
2010-08-23 10:17:29 +08:00
void TextLayer::restartCallback(Object* sender)
2010-08-23 10:17:29 +08:00
{
newScene();
2010-08-23 10:17:29 +08:00
}
void TextLayer::nextCallback(Object* sender)
2010-08-23 10:17:29 +08:00
{
// update the action index
actionIdx++;
actionIdx = actionIdx % MAX_LAYER;
newScene();
2010-08-23 10:17:29 +08:00
}
void TextLayer::backCallback(Object* sender)
2010-08-23 10:17:29 +08:00
{
// update the action index
actionIdx--;
int total = MAX_LAYER;
if( actionIdx < 0 )
actionIdx += total;
2010-08-23 10:17:29 +08:00
newScene();
2010-08-23 10:17:29 +08:00
}