Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
axmol/tests/cpp-tests/Classes/LayerTest/LayerTest.cpp

988 lines
30 KiB
C++
Raw Blame History

/****************************************************************************
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
https://axmolengine.github.io/
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 "LayerTest.h"
#include "../testResource.h"
#include "../core/ui/UIText.h"
USING_NS_AX;
enum
{
kTagLayer = 1,
};
LayerTests::LayerTests()
{
ADD_TEST_CASE(LayerTestCascadingOpacityA);
ADD_TEST_CASE(LayerTestCascadingOpacityB);
ADD_TEST_CASE(LayerTestCascadingOpacityC);
ADD_TEST_CASE(LayerTestCascadingColorA);
ADD_TEST_CASE(LayerTestCascadingColorB);
ADD_TEST_CASE(LayerTestCascadingColorC);
ADD_TEST_CASE(LayerTest1);
ADD_TEST_CASE(LayerTest2);
ADD_TEST_CASE(LayerTestBlend);
ADD_TEST_CASE(LayerGradientTest);
ADD_TEST_CASE(LayerGradientTest2);
ADD_TEST_CASE(LayerIgnoreAnchorPointPos);
ADD_TEST_CASE(LayerIgnoreAnchorPointRot);
ADD_TEST_CASE(LayerIgnoreAnchorPointScale);
ADD_TEST_CASE(LayerExtendedBlendOpacityTest);
ADD_TEST_CASE(LayerBug3162A);
ADD_TEST_CASE(LayerBug3162B);
ADD_TEST_CASE(LayerColorOccludeBug);
ADD_TEST_CASE(LayerRadialGradientTest);
}
// Cascading support extensions
static void setEnableRecursiveCascading(Node* node, bool enable)
{
node->setCascadeColorEnabled(enable);
node->setCascadeOpacityEnabled(enable);
auto& children = node->getChildren();
for (const auto& child : children)
{
setEnableRecursiveCascading(child, enable);
}
}
std::string LayerTest::title() const
{
return "Layer Test";
}
// LayerTestCascadingOpacityA
void LayerTestCascadingOpacityA::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = Layer::create();
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, s.height / 2));
sister2->setPosition(Vec2(s.width * 2 / 3, s.height / 2));
label->setPosition(Vec2(s.width / 2, s.height / 2));
layer1->runAction(RepeatForever::create(
Sequence::create(FadeTo::create(4, 0), FadeTo::create(4, 255), DelayTime::create(1), nullptr)));
sister1->runAction(
RepeatForever::create(Sequence::create(FadeTo::create(2, 0), FadeTo::create(2, 255), FadeTo::create(2, 0),
FadeTo::create(2, 255), DelayTime::create(1), nullptr)));
// Enable cascading in scene
setEnableRecursiveCascading(this, true);
}
std::string LayerTestCascadingOpacityA::subtitle() const
{
return "Layer: cascading opacity";
}
// LayerTestCascadingOpacityB
void LayerTestCascadingOpacityB::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(192, 0, 0, 255), s.width, s.height / 2);
layer1->setCascadeColorEnabled(false);
layer1->setPosition(Vec2(0.0f, s.height / 2));
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, 0.0f));
sister2->setPosition(Vec2(s.width * 2 / 3, 0.0f));
label->setPosition(Vec2(s.width / 2, 0.0f));
layer1->runAction(RepeatForever::create(
Sequence::create(FadeTo::create(4, 0), FadeTo::create(4, 255), DelayTime::create(1), nullptr)));
sister1->runAction(
RepeatForever::create(Sequence::create(FadeTo::create(2, 0), FadeTo::create(2, 255), FadeTo::create(2, 0),
FadeTo::create(2, 255), DelayTime::create(1), nullptr)));
// Enable cascading in scene
setEnableRecursiveCascading(this, true);
}
std::string LayerTestCascadingOpacityB::subtitle() const
{
return "CCLayerColor: cascading opacity";
}
// LayerTestCascadingOpacityC
void LayerTestCascadingOpacityC::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(192, 0, 0, 255), s.width, s.height / 2);
layer1->setCascadeColorEnabled(false);
layer1->setCascadeOpacityEnabled(false);
layer1->setPosition(Vec2(0.0f, s.height / 2));
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, 0.0f));
sister2->setPosition(Vec2(s.width * 2 / 3, 0.0f));
label->setPosition(Vec2(s.width / 2, 0.0f));
layer1->runAction(RepeatForever::create(
Sequence::create(FadeTo::create(4, 0), FadeTo::create(4, 255), DelayTime::create(1), nullptr)));
sister1->runAction(
RepeatForever::create(Sequence::create(FadeTo::create(2, 0), FadeTo::create(2, 255), FadeTo::create(2, 0),
FadeTo::create(2, 255), DelayTime::create(1), nullptr)));
}
std::string LayerTestCascadingOpacityC::subtitle() const
{
return "CCLayerColor: non-cascading opacity";
}
//// Example LayerTestCascadingColor
// LayerTestCascadingColorA
void LayerTestCascadingColorA::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = Layer::create();
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, s.height / 2));
sister2->setPosition(Vec2(s.width * 2 / 3, s.height / 2));
label->setPosition(Vec2(s.width / 2, s.height / 2));
layer1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(6, 255, 0, 255), TintTo::create(6, 255, 255, 255), DelayTime::create(1), nullptr)));
sister1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(2, 255, 255, 0), TintTo::create(2, 255, 255, 255), TintTo::create(2, 0, 255, 255),
TintTo::create(2, 255, 255, 255), TintTo::create(2, 255, 0, 255), TintTo::create(2, 255, 255, 255),
DelayTime::create(1), nullptr)));
// Enable cascading in scene
setEnableRecursiveCascading(this, true);
}
std::string LayerTestCascadingColorA::subtitle() const
{
return "Layer: cascading color";
}
// LayerTestCascadingColorB
void LayerTestCascadingColorB::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(255, 255, 255, 255), s.width, s.height / 2);
layer1->setPosition(Vec2(0.0f, s.height / 2));
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, 0.0f));
sister2->setPosition(Vec2(s.width * 2 / 3, 0.0f));
label->setPosition(Vec2(s.width / 2, 0.0f));
layer1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(6, 255, 0, 255), TintTo::create(6, 255, 255, 255), DelayTime::create(1), nullptr)));
sister1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(2, 255, 255, 0), TintTo::create(2, 255, 255, 255), TintTo::create(2, 0, 255, 255),
TintTo::create(2, 255, 255, 255), TintTo::create(2, 255, 0, 255), TintTo::create(2, 255, 255, 255),
DelayTime::create(1), nullptr)));
// Enable cascading in scene
setEnableRecursiveCascading(this, true);
}
std::string LayerTestCascadingColorB::subtitle() const
{
return "CCLayerColor: cascading color";
}
// LayerTestCascadingColorC
void LayerTestCascadingColorC::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(255, 255, 255, 255), s.width, s.height / 2);
layer1->setCascadeColorEnabled(false);
layer1->setPosition(Vec2(0.0f, s.height / 2));
auto sister1 = Sprite::create("Images/grossinis_sister1.png");
auto sister2 = Sprite::create("Images/grossinis_sister2.png");
auto label = Label::createWithBMFont("fonts/bitmapFontTest.fnt", "Test");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild(layer1, 0, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, 0.0f));
sister2->setPosition(Vec2(s.width * 2 / 3, 0.0f));
label->setPosition(Vec2(s.width / 2, 0.0f));
layer1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(6, 255, 0, 255), TintTo::create(6, 255, 255, 255), DelayTime::create(1), nullptr)));
sister1->runAction(RepeatForever::create(Sequence::create(
TintTo::create(2, 255, 255, 0), TintTo::create(2, 255, 255, 255), TintTo::create(2, 0, 255, 255),
TintTo::create(2, 255, 255, 255), TintTo::create(2, 255, 0, 255), TintTo::create(2, 255, 255, 255),
DelayTime::create(1), nullptr)));
}
std::string LayerTestCascadingColorC::subtitle() const
{
return "CCLayerColor: non-cascading color";
}
//------------------------------------------------------------------
//
// LayerTest1
//
//------------------------------------------------------------------
void LayerTest1::onEnter()
{
LayerTest::onEnter();
auto listener = EventListenerTouchAllAtOnce::create();
listener->onTouchesBegan = AX_CALLBACK_2(LayerTest1::onTouchesBegan, this);
listener->onTouchesMoved = AX_CALLBACK_2(LayerTest1::onTouchesMoved, this);
listener->onTouchesEnded = AX_CALLBACK_2(LayerTest1::onTouchesEnded, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
auto s = Director::getInstance()->getWinSize();
auto layer = LayerColor::create(Color4B(0xFF, 0x00, 0x00, 0x80), 200, 200);
layer->setIgnoreAnchorPointForPosition(false);
layer->setPosition(Vec2(s.width / 2, s.height / 2));
addChild(layer, 1, kTagLayer);
}
void LayerTest1::updateSize(Vec2& touchLocation)
{
auto s = Director::getInstance()->getWinSize();
auto newSize = Size(fabs(touchLocation.x - s.width / 2) * 2, fabs(touchLocation.y - s.height / 2) * 2);
auto l = (LayerColor*)getChildByTag(kTagLayer);
l->setContentSize(newSize);
}
void LayerTest1::onTouchesBegan(const std::vector<Touch*>& touches, Event* event)
{
onTouchesMoved(touches, event);
}
void LayerTest1::onTouchesMoved(const std::vector<Touch*>& touches, Event* event)
{
auto touchLocation = touches[0]->getLocation();
updateSize(touchLocation);
}
void LayerTest1::onTouchesEnded(const std::vector<Touch*>& touches, Event* event)
{
onTouchesMoved(touches, event);
}
std::string LayerTest1::subtitle() const
{
return "ColorLayer resize (tap & move)";
}
//------------------------------------------------------------------
//
// LayerTest2
//
//------------------------------------------------------------------
void LayerTest2::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(255, 255, 0, 80), 100, 300);
layer1->setPosition(Vec2(s.width / 3, s.height / 2));
layer1->setIgnoreAnchorPointForPosition(false);
addChild(layer1, 1);
auto layer2 = LayerColor::create(Color4B(0, 0, 255, 255), 100, 300);
layer2->setPosition(Vec2((s.width / 3) * 2, s.height / 2));
layer2->setIgnoreAnchorPointForPosition(false);
addChild(layer2, 1);
auto actionTint = TintBy::create(2, -255, -127, 0);
auto actionTintBack = actionTint->reverse();
auto seq1 = Sequence::create(actionTint, actionTintBack, nullptr);
layer1->runAction(seq1);
auto actionFade = FadeOut::create(2.0f);
auto actionFadeBack = actionFade->reverse();
auto seq2 = Sequence::create(actionFade, actionFadeBack, nullptr);
layer2->runAction(seq2);
}
std::string LayerTest2::subtitle() const
{
return "ColorLayer: fade and tint";
}
//------------------------------------------------------------------
//
// LayerTestBlend
//
//------------------------------------------------------------------
LayerTestBlend::LayerTestBlend()
{
auto s = Director::getInstance()->getWinSize();
auto layer1 = LayerColor::create(Color4B(255, 255, 255, 80));
auto sister1 = Sprite::create(s_pathSister1);
auto sister2 = Sprite::create(s_pathSister2);
addChild(sister1);
addChild(sister2);
addChild(layer1, 100, kTagLayer);
sister1->setPosition(Vec2(s.width * 1 / 3, s.height / 2));
sister2->setPosition(Vec2(s.width * 2 / 3, s.height / 2));
schedule(AX_SCHEDULE_SELECTOR(LayerTestBlend::newBlend), 1.0f);
}
void LayerTestBlend::newBlend(float dt)
{
auto layer = (LayerColor*)getChildByTag(kTagLayer);
backend::BlendFactor src;
backend::BlendFactor dst;
if (layer->getBlendFunc().dst == backend::BlendFactor::ZERO)
{
src = backend::BlendFactor::SRC_ALPHA;
dst = backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
}
else
{
src = backend::BlendFactor::ONE_MINUS_DST_COLOR;
dst = backend::BlendFactor::ZERO;
}
BlendFunc bf = {src, dst};
layer->setBlendFunc(bf);
}
std::string LayerTestBlend::subtitle() const
{
return "ColorLayer: blend";
}
//------------------------------------------------------------------
//
// LayerGradientTest
//
//------------------------------------------------------------------
LayerGradientTest::LayerGradientTest()
{
auto layer1 = LayerGradient::create(Color4B(255, 0, 0, 255), Color4B(0, 255, 0, 255), Vec2(0.9f, 0.9f));
addChild(layer1, 0, kTagLayer);
auto listener = EventListenerTouchAllAtOnce::create();
listener->onTouchesMoved = AX_CALLBACK_2(LayerGradientTest::onTouchesMoved, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);
auto label1 = Label::createWithTTF("Compressed Interpolation: Enabled", "fonts/Marker Felt.ttf", 26);
auto label2 = Label::createWithTTF("Compressed Interpolation: Disabled", "fonts/Marker Felt.ttf", 26);
auto item1 = MenuItemLabel::create(label1);
auto item2 = MenuItemLabel::create(label2);
auto item =
MenuItemToggle::createWithCallback(AX_CALLBACK_1(LayerGradientTest::toggleItem, this), item1, item2, nullptr);
auto menu = Menu::create(item, nullptr);
addChild(menu);
auto s = Director::getInstance()->getWinSize();
menu->setPosition(Vec2(s.width / 2, 100.0f));
}
void LayerGradientTest::toggleItem(Ref* sender)
{
auto gradient = static_cast<LayerGradient*>(getChildByTag(kTagLayer));
gradient->setCompressedInterpolation(!gradient->isCompressedInterpolation());
}
void LayerGradientTest::onTouchesMoved(const std::vector<Touch*>& touches, Event* event)
{
auto s = Director::getInstance()->getWinSize();
auto touch = touches[0];
auto start = touch->getLocation();
auto diff = Vec2(s.width / 2, s.height / 2) - start;
diff = diff.getNormalized();
auto gradient = static_cast<LayerGradient*>(getChildByTag(1));
gradient->setVector(diff);
}
std::string LayerGradientTest::title() const
{
return "LayerGradientTest";
}
std::string LayerGradientTest::subtitle() const
{
return "Touch the screen and move your finger";
}
//------------------------------------------------------------------
//
// LayerGradientTest2
//
//------------------------------------------------------------------
LayerGradientTest2::LayerGradientTest2()
{
auto layer = LayerGradient::create(Color4B(255, 0, 0, 255), Color4B(255, 255, 0, 255));
addChild(layer);
}
std::string LayerGradientTest2::title() const
{
return "LayerGradientTest 2";
}
std::string LayerGradientTest2::subtitle() const
{
return "You should see a gradient";
}
// LayerIgnoreAnchorPointPos
#define kLayerIgnoreAnchorPoint 1000
void LayerIgnoreAnchorPointPos::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto l = LayerColor::create(Color4B(255, 0, 0, 255), 150, 150);
l->setAnchorPoint(Vec2(0.5f, 0.5f));
l->setPosition(Vec2(s.width / 2, s.height / 2));
auto move = MoveBy::create(2, Vec2(100, 2));
auto back = (MoveBy*)move->reverse();
auto seq = Sequence::create(move, back, nullptr);
l->runAction(RepeatForever::create(seq));
this->addChild(l, 0, kLayerIgnoreAnchorPoint);
auto child = Sprite::create("Images/grossini.png");
l->addChild(child);
auto lsize = l->getContentSize();
child->setPosition(Vec2(lsize.width / 2, lsize.height / 2));
auto item =
MenuItemFont::create("Toggle ignore anchor point", AX_CALLBACK_1(LayerIgnoreAnchorPointPos::onToggle, this));
auto menu = Menu::create(item, nullptr);
this->addChild(menu);
menu->setPosition(Vec2(s.width / 2, s.height / 2));
}
void LayerIgnoreAnchorPointPos::onToggle(Ref* pObject)
{
auto layer = this->getChildByTag(kLayerIgnoreAnchorPoint);
bool ignore = layer->isIgnoreAnchorPointForPosition();
layer->setIgnoreAnchorPointForPosition(!ignore);
}
std::string LayerIgnoreAnchorPointPos::title() const
{
return "IgnoreAnchorPoint - Position";
}
std::string LayerIgnoreAnchorPointPos::subtitle() const
{
return "Ignoring Anchor Vec2 for position";
}
// LayerIgnoreAnchorPointRot
void LayerIgnoreAnchorPointRot::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto l = LayerColor::create(Color4B(255, 0, 0, 255), 200, 200);
l->setAnchorPoint(Vec2(0.5f, 0.5f));
l->setPosition(Vec2(s.width / 2, s.height / 2));
this->addChild(l, 0, kLayerIgnoreAnchorPoint);
auto rot = RotateBy::create(2, 360);
l->runAction(RepeatForever::create(rot));
auto child = Sprite::create("Images/grossini.png");
l->addChild(child);
auto lsize = l->getContentSize();
child->setPosition(Vec2(lsize.width / 2, lsize.height / 2));
auto item =
MenuItemFont::create("Toggle ignore anchor point", AX_CALLBACK_1(LayerIgnoreAnchorPointRot::onToggle, this));
auto menu = Menu::create(item, nullptr);
this->addChild(menu);
menu->setPosition(Vec2(s.width / 2, s.height / 2));
}
void LayerIgnoreAnchorPointRot::onToggle(Ref* pObject)
{
auto layer = this->getChildByTag(kLayerIgnoreAnchorPoint);
bool ignore = layer->isIgnoreAnchorPointForPosition();
layer->setIgnoreAnchorPointForPosition(!ignore);
}
std::string LayerIgnoreAnchorPointRot::title() const
{
return "IgnoreAnchorPoint - Rotation";
}
std::string LayerIgnoreAnchorPointRot::subtitle() const
{
return "Ignoring Anchor Vec2 for rotations";
}
// LayerIgnoreAnchorPointScale
void LayerIgnoreAnchorPointScale::onEnter()
{
LayerTest::onEnter();
auto s = Director::getInstance()->getWinSize();
auto l = LayerColor::create(Color4B(255, 0, 0, 255), 200, 200);
l->setAnchorPoint(Vec2(0.5f, 1.0f));
l->setPosition(Vec2(s.width / 2, s.height / 2));
auto scale = ScaleBy::create(2, 2);
auto back = (ScaleBy*)scale->reverse();
auto seq = Sequence::create(scale, back, nullptr);
l->runAction(RepeatForever::create(seq));
this->addChild(l, 0, kLayerIgnoreAnchorPoint);
auto child = Sprite::create("Images/grossini.png");
l->addChild(child);
auto lsize = l->getContentSize();
child->setPosition(Vec2(lsize.width / 2, lsize.height / 2));
auto item =
MenuItemFont::create("Toggle ignore anchor point", AX_CALLBACK_1(LayerIgnoreAnchorPointScale::onToggle, this));
auto menu = Menu::create(item, nullptr);
this->addChild(menu);
menu->setPosition(Vec2(s.width / 2, s.height / 2));
}
void LayerIgnoreAnchorPointScale::onToggle(Ref* pObject)
{
auto layer = this->getChildByTag(kLayerIgnoreAnchorPoint);
bool ignore = layer->isIgnoreAnchorPointForPosition();
layer->setIgnoreAnchorPointForPosition(!ignore);
}
std::string LayerIgnoreAnchorPointScale::title() const
{
return "IgnoreAnchorPoint - Scale";
}
std::string LayerIgnoreAnchorPointScale::subtitle() const
{
return "Ignoring Anchor Vec2 for scale";
}
LayerExtendedBlendOpacityTest::LayerExtendedBlendOpacityTest()
{
auto layer1 = LayerGradient::create(Color4B(255, 0, 0, 255), Color4B(255, 0, 255, 255));
layer1->setContentSize(Size(80.0f, 80.0f));
layer1->setPosition(Vec2(50.0f, 50.0f));
addChild(layer1);
auto layer2 = LayerGradient::create(Color4B(0, 0, 0, 127), Color4B(255, 255, 255, 127));
layer2->setContentSize(Size(80.0f, 80.0f));
layer2->setPosition(Vec2(100.0f, 90.0f));
addChild(layer2);
auto layer3 = LayerGradient::create();
layer3->setContentSize(Size(80.0f, 80.0f));
layer3->setPosition(Vec2(150.0f, 140.0f));
layer3->setStartColor(Color3B(255, 0, 0));
layer3->setEndColor(Color3B(255, 0, 255));
layer3->setStartOpacity(255);
layer3->setEndOpacity(255);
layer3->setBlendFunc(BlendFunc::ALPHA_NON_PREMULTIPLIED);
addChild(layer3);
}
std::string LayerExtendedBlendOpacityTest::title() const
{
return "Extended Blend & Opacity";
}
std::string LayerExtendedBlendOpacityTest::subtitle() const
{
return "You should see 3 layers";
}
// LayerBug3162A
void LayerBug3162A::onEnter()
{
LayerTest::onEnter();
Size size = VisibleRect::getVisibleRect().size;
size.width = size.width / 2;
size.height = size.height / 3;
Color4B color[3] = {Color4B(255, 0, 0, 255), Color4B(0, 255, 0, 255), Color4B(0, 0, 255, 255)};
for (int i = 0; i < 3; ++i)
{
_layer[i] = LayerColor::create(color[i]);
_layer[i]->setContentSize(size);
_layer[i]->setPosition(Vec2(size.width / 2, size.height / 2) - Vec2(20.0f, 20.0f));
_layer[i]->setOpacity(150);
_layer[i]->setCascadeOpacityEnabled(true);
if (i > 0)
{
_layer[i - 1]->addChild(_layer[i]);
}
}
this->addChild(_layer[0]);
schedule(AX_SCHEDULE_SELECTOR(LayerBug3162A::step), 0.5, AX_REPEAT_FOREVER, 0);
}
void LayerBug3162A::step(float dt)
{
_layer[0]->setCascadeOpacityEnabled(!_layer[0]->isCascadeOpacityEnabled());
}
std::string LayerBug3162A::title() const
{
return "Bug 3162 red layer cascade opacity enable/disable";
}
std::string LayerBug3162A::subtitle() const
{
return "g and b layer opacity is effected/diseffected with r layer";
}
// LayerBug3162B
void LayerBug3162B::onEnter()
{
LayerTest::onEnter();
Size size = VisibleRect::getVisibleRect().size;
size.width = size.width / 2;
size.height = size.height / 3;
Color4B color[3] = {Color4B(200, 0, 0, 255), Color4B(150, 0, 0, 255), Color4B(100, 0, 0, 255)};
for (int i = 0; i < 3; ++i)
{
_layer[i] = LayerColor::create(color[i]);
_layer[i]->setContentSize(size);
_layer[i]->setPosition(Vec2(size.width / 2, size.height / 2) - Vec2(20.0f, 20.0f));
//_layer[i]->setOpacity(150);
if (i > 0)
{
_layer[i - 1]->addChild(_layer[i]);
}
}
this->addChild(_layer[0]);
_layer[0]->setCascadeColorEnabled(true);
_layer[1]->setCascadeColorEnabled(true);
_layer[2]->setCascadeColorEnabled(true);
schedule(AX_SCHEDULE_SELECTOR(LayerBug3162B::step), 0.5, AX_REPEAT_FOREVER, 0);
}
void LayerBug3162B::step(float dt)
{
_layer[0]->setCascadeColorEnabled(!_layer[0]->isCascadeColorEnabled());
}
std::string LayerBug3162B::title() const
{
return "Bug 3162 bottom layer cascade color enable/disable";
}
std::string LayerBug3162B::subtitle() const
{
return "u and m layer color is effected/diseffected with b layer";
}
std::string LayerColorOccludeBug::title() const
{
return "Layer Color Occlude Bug Test";
}
std::string LayerColorOccludeBug::subtitle() const
{
return "Layer Color Should not occlude titles and any sprites";
}
void LayerColorOccludeBug::onEnter()
{
LayerTest::onEnter();
Director::getInstance()->getRenderer()->setDepthTest(true);
_layer = LayerColor::create(Color4B(0, 80, 95, 255));
addChild(_layer);
}
void LayerColorOccludeBug::onExit()
{
LayerTest::onExit();
Director::getInstance()->getRenderer()->setDepthTest(false);
}
// LayerRadialGradient
std::string LayerRadialGradientTest::title() const
{
return "LayerRadialGradient test";
}
void LayerRadialGradientTest::onEnter()
{
LayerTest::onEnter();
_currentSeletedItemIndex = 0;
auto director = Director::getInstance();
director->setClearColor(Color4F(0, 0, 0, 0));
auto origin = director->getVisibleOrigin();
auto size = director->getVisibleSize();
Vec2 center(origin.x + size.width / 2 + 50, origin.y + size.height / 2);
float radius = (size.height - 50) / 2;
_layer = LayerRadialGradient::create(Color4B(145, 106, 209, 140), Color4B(0, 0, 0, 0), radius, center, 1.0f);
addChild(_layer);
auto scaleSlider = LayerRadialGradientTest::createSlider();
scaleSlider->setPosition(Vec2(50.0f, 130.0f));
addChild(scaleSlider);
auto listview = createListView();
listview->setPosition(Vec2(100.0f, 150.0f));
addChild(listview);
}
axis::ui::Slider* LayerRadialGradientTest::createSlider()
{
auto slider = ui::Slider::create();
slider->setTouchEnabled(true);
slider->loadBarTexture("cocosui/sliderTrack.png");
slider->loadSlidBallTextures("cocosui/sliderThumb.png", "cocosui/sliderThumb.png", "");
slider->loadProgressBarTexture("cocosui/sliderProgress.png");
slider->addEventListener(AX_CALLBACK_2(LayerRadialGradientTest::sliderCallback, this));
slider->setRotation(90);
slider->setTag(101);
slider->setPercent(50);
return slider;
}
void LayerRadialGradientTest::listviewCallback(axis::Ref* sender, axis::ui::ListView::EventType type)
{
// clear all text to white
auto listview = static_cast<axis::ui::ListView*>(sender);
for (auto&& item : listview->getItems())
static_cast<axis::ui::Text*>(item)->setColor(axis::Color3B::WHITE);
_currentSeletedItemIndex = (int)listview->getCurSelectedIndex();
listview->getItem(_currentSeletedItemIndex)->setColor(axis::Color3B::RED);
int percent = 100;
auto slider = static_cast<axis::ui::Slider*>(getChildByTag(101));
switch (_currentSeletedItemIndex)
{
case 0:
// scale
slider->setPercent(_layer->getScaleX() / 2 * percent);
break;
case 1:
// skewx
slider->setPercent(_layer->getSkewX() / 90 * percent);
break;
case 2:
// skewy
slider->setPercent(_layer->getSkewY() / 90 * percent);
break;
case 3:
// expand
slider->setPercent(_layer->getExpand() * percent);
break;
case 4:
// radius
slider->setPercent(_layer->getRadius() / 300 * percent);
break;
default:
break;
}
}
void LayerRadialGradientTest::sliderCallback(axis::Ref* sender, axis::ui::Slider::EventType type)
{
auto slider = static_cast<axis::ui::Slider*>(sender);
float percent = slider->getPercent() / 100.f;
switch (_currentSeletedItemIndex)
{
case 0:
// scale
_layer->setScale(percent * 2);
AXLOG("scale is %f", percent * 2);
break;
case 1:
// skewx
_layer->setSkewX(90 * percent);
AXLOG("SkewX is %f", 90 * percent);
break;
case 2:
// skewy
_layer->setSkewY(90 * percent);
AXLOG("SkewY is %f", 90 * percent);
break;
case 3:
// expand
_layer->setExpand(percent);
AXLOG("expand is %f", percent);
break;
case 4:
// radius
_layer->setRadius(300 * percent);
AXLOG("radius is %f", 300 * percent);
break;
default:
break;
}
}
axis::ui::ListView* LayerRadialGradientTest::createListView()
{
auto listview = axis::ui::ListView::create();
auto scale = axis::ui::Text::create();
scale->setString("scale[0-2]");
scale->setColor(axis::Color3B::RED); // default seleted item
scale->setTouchEnabled(true);
listview->pushBackCustomItem(scale);
auto skewx = axis::ui::Text::create();
skewx->setString("skewx[0-90]");
skewx->setTouchEnabled(true);
listview->pushBackCustomItem(skewx);
auto skewy = axis::ui::Text::create();
skewy->setString("skewy[0-90]");
skewy->setTouchEnabled(true);
listview->pushBackCustomItem(skewy);
auto expand = axis::ui::Text::create();
expand->setString("expand[0-1]");
expand->setTouchEnabled(true);
listview->pushBackCustomItem(expand);
auto radius = axis::ui::Text::create();
radius->setString("radius[0-300]");
radius->setTouchEnabled(true);
listview->pushBackCustomItem(radius);
listview->setContentSize(scale->getContentSize() * 5);
listview->setCurSelectedIndex(0);
listview->setTouchEnabled(true);
listview->addEventListener(
(ui::ListView::ccListViewCallback)AX_CALLBACK_2(LayerRadialGradientTest::listviewCallback, this));
listview->setTag(100);
return listview;
}
Reference in New Issue View Git Blame Copy Permalink