mirror of https://github.com/axmolengine/axmol.git
852 lines
22 KiB
C++
852 lines
22 KiB
C++
#include "NodeTest.h"
|
|
#include "../testResource.h"
|
|
|
|
enum
|
|
{
|
|
kTagSprite1 = 1,
|
|
kTagSprite2 = 2,
|
|
kTagSprite3 = 3,
|
|
kTagSlider,
|
|
};
|
|
|
|
|
|
CCLayer* nextCocosNodeAction();
|
|
CCLayer* backCocosNodeAction();
|
|
CCLayer* restartCocosNodeAction();
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// TestCocosNodeDemo
|
|
//
|
|
//------------------------------------------------------------------
|
|
|
|
static int sceneIdx = -1;
|
|
|
|
#define MAX_LAYER 14
|
|
|
|
CCLayer* createCocosNodeLayer(int nIndex)
|
|
{
|
|
switch(nIndex)
|
|
{
|
|
case 0: return new CameraCenterTest();
|
|
case 1: return new Test2();
|
|
case 2: return new Test4();
|
|
case 3: return new Test5();
|
|
case 4: return new Test6();
|
|
case 5: return new StressTest1();
|
|
case 6: return new StressTest2();
|
|
case 7: return new NodeToWorld();
|
|
case 8: return new SchedulerTest1();
|
|
case 9: return new CameraOrbitTest();
|
|
case 10: return new CameraZoomTest();
|
|
case 11: return new ConvertToNode();
|
|
case 12: return new NodeOpaqueTest();
|
|
case 13: return new NodeNonOpaqueTest();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CCLayer* nextCocosNodeAction()
|
|
{
|
|
sceneIdx++;
|
|
sceneIdx = sceneIdx % MAX_LAYER;
|
|
|
|
CCLayer* pLayer = createCocosNodeLayer(sceneIdx);
|
|
pLayer->autorelease();
|
|
|
|
return pLayer;
|
|
}
|
|
|
|
CCLayer* backCocosNodeAction()
|
|
{
|
|
sceneIdx--;
|
|
int total = MAX_LAYER;
|
|
if( sceneIdx < 0 )
|
|
sceneIdx += total;
|
|
|
|
CCLayer* pLayer = createCocosNodeLayer(sceneIdx);
|
|
pLayer->autorelease();
|
|
|
|
return pLayer;
|
|
}
|
|
|
|
CCLayer* restartCocosNodeAction()
|
|
{
|
|
CCLayer* pLayer = createCocosNodeLayer(sceneIdx);
|
|
pLayer->autorelease();
|
|
|
|
return pLayer;
|
|
}
|
|
|
|
|
|
TestCocosNodeDemo::TestCocosNodeDemo(void)
|
|
{
|
|
}
|
|
|
|
TestCocosNodeDemo::~TestCocosNodeDemo(void)
|
|
{
|
|
}
|
|
|
|
std::string TestCocosNodeDemo::title()
|
|
{
|
|
return "No title";
|
|
}
|
|
|
|
std::string TestCocosNodeDemo::subtitle()
|
|
{
|
|
return "";
|
|
}
|
|
|
|
void TestCocosNodeDemo::onEnter()
|
|
{
|
|
BaseTest::onEnter();
|
|
}
|
|
|
|
void TestCocosNodeDemo::restartCallback(CCObject* pSender)
|
|
{
|
|
CCScene* s = new CocosNodeTestScene();//CCScene::create();
|
|
s->addChild(restartCocosNodeAction());
|
|
|
|
CCDirector::sharedDirector()->replaceScene(s);
|
|
s->release();
|
|
}
|
|
|
|
void TestCocosNodeDemo::nextCallback(CCObject* pSender)
|
|
{
|
|
CCScene* s = new CocosNodeTestScene();//CCScene::create();
|
|
s->addChild( nextCocosNodeAction() );
|
|
CCDirector::sharedDirector()->replaceScene(s);
|
|
s->release();
|
|
}
|
|
|
|
void TestCocosNodeDemo::backCallback(CCObject* pSender)
|
|
{
|
|
CCScene* s = new CocosNodeTestScene();//CCScene::create();
|
|
s->addChild( backCocosNodeAction() );
|
|
CCDirector::sharedDirector()->replaceScene(s);
|
|
s->release();
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// Test2
|
|
//
|
|
//------------------------------------------------------------------
|
|
void Test2::onEnter()
|
|
{
|
|
TestCocosNodeDemo::onEnter();
|
|
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCSprite *sp1 = CCSprite::create(s_pPathSister1);
|
|
CCSprite *sp2 = CCSprite::create(s_pPathSister2);
|
|
CCSprite *sp3 = CCSprite::create(s_pPathSister1);
|
|
CCSprite *sp4 = CCSprite::create(s_pPathSister2);
|
|
|
|
sp1->setPosition(ccp(100, s.height /2 ));
|
|
sp2->setPosition(ccp(380, s.height /2 ));
|
|
addChild(sp1);
|
|
addChild(sp2);
|
|
|
|
sp3->setScale(0.25f);
|
|
sp4->setScale(0.25f);
|
|
|
|
sp1->addChild(sp3);
|
|
sp2->addChild(sp4);
|
|
|
|
CCActionInterval* a1 = CCRotateBy::create(2, 360);
|
|
CCActionInterval* a2 = CCScaleBy::create(2, 2);
|
|
|
|
CCAction* action1 = CCRepeatForever::create( CCSequence::create(a1, a2, a2->reverse(), NULL) );
|
|
CCAction* action2 = CCRepeatForever::create(
|
|
CCSequence::create(
|
|
(CCActionInterval*)(a1->copy()->autorelease()),
|
|
(CCActionInterval*)(a2->copy()->autorelease()),
|
|
a2->reverse(),
|
|
NULL)
|
|
);
|
|
|
|
sp2->setAnchorPoint(ccp(0,0));
|
|
|
|
sp1->runAction(action1);
|
|
sp2->runAction(action2);
|
|
}
|
|
|
|
std::string Test2::title()
|
|
{
|
|
return "anchorPoint and children";
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// Test4
|
|
//
|
|
//------------------------------------------------------------------
|
|
#define SID_DELAY2 1
|
|
#define SID_DELAY4 2
|
|
|
|
Test4::Test4()
|
|
{
|
|
CCSprite *sp1 = CCSprite::create(s_pPathSister1);
|
|
CCSprite *sp2 = CCSprite::create(s_pPathSister2);
|
|
|
|
sp1->setPosition( ccp(100,160) );
|
|
sp2->setPosition( ccp(380,160) );
|
|
|
|
addChild(sp1, 0, 2);
|
|
addChild(sp2, 0, 3);
|
|
|
|
schedule( schedule_selector(Test4::delay2), 2.0f);
|
|
schedule( schedule_selector(Test4::delay4), 4.0f);
|
|
}
|
|
|
|
void Test4::delay2(float dt)
|
|
{
|
|
CCSprite* node = (CCSprite*)(getChildByTag(2));
|
|
CCAction* action1 = CCRotateBy::create(1, 360);
|
|
node->runAction(action1);
|
|
}
|
|
|
|
void Test4::delay4(float dt)
|
|
{
|
|
unschedule(schedule_selector(Test4::delay4));
|
|
removeChildByTag(3, false);
|
|
}
|
|
|
|
std::string Test4::title()
|
|
{
|
|
return "tags";
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// Test5
|
|
//
|
|
//------------------------------------------------------------------
|
|
Test5::Test5()
|
|
{
|
|
CCSprite* sp1 = CCSprite::create(s_pPathSister1);
|
|
CCSprite* sp2 = CCSprite::create(s_pPathSister2);
|
|
|
|
sp1->setPosition(ccp(100,160));
|
|
sp2->setPosition(ccp(380,160));
|
|
|
|
CCRotateBy* rot = CCRotateBy::create(2, 360);
|
|
CCActionInterval* rot_back = rot->reverse();
|
|
CCAction* forever = CCRepeatForever::create(CCSequence::create(rot, rot_back, NULL));
|
|
CCAction* forever2 = (CCAction*)(forever->copy()->autorelease());
|
|
forever->setTag(101);
|
|
forever2->setTag(102);
|
|
|
|
addChild(sp1, 0, kTagSprite1);
|
|
addChild(sp2, 0, kTagSprite2);
|
|
|
|
sp1->runAction(forever);
|
|
sp2->runAction(forever2);
|
|
|
|
schedule( schedule_selector(Test5::addAndRemove), 2.0f);
|
|
}
|
|
|
|
void Test5::addAndRemove(float dt)
|
|
{
|
|
CCNode* sp1 = getChildByTag(kTagSprite1);
|
|
CCNode* sp2 = getChildByTag(kTagSprite2);
|
|
|
|
sp1->retain();
|
|
sp2->retain();
|
|
|
|
removeChild(sp1, false);
|
|
removeChild(sp2, true);
|
|
|
|
addChild(sp1, 0, kTagSprite1);
|
|
addChild(sp2, 0, kTagSprite2);
|
|
|
|
sp1->release();
|
|
sp2->release();
|
|
}
|
|
|
|
std::string Test5::title()
|
|
{
|
|
return "remove and cleanup";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// Test6
|
|
//
|
|
//------------------------------------------------------------------
|
|
Test6::Test6()
|
|
{
|
|
CCSprite* sp1 = CCSprite::create(s_pPathSister1);
|
|
CCSprite* sp11 = CCSprite::create(s_pPathSister1);
|
|
|
|
CCSprite* sp2 = CCSprite::create(s_pPathSister2);
|
|
CCSprite* sp21 = CCSprite::create(s_pPathSister2);
|
|
|
|
sp1->setPosition(ccp(100,160));
|
|
sp2->setPosition(ccp(380,160));
|
|
|
|
CCActionInterval* rot = CCRotateBy::create(2, 360);
|
|
CCActionInterval* rot_back = rot->reverse();
|
|
CCAction* forever1 = CCRepeatForever::create(CCSequence::create(rot, rot_back, NULL));
|
|
CCAction* forever11 = (CCAction*)(forever1->copy()->autorelease());
|
|
|
|
CCAction* forever2 = (CCAction*)(forever1->copy()->autorelease());
|
|
CCAction* forever21 = (CCAction*)(forever1->copy()->autorelease());
|
|
|
|
addChild(sp1, 0, kTagSprite1);
|
|
sp1->addChild(sp11);
|
|
addChild(sp2, 0, kTagSprite2);
|
|
sp2->addChild(sp21);
|
|
|
|
sp1->runAction(forever1);
|
|
sp11->runAction(forever11);
|
|
sp2->runAction(forever2);
|
|
sp21->runAction(forever21);
|
|
|
|
schedule( schedule_selector(Test6::addAndRemove), 2.0f);
|
|
}
|
|
|
|
void Test6::addAndRemove(float dt)
|
|
{
|
|
CCNode* sp1 = getChildByTag(kTagSprite1);
|
|
CCNode* sp2 = getChildByTag(kTagSprite2);
|
|
|
|
sp1->retain();
|
|
sp2->retain();
|
|
|
|
removeChild(sp1, false);
|
|
removeChild(sp2, true);
|
|
|
|
addChild(sp1, 0, kTagSprite1);
|
|
addChild(sp2, 0, kTagSprite2);
|
|
|
|
sp1->release();
|
|
sp2->release();
|
|
|
|
}
|
|
|
|
std::string Test6::title()
|
|
{
|
|
return "remove/cleanup with children";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// StressTest1
|
|
//
|
|
//------------------------------------------------------------------
|
|
StressTest1::StressTest1()
|
|
{
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCSprite *sp1 = CCSprite::create(s_pPathSister1);
|
|
addChild(sp1, 0, kTagSprite1);
|
|
|
|
sp1->setPosition( ccp(s.width/2, s.height/2) );
|
|
|
|
schedule( schedule_selector(StressTest1::shouldNotCrash), 1.0f);
|
|
}
|
|
|
|
void StressTest1::shouldNotCrash(float dt)
|
|
{
|
|
unschedule(schedule_selector(StressTest1::shouldNotCrash));
|
|
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
// if the node has timers, it crashes
|
|
CCNode* explosion = CCParticleSun::create();
|
|
((CCParticleSun*)explosion)->setTexture(CCTextureCache::sharedTextureCache()->addImage("Images/fire.png"));
|
|
|
|
// if it doesn't, it works Ok.
|
|
// CocosNode *explosion = [Sprite create:@"grossinis_sister2.png");
|
|
|
|
explosion->setPosition( ccp(s.width/2, s.height/2) );
|
|
|
|
runAction( CCSequence::create(
|
|
CCRotateBy::create(2, 360),
|
|
CCCallFuncN::create(this, callfuncN_selector(StressTest1::removeMe)),
|
|
NULL) );
|
|
|
|
addChild(explosion);
|
|
}
|
|
|
|
// remove
|
|
void StressTest1::removeMe(CCNode* node)
|
|
{
|
|
getParent()->removeChild(node, true);
|
|
nextCallback(this);
|
|
}
|
|
|
|
|
|
std::string StressTest1::title()
|
|
{
|
|
return "stress test #1: no crashes";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// StressTest2
|
|
//
|
|
//------------------------------------------------------------------
|
|
StressTest2::StressTest2()
|
|
{
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCLayer* sublayer = CCLayer::create();
|
|
|
|
CCSprite *sp1 = CCSprite::create(s_pPathSister1);
|
|
sp1->setPosition( ccp(80, s.height/2) );
|
|
|
|
CCActionInterval* move = CCMoveBy::create(3, ccp(350,0));
|
|
CCActionInterval* move_ease_inout3 = CCEaseInOut::create((CCActionInterval*)(move->copy()->autorelease()), 2.0f);
|
|
CCActionInterval* move_ease_inout_back3 = move_ease_inout3->reverse();
|
|
CCSequence* seq3 = CCSequence::create( move_ease_inout3, move_ease_inout_back3, NULL);
|
|
sp1->runAction( CCRepeatForever::create(seq3) );
|
|
sublayer->addChild(sp1, 1);
|
|
|
|
CCParticleFire* fire = CCParticleFire::create();
|
|
fire->setTexture(CCTextureCache::sharedTextureCache()->addImage("Images/fire.png"));
|
|
fire->setPosition( ccp(80, s.height/2-50) );
|
|
|
|
CCActionInterval* copy_seq3 = (CCActionInterval*)(seq3->copy()->autorelease());
|
|
|
|
fire->runAction( CCRepeatForever::create(copy_seq3) );
|
|
sublayer->addChild(fire, 2);
|
|
|
|
schedule(schedule_selector(StressTest2::shouldNotLeak), 6.0f);
|
|
|
|
addChild(sublayer, 0, kTagSprite1);
|
|
}
|
|
|
|
void StressTest2::shouldNotLeak(float dt)
|
|
{
|
|
unschedule( schedule_selector(StressTest2::shouldNotLeak) );
|
|
CCLayer* sublayer = (CCLayer*)getChildByTag(kTagSprite1);
|
|
sublayer->removeAllChildrenWithCleanup(true);
|
|
}
|
|
|
|
std::string StressTest2::title()
|
|
{
|
|
return "stress test #2: no leaks";
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// SchedulerTest1
|
|
//
|
|
//------------------------------------------------------------------
|
|
SchedulerTest1::SchedulerTest1()
|
|
{
|
|
CCLayer*layer = CCLayer::create();
|
|
//CCLOG("retain count after init is %d", layer->retainCount()); // 1
|
|
|
|
addChild(layer, 0);
|
|
//CCLOG("retain count after addChild is %d", layer->retainCount()); // 2
|
|
|
|
layer->schedule( schedule_selector(SchedulerTest1::doSomething) );
|
|
//CCLOG("retain count after schedule is %d", layer->retainCount()); // 3 : (object-c viersion), but win32 version is still 2, because CCTimer class don't save target.
|
|
|
|
layer->unschedule(schedule_selector(SchedulerTest1::doSomething));
|
|
//CCLOG("retain count after unschedule is %d", layer->retainCount()); // STILL 3! (win32 is '2')
|
|
}
|
|
|
|
void SchedulerTest1::doSomething(float dt)
|
|
{
|
|
|
|
}
|
|
|
|
std::string SchedulerTest1::title()
|
|
{
|
|
return "cocosnode scheduler test #1";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// NodeToWorld
|
|
//
|
|
//------------------------------------------------------------------
|
|
NodeToWorld::NodeToWorld()
|
|
{
|
|
//
|
|
// This code tests that nodeToParent works OK:
|
|
// - It tests different anchor Points
|
|
// - It tests different children anchor points
|
|
|
|
CCSprite *back = CCSprite::create(s_back3);
|
|
addChild( back, -10);
|
|
back->setAnchorPoint( ccp(0,0) );
|
|
CCSize backSize = back->getContentSize();
|
|
|
|
CCMenuItem *item = CCMenuItemImage::create(s_PlayNormal, s_PlaySelect);
|
|
CCMenu *menu = CCMenu::create(item, NULL);
|
|
menu->alignItemsVertically();
|
|
menu->setPosition( ccp(backSize.width/2, backSize.height/2));
|
|
back->addChild(menu);
|
|
|
|
CCActionInterval* rot = CCRotateBy::create(5, 360);
|
|
CCAction* fe = CCRepeatForever::create( rot);
|
|
item->runAction( fe );
|
|
|
|
CCActionInterval* move = CCMoveBy::create(3, ccp(200,0));
|
|
CCActionInterval* move_back = move->reverse();
|
|
CCSequence* seq = CCSequence::create( move, move_back, NULL);
|
|
CCAction* fe2 = CCRepeatForever::create(seq);
|
|
back->runAction(fe2);
|
|
}
|
|
|
|
std::string NodeToWorld::title()
|
|
{
|
|
return "nodeToParent transform";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// CameraOrbitTest
|
|
//
|
|
//------------------------------------------------------------------
|
|
void CameraOrbitTest::onEnter()
|
|
{
|
|
TestCocosNodeDemo::onEnter();
|
|
CCDirector::sharedDirector()->setProjection(kCCDirectorProjection3D);
|
|
}
|
|
|
|
void CameraOrbitTest::onExit()
|
|
{
|
|
CCDirector::sharedDirector()->setProjection(kCCDirectorProjection2D);
|
|
TestCocosNodeDemo::onExit();
|
|
}
|
|
|
|
CameraOrbitTest::CameraOrbitTest()
|
|
{
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCSprite *p = CCSprite::create(s_back3);
|
|
addChild( p, 0);
|
|
p->setPosition( ccp(s.width/2, s.height/2) );
|
|
p->setOpacity( 128 );
|
|
|
|
CCSprite* sprite;
|
|
CCOrbitCamera* orbit;
|
|
CCSize ss;
|
|
|
|
// LEFT
|
|
s = p->getContentSize();
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
sprite->setScale(0.5f);
|
|
p->addChild(sprite, 0);
|
|
sprite->setPosition( ccp(s.width/4*1, s.height/2) );
|
|
orbit = CCOrbitCamera::create(2, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction( CCRepeatForever::create( orbit ) );
|
|
|
|
// CENTER
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
sprite->setScale( 1.0f );
|
|
p->addChild(sprite, 0);
|
|
sprite->setPosition( ccp(s.width/4*2, s.height/2) );
|
|
orbit = CCOrbitCamera::create(2, 1, 0, 0, 360, 45, 0);
|
|
sprite->runAction( CCRepeatForever::create( orbit ) );
|
|
|
|
|
|
// RIGHT
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
sprite->setScale( 2.0f );
|
|
p->addChild(sprite, 0);
|
|
sprite->setPosition( ccp(s.width/4*3, s.height/2) );
|
|
ss = sprite->getContentSize();
|
|
orbit = CCOrbitCamera::create(2, 1, 0, 0, 360, 90, -45),
|
|
sprite->runAction( CCRepeatForever::create(orbit) );
|
|
|
|
|
|
// PARENT
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 90);
|
|
p->runAction( CCRepeatForever::create( orbit ) );
|
|
|
|
setScale( 1 );
|
|
}
|
|
|
|
std::string CameraOrbitTest::title()
|
|
{
|
|
return "Camera Orbit test";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// CameraZoomTest
|
|
//
|
|
//------------------------------------------------------------------
|
|
|
|
void CameraZoomTest::onEnter()
|
|
{
|
|
TestCocosNodeDemo::onEnter();
|
|
|
|
CCDirector::sharedDirector()->setProjection(kCCDirectorProjection3D);
|
|
}
|
|
|
|
void CameraZoomTest::onExit()
|
|
{
|
|
CCDirector::sharedDirector()->setProjection(kCCDirectorProjection2D);
|
|
TestCocosNodeDemo::onExit();
|
|
}
|
|
|
|
CameraZoomTest::CameraZoomTest()
|
|
{
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCSprite *sprite;
|
|
CCCamera *cam;
|
|
|
|
// LEFT
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
addChild( sprite, 0);
|
|
sprite->setPosition( ccp(s.width/4*1, s.height/2) );
|
|
cam = sprite->getCamera();
|
|
cam->setEyeXYZ(0, 0, 415/2);
|
|
cam->setCenterXYZ(0, 0, 0);
|
|
|
|
// CENTER
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
addChild( sprite, 0, 40);
|
|
sprite->setPosition(ccp(s.width/4*2, s.height/2));
|
|
|
|
// RIGHT
|
|
sprite = CCSprite::create(s_pPathGrossini);
|
|
addChild( sprite, 0, 20);
|
|
sprite->setPosition(ccp(s.width/4*3, s.height/2));
|
|
|
|
_z = 0;
|
|
scheduleUpdate();
|
|
}
|
|
|
|
void CameraZoomTest::update(float dt)
|
|
{
|
|
CCNode *sprite;
|
|
CCCamera *cam;
|
|
|
|
_z += dt * 100;
|
|
|
|
sprite = getChildByTag(20);
|
|
cam = sprite->getCamera();
|
|
cam->setEyeXYZ(0, 0, _z);
|
|
|
|
sprite = getChildByTag(40);
|
|
cam = sprite->getCamera();
|
|
cam->setEyeXYZ(0, 0, -_z);
|
|
}
|
|
|
|
std::string CameraZoomTest::title()
|
|
{
|
|
return "Camera Zoom test";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// CameraCenterTest
|
|
//
|
|
//------------------------------------------------------------------
|
|
CameraCenterTest::CameraCenterTest()
|
|
{
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCSprite *sprite;
|
|
CCOrbitCamera *orbit;
|
|
|
|
// LEFT-TOP
|
|
sprite = CCSprite::create("Images/white-512x512.png");
|
|
addChild( sprite, 0);
|
|
sprite->setPosition(ccp(s.width/5*1, s.height/5*1));
|
|
sprite->setColor(ccRED);
|
|
sprite->setTextureRect(CCRectMake(0, 0, 120, 50));
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction(CCRepeatForever::create( orbit ));
|
|
// [sprite setAnchorPoint: ccp(0,1));
|
|
|
|
|
|
|
|
// LEFT-BOTTOM
|
|
sprite = CCSprite::create("Images/white-512x512.png");
|
|
addChild( sprite, 0, 40);
|
|
sprite->setPosition(ccp(s.width/5*1, s.height/5*4));
|
|
sprite->setColor(ccBLUE);
|
|
sprite->setTextureRect(CCRectMake(0, 0, 120, 50));
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction(CCRepeatForever::create( orbit ));
|
|
|
|
|
|
// RIGHT-TOP
|
|
sprite = CCSprite::create("Images/white-512x512.png");
|
|
addChild( sprite, 0);
|
|
sprite->setPosition(ccp(s.width/5*4, s.height/5*1));
|
|
sprite->setColor(ccYELLOW);
|
|
sprite->setTextureRect(CCRectMake(0, 0, 120, 50));
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction(CCRepeatForever::create( orbit) );
|
|
|
|
|
|
// RIGHT-BOTTOM
|
|
sprite = CCSprite::create("Images/white-512x512.png");
|
|
addChild( sprite, 0, 40);
|
|
sprite->setPosition(ccp(s.width/5*4, s.height/5*4));
|
|
sprite->setColor(ccGREEN);
|
|
sprite->setTextureRect(CCRectMake(0, 0, 120, 50));
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction( CCRepeatForever::create( orbit ) );
|
|
|
|
// CENTER
|
|
sprite = CCSprite::create("Images/white-512x512.png");
|
|
addChild( sprite, 0, 40);
|
|
sprite->setPosition(ccp(s.width/2, s.height/2));
|
|
sprite->setColor(ccWHITE);
|
|
sprite->setTextureRect(CCRectMake(0, 0, 120, 50));
|
|
orbit = CCOrbitCamera::create(10, 1, 0, 0, 360, 0, 0);
|
|
sprite->runAction(CCRepeatForever::create( orbit ) );
|
|
}
|
|
|
|
std::string CameraCenterTest::title()
|
|
{
|
|
return "Camera Center test";
|
|
}
|
|
|
|
std::string CameraCenterTest::subtitle()
|
|
{
|
|
return "Sprites should rotate at the same speed";
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
//
|
|
// ConvertToNode
|
|
//
|
|
//------------------------------------------------------------------
|
|
ConvertToNode::ConvertToNode()
|
|
{
|
|
setTouchEnabled(true);
|
|
CCSize s = CCDirector::sharedDirector()->getWinSize();
|
|
|
|
CCRotateBy* rotate = CCRotateBy::create(10, 360);
|
|
CCRepeatForever* action = CCRepeatForever::create(rotate);
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
CCSprite *sprite = CCSprite::create("Images/grossini.png");
|
|
sprite->setPosition(ccp( s.width/4*(i+1), s.height/2));
|
|
|
|
CCSprite *point = CCSprite::create("Images/r1.png");
|
|
point->setScale(0.25f);
|
|
point->setPosition(sprite->getPosition());
|
|
addChild(point, 10, 100 + i);
|
|
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
sprite->setAnchorPoint(CCPointZero);
|
|
break;
|
|
case 1:
|
|
sprite->setAnchorPoint(ccp(0.5f, 0.5f));
|
|
break;
|
|
case 2:
|
|
sprite->setAnchorPoint(ccp(1,1));
|
|
break;
|
|
}
|
|
|
|
point->setPosition(sprite->getPosition());
|
|
|
|
CCRepeatForever* copy = (CCRepeatForever*) action->copy();
|
|
copy->autorelease();
|
|
sprite->runAction(copy);
|
|
addChild(sprite, i);
|
|
}
|
|
}
|
|
|
|
void ConvertToNode::ccTouchesEnded(CCSet* touches, CCEvent *event)
|
|
{
|
|
for( CCSetIterator it = touches->begin(); it != touches->end(); ++it)
|
|
{
|
|
CCTouch* touch = (CCTouch*)(*it);
|
|
CCPoint location = touch->getLocation();
|
|
|
|
for( int i = 0; i < 3; i++)
|
|
{
|
|
CCNode *node = getChildByTag(100+i);
|
|
CCPoint p1, p2;
|
|
|
|
p1 = node->convertToNodeSpaceAR(location);
|
|
p2 = node->convertToNodeSpace(location);
|
|
|
|
CCLOG("AR: x=%.2f, y=%.2f -- Not AR: x=%.2f, y=%.2f", p1.x, p1.y, p2.x, p2.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string ConvertToNode::title()
|
|
{
|
|
return "Convert To Node Space";
|
|
}
|
|
|
|
std::string ConvertToNode::subtitle()
|
|
{
|
|
return "testing convertToNodeSpace / AR. Touch and see console";
|
|
}
|
|
|
|
/// NodeOpaqueTest
|
|
|
|
NodeOpaqueTest::NodeOpaqueTest()
|
|
{
|
|
CCSprite *background = NULL;
|
|
|
|
for (int i = 0; i < 50; i++)
|
|
{
|
|
background = CCSprite::create("Images/background1.png");
|
|
ccBlendFunc blendFunc = {GL_ONE, GL_ONE_MINUS_SRC_ALPHA};
|
|
background->setBlendFunc(blendFunc);
|
|
background->setAnchorPoint(CCPointZero);
|
|
addChild(background);
|
|
}
|
|
}
|
|
|
|
std::string NodeOpaqueTest::title()
|
|
{
|
|
return "Node Opaque Test";
|
|
}
|
|
|
|
std::string NodeOpaqueTest::subtitle()
|
|
{
|
|
return "Node rendered with GL_BLEND disabled";
|
|
}
|
|
|
|
/// NodeNonOpaqueTest
|
|
|
|
NodeNonOpaqueTest::NodeNonOpaqueTest()
|
|
{
|
|
CCSprite *background = NULL;
|
|
|
|
for (int i = 0; i < 50; i++)
|
|
{
|
|
background = CCSprite::create("Images/background1.jpg");
|
|
background->setBlendFunc(kCCBlendFuncDisable);
|
|
background->setAnchorPoint(CCPointZero);
|
|
addChild(background);
|
|
}
|
|
}
|
|
|
|
std::string NodeNonOpaqueTest::title()
|
|
{
|
|
return "Node Non Opaque Test";
|
|
}
|
|
|
|
std::string NodeNonOpaqueTest::subtitle()
|
|
{
|
|
return "Node rendered with GL_BLEND enabled";
|
|
}
|
|
|
|
void CocosNodeTestScene::runThisTest()
|
|
{
|
|
CCLayer* pLayer = nextCocosNodeAction();
|
|
addChild(pLayer);
|
|
|
|
CCDirector::sharedDirector()->replaceScene(this);
|
|
}
|