/****************************************************************************
 Copyright (c) 2012 cocos2d-x.org
 Copyright (c) 2013-2016 Chukong Technologies Inc.
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.

 https://axis-project.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 "SpriteTest.h"

#include <cmath>
#include <algorithm>

#include "../testResource.h"
#include "cocostudio/CocosStudioExtension.h"

USING_NS_AX;

enum
{
    kTagTileMap         = 1,
    kTagSpriteBatchNode = 1,
    kTagNode            = 2,
    kTagAnimation1      = 1,
    kTagSpriteLeft,
    kTagSpriteRight,
};

enum
{
    kTagSprite1,
    kTagSprite2,
    kTagSprite3,
    kTagSprite4,
    kTagSprite5,
    kTagSprite6,
    kTagSprite7,
    kTagSprite8,
};

SpriteTests::SpriteTests()
{
    ADD_TEST_CASE(Sprite1);
    ADD_TEST_CASE(SpriteBatchNode1);
    ADD_TEST_CASE(SpriteAnchorPoint);
    ADD_TEST_CASE(SpriteBatchNodeAnchorPoint);
    ADD_TEST_CASE(SpriteAnchorPointFromFile);
    ADD_TEST_CASE(SpriteOffsetAnchorRotation);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorRotation);
    ADD_TEST_CASE(SpriteOffsetAnchorScale);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorScale);
    ADD_TEST_CASE(SpriteOffsetAnchorSkew);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorSkew);
    ADD_TEST_CASE(SpriteOffsetAnchorRotationalSkew);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorRotationalSkew);
    ADD_TEST_CASE(SpriteOffsetAnchorSkewScale);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorSkewScale);
    ADD_TEST_CASE(SpriteOffsetAnchorRotationalSkewScale);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorRotationalSkewScale);
    ADD_TEST_CASE(SpriteSkewNegativeScaleChildren);
    ADD_TEST_CASE(SpriteBatchNodeSkewNegativeScaleChildren);
    ADD_TEST_CASE(SpriteRotationalSkewNegativeScaleChildren);
    ADD_TEST_CASE(SpriteBatchNodeRotationalSkewNegativeScaleChildren);
    ADD_TEST_CASE(SpriteOffsetAnchorFlip);
    ADD_TEST_CASE(SpriteBatchNodeOffsetAnchorFlip);
    ADD_TEST_CASE(SpriteChildrenChildren);
    ADD_TEST_CASE(SpriteBatchNodeChildrenChildren);
    ADD_TEST_CASE(SpriteChildrenAnchorPoint);
    ADD_TEST_CASE(SpriteBatchNodeChildrenAnchorPoint);
    ADD_TEST_CASE(SpriteColorOpacity);
    ADD_TEST_CASE(SpriteColorOpacityHSVHSL);
    ADD_TEST_CASE(SpriteBatchNodeColorOpacity);
    ADD_TEST_CASE(SpriteZOrder);
    ADD_TEST_CASE(SpriteBatchNodeZOrder);
    //    ADD_TEST_CASE(SpriteZVertex); // TODO shouldn't call OpenGL API directly
    //    ADD_TEST_CASE(SpriteBatchNodeZVertex);
    ADD_TEST_CASE(SpriteAliased);
    ADD_TEST_CASE(SpriteBatchNodeAliased);
    ADD_TEST_CASE(SpriteNewTexture);
    ADD_TEST_CASE(SpriteBatchNodeNewTexture);
    ADD_TEST_CASE(SpriteFlip);
    ADD_TEST_CASE(SpriteBatchNodeFlip);
    ADD_TEST_CASE(SpriteAnimationSplit);
    ADD_TEST_CASE(SpriteFrameTest);
    ADD_TEST_CASE(SpriteFrameAliasNameTest);
    ADD_TEST_CASE(SpriteFramesFromFileContent);
    ADD_TEST_CASE(SpritePolygonFromFileContent);
    ADD_TEST_CASE(SpriteBatchNodeReorder);
    ADD_TEST_CASE(SpriteBatchNodeReorderIssue744);
    ADD_TEST_CASE(SpriteBatchNodeReorderIssue766);
    ADD_TEST_CASE(SpriteBatchNodeReorderIssue767);
    ADD_TEST_CASE(SpriteBatchNodeReorderSameIndex);
    ADD_TEST_CASE(SpriteBatchNodeReorderOneChild);
    ADD_TEST_CASE(NodeSort);
    ADD_TEST_CASE(Sprite6);
    ADD_TEST_CASE(SpriteHybrid);
    ADD_TEST_CASE(SpriteBatchNodeChildren);
    ADD_TEST_CASE(SpriteBatchNodeChildrenZ);
    ADD_TEST_CASE(SpriteChildrenVisibility);
    ADD_TEST_CASE(SpriteChildrenVisibilityIssue665);
    ADD_TEST_CASE(SpriteBatchNodeChildrenScale);
    ADD_TEST_CASE(SpriteNilTexture);
    ADD_TEST_CASE(SpriteSubclass);
    ADD_TEST_CASE(SpriteBatchBug1217);
    ADD_TEST_CASE(AnimationCacheTest);
    ADD_TEST_CASE(AnimationCacheFile);
    ADD_TEST_CASE(SpriteCullTest1);
    ADD_TEST_CASE(SpriteCullTest2);
    ADD_TEST_CASE(Sprite3DRotationTest);
    ADD_TEST_CASE(SpriteGetSpriteFrameTest);
    ADD_TEST_CASE(SpriteSlice9Test1);
    ADD_TEST_CASE(SpriteSlice9Test2);
    ADD_TEST_CASE(SpriteSlice9Test3);
    ADD_TEST_CASE(SpriteSlice9Test4);
    ADD_TEST_CASE(SpriteSlice9Test5);
    ADD_TEST_CASE(SpriteSlice9Test6);
    ADD_TEST_CASE(SpriteSlice9Test7);
    ADD_TEST_CASE(SpriteSlice9Test8);
    ADD_TEST_CASE(SpriteSlice9Test9);
    ADD_TEST_CASE(SpriteSlice9Test10);
    ADD_TEST_CASE(Issue17119);
};

//------------------------------------------------------------------
//
// Sprite1
//
//------------------------------------------------------------------

Sprite1::Sprite1()
{
    auto listener            = EventListenerTouchAllAtOnce::create();
    listener->onTouchesEnded = AX_CALLBACK_2(Sprite1::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

    auto s = Director::getInstance()->getWinSize();
    addNewSpriteWithCoords(Vec2(s.width / 2, s.height / 2));
}

void Sprite1::addNewSpriteWithCoords(Vec2 p)
{
    int idx = (int)(AXRANDOM_0_1() * 1400.0f / 100.0f);
    int x   = (idx % 5) * 85;
    int y   = (idx / 5) * 121;

    auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(x, y, 85, 121));
    addChild(sprite);

    sprite->setPosition(Vec2(p.x, p.y));

    ActionInterval* action;
    float random = AXRANDOM_0_1();

    if (random < 0.20)
        action = ScaleBy::create(3, 2);
    else if (random < 0.40)
        action = RotateBy::create(3, 360);
    else if (random < 0.60)
        action = Blink::create(1, 3);
    else if (random < 0.8)
        action = TintBy::create(2, 0, -255, -255);
    else
        action = FadeOut::create(2);
    auto action_back = action->reverse();
    auto seq         = Sequence::create(action, action_back, nullptr);

    sprite->runAction(RepeatForever::create(seq));
}

void Sprite1::onTouchesEnded(const std::vector<Touch*>& touches, Event* event)
{
    for (auto touch : touches)
    {
        auto location = touch->getLocation();

        addNewSpriteWithCoords(location);
    }
}

std::string Sprite1::title() const
{
    return "Testing Sprite";
}

std::string Sprite1::subtitle() const
{
    return "Tap screen to add more sprites";
}

//------------------------------------------------------------------
//
// SpriteBatchNode1
//
//------------------------------------------------------------------

SpriteBatchNode1::SpriteBatchNode1()
{
    auto listener            = EventListenerTouchAllAtOnce::create();
    listener->onTouchesEnded = AX_CALLBACK_2(SpriteBatchNode1::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

    auto BatchNode = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 50);
    addChild(BatchNode, 0, kTagSpriteBatchNode);

    auto s = Director::getInstance()->getWinSize();
    addNewSpriteWithCoords(Vec2(s.width / 2, s.height / 2));
}

void SpriteBatchNode1::addNewSpriteWithCoords(Vec2 p)
{
    auto BatchNode = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));

    int idx = AXRANDOM_0_1() * 1400 / 100;
    int x   = (idx % 5) * 85;
    int y   = (idx / 5) * 121;

    auto sprite = Sprite::createWithTexture(BatchNode->getTexture(), Rect(x, y, 85, 121));
    BatchNode->addChild(sprite);

    sprite->setPosition(Vec2(p.x, p.y));

    ActionInterval* action;
    float random = AXRANDOM_0_1();

    if (random < 0.20)
        action = ScaleBy::create(3, 2);
    else if (random < 0.40)
        action = RotateBy::create(3, 360);
    else if (random < 0.60)
        action = Blink::create(1, 3);
    else if (random < 0.8)
        action = TintBy::create(2, 0, -255, -255);
    else
        action = FadeOut::create(2);

    auto action_back = action->reverse();
    auto seq         = Sequence::create(action, action_back, nullptr);

    sprite->runAction(RepeatForever::create(seq));
}

void SpriteBatchNode1::onTouchesEnded(const std::vector<Touch*>& touches, Event* event)
{
    for (auto& touch : touches)
    {
        auto location = touch->getLocation();

        addNewSpriteWithCoords(location);
    }
}

std::string SpriteBatchNode1::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNode1::subtitle() const
{
    return "SpriteBatchNode: Tap screen to add more sprites";
}

//------------------------------------------------------------------
//
// SpriteColorOpacity
//
//------------------------------------------------------------------

SpriteColorOpacity::SpriteColorOpacity()
{
    auto sprite1 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite2 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite3 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite4 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 3, 121 * 1, 85, 121));

    auto sprite5 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite6 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite7 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite8 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 3, 121 * 1, 85, 121));

    auto s = Director::getInstance()->getWinSize();
    sprite1->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 1));
    sprite2->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 1));
    sprite3->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 1));
    sprite4->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 1));
    sprite5->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 2));
    sprite6->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 2));
    sprite7->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 2));
    sprite8->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 2));

    auto action      = FadeIn::create(2);
    auto action_back = action->reverse();
    auto fade        = RepeatForever::create(Sequence::create(action, action_back, nullptr));

    auto tintred      = TintBy::create(2, 0, -255, -255);
    auto tintred_back = tintred->reverse();
    auto red          = RepeatForever::create(Sequence::create(tintred, tintred_back, nullptr));

    auto tintgreen      = TintBy::create(2, -255, 0, -255);
    auto tintgreen_back = tintgreen->reverse();
    auto green          = RepeatForever::create(Sequence::create(tintgreen, tintgreen_back, nullptr));

    auto tintblue      = TintBy::create(2, -255, -255, 0);
    auto tintblue_back = tintblue->reverse();
    auto blue          = RepeatForever::create(Sequence::create(tintblue, tintblue_back, nullptr));

    sprite5->runAction(red);
    sprite6->runAction(green);
    sprite7->runAction(blue);
    sprite8->runAction(fade);

    // late add: test dirtyColor and dirtyPosition
    addChild(sprite1, 0, kTagSprite1);
    addChild(sprite2, 0, kTagSprite2);
    addChild(sprite3, 0, kTagSprite3);
    addChild(sprite4, 0, kTagSprite4);
    addChild(sprite5, 0, kTagSprite5);
    addChild(sprite6, 0, kTagSprite6);
    addChild(sprite7, 0, kTagSprite7);
    addChild(sprite8, 0, kTagSprite8);

    schedule(AX_CALLBACK_1(SpriteColorOpacity::removeAndAddSprite, this), 2, "remove_add_key");
}

// this function test if remove and add works as expected:
//   color array and vertex array should be reindexed
void SpriteColorOpacity::removeAndAddSprite(float dt)
{
    auto sprite = static_cast<Sprite*>(getChildByTag(kTagSprite5));
    sprite->retain();

    removeChild(sprite, false);
    addChild(sprite, 0, kTagSprite5);

    sprite->release();
}

std::string SpriteColorOpacity::title() const
{
    return "Testing Sprite";
}

std::string SpriteColorOpacity::subtitle() const
{
    return "Color & Opacity";
}

//------------------------------------------------------------------
//
// SpriteColorOpacityHSVHSL
//
//------------------------------------------------------------------

SpriteColorOpacityHSVHSL::SpriteColorOpacityHSVHSL()
{
    auto sprite1 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite2 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite3 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite4 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 3, 121 * 1, 85, 121));

    auto sprite5 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite6 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite7 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite8 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 3, 121 * 1, 85, 121));

    auto s = Director::getInstance()->getWinSize();
    sprite1->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 1));
    sprite2->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 1));
    sprite3->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 1));
    sprite4->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 1));
    sprite5->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 2));
    sprite6->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 2));
    sprite7->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 2));
    sprite8->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 2));

    auto action      = FadeIn::create(2);
    auto action_back = action->reverse();
    auto fade        = RepeatForever::create(Sequence::create(action, action_back, nullptr));

    auto col          = HSV(0, 1, 1, 1).toColor3B();
    auto tintred      = TintBy::create(2, col.r, col.g, col.b);
    auto tintred_back = tintred->reverse();
    auto red          = RepeatForever::create(Sequence::create(tintred, tintred_back, nullptr));

    col                 = HSV(120, 1, 1, 1).toColor3B();
    auto tintgreen      = TintBy::create(2, col.r, col.g, col.b);
    auto tintgreen_back = tintgreen->reverse();
    auto green          = RepeatForever::create(Sequence::create(tintgreen, tintgreen_back, nullptr));

    col                = HSV(240, 1, 1, 1).toColor3B();
    auto tintblue      = TintBy::create(2, col.r, col.g, col.b);
    auto tintblue_back = tintblue->reverse();
    auto blue          = RepeatForever::create(Sequence::create(tintblue, tintblue_back, nullptr));

    sprite1->runAction(red);
    sprite2->runAction(green);
    sprite3->runAction(blue);
    sprite4->runAction(fade);

    action      = FadeIn::create(2);
    action_back = action->reverse();
    fade        = RepeatForever::create(Sequence::create(action, action_back, nullptr));

    col          = HSL(0, 1, .7, 1).toColor3B();
    tintred      = TintBy::create(2, col.r, col.g, col.b);
    tintred_back = tintred->reverse();
    red          = RepeatForever::create(Sequence::create(tintred, tintred_back, nullptr));

    col            = HSL(120, 1, .7, 1).toColor3B();
    tintgreen      = TintBy::create(2, col.r, col.g, col.b);
    tintgreen_back = tintgreen->reverse();
    green          = RepeatForever::create(Sequence::create(tintgreen, tintgreen_back, nullptr));

    col           = HSL(240, 1, .7, 1).toColor3B();
    tintblue      = TintBy::create(2, col.r, col.g, col.b);
    tintblue_back = tintblue->reverse();
    blue          = RepeatForever::create(Sequence::create(tintblue, tintblue_back, nullptr));

    sprite5->runAction(red);
    sprite6->runAction(green);
    sprite7->runAction(blue);
    sprite8->runAction(fade);

    // late add: test dirtyColor and dirtyPosition
    addChild(sprite1, 0, kTagSprite1);
    addChild(sprite2, 0, kTagSprite2);
    addChild(sprite3, 0, kTagSprite3);
    addChild(sprite4, 0, kTagSprite4);
    addChild(sprite5, 0, kTagSprite5);
    addChild(sprite6, 0, kTagSprite6);
    addChild(sprite7, 0, kTagSprite7);
    addChild(sprite8, 0, kTagSprite8);

    schedule(AX_CALLBACK_1(SpriteColorOpacityHSVHSL::removeAndAddSprite, this), 2, "remove_add_key");
}

// this function test if remove and add works as expected:
//   color array and vertex array should be reindexed
void SpriteColorOpacityHSVHSL::removeAndAddSprite(float dt)
{
    auto sprite = static_cast<Sprite*>(getChildByTag(kTagSprite5));
    sprite->retain();

    removeChild(sprite, false);
    addChild(sprite, 0, kTagSprite5);

    sprite->release();
}

std::string SpriteColorOpacityHSVHSL::title() const
{
    return "Testing Sprite";
}

std::string SpriteColorOpacityHSVHSL::subtitle() const
{
    return "Color & Opacity using HSV/HSL";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeColorOpacity
//
//------------------------------------------------------------------

SpriteBatchNodeColorOpacity::SpriteBatchNodeColorOpacity()
{
    // small capacity. Testing resizing.
    // Don't use capacity=1 in your real game. It is expensive to resize the capacity
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 1);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto sprite1 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite2 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite3 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite4 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 3, 121 * 1, 85, 121));

    auto sprite5 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 0, 121 * 1, 85, 121));
    auto sprite6 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    auto sprite7 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 2, 121 * 1, 85, 121));
    auto sprite8 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 3, 121 * 1, 85, 121));

    auto s = Director::getInstance()->getWinSize();
    sprite1->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 1));
    sprite2->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 1));
    sprite3->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 1));
    sprite4->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 1));
    sprite5->setPosition(Vec2((s.width / 5) * 1, (s.height / 3) * 2));
    sprite6->setPosition(Vec2((s.width / 5) * 2, (s.height / 3) * 2));
    sprite7->setPosition(Vec2((s.width / 5) * 3, (s.height / 3) * 2));
    sprite8->setPosition(Vec2((s.width / 5) * 4, (s.height / 3) * 2));

    auto action      = FadeIn::create(2);
    auto action_back = action->reverse();
    auto fade        = RepeatForever::create(Sequence::create(action, action_back, nullptr));

    auto tintred      = TintBy::create(2, 0, -255, -255);
    auto tintred_back = tintred->reverse();
    auto red          = RepeatForever::create(Sequence::create(tintred, tintred_back, nullptr));

    auto tintgreen      = TintBy::create(2, -255, 0, -255);
    auto tintgreen_back = tintgreen->reverse();
    auto green          = RepeatForever::create(Sequence::create(tintgreen, tintgreen_back, nullptr));

    auto tintblue      = TintBy::create(2, -255, -255, 0);
    auto tintblue_back = tintblue->reverse();
    auto blue          = RepeatForever::create(Sequence::create(tintblue, tintblue_back, nullptr));

    sprite5->runAction(red);
    sprite6->runAction(green);
    sprite7->runAction(blue);
    sprite8->runAction(fade);

    // late add: test dirtyColor and dirtyPosition
    batch->addChild(sprite1, 0, kTagSprite1);
    batch->addChild(sprite2, 0, kTagSprite2);
    batch->addChild(sprite3, 0, kTagSprite3);
    batch->addChild(sprite4, 0, kTagSprite4);
    batch->addChild(sprite5, 0, kTagSprite5);
    batch->addChild(sprite6, 0, kTagSprite6);
    batch->addChild(sprite7, 0, kTagSprite7);
    batch->addChild(sprite8, 0, kTagSprite8);

    schedule(AX_CALLBACK_1(SpriteBatchNodeColorOpacity::removeAndAddSprite, this), 2, "remove_add_key");
}

// this function test if remove and add works as expected:
//   color array and vertex array should be reindexed
void SpriteBatchNodeColorOpacity::removeAndAddSprite(float dt)
{
    auto batch  = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));
    auto sprite = static_cast<Sprite*>(batch->getChildByTag(kTagSprite5));

    sprite->retain();

    batch->removeChild(sprite, false);
    batch->addChild(sprite, 0, kTagSprite5);

    sprite->release();
}

std::string SpriteBatchNodeColorOpacity::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeColorOpacity::subtitle() const
{
    return "Color & Opacity";
}

//------------------------------------------------------------------
//
// SpriteZOrder
//
//------------------------------------------------------------------

SpriteZOrder::SpriteZOrder()
{
    _dir = 1;

    auto s = Director::getInstance()->getWinSize();

    float step = s.width / 11;
    for (int i = 0; i < 5; i++)
    {
        auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        addChild(sprite, i);
    }

    for (int i = 5; i < 10; i++)
    {
        auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 0, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        addChild(sprite, 14 - i);
    }

    auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 3, 121 * 0, 85, 121));
    addChild(sprite, -1, kTagSprite1);
    sprite->setPosition(Vec2(s.width / 2, s.height / 2 - 20));
    sprite->setScaleX(6);
    sprite->setColor(Color3B::RED);

    schedule(AX_CALLBACK_1(SpriteZOrder::reorderSprite, this), 1, "reorder_key");
}

void SpriteZOrder::reorderSprite(float dt)
{
    auto sprite = static_cast<Sprite*>(getChildByTag(kTagSprite1));

    int z = sprite->getLocalZOrder();

    if (z < -1)
        _dir = 1;
    if (z > 10)
        _dir = -1;

    z += _dir * 3;

    reorderChild(sprite, z);
}

std::string SpriteZOrder::title() const
{
    return "Testing Sprite";
}

std::string SpriteZOrder::subtitle() const
{
    return "Z order";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeZOrder
//
//------------------------------------------------------------------

SpriteBatchNodeZOrder::SpriteBatchNodeZOrder()
{
    _dir = 1;

    // small capacity. Testing resizing.
    // Don't use capacity=1 in your real game. It is expensive to resize the capacity
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 1);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto s = Director::getInstance()->getWinSize();

    float step = s.width / 11;
    for (int i = 0; i < 5; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 0, 121 * 1, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        batch->addChild(sprite, i);
    }

    for (int i = 5; i < 10; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 0, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        batch->addChild(sprite, 14 - i);
    }

    auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 3, 121 * 0, 85, 121));
    batch->addChild(sprite, -1, kTagSprite1);
    sprite->setPosition(Vec2(s.width / 2, s.height / 2 - 20));
    sprite->setScaleX(6);
    sprite->setColor(Color3B::RED);

    schedule(AX_CALLBACK_1(SpriteBatchNodeZOrder::reorderSprite, this), 1, "reorder_key");
}

void SpriteBatchNodeZOrder::reorderSprite(float dt)
{
    auto batch  = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));
    auto sprite = static_cast<Sprite*>(batch->getChildByTag(kTagSprite1));

    int z = sprite->getLocalZOrder();

    if (z < -1)
        _dir = 1;
    if (z > 10)
        _dir = -1;

    z += _dir * 3;

    batch->reorderChild(sprite, z);
}

std::string SpriteBatchNodeZOrder::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeZOrder::subtitle() const
{
    return "Z order";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeReorder
//
//------------------------------------------------------------------

SpriteBatchNodeReorder::SpriteBatchNodeReorder()
{
    Vector<Sprite*> a;
    auto asmtest = SpriteBatchNode::create("animations/ghosts.png");

    for (int i = 0; i < 10; i++)
    {
        auto s1 = Sprite::createWithTexture(asmtest->getTexture(), Rect(0.0f, 0.0f, 50.0f, 50.0f));
        a.pushBack(s1);
        asmtest->addChild(s1, 10);
    }

    for (int i = 0; i < 10; i++)
    {
        if (i != 5)
        {
            asmtest->reorderChild(static_cast<Node*>(a.at(i)), 9);
        }
    }

    ssize_t AX_UNUSED prev = -1;

    auto& children = asmtest->getChildren();

    for (const auto& obj : children)
    {
        auto child = static_cast<Sprite*>(obj);

        ssize_t currentIndex = child->getAtlasIndex();
        AXASSERT(prev == currentIndex - 1, "Child order failed");
        ////----AXLOG("children %x - atlasIndex:%d", child, currentIndex);
        prev = currentIndex;
    }

    prev              = -1;
    auto& descendants = asmtest->getDescendants();
    for (const auto& sprite : descendants)
    {
        ssize_t currentIndex = sprite->getAtlasIndex();
        AXASSERT(prev == currentIndex - 1, "Child order failed");
        ////----AXLOG("descendant %x - atlasIndex:%d", child, currentIndex);
        prev = currentIndex;
    }
}

std::string SpriteBatchNodeReorder::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeReorder::subtitle() const
{
    return "reorder #1. Should not crash";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeReorderIssue744
//
//------------------------------------------------------------------

SpriteBatchNodeReorderIssue744::SpriteBatchNodeReorderIssue744()
{
    auto s = Director::getInstance()->getWinSize();

    // Testing issue #744
    // http://code.google.com/p/cocos2d-iphone/issues/detail?id=744
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 15);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(0, 0, 85, 121));
    sprite->setPosition(Vec2(s.width / 2, s.height / 2));
    batch->addChild(sprite, 3);
    batch->reorderChild(sprite, 1);
}

std::string SpriteBatchNodeReorderIssue744::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeReorderIssue744::subtitle() const
{
    return "reorder issue #744. Should not crash";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeReorderIssue766
//
//------------------------------------------------------------------

Sprite* SpriteBatchNodeReorderIssue766::makeSpriteZ(int aZ)
{
    Rect rcw(128, 0, 64, 64);
    rcw         = AX_RECT_PIXELS_TO_POINTS(rcw);
    auto sprite = Sprite::createWithTexture(batchNode->getTexture(), rcw);
    sprite->setScale(AX_CONTENT_SCALE_FACTOR());
    batchNode->addChild(sprite, aZ + 1, 0);

    // children
    Rect rc1(0, 0, 64, 64);
    rc1               = AX_RECT_PIXELS_TO_POINTS(rc1);
    auto spriteShadow = Sprite::createWithTexture(batchNode->getTexture(), rc1);
    spriteShadow->setOpacity(128);
    sprite->setScale(AX_CONTENT_SCALE_FACTOR());
    sprite->addChild(spriteShadow, aZ, 3);

    Rect rc2(64, 0, 64, 64);
    rc2            = AX_RECT_PIXELS_TO_POINTS(rc2);
    auto spriteTop = Sprite::createWithTexture(batchNode->getTexture(), rc2);
    sprite->setScale(AX_CONTENT_SCALE_FACTOR());
    sprite->addChild(spriteTop, aZ + 2, 3);

    return sprite;
}

void SpriteBatchNodeReorderIssue766::reorderSprite(float dt)
{
    unschedule("issue_766_key");

    batchNode->reorderChild(sprite1, 4);
}

// on "init" you need to initialize your instance
SpriteBatchNodeReorderIssue766::SpriteBatchNodeReorderIssue766()
{
    batchNode = SpriteBatchNode::create("Images/piece.png", 15);
    addChild(batchNode, 1, 0);

    sprite1 = makeSpriteZ(2);
    sprite1->setPosition(Vec2(200.0f, 160.0f));

    sprite2 = makeSpriteZ(3);
    sprite2->setPosition(Vec2(264.0f, 160.0f));

    sprite3 = makeSpriteZ(4);
    sprite3->setPosition(Vec2(328.0f, 160.0f));

    schedule(AX_CALLBACK_1(SpriteBatchNodeReorderIssue766::reorderSprite, this), 2, "issue_766_key");
}

std::string SpriteBatchNodeReorderIssue766::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeReorderIssue766::subtitle() const
{
    return "reorder issue #766. In 2 seconds 1 sprite will be reordered";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeReorderIssue767
//
//------------------------------------------------------------------
SpriteBatchNodeReorderIssue767::SpriteBatchNodeReorderIssue767()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/ghosts.plist", "animations/ghosts.png");
    Node* aParent;
    Sprite *l1, *l2a, *l2b, *l3a1, *l3a2, *l3b1, *l3b2;

    //
    // SpriteBatchNode: 3 levels of children
    //
    aParent = SpriteBatchNode::create("animations/ghosts.png");
    addChild(aParent, 0, kTagSprite1);

    // parent
    l1 = Sprite::createWithSpriteFrameName("father.gif");
    l1->setPosition(Vec2(s.width / 2, s.height / 2));
    aParent->addChild(l1, 0, kTagSprite2);
    auto l1Size = l1->getContentSize();

    // child left
    l2a = Sprite::createWithSpriteFrameName("sister1.gif");
    l2a->setPosition(Vec2(-25 + l1Size.width / 2, 0 + l1Size.height / 2));
    l1->addChild(l2a, -1, kTagSpriteLeft);
    auto l2aSize = l2a->getContentSize();

    // child right
    l2b = Sprite::createWithSpriteFrameName("sister2.gif");
    l2b->setPosition(Vec2(+25 + l1Size.width / 2, 0 + l1Size.height / 2));
    l1->addChild(l2b, 1, kTagSpriteRight);
    auto l2bSize = l2a->getContentSize();

    // child left bottom
    l3a1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a1->setScale(0.65f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, -50 + l2aSize.height / 2));
    l2a->addChild(l3a1, -1);

    // child left top
    l3a2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a2->setScale(0.65f);
    l3a2->setPosition(Vec2(0 + l2aSize.width / 2, +50 + l2aSize.height / 2));
    l2a->addChild(l3a2, 1);

    // child right bottom
    l3b1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b1->setScale(0.65f);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, -50 + l2bSize.height / 2));
    l2b->addChild(l3b1, -1);

    // child right top
    l3b2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b2->setScale(0.65f);
    l3b2->setPosition(Vec2(0 + l2bSize.width / 2, +50 + l2bSize.height / 2));
    l2b->addChild(l3b2, 1);

    schedule(AX_CALLBACK_1(SpriteBatchNodeReorderIssue767::reorderSprites, this), 1, "issue_767_key");
}

std::string SpriteBatchNodeReorderIssue767::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeReorderIssue767::subtitle() const
{
    return "reorder issue #767. Should not crash";
}

void SpriteBatchNodeReorderIssue767::reorderSprites(float dt)
{
    auto spritebatch = static_cast<SpriteBatchNode*>(getChildByTag(kTagSprite1));
    auto father      = static_cast<Sprite*>(spritebatch->getChildByTag(kTagSprite2));
    auto left        = static_cast<Sprite*>(father->getChildByTag(kTagSpriteLeft));
    auto right       = static_cast<Sprite*>(father->getChildByTag(kTagSpriteRight));

    int newZLeft = 1;

    if (left->getLocalZOrder() == 1)
        newZLeft = -1;

    father->reorderChild(left, newZLeft);
    father->reorderChild(right, -newZLeft);
}

//------------------------------------------------------------------
//
// SpriteZVertex
//
//------------------------------------------------------------------

void SpriteZVertex::onEnter()
{
    SpriteTestDemo::onEnter();

    Director::getInstance()->setProjection(Director::Projection::_3D);
}

void SpriteZVertex::onExit()
{
    Director::getInstance()->setProjection(Director::Projection::DEFAULT);
    SpriteTestDemo::onExit();
}

SpriteZVertex::SpriteZVertex()
{
    //
    // This test tests z-order
    // If you are going to use it is better to use a 3D projection
    //
    // WARNING:
    // The developer is responsible for ordering its sprites according to its Z if the sprite has
    // transparent parts.
    //

    //
    // Configure shader to mimic glAlphaTest
    //
    //    auto alphaTestShader =
    //    GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST); GLint
    //    alphaValueLocation = glGetUniformLocation(alphaTestShader->getProgram(),
    //    GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE);
    //
    //    // set alpha test value
    //    // NOTE: alpha test shader is hard-coded to use the equivalent of a glAlphaFunc(GL_GREATER) comparison
    //    if (getGLProgram())
    //    {
    //        getGLProgram()->setUniformLocationWith1f(alphaValueLocation, 0.0f);
    //    }

    _dir  = 1;
    _time = 0;

    auto s     = Director::getInstance()->getWinSize();
    float step = s.width / 12;

    auto node = Node::create();
    // camera uses the center of the image as the pivoting point
    node->setContentSize(Size(s.width, s.height));
    node->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    node->setPosition(Vec2(s.width / 2, s.height / 2));

    addChild(node, 0);

    for (int i = 0; i < 5; i++)
    {
        auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 0, 121 * 1, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        sprite->setPositionZ(10 + i * 40);
        //        sprite->setGLProgram(alphaTestShader);
        node->addChild(sprite, 0);
    }

    for (int i = 5; i < 11; i++)
    {
        auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 0, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        sprite->setPositionZ(10 + (10 - i) * 40);
        //        sprite->setGLProgram(alphaTestShader);
        node->addChild(sprite, 0);
    }

    node->runAction(OrbitCamera::create(10, 1, 0, 0, 360, 0, 0));
}

std::string SpriteZVertex::title() const
{
    return "Testing Sprite";
}

std::string SpriteZVertex::subtitle() const
{
    return "openGL Z vertex";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeZVertex
//
//------------------------------------------------------------------

void SpriteBatchNodeZVertex::onEnter()
{
    SpriteTestDemo::onEnter();

    Director::getInstance()->setProjection(Director::Projection::_3D);
}

void SpriteBatchNodeZVertex::onExit()
{
    Director::getInstance()->setProjection(Director::Projection::DEFAULT);
    SpriteTestDemo::onExit();
}

SpriteBatchNodeZVertex::SpriteBatchNodeZVertex()
{
    //
    // This test tests z-order
    // If you are going to use it is better to use a 3D projection
    //
    // WARNING:
    // The developer is responsible for ordering its sprites according to its Z if the sprite has
    // transparent parts.
    //

    //
    // Configure shader to mimic glAlphaTest
    //
    //    auto alphaTestShader =
    //    GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_ALPHA_TEST); GLint
    //    alphaValueLocation = glGetUniformLocation(alphaTestShader->getProgram(),
    //    GLProgram::UNIFORM_NAME_ALPHA_TEST_VALUE);

    // set alpha test value
    // NOTE: alpha test shader is hard-coded to use the equivalent of a glAlphaFunc(GL_GREATER) comparison
    //    if (getGLProgram())
    //    {
    //        getGLProgram()->setUniformLocationWith1f(alphaValueLocation, 0.0f);
    //    }

    auto s     = Director::getInstance()->getWinSize();
    float step = s.width / 12;

    // small capacity. Testing resizing.
    // Don't use capacity=1 in your real game. It is expensive to resize the capacity
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 1);
    // camera uses the center of the image as the pivoting point
    batch->setContentSize(Size(s.width, s.height));
    batch->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    batch->setPosition(Vec2(s.width / 2, s.height / 2));

    //    batch->setGLProgram(alphaTestShader);
    addChild(batch, 0, kTagSpriteBatchNode);

    for (int i = 0; i < 5; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 0, 121 * 1, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        sprite->setPositionZ(10 + i * 40);
        batch->addChild(sprite, 0);
    }

    for (int i = 5; i < 11; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 0, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));
        sprite->setPositionZ(10 + (10 - i) * 40);
        batch->addChild(sprite, 0);
    }

    batch->runAction(OrbitCamera::create(10, 1, 0, 0, 360, 0, 0));
}

std::string SpriteBatchNodeZVertex::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeZVertex::subtitle() const
{
    return "openGL Z vertex";
}

//------------------------------------------------------------------
//
// SpriteAnchorPoint
//
//------------------------------------------------------------------

SpriteAnchorPoint::SpriteAnchorPoint()
{
    auto s = Director::getInstance()->getWinSize();

    auto rotate = RotateBy::create(10, 360);
    auto action = RepeatForever::create(rotate);

    for (int i = 0; i < 3; i++)
    {
        auto sprite = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * i, 121 * 1, 85, 121));
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 10);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        sprite->runAction(action->clone());
        addChild(sprite, i);
    }
}

std::string SpriteAnchorPoint::title() const
{
    return "Testing Sprite";
}

std::string SpriteAnchorPoint::subtitle() const
{
    return "anchor point";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeAnchorPoint
//
//------------------------------------------------------------------
SpriteBatchNodeAnchorPoint::SpriteBatchNodeAnchorPoint()
{
    // small capacity. Testing resizing.
    // Don't use capacity=1 in your real game. It is expensive to resize the capacity
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 1);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto s = Director::getInstance()->getWinSize();

    auto rotate = RotateBy::create(10, 360);
    auto action = RepeatForever::create(rotate);
    for (int i = 0; i < 3; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * i, 121 * 1, 85, 121));
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        sprite->runAction(action->clone());
        batch->addChild(sprite, i);
    }
}

std::string SpriteBatchNodeAnchorPoint::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeAnchorPoint::subtitle() const
{
    return "anchor point";
}

//------------------------------------------------------------------
//
// SpriteAnchorPointFromFile
//
//------------------------------------------------------------------

void SpriteAnchorPointFromFile::onEnter()
{
    SpriteTestDemo::onEnter();
    auto screen = Director::getInstance()->getWinSize();

    auto rotate   = RotateBy::create(10, 360);
    auto action   = RepeatForever::create(rotate);
    char str[100] = {0};

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini_anchors.plist");

    Sprite* sprite;
    for (int i = 0; i < 10; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i + 1);
        sprite = Sprite::createWithSpriteFrameName(str);

        sprite->setPosition(Vec2(screen.width / 6 * (i % 5 + 1), screen.height * 2 / 3 - screen.height * (i / 5) / 3));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.1f);
        point->setPosition(sprite->getPosition());
        addChild(point, 10);

        sprite->runAction(action->clone());
        addChild(sprite, i);
    }

    Vector<SpriteFrame*> animFrames(5);
    for (int i = 9; i < 14; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i + 1);
        animFrames.pushBack(cache->getSpriteFrameByName(str));
    }
    auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
    sprite->runAction(RepeatForever::create(Animate::create(animation)));
}

void SpriteAnchorPointFromFile::onExit()
{
    SpriteFrameCache::getInstance()->removeSpriteFramesFromFile("animations/grossini_anchors.plist");
    SpriteTestDemo::onExit();
}

std::string SpriteAnchorPointFromFile::title() const
{
    return "Testing SpriteFrame";
}

std::string SpriteAnchorPointFromFile::subtitle() const
{
    return "anchor point";
}

//------------------------------------------------------------------
//
// Sprite6
//
//------------------------------------------------------------------

Sprite6::Sprite6()
{
    // small capacity. Testing resizing
    // Don't use capacity=1 in your real game. It is expensive to resize the capacity
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 1);
    addChild(batch, 0, kTagSpriteBatchNode);
    batch->setIgnoreAnchorPointForPosition(true);

    auto s = Director::getInstance()->getWinSize();

    batch->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    batch->setContentSize(Size(s.width, s.height));

    // SpriteBatchNode actions
    auto rotate = RotateBy::create(5, 360);
    auto action = RepeatForever::create(rotate);

    // SpriteBatchNode actions
    auto rotate_back    = rotate->reverse();
    auto rotate_seq     = Sequence::create(rotate, rotate_back, nullptr);
    auto rotate_forever = RepeatForever::create(rotate_seq);

    auto scale         = ScaleBy::create(5, 1.5f);
    auto scale_back    = scale->reverse();
    auto scale_seq     = Sequence::create(scale, scale_back, nullptr);
    auto scale_forever = RepeatForever::create(scale_seq);

    float step = s.width / 4;

    for (int i = 0; i < 3; i++)
    {
        auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(85 * i, 121 * 1, 85, 121));
        sprite->setPosition(Vec2((i + 1) * step, s.height / 2));

        sprite->runAction(action->clone());
        batch->addChild(sprite, i);
    }

    batch->runAction(scale_forever);
    batch->runAction(rotate_forever);
}

std::string Sprite6::title() const
{
    return "SpriteBatchNode transformation";
}

//------------------------------------------------------------------
//
// SpriteFlip
//
//------------------------------------------------------------------
SpriteFlip::SpriteFlip()
{
    auto s = Director::getInstance()->getWinSize();

    auto sprite1 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    sprite1->setPosition(Vec2(s.width / 2 - 100, s.height / 2));
    addChild(sprite1, 0, kTagSprite1);

    auto sprite2 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    sprite2->setPosition(Vec2(s.width / 2 + 100, s.height / 2));
    addChild(sprite2, 0, kTagSprite2);

    schedule(AX_CALLBACK_1(SpriteFlip::flipSprites, this), 1, "sprite_flip_key");
}

void SpriteFlip::flipSprites(float dt)
{
    auto sprite1 = static_cast<Sprite*>(getChildByTag(kTagSprite1));
    auto sprite2 = static_cast<Sprite*>(getChildByTag(kTagSprite2));

    bool x = sprite1->isFlippedX();
    bool y = sprite2->isFlippedY();

    AXLOG("Pre: %g", sprite1->getContentSize().height);
    sprite1->setFlippedX(!x);
    sprite2->setFlippedY(!y);
    AXLOG("Post: %g", sprite1->getContentSize().height);
}

std::string SpriteFlip::title() const
{
    return "Testing Sprite";
}

std::string SpriteFlip::subtitle() const
{
    return "Flip X & Y";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeFlip
//
//------------------------------------------------------------------
SpriteBatchNodeFlip::SpriteBatchNodeFlip()
{
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 10);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto s = Director::getInstance()->getWinSize();

    auto sprite1 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    sprite1->setPosition(Vec2(s.width / 2 - 100, s.height / 2));
    batch->addChild(sprite1, 0, kTagSprite1);

    auto sprite2 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    sprite2->setPosition(Vec2(s.width / 2 + 100, s.height / 2));
    batch->addChild(sprite2, 0, kTagSprite2);

    schedule(AX_CALLBACK_1(SpriteBatchNodeFlip::flipSprites, this), 1, "flip_sprites_key");
}

void SpriteBatchNodeFlip::flipSprites(float dt)
{
    auto batch   = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));
    auto sprite1 = static_cast<Sprite*>(batch->getChildByTag(kTagSprite1));
    auto sprite2 = static_cast<Sprite*>(batch->getChildByTag(kTagSprite2));

    bool x = sprite1->isFlippedX();
    bool y = sprite2->isFlippedY();

    AXLOG("Pre: %g", sprite1->getContentSize().height);
    sprite1->setFlippedX(!x);
    sprite2->setFlippedY(!y);
    AXLOG("Post: %g", sprite1->getContentSize().height);
}

std::string SpriteBatchNodeFlip::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeFlip::subtitle() const
{
    return "Flip X & Y";
}

//------------------------------------------------------------------
//
// SpriteAliased
//
//------------------------------------------------------------------

SpriteAliased::SpriteAliased()
{
    auto s = Director::getInstance()->getWinSize();

    auto sprite1 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    sprite1->setPosition(Vec2(s.width / 2 - 100, s.height / 2));
    addChild(sprite1, 0, kTagSprite1);

    auto sprite2 = Sprite::create("Images/grossini_dance_atlas.png", Rect(85 * 1, 121 * 1, 85, 121));
    sprite2->setPosition(Vec2(s.width / 2 + 100, s.height / 2));
    addChild(sprite2, 0, kTagSprite2);

    auto scale      = ScaleBy::create(2, 5);
    auto scale_back = scale->reverse();
    auto seq        = Sequence::create(scale, scale_back, nullptr);
    auto repeat     = RepeatForever::create(seq);

    auto repeat2 = repeat->clone();

    sprite1->runAction(repeat);
    sprite2->runAction(repeat2);
}

void SpriteAliased::onEnter()
{
    SpriteTestDemo::onEnter();

    //
    // IMPORTANT:
    // This change will affect every sprite that uses the same texture
    // So sprite1 and sprite2 will be affected by this change
    //
    auto sprite = static_cast<Sprite*>(getChildByTag(kTagSprite1));
    sprite->getTexture()->setAliasTexParameters();
}

void SpriteAliased::onExit()
{
    // restore the tex parameter to AntiAliased.
    auto sprite = static_cast<Sprite*>(getChildByTag(kTagSprite1));
    sprite->getTexture()->setAntiAliasTexParameters();
    SpriteTestDemo::onExit();
}

std::string SpriteAliased::title() const
{
    return "Testing Sprite";
}

std::string SpriteAliased::subtitle() const
{
    return "AliasTexParameters()";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeAliased
//
//------------------------------------------------------------------

SpriteBatchNodeAliased::SpriteBatchNodeAliased()
{
    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 10);
    addChild(batch, 0, kTagSpriteBatchNode);

    auto s = Director::getInstance()->getWinSize();

    auto sprite1 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    sprite1->setPosition(Vec2(s.width / 2 - 100, s.height / 2));
    batch->addChild(sprite1, 0, kTagSprite1);

    auto sprite2 = Sprite::createWithTexture(batch->getTexture(), Rect(85 * 1, 121 * 1, 85, 121));
    sprite2->setPosition(Vec2(s.width / 2 + 100, s.height / 2));
    batch->addChild(sprite2, 0, kTagSprite2);

    auto scale      = ScaleBy::create(2, 5);
    auto scale_back = scale->reverse();
    auto seq        = Sequence::create(scale, scale_back, nullptr);
    auto repeat     = RepeatForever::create(seq);

    auto repeat2 = repeat->clone();

    sprite1->runAction(repeat);
    sprite2->runAction(repeat2);
}
void SpriteBatchNodeAliased::onEnter()
{
    SpriteTestDemo::onEnter();
    auto batch = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));
    batch->getTexture()->setAliasTexParameters();
}

void SpriteBatchNodeAliased::onExit()
{
    // restore the tex parameter to AntiAliased.
    auto batch = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));
    batch->getTexture()->setAntiAliasTexParameters();
    SpriteTestDemo::onExit();
}

std::string SpriteBatchNodeAliased::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeAliased::subtitle() const
{
    return "AliasTexParameters()";
}

//------------------------------------------------------------------
//
// SpriteNewTexture
//
//------------------------------------------------------------------

SpriteNewTexture::SpriteNewTexture()
{
    auto listener            = EventListenerTouchAllAtOnce::create();
    listener->onTouchesEnded = AX_CALLBACK_2(SpriteNewTexture::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

    auto node = Node::create();
    addChild(node, 0, kTagSpriteBatchNode);

    _texture1 = Director::getInstance()->getTextureCache()->addImage("Images/grossini_dance_atlas.png");
    _texture1->retain();
    _texture2 = Director::getInstance()->getTextureCache()->addImage("Images/grossini_dance_atlas-mono.png");
    _texture2->retain();

    _usingTexture1 = true;

    for (int i = 0; i < 30; i++)
        addNewSprite();
}

SpriteNewTexture::~SpriteNewTexture()
{
    _texture1->release();
    _texture2->release();
}

void SpriteNewTexture::addNewSprite()
{
    auto s = Director::getInstance()->getWinSize();

    auto p = Vec2(AXRANDOM_0_1() * s.width, AXRANDOM_0_1() * s.height);

    int idx = AXRANDOM_0_1() * 1400 / 100;
    int x   = (idx % 5) * 85;
    int y   = (idx / 5) * 121;

    auto node   = getChildByTag(kTagSpriteBatchNode);
    auto sprite = Sprite::createWithTexture(_texture1, Rect(x, y, 85, 121));
    node->addChild(sprite);

    sprite->setPosition(Vec2(p.x, p.y));

    ActionInterval* action;
    float random = AXRANDOM_0_1();

    if (random < 0.20)
        action = ScaleBy::create(3, 2);
    else if (random < 0.40)
        action = RotateBy::create(3, 360);
    else if (random < 0.60)
        action = Blink::create(1, 3);
    else if (random < 0.8)
        action = TintBy::create(2, 0, -255, -255);
    else
        action = FadeOut::create(2);

    auto action_back = action->reverse();
    auto seq         = Sequence::create(action, action_back, nullptr);

    sprite->runAction(RepeatForever::create(seq));
}

void SpriteNewTexture::onTouchesEnded(const std::vector<Touch*>& touches, Event* event)
{

    auto node = getChildByTag(kTagSpriteBatchNode);

    auto& children = node->getChildren();
    Sprite* sprite;

    if (_usingTexture1)  //--> win32 : Let's it make just simple sentence
    {
        for (const auto& obj : children)
        {
            sprite = static_cast<Sprite*>(obj);
            sprite->setTexture(_texture2);
        }

        _usingTexture1 = false;
    }
    else
    {
        for (const auto& obj : children)
        {
            sprite = static_cast<Sprite*>(obj);
            sprite->setTexture(_texture1);
        }

        _usingTexture1 = true;
    }
}

std::string SpriteNewTexture::title() const
{
    return "Testing Sprite";
}

std::string SpriteNewTexture::subtitle() const
{
    return "setTexture() (tap / touch the screen)";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeNewTexture
//
//------------------------------------------------------------------

SpriteBatchNodeNewTexture::SpriteBatchNodeNewTexture()
{
    auto listener            = EventListenerTouchAllAtOnce::create();
    listener->onTouchesEnded = AX_CALLBACK_2(SpriteBatchNodeNewTexture::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

    auto batch = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 50);
    addChild(batch, 0, kTagSpriteBatchNode);

    _texture1 = batch->getTexture();
    _texture1->retain();
    _texture2 = Director::getInstance()->getTextureCache()->addImage("Images/grossini_dance_atlas-mono.png");
    _texture2->retain();

    for (int i = 0; i < 30; i++)
        addNewSprite();
}

SpriteBatchNodeNewTexture::~SpriteBatchNodeNewTexture()
{
    _texture1->release();
    _texture2->release();
}

void SpriteBatchNodeNewTexture::addNewSprite()
{
    auto s = Director::getInstance()->getWinSize();

    auto p = Vec2(AXRANDOM_0_1() * s.width, AXRANDOM_0_1() * s.height);

    auto batch = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));

    int idx = AXRANDOM_0_1() * 1400 / 100;
    int x   = (idx % 5) * 85;
    int y   = (idx / 5) * 121;

    auto sprite = Sprite::createWithTexture(batch->getTexture(), Rect(x, y, 85, 121));
    batch->addChild(sprite);

    sprite->setPosition(Vec2(p.x, p.y));

    ActionInterval* action;
    float random = AXRANDOM_0_1();

    if (random < 0.20)
        action = ScaleBy::create(3, 2);
    else if (random < 0.40)
        action = RotateBy::create(3, 360);
    else if (random < 0.60)
        action = Blink::create(1, 3);
    else if (random < 0.8)
        action = TintBy::create(2, 0, -255, -255);
    else
        action = FadeOut::create(2);
    auto action_back = action->reverse();
    auto seq         = Sequence::create(action, action_back, nullptr);

    sprite->runAction(RepeatForever::create(seq));
}

void SpriteBatchNodeNewTexture::onTouchesEnded(const std::vector<Touch*>& touches, Event* event)
{
    auto batch = static_cast<SpriteBatchNode*>(getChildByTag(kTagSpriteBatchNode));

    if (batch->getTexture() == _texture1)
        batch->setTexture(_texture2);
    else
        batch->setTexture(_texture1);
}

std::string SpriteBatchNodeNewTexture::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeNewTexture::subtitle() const
{
    return "setTexture() (tap / touch the screen)";
}

//------------------------------------------------------------------
//
// SpriteFrameTest
//
//------------------------------------------------------------------

void SpriteFrameTest::onEnter()
{
    SpriteTestDemo::onEnter();
    auto s = Director::getInstance()->getWinSize();

    // IMPORTANT:
    // The sprite frames will be cached AND RETAINED, and they won't be released unless you call
    //     SpriteFrameCache::getInstance()->removeUnusedSpriteFrames);
    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");
    cache->addSpriteFramesWithFile("animations/grossini_blue.plist", "animations/grossini_blue.png");

    //
    // Animation using Sprite BatchNode
    //
    _sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    _sprite1->setPosition(Vec2(s.width / 2 - 80, s.height / 2));

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    spritebatch->addChild(_sprite1);
    addChild(spritebatch);

    Vector<SpriteFrame*> animFrames(15);

    char str[100] = {0};
    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i);
        auto frame = cache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
    _sprite1->runAction(RepeatForever::create(Animate::create(animation)));

    // to test issue #732, uncomment the following line
    _sprite1->setFlippedX(false);
    _sprite1->setFlippedY(false);

    //
    // Animation using standard Sprite
    //
    _sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    _sprite2->setPosition(Vec2(s.width / 2 + 80, s.height / 2));
    addChild(_sprite2);

    Vector<SpriteFrame*> moreFrames(20);
    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_gray_%02d.png", i);
        auto frame = cache->getSpriteFrameByName(str);
        moreFrames.pushBack(frame);
    }

    for (int i = 1; i < 5; i++)
    {
        sprintf(str, "grossini_blue_%02d.png", i);
        auto frame = cache->getSpriteFrameByName(str);
        moreFrames.pushBack(frame);
    }

    // append frames from another batch
    moreFrames.pushBack(animFrames);
    auto animMixed = Animation::createWithSpriteFrames(moreFrames, 0.3f);

    _sprite2->runAction(RepeatForever::create(Animate::create(animMixed)));

    // to test issue #732, uncomment the following line
    _sprite2->setFlippedX(false);
    _sprite2->setFlippedY(false);

    schedule(AX_CALLBACK_1(SpriteFrameTest::startIn05Secs, this), 0.5f, "in_05_secs_key");
    _counter = 0;
}

void SpriteFrameTest::onExit()
{
    SpriteTestDemo::onExit();
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_blue.plist");
}

std::string SpriteFrameTest::title() const
{
    return "Sprite vs. SpriteBatchNode";
}

std::string SpriteFrameTest::subtitle() const
{
    return "Animation. Testing issue #792";
}

void SpriteFrameTest::startIn05Secs(float dt)
{
    unschedule("in_05_secs_key");
    schedule(AX_CALLBACK_1(SpriteFrameTest::flipSprites, this), 1.0f, "flip_sprites_key");
}

void SpriteFrameTest::flipSprites(float dt)
{
    _counter++;

    bool fx = false;
    bool fy = false;
    int i   = _counter % 4;

    switch (i)
    {
    case 0:
        fx = false;
        fy = false;
        break;
    case 1:
        fx = true;
        fy = false;
        break;
    case 2:
        fx = false;
        fy = true;
        break;
    case 3:
        fx = true;
        fy = true;
        break;
    }

    _sprite1->setFlippedX(fx);
    _sprite1->setFlippedY(fy);
    _sprite2->setFlippedX(fx);
    _sprite2->setFlippedY(fy);
    // NSLog(@"flipX:%d, flipY:%d", fx, fy);
}

//------------------------------------------------------------------
//
// SpriteFrameAliasNameTest
//
//------------------------------------------------------------------
void SpriteFrameAliasNameTest::onEnter()
{
    SpriteTestDemo::onEnter();
    auto s = Director::getInstance()->getWinSize();

    // IMPORTANT:
    // The sprite frames will be cached AND RETAINED, and they won't be released unless you call
    //     SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
    //
    // SpriteFrameCache is a cache of SpriteFrames
    // SpriteFrames each contain a texture id and a rect (frame).

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini-aliases.plist", "animations/grossini-aliases.png");

    //
    // Animation using Sprite batch
    //
    // A SpriteBatchNode can reference one and only one texture (one .png file)
    // Sprites that are contained in that texture can be instantiated as Sprites and then added to the SpriteBatchNode
    // All Sprites added to a SpriteBatchNode are drawn in one OpenGL ES draw call
    // If the Sprites are not added to a SpriteBatchNode then an OpenGL ES draw call will be needed for each one, which
    // is less efficient
    //
    // When you animate a sprite, Animation changes the frame of the sprite using setDisplayFrame: (this is why the
    // animation must be in the same texture) When setDisplayFrame: is used in the Animation it changes the frame to one
    // specified by the SpriteFrames that were added to the animation, but texture id is still the same and so the
    // sprite is still a child of the SpriteBatchNode, and therefore all the animation sprites are also drawn as part of
    // the SpriteBatchNode
    //

    auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite->setPosition(Vec2(s.width * 0.5f, s.height * 0.5f));

    auto spriteBatch = SpriteBatchNode::create("animations/grossini-aliases.png");
    spriteBatch->addChild(sprite);
    addChild(spriteBatch);

    Vector<SpriteFrame*> animFrames(15);
    char str[100] = {0};
    for (int i = 1; i < 15; i++)
    {
        // Obtain frames by alias name
        sprintf(str, "dance_%02d", i);
        auto frame = cache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
    // 14 frames * 1sec = 14 seconds
    sprite->runAction(RepeatForever::create(Animate::create(animation)));

    cache->reloadTexture("animations/grossini-aliases.plist");
}

void SpriteFrameAliasNameTest::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeSpriteFramesFromFile("animations/grossini-aliases.plist");
}

std::string SpriteFrameAliasNameTest::title() const
{
    return "SpriteFrame Alias Name";
}

std::string SpriteFrameAliasNameTest::subtitle() const
{
    return "SpriteFrames are obtained using the alias name";
}

//------------------------------------------------------------------
//
// SpriteFramesFromFileContent
//
//------------------------------------------------------------------
void SpriteFramesFromFileContent::onEnter()
{
    SpriteTestDemo::onEnter();
    auto s = Director::getInstance()->getWinSize();

    Data plist_content = FileUtils::getInstance()->getDataFromFile(sheetName() + ".plist");
    Data image_content = FileUtils::getInstance()->getDataFromFile(sheetName() + ".png");

    Image* image = new Image();
    image->initWithImageData((const uint8_t*)image_content.getBytes(), image_content.getSize());
    Texture2D* texture = new Texture2D();
    texture->initWithImage(image);
    texture->autorelease();

    AX_SAFE_RELEASE(image);

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFileContent(plist_content, texture);

    //
    // Animation using Sprite BatchNode
    //
    Sprite* sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite->setPosition(Vec2(s.width / 2, s.height / 2));
    addChild(sprite);

    Vector<SpriteFrame*> animFrames(15);

    char str[100] = {0};
    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i);
        auto frame = cache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
    sprite->runAction(RepeatForever::create(Animate::create(animation)));
}

void SpriteFramesFromFileContent::onExit()
{
    SpriteTestDemo::onExit();

    std::string plist_content = FileUtils::getInstance()->getStringFromFile("animations/grossini.plist");

    SpriteFrameCache::getInstance()->removeSpriteFramesFromFileContent(plist_content);
}

std::string SpriteFramesFromFileContent::title() const
{
    return "SpriteFrameCache load form file content";
}

std::string SpriteFramesFromFileContent::subtitle() const
{
    return "SpriteFrameCache load from plist file content";
}

std::string SpriteFramesFromFileContent::sheetName() const
{
    return "animations/grossini";
}

//------------------------------------------------------------------
//
// SpritePolygonFromFileContent
//
//------------------------------------------------------------------

std::string SpritePolygonFromFileContent::subtitle() const
{
    return "SpriteFrameCache load polygon info from plist file";
}

std::string SpritePolygonFromFileContent::sheetName() const
{
    return "animations/grossini_polygon";
}

//------------------------------------------------------------------
//
// SpriteOffsetAnchorRotation
//
//------------------------------------------------------------------
void SpriteOffsetAnchorRotation::onEnter()
{
    SpriteTestDemo::onEnter();

    auto s     = Director::getInstance()->getWinSize();
    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char str[100] = {0};
        for (int i = 0; i < 14; i++)
        {
            sprintf(str, "grossini_dance_%02d.png", (i + 1));
            auto frame = cache->getSpriteFrameByName(str);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));
        sprite->runAction(RepeatForever::create(RotateBy::create(10, 360)));

        addChild(sprite, 0);
    }
}

void SpriteOffsetAnchorRotation::onExit()
{
    SpriteTestDemo::onExit();
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorRotation::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorRotation::subtitle() const
{
    return "offset + anchor + rotation";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeOffsetAnchorRotation
//
//------------------------------------------------------------------

SpriteBatchNodeOffsetAnchorRotation::SpriteBatchNodeOffsetAnchorRotation()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite BatchNode
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 200);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char str[100] = {0};
        for (int k = 0; k < 14; k++)
        {
            sprintf(str, "grossini_dance_%02d.png", (k + 1));
            auto frame = cache->getSpriteFrameByName(str);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));
        sprite->runAction(RepeatForever::create(RotateBy::create(10, 360)));

        spritebatch->addChild(sprite, i);
    }
}

void SpriteBatchNodeOffsetAnchorRotation::onExit()
{
    SpriteTestDemo::onExit();
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorRotation::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorRotation::subtitle() const
{
    return "offset + anchor + rotation";
}

//------------------------------------------------------------------
//
// SpriteOffsetAnchorScale
//
//------------------------------------------------------------------

SpriteOffsetAnchorScale::SpriteOffsetAnchorScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite BatchNode
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char str[100] = {0};
        for (int i = 0; i < 14; i++)
        {
            sprintf(str, "grossini_dance_%02d.png", (i + 1));
            auto frame = cache->getSpriteFrameByName(str);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        addChild(sprite, 0);
    }
}

void SpriteOffsetAnchorScale::onExit()
{
    SpriteTestDemo::onExit();
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorScale::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorScale::subtitle() const
{
    return "offset + anchor + scale";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeOffsetAnchorScale
//
//------------------------------------------------------------------
SpriteBatchNodeOffsetAnchorScale::SpriteBatchNodeOffsetAnchorScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritesheet = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritesheet);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite BatchNode
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 200);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char str[100] = {0};
        for (int k = 0; k < 14; k++)
        {
            sprintf(str, "grossini_dance_%02d.png", (k + 1));
            auto frame = cache->getSpriteFrameByName(str);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        spritesheet->addChild(sprite, i);
    }
}

void SpriteBatchNodeOffsetAnchorScale::onExit()
{
    SpriteTestDemo::onExit();
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorScale::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorScale::subtitle() const
{
    return "offset + anchor + scale";
}

//------------------------------------------------------------------
//
// SpriteAnimationSplit
//
//------------------------------------------------------------------

SpriteAnimationSplit::SpriteAnimationSplit()
{
    auto s = Director::getInstance()->getWinSize();

    auto texture = Director::getInstance()->getTextureCache()->addImage("animations/dragon_animation.png");

    // manually add frames to the frame cache
    auto frame0 = SpriteFrame::createWithTexture(texture, Rect(132 * 0, 132 * 0, 132, 132));
    auto frame1 = SpriteFrame::createWithTexture(texture, Rect(132 * 1, 132 * 0, 132, 132));
    auto frame2 = SpriteFrame::createWithTexture(texture, Rect(132 * 2, 132 * 0, 132, 132));
    auto frame3 = SpriteFrame::createWithTexture(texture, Rect(132 * 3, 132 * 0, 132, 132));
    auto frame4 = SpriteFrame::createWithTexture(texture, Rect(132 * 0, 132 * 1, 132, 132));
    auto frame5 = SpriteFrame::createWithTexture(texture, Rect(132 * 1, 132 * 1, 132, 132));

    //
    // Animation using Sprite BatchNode
    //
    auto sprite = Sprite::createWithSpriteFrame(frame0);
    sprite->setPosition(Vec2(s.width / 2 - 80, s.height / 2));
    addChild(sprite);

    Vector<SpriteFrame*> animFrames(6);
    animFrames.pushBack(frame0);
    animFrames.pushBack(frame1);
    animFrames.pushBack(frame2);
    animFrames.pushBack(frame3);
    animFrames.pushBack(frame4);
    animFrames.pushBack(frame5);

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.2f);
    auto animate   = Animate::create(animation);
    auto seq       = Sequence::create(animate, FlipX::create(true), animate->clone(), FlipX::create(false), nullptr);

    sprite->runAction(RepeatForever::create(seq));
}

void SpriteAnimationSplit::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteAnimationSplit::title() const
{
    return "Sprite: Animation + flip";
}

//------------------------------------------------------------------
//
// SpriteHybrid
//
//------------------------------------------------------------------
SpriteHybrid::SpriteHybrid()
{
    auto s = Director::getInstance()->getWinSize();

    // parents
    auto parent1 = Node::create();
    auto parent2 = SpriteBatchNode::create("animations/grossini.png", 50);

    addChild(parent1, 0, kTagNode);
    addChild(parent2, 0, kTagSpriteBatchNode);

    // IMPORTANT:
    // The sprite frames will be cached AND RETAINED, and they won't be released unless you call
    //     SpriteFrameCache::getInstance()->removeUnusedSpriteFrames);
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // create 250 sprites
    // only show 80% of them
    for (int i = 0; i < 250; i++)
    {
        int spriteIdx = AXRANDOM_0_1() * 14;
        char str[25]  = {0};
        sprintf(str, "grossini_dance_%02d.png", (spriteIdx + 1));
        auto frame  = SpriteFrameCache::getInstance()->getSpriteFrameByName(str);
        auto sprite = Sprite::createWithSpriteFrame(frame);
        parent1->addChild(sprite, i, i);

        float x = -1000;
        float y = -1000;
        if (AXRANDOM_0_1() < 0.2f)
        {
            x = AXRANDOM_0_1() * s.width;
            y = AXRANDOM_0_1() * s.height;
        }
        sprite->setPosition(Vec2(x, y));

        auto action = RotateBy::create(4, 360);
        sprite->runAction(RepeatForever::create(action));
    }

    _usingSpriteBatchNode = false;

    schedule(AX_CALLBACK_1(SpriteHybrid::reparentSprite, this), 2, "reparent_sprite_key");
}

void SpriteHybrid::reparentSprite(float dt)
{
    auto p1 = getChildByTag(kTagNode);
    auto p2 = getChildByTag(kTagSpriteBatchNode);

    Vector<Node*> retArray(250);

    if (_usingSpriteBatchNode)
        std::swap(p1, p2);

    ////----AXLOG("New parent is: %x", p2);

    auto& p1Children = p1->getChildren();
    for (const auto& node : p1Children)
    {
        retArray.pushBack(node);
    }

    int i = 0;
    p1->removeAllChildrenWithCleanup(false);

    for (const auto& node : retArray)
    {
        p2->addChild(node, i, i);
        i++;
    }

    _usingSpriteBatchNode = !_usingSpriteBatchNode;
}

void SpriteHybrid::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeSpriteFramesFromFile("animations/grossini.plist");
}

std::string SpriteHybrid::title() const
{
    return "HybridSprite* sprite Test";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeChildren
//
//------------------------------------------------------------------

SpriteBatchNodeChildren::SpriteBatchNodeChildren()
{
    auto s = Director::getInstance()->getWinSize();

    // parents
    auto batch = SpriteBatchNode::create("animations/grossini.png", 50);

    addChild(batch, 0, kTagSpriteBatchNode);

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    auto sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(s.width / 3, s.height / 2));

    auto sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(50.0f, 50.0f));

    auto sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-50.0f, -50.0f));

    batch->addChild(sprite1);
    sprite1->addChild(sprite2);
    sprite1->addChild(sprite3);

    // BEGIN NEW CODE
    Vector<SpriteFrame*> animFrames(14);
    char str[100] = {0};
    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i);
        auto frame = SpriteFrameCache::getInstance()->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.2f);
    sprite1->runAction(RepeatForever::create(Animate::create(animation)));
    // END NEW CODE

    auto action        = MoveBy::create(2, Vec2(200.0f, 0.0f));
    auto action_back   = action->reverse();
    auto action_rot    = RotateBy::create(2.0f, 360.0f);
    auto action_s      = ScaleBy::create(2.0f, 2.0f);
    auto action_s_back = action_s->reverse();

    auto seq2 = action_rot->reverse();
    sprite2->runAction(RepeatForever::create(seq2));

    sprite1->runAction(RepeatForever::create(action_rot));
    sprite1->runAction(RepeatForever::create(Sequence::create(action, action_back, nullptr)));
    sprite1->runAction(RepeatForever::create(Sequence::create(action_s, action_s_back, nullptr)));
}

void SpriteBatchNodeChildren::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteBatchNodeChildren::title() const
{
    return "SpriteBatchNode Grand Children";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeChildrenZ
//
//------------------------------------------------------------------
SpriteBatchNodeChildrenZ::SpriteBatchNodeChildrenZ()
{
    auto s = Director::getInstance()->getWinSize();

    // parents
    SpriteBatchNode* batch;
    Sprite *sprite1, *sprite2, *sprite3;

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // test 1
    batch = SpriteBatchNode::create("animations/grossini.png", 50);
    addChild(batch, 0, kTagSpriteBatchNode);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(s.width / 3, s.height / 2));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    batch->addChild(sprite1);
    sprite1->addChild(sprite2, 2);
    sprite1->addChild(sprite3, -2);

    // test 2
    batch = SpriteBatchNode::create("animations/grossini.png", 50);
    addChild(batch, 0, kTagSpriteBatchNode);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(2 * s.width / 3, s.height / 2));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    batch->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, 2);

    // test 3
    batch = SpriteBatchNode::create("animations/grossini.png", 50);
    addChild(batch, 0, kTagSpriteBatchNode);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(s.width / 2 - 90, s.height / 4));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(s.width / 2 - 60, s.height / 4));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(s.width / 2 - 30, s.height / 4));

    batch->addChild(sprite1, 10);
    batch->addChild(sprite2, -10);
    batch->addChild(sprite3, -5);

    // test 4
    batch = SpriteBatchNode::create("animations/grossini.png", 50);
    addChild(batch, 0, kTagSpriteBatchNode);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(s.width / 2 + 30, s.height / 4));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(s.width / 2 + 60, s.height / 4));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(s.width / 2 + 90, s.height / 4));

    batch->addChild(sprite1, -10);
    batch->addChild(sprite2, -5);
    batch->addChild(sprite3, -2);
}

void SpriteBatchNodeChildrenZ::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteBatchNodeChildrenZ::title() const
{
    return "SpriteBatchNode Children Z";
}

//------------------------------------------------------------------
//
// SpriteChildrenVisibility
//
//------------------------------------------------------------------

SpriteChildrenVisibility::SpriteChildrenVisibility()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Node* aParent;
    Sprite *sprite1, *sprite2, *sprite3;
    //
    // SpriteBatchNode
    //
    // parents
    aParent = SpriteBatchNode::create("animations/grossini.png", 50);
    aParent->setPosition(Vec2(s.width / 3, s.height / 2));
    addChild(aParent, 0);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(0.0f, 0.0f));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, 2);

    sprite1->runAction(Blink::create(5.0f, 10.0f));

    //
    // Sprite
    //
    aParent = Node::create();
    aParent->setPosition(Vec2(2 * s.width / 3, s.height / 2));
    addChild(aParent, 0);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(0.0f, 0.0f));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, 2);

    sprite1->runAction(Blink::create(5.0f, 10.0f));
}

void SpriteChildrenVisibility::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteChildrenVisibility::title() const
{
    return "Sprite & SpriteBatchNode Visibility";
}

//------------------------------------------------------------------
//
// SpriteChildrenVisibilityIssue665
//
//------------------------------------------------------------------
SpriteChildrenVisibilityIssue665::SpriteChildrenVisibilityIssue665()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Node* aParent;
    Sprite *sprite1, *sprite2, *sprite3;
    //
    // SpriteBatchNode
    //
    // parents
    aParent = SpriteBatchNode::create("animations/grossini.png", 50);
    aParent->setPosition(Vec2(s.width / 3, s.height / 2));
    addChild(aParent, 0);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(0.0f, 0.0f));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    // test issue #665
    sprite1->setVisible(false);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, 2);

    //
    // Sprite
    //
    aParent = Node::create();
    aParent->setPosition(Vec2(2 * s.width / 3, s.height / 2));
    addChild(aParent, 0);

    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
    sprite1->setPosition(Vec2(0.0f, 0.0f));

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    // test issue #665
    sprite1->setVisible(false);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, 2);
}

SpriteChildrenVisibilityIssue665::~SpriteChildrenVisibilityIssue665()
{
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteChildrenVisibilityIssue665::title() const
{
    return "Sprite & SpriteBatchNode Visibility";
}

std::string SpriteChildrenVisibilityIssue665::subtitle() const
{
    return "No sprites should be visible";
}

//------------------------------------------------------------------
//
// SpriteChildrenAnchorPoint
//
//------------------------------------------------------------------
SpriteChildrenAnchorPoint::SpriteChildrenAnchorPoint()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Node* aParent;
    Sprite *sprite1, *sprite2, *sprite3, *sprite4, *point;
    //
    // SpriteBatchNode
    //
    // parents

    aParent = Node::create();
    addChild(aParent, 0);

    // anchor (0,0)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 4, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);

    // anchor (0.5, 0.5)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 2, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);

    // anchor (1,1)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 2 + s.width / 4, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);
}

void SpriteChildrenAnchorPoint::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteChildrenAnchorPoint::title() const
{
    return "Testing Sprite";
}

std::string SpriteChildrenAnchorPoint::subtitle() const
{
    return "children + anchor point";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeChildrenAnchorPoint
//
//------------------------------------------------------------------
SpriteBatchNodeChildrenAnchorPoint::SpriteBatchNodeChildrenAnchorPoint()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Node* aParent;
    Sprite *sprite1, *sprite2, *sprite3, *sprite4, *point;
    //
    // SpriteBatchNode
    //
    // parents

    aParent = SpriteBatchNode::create("animations/grossini.png", 50);
    addChild(aParent, 0);

    // anchor (0,0)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 4, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);

    // anchor (0.5, 0.5)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 2, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);

    // anchor (1,1)
    sprite1 = Sprite::createWithSpriteFrameName("grossini_dance_08.png");
    sprite1->setPosition(Vec2(s.width / 2 + s.width / 4, s.height / 2));
    sprite1->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);

    sprite2 = Sprite::createWithSpriteFrameName("grossini_dance_02.png");
    sprite2->setPosition(Vec2(20.0f, 30.0f));

    sprite3 = Sprite::createWithSpriteFrameName("grossini_dance_03.png");
    sprite3->setPosition(Vec2(-20.0f, 30.0f));

    sprite4 = Sprite::createWithSpriteFrameName("grossini_dance_04.png");
    sprite4->setPosition(Vec2(0.0f, 0.0f));
    sprite4->setScale(0.5f);

    aParent->addChild(sprite1);
    sprite1->addChild(sprite2, -2);
    sprite1->addChild(sprite3, -2);
    sprite1->addChild(sprite4, 3);

    point = Sprite::create("Images/r1.png");
    point->setScale(0.25f);
    point->setPosition(sprite1->getPosition());
    addChild(point, 10);
}

void SpriteBatchNodeChildrenAnchorPoint::onExit()
{
    SpriteTestDemo::onExit();
    SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
}

std::string SpriteBatchNodeChildrenAnchorPoint::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeChildrenAnchorPoint::subtitle() const
{
    return "children + anchor point";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeChildrenScale
//
//------------------------------------------------------------------
SpriteBatchNodeChildrenScale::SpriteBatchNodeChildrenScale()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");

    Node* aParent;
    Sprite *sprite1, *sprite2;
    auto rot = RotateBy::create(10, 360);
    auto seq = RepeatForever::create(rot);

    //
    // Children + Scale using Sprite
    // Test 1
    //
    aParent = Node::create();
    sprite1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    sprite1->setPosition(Vec2(s.width / 4, s.height / 4));
    sprite1->setScaleX(-0.5f);
    sprite1->setScaleY(2.0f);
    sprite1->runAction(seq);

    sprite2 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    sprite2->setPosition(Vec2(50, 0));

    addChild(aParent);
    aParent->addChild(sprite1);
    sprite1->addChild(sprite2);

    //
    // Children + Scale using SpriteBatchNode
    // Test 2
    //

    aParent = SpriteBatchNode::create("animations/grossini_family.png");
    sprite1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    sprite1->setPosition(Vec2(3 * s.width / 4, s.height / 4));
    sprite1->setScaleX(-0.5f);
    sprite1->setScaleY(2.0f);
    sprite1->runAction(seq->clone());

    sprite2 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    sprite2->setPosition(Vec2(50, 0));

    addChild(aParent);
    aParent->addChild(sprite1);
    sprite1->addChild(sprite2);

    //
    // Children + Scale using Sprite
    // Test 3
    //

    aParent = Node::create();
    sprite1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    sprite1->setPosition(Vec2(s.width / 4, 2 * s.height / 3));
    sprite1->setScaleX(1.5f);
    sprite1->setScaleY(-0.5f);
    sprite1->runAction(seq->clone());

    sprite2 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    sprite2->setPosition(Vec2(50, 0));

    addChild(aParent);
    aParent->addChild(sprite1);
    sprite1->addChild(sprite2);

    //
    // Children + Scale using Sprite
    // Test 4
    //

    aParent = SpriteBatchNode::create("animations/grossini_family.png");
    sprite1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    sprite1->setPosition(Vec2(3 * s.width / 4, 2 * s.height / 3));
    sprite1->setScaleX(1.5f);
    sprite1->setScaleY(-0.5f);
    sprite1->runAction(seq->clone());

    sprite2 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    sprite2->setPosition(Vec2(50, 0));

    addChild(aParent);
    aParent->addChild(sprite1);
    sprite1->addChild(sprite2);
}

std::string SpriteBatchNodeChildrenScale::title() const
{
    return "Testing Sprite / SpriteBatchNode";
}

std::string SpriteBatchNodeChildrenScale::subtitle() const
{
    return "child + scale + rot";
}

//------------------------------------------------------------------
//
// SpriteChildrenChildren
//
//------------------------------------------------------------------
SpriteChildrenChildren::SpriteChildrenChildren()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/ghosts.plist");

    Node* aParent;
    Sprite *l1, *l2a, *l2b, *l3a1, *l3a2, *l3b1, *l3b2;
    auto rot = RotateBy::create(10, 360);
    auto seq = RepeatForever::create(rot);

    auto rot_back    = rot->reverse();
    auto rot_back_fe = RepeatForever::create(rot_back);

    //
    // SpriteBatchNode: 3 levels of children
    //

    aParent = Node::create();
    addChild(aParent);

    // parent
    l1 = Sprite::createWithSpriteFrameName("father.gif");
    l1->setPosition(Vec2(s.width / 2, s.height / 2));
    l1->runAction(seq->clone());
    aParent->addChild(l1);
    auto l1Size = l1->getContentSize();

    // child left
    l2a = Sprite::createWithSpriteFrameName("sister1.gif");
    l2a->setPosition(Vec2(-50 + l1Size.width / 2, 0 + l1Size.height / 2));
    l2a->runAction(rot_back_fe->clone());
    l1->addChild(l2a);
    auto l2aSize = l2a->getContentSize();

    // child right
    l2b = Sprite::createWithSpriteFrameName("sister2.gif");
    l2b->setPosition(Vec2(+50 + l1Size.width / 2, 0 + l1Size.height / 2));
    l2b->runAction(rot_back_fe->clone());
    l1->addChild(l2b);
    auto l2bSize = l2a->getContentSize();

    // child left bottom
    l3a1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a1->setScale(0.45f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, -100 + l2aSize.height / 2));
    l2a->addChild(l3a1);

    // child left top
    l3a2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a2->setScale(0.45f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, +100 + l2aSize.height / 2));
    l2a->addChild(l3a2);

    // child right bottom
    l3b1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b1->setScale(0.45f);
    l3b1->setFlippedY(true);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, -100 + l2bSize.height / 2));
    l2b->addChild(l3b1);

    // child right top
    l3b2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b2->setScale(0.45f);
    l3b2->setFlippedY(true);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, +100 + l2bSize.height / 2));
    l2b->addChild(l3b2);
}

std::string SpriteChildrenChildren::title() const
{
    return "Testing Sprite";
}

std::string SpriteChildrenChildren::subtitle() const
{
    return "multiple levels of children";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeChildrenChildren
//
//------------------------------------------------------------------

SpriteBatchNodeChildrenChildren::SpriteBatchNodeChildrenChildren()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/ghosts.plist");

    SpriteBatchNode* aParent;
    Sprite *l1, *l2a, *l2b, *l3a1, *l3a2, *l3b1, *l3b2;
    auto rot = RotateBy::create(10, 360);
    auto seq = RepeatForever::create(rot);

    auto rot_back    = rot->reverse();
    auto rot_back_fe = RepeatForever::create(rot_back);

    //
    // SpriteBatchNode: 3 levels of children
    //

    aParent = SpriteBatchNode::create("animations/ghosts.png");
    // TODO: minggo
    //    aParent->getTexture()->generateMipmap();
    addChild(aParent);

    // parent
    l1 = Sprite::createWithSpriteFrameName("father.gif");
    l1->setPosition(Vec2(s.width / 2, s.height / 2));
    l1->runAction(seq->clone());
    aParent->addChild(l1);
    auto l1Size = l1->getContentSize();

    // child left
    l2a = Sprite::createWithSpriteFrameName("sister1.gif");
    l2a->setPosition(Vec2(-50 + l1Size.width / 2, 0 + l1Size.height / 2));
    l2a->runAction(rot_back_fe->clone());
    l1->addChild(l2a);
    auto l2aSize = l2a->getContentSize();

    // child right
    l2b = Sprite::createWithSpriteFrameName("sister2.gif");
    l2b->setPosition(Vec2(+50 + l1Size.width / 2, 0 + l1Size.height / 2));
    l2b->runAction(rot_back_fe->clone());
    l1->addChild(l2b);
    auto l2bSize = l2a->getContentSize();

    // child left bottom
    l3a1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a1->setScale(0.45f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, -100 + l2aSize.height / 2));
    l2a->addChild(l3a1);

    // child left top
    l3a2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a2->setScale(0.45f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, +100 + l2aSize.height / 2));
    l2a->addChild(l3a2);

    // child right bottom
    l3b1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b1->setScale(0.45f);
    l3b1->setFlippedY(true);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, -100 + l2bSize.height / 2));
    l2b->addChild(l3b1);

    // child right top
    l3b2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b2->setScale(0.45f);
    l3b2->setFlippedY(true);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, +100 + l2bSize.height / 2));
    l2b->addChild(l3b2);
}

std::string SpriteBatchNodeChildrenChildren::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeChildrenChildren::subtitle() const
{
    return "multiple levels of children";
}

//------------------------------------------------------------------
//
// SpriteBatchNodeSkewNegativeScaleChildren
//
//------------------------------------------------------------------

SpriteBatchNodeSkewNegativeScaleChildren::SpriteBatchNodeSkewNegativeScaleChildren()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 2; i++)
    {
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        // Skew
        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        if (i == 1)
        {
            sprite->setScale(-1.0f);
        }

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        auto child1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        child1->setPosition(Vec2(sprite->getContentSize().width / 2.0f, sprite->getContentSize().height / 2.0f));

        child1->setScale(0.8f);

        sprite->addChild(child1);

        spritebatch->addChild(sprite, i);
    }
}

SpriteBatchNodeSkewNegativeScaleChildren::~SpriteBatchNodeSkewNegativeScaleChildren()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeSkewNegativeScaleChildren::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeSkewNegativeScaleChildren::subtitle() const
{
    return "skew + negative scale with children";
}

// SpriteSkewNegativeScaleChildren

SpriteSkewNegativeScaleChildren::SpriteSkewNegativeScaleChildren()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto parent = Node::create();
    addChild(parent);

    for (int i = 0; i < 2; i++)
    {
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        // Skew
        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        if (i == 1)
        {
            sprite->setScale(-1.0f);
        }

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        auto child1 = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        child1->setPosition(Vec2(sprite->getContentSize().width / 2.0f, sprite->getContentSize().height / 2.0f));

        sprite->addChild(child1);

        child1->setScale(0.8f);

        parent->addChild(sprite, i);
    }
}

SpriteSkewNegativeScaleChildren::~SpriteSkewNegativeScaleChildren()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteSkewNegativeScaleChildren::title() const
{
    return "Testing Sprite";
}

std::string SpriteSkewNegativeScaleChildren::subtitle() const
{
    return "skew + negative scale with children";
}

//------------------------------------------------------------------
//
// SpriteNilTexture
//
//------------------------------------------------------------------

SpriteNilTexture::SpriteNilTexture()
{
    auto s = Director::getInstance()->getWinSize();

    Sprite* sprite = nullptr;

    // TEST: If no texture is given, then Opacity + Color should work.

    sprite = Sprite::create();
    sprite->setTextureRect(Rect(0, 0, 300, 300));
    sprite->setColor(Color3B::RED);
    sprite->setOpacity(128);
    sprite->setPosition(Vec2(3 * s.width / 4, s.height / 2));
    addChild(sprite, 100);

    sprite = Sprite::create();
    sprite->setTextureRect(Rect(0.0f, 0.0f, 300.0f, 300.0f));
    sprite->setColor(Color3B::BLUE);
    sprite->setOpacity(128);
    sprite->setPosition(Vec2(1 * s.width / 4, s.height / 2));
    addChild(sprite, 100);
}

std::string SpriteNilTexture::title() const
{
    return "Sprite without texture";
}

std::string SpriteNilTexture::subtitle() const
{
    return "opacity and color should work";
}

class MySprite1 : public Sprite
{
public:
    CREATE_FUNC(MySprite1);
    MySprite1() {}
    static MySprite1* createWithSpriteFrameName(std::string_view spriteFrameName)
    {
        auto sprite = MySprite1::create();
        sprite->setSpriteFrame(spriteFrameName);
        return sprite;
    }
};

class MySprite2 : public Sprite
{
public:
    CREATE_FUNC(MySprite2);
    MySprite2() {}
    static MySprite2* create(std::string_view name)
    {
        auto sprite = MySprite2::create();
        sprite->setTexture(name);
        return sprite;
    }
};

//------------------------------------------------------------------
//
// SpriteSubclass
//
//------------------------------------------------------------------
SpriteSubclass::SpriteSubclass()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/ghosts.plist");
    auto aParent = SpriteBatchNode::create("animations/ghosts.png");

    // MySprite1
    MySprite1* sprite = MySprite1::createWithSpriteFrameName("father.gif");
    sprite->setPosition(Vec2(s.width / 4 * 1, s.height / 2));
    aParent->addChild(sprite);
    addChild(aParent);

    // MySprite2
    MySprite2* sprite2 = MySprite2::create("Images/grossini.png");
    addChild(sprite2);
    sprite2->setPosition(Vec2(s.width / 4 * 3, s.height / 2));
}

std::string SpriteSubclass::title() const
{
    return "Sprite subclass";
}

std::string SpriteSubclass::subtitle() const
{
    return "Testing initWithTexture:rect method";
}

//------------------------------------------------------------------
//
// AnimationCache
//
//------------------------------------------------------------------
AnimationCacheTest::AnimationCacheTest()
{
    auto frameCache = SpriteFrameCache::getInstance();
    frameCache->addSpriteFramesWithFile("animations/grossini.plist");
    frameCache->addSpriteFramesWithFile("animations/grossini_gray.plist");
    frameCache->addSpriteFramesWithFile("animations/grossini_blue.plist");

    //
    // create animation "dance"
    //
    Vector<SpriteFrame*> animFrames(15);
    char str[100] = {0};
    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_%02d.png", i);
        auto frame = frameCache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    auto animation = Animation::createWithSpriteFrames(animFrames, 0.2f);

    // Add an animation to the Cache
    AnimationCache::getInstance()->addAnimation(animation, "dance");

    //
    // create animation "dance gray"
    //
    animFrames.clear();

    for (int i = 1; i < 15; i++)
    {
        sprintf(str, "grossini_dance_gray_%02d.png", i);
        auto frame = frameCache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    animation = Animation::createWithSpriteFrames(animFrames, 0.2f);

    // Add an animation to the Cache
    AnimationCache::getInstance()->addAnimation(animation, "dance_gray");

    //
    // create animation "dance blue"
    //
    animFrames.clear();

    for (int i = 1; i < 4; i++)
    {
        sprintf(str, "grossini_blue_%02d.png", i);
        auto frame = frameCache->getSpriteFrameByName(str);
        animFrames.pushBack(frame);
    }

    animation = Animation::createWithSpriteFrames(animFrames, 0.2f);

    // Add an animation to the Cache
    AnimationCache::getInstance()->addAnimation(animation, "dance_blue");

    auto animCache = AnimationCache::getInstance();

    auto normal = animCache->getAnimation("dance");
    normal->setRestoreOriginalFrame(true);
    auto dance_grey = animCache->getAnimation("dance_gray");
    dance_grey->setRestoreOriginalFrame(true);
    auto dance_blue = animCache->getAnimation("dance_blue");
    dance_blue->setRestoreOriginalFrame(true);

    auto animN = Animate::create(normal);
    auto animG = Animate::create(dance_grey);
    auto animB = Animate::create(dance_blue);

    auto seq = Sequence::create(animN, animG, animB, nullptr);

    // create an sprite without texture
    auto grossini = Sprite::create();
    auto frame    = frameCache->getSpriteFrameByName("grossini_dance_01.png");
    grossini->setSpriteFrame(frame);

    auto winSize = Director::getInstance()->getWinSize();
    grossini->setPosition(Vec2(winSize.width / 2, winSize.height / 2));
    addChild(grossini);

    // run the animation
    grossini->runAction(seq);
}

AnimationCacheTest::~AnimationCacheTest()
{
    auto frameCache = SpriteFrameCache::getInstance();
    frameCache->removeSpriteFramesFromFile("animations/grossini.plist");
    frameCache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
    frameCache->removeSpriteFramesFromFile("animations/grossini_blue.plist");
}

std::string AnimationCacheTest::title() const
{
    return "AnimationCache";
}

std::string AnimationCacheTest::subtitle() const
{
    return "Sprite should be animated";
}

// AnimationCacheFile

AnimationCacheFile::AnimationCacheFile()
{
    auto frameCache = SpriteFrameCache::getInstance();
    frameCache->addSpriteFramesWithFile("animations/grossini.plist");
    frameCache->addSpriteFramesWithFile("animations/grossini_gray.plist");
    frameCache->addSpriteFramesWithFile("animations/grossini_blue.plist");

    // Purge previously loaded animation
    AnimationCache::destroyInstance();

    auto animCache = AnimationCache::getInstance();

    // Add an animation to the Cache
    animCache->addAnimationsWithFile("animations/animations.plist");

    auto normal = animCache->getAnimation("dance_1");
    normal->setRestoreOriginalFrame(true);
    auto dance_grey = animCache->getAnimation("dance_2");
    dance_grey->setRestoreOriginalFrame(true);
    auto dance_blue = animCache->getAnimation("dance_3");
    dance_blue->setRestoreOriginalFrame(true);

    auto animN = Animate::create(normal);
    auto animG = Animate::create(dance_grey);
    auto animB = Animate::create(dance_blue);

    auto seq = Sequence::create(animN, animG, animB, nullptr);

    // create an sprite without texture
    auto grossini = Sprite::create();

    auto frame = frameCache->getSpriteFrameByName("grossini_dance_01.png");
    grossini->setSpriteFrame(frame);

    auto winSize = Director::getInstance()->getWinSize();

    grossini->setPosition(Vec2(winSize.width / 2, winSize.height / 2));

    addChild(grossini);

    // run the animation
    grossini->runAction(seq);
}

AnimationCacheFile::~AnimationCacheFile()
{
    auto frameCache = SpriteFrameCache::getInstance();
    frameCache->removeSpriteFramesFromFile("animations/grossini.plist");
    frameCache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
    frameCache->removeSpriteFramesFromFile("animations/grossini_blue.plist");
}

std::string AnimationCacheFile::title() const
{
    return "AnimationCache - Load file";
}

std::string AnimationCacheFile::subtitle() const
{
    return "Sprite should be animated";
}

// SpriteBatchBug1217

SpriteBatchBug1217::SpriteBatchBug1217()
{
    auto bn = SpriteBatchNode::create("Images/grossini_dance_atlas.png", 15);

    auto s1 = Sprite::createWithTexture(bn->getTexture(), Rect(0.0f, 0.0f, 57.0f, 57.0f));
    auto s2 = Sprite::createWithTexture(bn->getTexture(), Rect(0.0f, 0.0f, 57.0f, 57.0f));
    auto s3 = Sprite::createWithTexture(bn->getTexture(), Rect(0.0f, 0.0f, 57.0f, 57.0f));

    s1->setColor(Color3B(255, 0, 0));
    s2->setColor(Color3B(0, 255, 0));
    s3->setColor(Color3B(0, 0, 255));

    s1->setPosition(Vec2(20.0f, 200.0f));
    s2->setPosition(Vec2(100.0f, 0.0f));
    s3->setPosition(Vec2(100.0f, 0.0f));

    bn->setPosition(Vec2(0.0f, 0.0f));

    //!!!!!
    s1->addChild(s2);
    s2->addChild(s3);
    bn->addChild(s1);

    addChild(bn);
}

std::string SpriteBatchBug1217::title() const
{
    return "SpriteBatch - Bug 1217";
}

std::string SpriteBatchBug1217::subtitle() const
{
    return "Adding big family to spritebatch. You shall see 3 heads";
}

//
// SpriteOffsetAnchorSkew
//
SpriteOffsetAnchorSkew::SpriteOffsetAnchorSkew()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", j + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        addChild(sprite, 0);
    }
}

SpriteOffsetAnchorSkew::~SpriteOffsetAnchorSkew()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorSkew::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorSkew::subtitle() const
{
    return "offset + anchor + skew";
}

//
// SpriteBatchNodeOffsetAnchorSkew
//
SpriteBatchNodeOffsetAnchorSkew::SpriteBatchNodeOffsetAnchorSkew()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 200);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", j + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        spritebatch->addChild(sprite, i);
    }
}

SpriteBatchNodeOffsetAnchorSkew::~SpriteBatchNodeOffsetAnchorSkew()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorSkew::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorSkew::subtitle() const
{
    return "offset + anchor + skew";
}

//
// SpriteOffsetAnchorSkewScale
//
SpriteOffsetAnchorSkewScale::SpriteOffsetAnchorSkewScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", j + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        // Skew
        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        // Scale
        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        addChild(sprite, 0);
    }
}

SpriteOffsetAnchorSkewScale::~SpriteOffsetAnchorSkewScale()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorSkewScale::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorSkewScale::subtitle() const
{
    return "anchor + skew + scale";
}

///

SpriteBatchNodeOffsetAnchorSkewScale::SpriteBatchNodeOffsetAnchorSkewScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 200);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", j + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        // skew
        auto skewX      = SkewBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = SkewBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        // scale
        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        spritebatch->addChild(sprite, i);
    }
}

SpriteBatchNodeOffsetAnchorSkewScale::~SpriteBatchNodeOffsetAnchorSkewScale()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorSkewScale::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorSkewScale::subtitle() const
{
    return "anchor + skew + scale";
}

//
// SpriteOffsetAnchorFlip
//
SpriteOffsetAnchorFlip::SpriteOffsetAnchorFlip()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", i + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto flip      = FlipY::create(true);
        auto flip_back = FlipY::create(false);
        auto delay     = DelayTime::create(1);
        auto seq       = Sequence::create(delay, flip, delay->clone(), flip_back, nullptr);
        sprite->runAction(RepeatForever::create(seq));

        addChild(sprite, 0);
    }
}

SpriteOffsetAnchorFlip::~SpriteOffsetAnchorFlip()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorFlip::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorFlip::subtitle() const
{
    return "issue #1078: offset + anchor + flip";
}

//
// SpriteBatchNodeOffsetAnchorFlip
//

SpriteBatchNodeOffsetAnchorFlip::SpriteBatchNodeOffsetAnchorFlip()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 200);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        char tmp[50];
        for (int j = 0; j < 14; j++)
        {
            sprintf(tmp, "grossini_dance_%02d.png", i + 1);
            auto frame = cache->getSpriteFrameByName(tmp);
            animFrames.pushBack(frame);
        }

        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto flip      = FlipY::create(true);
        auto flip_back = FlipY::create(false);
        auto delay     = DelayTime::create(1);
        auto seq       = Sequence::create(delay, flip, delay->clone(), flip_back, nullptr);
        sprite->runAction(RepeatForever::create(seq));

        spritebatch->addChild(sprite, i);
    }
}

SpriteBatchNodeOffsetAnchorFlip::~SpriteBatchNodeOffsetAnchorFlip()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorFlip::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorFlip::subtitle() const
{
    return "issue #1078: offset + anchor + flip";
}

/// NodeSort

NodeSort::NodeSort()
{
    _node = Node::create();
    addChild(_node, 0, 0);

    _sprite1 = Sprite::create("Images/piece.png", Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite1->setPosition(Vec2(100.0f, 160.0f));
    _node->addChild(_sprite1, -6, 1);

    _sprite2 = Sprite::create("Images/piece.png", Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite2->setPosition(Vec2(164.0f, 160.0f));
    _node->addChild(_sprite2, -6, 2);

    _sprite4 = Sprite::create("Images/piece.png", Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite4->setPosition(Vec2(292.0f, 160.0f));
    _node->addChild(_sprite4, -3, 4);

    _sprite3 = Sprite::create("Images/piece.png", Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite3->setPosition(Vec2(228.0f, 160.0f));
    _node->addChild(_sprite3, -4, 3);

    _sprite5 = Sprite::create("Images/piece.png", Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite5->setPosition(Vec2(356.0f, 160.0f));
    _node->addChild(_sprite5, -3, 5);

    schedule(AX_CALLBACK_1(NodeSort::reorderSprite, this), "reorder_sprite_key");
}

std::string NodeSort::title() const
{
    return "node sort same index";
}

std::string NodeSort::subtitle() const
{
    return "tag order in console should be 2,1,3,4,5";
}

void NodeSort::reorderSprite(float dt)
{
    unschedule("reorder_sprite_key");

    log("Before reorder--");

    auto& children = _node->getChildren();

    for (const auto& child : children)
    {
        log("tag %i z %i", (int)child->getTag(), (int)child->getLocalZOrder());
    }
    // z-4
    _node->reorderChild(_node->getChildren().at(0), -6);

    _node->sortAllChildren();

    log("After reorder--");
    for (const auto& child : children)
    {
        log("tag %i z %i", (int)child->getTag(), (int)child->getLocalZOrder());
    }
}

/// SpriteBatchNodeReorderSameIndex
SpriteBatchNodeReorderSameIndex::SpriteBatchNodeReorderSameIndex()
{
    _batchNode = SpriteBatchNode::create("Images/piece.png", 15);
    addChild(_batchNode, 1, 0);

    _sprite1 = Sprite::createWithTexture(_batchNode->getTexture(), Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite1->setPosition(Vec2(100.0f, 160.0f));
    _batchNode->addChild(_sprite1, 3, 1);

    _sprite2 = Sprite::createWithTexture(_batchNode->getTexture(), Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite2->setPosition(Vec2(164.0f, 160.0f));
    _batchNode->addChild(_sprite2, 4, 2);

    _sprite3 = Sprite::createWithTexture(_batchNode->getTexture(), Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite3->setPosition(Vec2(228.0f, 160.0f));
    _batchNode->addChild(_sprite3, 4, 3);

    _sprite4 = Sprite::createWithTexture(_batchNode->getTexture(), Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite4->setPosition(Vec2(292.0f, 160.0f));
    _batchNode->addChild(_sprite4, 5, 4);

    _sprite5 = Sprite::createWithTexture(_batchNode->getTexture(), Rect(128.0f, 0.0f, 64.0f, 64.0f));
    _sprite5->setPosition(Vec2(356.0f, 160.0f));
    _batchNode->addChild(_sprite5, 6, 5);

    scheduleOnce(AX_CALLBACK_1(SpriteBatchNodeReorderSameIndex::reorderSprite, this), 2, "reorder_sprite_key");
}

std::string SpriteBatchNodeReorderSameIndex::title() const
{
    return "SpriteBatchNodeReorder same index";
}

std::string SpriteBatchNodeReorderSameIndex::subtitle() const
{
    return "tag order in console should be 2,3,4,5,1";
}

void SpriteBatchNodeReorderSameIndex::reorderSprite(float dt)
{
    _batchNode->reorderChild(_sprite4, 4);
    _batchNode->reorderChild(_sprite5, 4);
    _batchNode->reorderChild(_sprite1, 4);

    _batchNode->sortAllChildren();

    for (const auto& sprite : _batchNode->getDescendants())
    {
        log("tag %i", sprite->getTag());
    }
}

/// SpriteBatchNodeReorderOneChild
SpriteBatchNodeReorderOneChild::SpriteBatchNodeReorderOneChild()
{
    auto s = Director::getInstance()->getWinSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/ghosts.plist");

    SpriteBatchNode* aParent;
    Sprite *l1, *l2a, *l2b, *l3a1, *l3a2, *l3b1, *l3b2;

    //
    // SpriteBatchNode: 3 levels of children
    //

    aParent = SpriteBatchNode::create("animations/ghosts.png");

    _batchNode = aParent;
    //[[aParent texture] generateMipmap];
    addChild(aParent);

    // parent
    l1 = Sprite::createWithSpriteFrameName("father.gif");
    l1->setPosition(Vec2(s.width / 2, s.height / 2));

    aParent->addChild(l1);
    auto l1Size = l1->getContentSize();

    // child left
    l2a = Sprite::createWithSpriteFrameName("sister1.gif");
    l2a->setPosition(Vec2(-10 + l1Size.width / 2, 0 + l1Size.height / 2));

    l1->addChild(l2a, 1);
    auto l2aSize = l2a->getContentSize();

    // child right
    l2b = Sprite::createWithSpriteFrameName("sister2.gif");
    l2b->setPosition(Vec2(+50 + l1Size.width / 2, 0 + l1Size.height / 2));

    l1->addChild(l2b, 2);
    auto l2bSize = l2a->getContentSize();

    // child left bottom
    l3a1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a1->setScale(0.45f);
    l3a1->setPosition(Vec2(0 + l2aSize.width / 2, -50 + l2aSize.height / 2));
    l2a->addChild(l3a1, 1);

    // child left top
    l3a2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3a2->setScale(0.45f);
    l3a2->setPosition(Vec2(0 + l2aSize.width / 2, +50 + l2aSize.height / 2));
    l2a->addChild(l3a2, 2);

    _reorderSprite = l2a;

    // child right bottom
    l3b1 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b1->setScale(0.45f);
    l3b1->setFlippedY(true);
    l3b1->setPosition(Vec2(0 + l2bSize.width / 2, -50 + l2bSize.height / 2));
    l2b->addChild(l3b1);

    // child right top
    l3b2 = Sprite::createWithSpriteFrameName("child1.gif");
    l3b2->setScale(0.45f);
    l3b2->setFlippedY(true);
    l3b2->setPosition(Vec2(0 + l2bSize.width / 2, +50 + l2bSize.height / 2));
    l2b->addChild(l3b2);

    scheduleOnce(AX_CALLBACK_1(SpriteBatchNodeReorderOneChild::reorderSprite, this), 2.0f, "reorder_sprite_key");
}

void SpriteBatchNodeReorderOneChild::reorderSprite(float dt)
{
    _reorderSprite->getParent()->reorderChild(_reorderSprite, -1);

    _batchNode->sortAllChildren();
    // CCSprite* child;
    // CCARRAY_FOREACH(batchNode.descendants,child) NSLog(@"tag %i",child.tag);
}

std::string SpriteBatchNodeReorderOneChild::title() const
{
    return "SpriteBatchNode reorder 1 child";
}

//
// SpriteOffsetAnchorRotationalSkew
//
SpriteOffsetAnchorRotationalSkew::SpriteOffsetAnchorRotationalSkew()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        for (int i = 0; i < 14; i++)
        {
            char pngName[30];
            snprintf(pngName, 30, "grossini_dance_%02d.png", (i + 1));
            auto frame = cache->getSpriteFrameByName(pngName);
            animFrames.pushBack(frame);
        }
        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        addChild(sprite, 0);
    }
}

SpriteOffsetAnchorRotationalSkew::~SpriteOffsetAnchorRotationalSkew()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorRotationalSkew::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorRotationalSkew::subtitle() const
{
    return "offset + anchor + rotational skew";
}

//
// SpriteBatchNodeOffsetAnchorRotationalSkew
//
SpriteBatchNodeOffsetAnchorRotationalSkew::SpriteBatchNodeOffsetAnchorRotationalSkew()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        for (int j = 0; j < 14; j++)
        {
            char pngName[30];
            snprintf(pngName, 30, "grossini_dance_%02d.png", (j + 1));
            auto frame = cache->getSpriteFrameByName(pngName);
            animFrames.pushBack(frame);
        }
        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        spritebatch->addChild(sprite, 0);
    }
}

SpriteBatchNodeOffsetAnchorRotationalSkew::~SpriteBatchNodeOffsetAnchorRotationalSkew()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorRotationalSkew::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorRotationalSkew::subtitle() const
{
    return "offset + anchor + rotational skew";
}

//
// SpriteOffsetAnchorRotationalSkewScale
//
SpriteOffsetAnchorRotationalSkewScale::SpriteOffsetAnchorRotationalSkewScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        for (int j = 0; j < 14; j++)
        {
            char pngName[30];
            snprintf(pngName, 30, "grossini_dance_%02d.png", (j + 1));
            auto frame = cache->getSpriteFrameByName(pngName);
            animFrames.pushBack(frame);
        }
        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        // Skew
        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        // Scale
        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        addChild(sprite, 0);
    }
}

SpriteOffsetAnchorRotationalSkewScale::~SpriteOffsetAnchorRotationalSkewScale()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteOffsetAnchorRotationalSkewScale::title() const
{
    return "Testing Sprite";
}

std::string SpriteOffsetAnchorRotationalSkewScale::subtitle() const
{
    return "anchor + rot skew + scale";
}

// SpriteBatchNodeOffsetAnchorRotationalSkewScale
SpriteBatchNodeOffsetAnchorRotationalSkewScale::SpriteBatchNodeOffsetAnchorRotationalSkewScale()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto spritebatch = SpriteBatchNode::create("animations/grossini.png");
    addChild(spritebatch);

    for (int i = 0; i < 3; i++)
    {
        //
        // Animation using Sprite batch
        //
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        switch (i)
        {
        case 0:
            sprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
            break;
        case 1:
            sprite->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
            break;
        case 2:
            sprite->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
            break;
        }

        point->setPosition(sprite->getPosition());

        Vector<SpriteFrame*> animFrames(14);
        for (int j = 0; j < 14; j++)
        {
            char pngName[30];
            snprintf(pngName, 30, "grossini_dance_%02d.png", (j + 1));
            auto frame = cache->getSpriteFrameByName(pngName);
            animFrames.pushBack(frame);
        }
        auto animation = Animation::createWithSpriteFrames(animFrames, 0.3f);
        sprite->runAction(RepeatForever::create(Animate::create(animation)));

        // Skew
        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        // Scale
        auto scale      = ScaleBy::create(2, 2);
        auto scale_back = scale->reverse();
        auto seq_scale  = Sequence::create(scale, scale_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_scale));

        spritebatch->addChild(sprite, 0);
    }
}

SpriteBatchNodeOffsetAnchorRotationalSkewScale::~SpriteBatchNodeOffsetAnchorRotationalSkewScale()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteBatchNodeOffsetAnchorRotationalSkewScale::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeOffsetAnchorRotationalSkewScale::subtitle() const
{
    return "anchor + rot skew + scale";
}

//
// SpriteRotationalSkewNegativeScaleChildren
//
SpriteRotationalSkewNegativeScaleChildren::SpriteRotationalSkewNegativeScaleChildren()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto parent = Node::create();
    addChild(parent);

    for (int i = 0; i < 2; i++)
    {
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        // Skew
        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        if (1 == 1)
        {
            sprite->setScale(-1.0f);
        }

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        auto child1 = Sprite::create("Images/grossini_dance_01.png");
        child1->setPosition(Vec2(sprite->getContentSize().width / 2.0f, sprite->getContentSize().height / 2.0f));

        sprite->addChild(child1);

        child1->setScale(0.8f);

        parent->addChild(sprite, 0);
    }
}

SpriteRotationalSkewNegativeScaleChildren::~SpriteRotationalSkewNegativeScaleChildren()
{
    auto cache = SpriteFrameCache::getInstance();
    cache->removeSpriteFramesFromFile("animations/grossini.plist");
    cache->removeSpriteFramesFromFile("animations/grossini_gray.plist");
}

std::string SpriteRotationalSkewNegativeScaleChildren::title() const
{
    return "Testing Sprite";
}

std::string SpriteRotationalSkewNegativeScaleChildren::subtitle() const
{
    return "rot skew + negative scale with children";
}

//
// SpriteBatchNodeRotationalSkewNegativeScaleChildren
//
SpriteBatchNodeRotationalSkewNegativeScaleChildren::SpriteBatchNodeRotationalSkewNegativeScaleChildren()
{
    auto s = Director::getInstance()->getWinSize();

    auto cache = SpriteFrameCache::getInstance();
    cache->addSpriteFramesWithFile("animations/grossini.plist");
    cache->addSpriteFramesWithFile("animations/grossini_gray.plist", "animations/grossini_gray.png");

    auto parent = SpriteBatchNode::create("animations/grossini.png");
    addChild(parent);

    for (int i = 0; i < 2; i++)
    {
        auto sprite = Sprite::createWithSpriteFrameName("grossini_dance_01.png");
        sprite->setPosition(Vec2(s.width / 4 * (i + 1), s.height / 2));

        auto point = Sprite::create("Images/r1.png");

        point->setScale(0.25f);
        point->setPosition(sprite->getPosition());
        addChild(point, 1);

        // Skew
        auto skewX      = RotateBy::create(2, 45, 0);
        auto skewX_back = skewX->reverse();
        auto skewY      = RotateBy::create(2, 0, 45);
        auto skewY_back = skewY->reverse();

        if (1 == 1)
        {
            sprite->setScale(-1.0f);
        }

        auto seq_skew = Sequence::create(skewX, skewX_back, skewY, skewY_back, nullptr);
        sprite->runAction(RepeatForever::create(seq_skew));

        auto child1 = Sprite::create("Images/grossini_dance_01.png");
        child1->setPosition(Vec2(sprite->getContentSize().width / 2.0f, sprite->getContentSize().height / 2.0f));

        sprite->addChild(child1);

        child1->setScale(0.8f);

        parent->addChild(sprite, 0);
    }
}

SpriteBatchNodeRotationalSkewNegativeScaleChildren::~SpriteBatchNodeRotationalSkewNegativeScaleChildren() {}

std::string SpriteBatchNodeRotationalSkewNegativeScaleChildren::title() const
{
    return "Testing SpriteBatchNode";
}

std::string SpriteBatchNodeRotationalSkewNegativeScaleChildren::subtitle() const
{
    return "rot skew + negative scale with children";
}

//------------------------------------------------------------------
//
// SpriteCullTest1
//
//------------------------------------------------------------------

SpriteCullTest1::SpriteCullTest1()
{
    Size s        = Director::getInstance()->getWinSize();
    auto grossini = Sprite::create("Images/grossini.png");

    grossini->setPosition(s.width / 2, s.height / 2);

    auto right = MoveBy::create(3, Vec2(s.width * 2, 0.0f));
    auto back1 = right->reverse();
    auto left  = MoveBy::create(3, Vec2(-s.width * 2, 0.0f));
    auto back2 = left->reverse();
    auto up    = MoveBy::create(3, Vec2(0.0f, s.height * 2));
    auto back3 = up->reverse();
    auto down  = MoveBy::create(3, Vec2(0.0f, -s.height * 2));
    auto back4 = down->reverse();

    auto seq = Sequence::create(right, back1, left, back2, up, back3, down, back4, nullptr);
    grossini->runAction(seq);
    this->addChild(grossini);
}

std::string SpriteCullTest1::title() const
{
    return "Testing Culling: No Scale, No Rotation";
}

std::string SpriteCullTest1::subtitle() const
{
    return "Look at the GL calls";
}

//------------------------------------------------------------------
//
// SpriteCullTest2
//
//------------------------------------------------------------------

SpriteCullTest2::SpriteCullTest2()
{
    Size s        = Director::getInstance()->getWinSize();
    auto grossini = Sprite::create("Images/grossini.png");

    grossini->setPosition(s.width / 2, s.height / 2);

    auto right = MoveBy::create(3, Vec2(s.width * 2, 0.0f));
    auto back1 = right->reverse();
    auto left  = MoveBy::create(3, Vec2(-s.width * 2, 0.0f));
    auto back2 = left->reverse();
    auto up    = MoveBy::create(3, Vec2(0.0f, s.height * 2));
    auto back3 = up->reverse();
    auto down  = MoveBy::create(3, Vec2(0.0f, -s.height * 2));
    auto back4 = down->reverse();

    grossini->setScale(0.1f);

    auto seq = Sequence::create(right, back1, left, back2, up, back3, down, back4, nullptr);
    grossini->runAction(seq);
    this->addChild(grossini);
}

std::string SpriteCullTest2::title() const
{
    return "Testing Culling: Scale, No Rotation";
}

std::string SpriteCullTest2::subtitle() const
{
    return "Look at the GL calls";
}

//------------------------------------------------------------------
//
// Sprite 3D rotation test
//
//------------------------------------------------------------------
Sprite3DRotationTest::Sprite3DRotationTest()
{
    Size s = Director::getInstance()->getWinSize();

    // Create reference sprite that's rotating based on there anchor point
    auto s1 = Sprite::create("Images/grossini.png");
    s1->setPosition(s.width / 4, s.height / 4 * 3);
    s1->setAnchorPoint(Vec2(0.0f, 0.0f));
    s1->runAction(RepeatForever::create(RotateBy::create(6.0f, 360.0f)));
    addChild(s1);

    auto s2 = Sprite::create("Images/grossini.png");
    s2->setPosition(s.width / 4 * 3, s.height / 4 * 3);
    s2->runAction(RepeatForever::create(RotateBy::create(6.0f, 360.0f)));
    addChild(s2);

    sprite1 = Sprite::create("Images/grossini.png");
    sprite1->setPosition(s.width / 4, s.height / 4);
    sprite1->setAnchorPoint(Vec2(0.0f, 0.0f));

    addChild(sprite1);

    sprite2 = Sprite::create("Images/grossini.png");
    sprite2->setPosition(s.width / 4 * 3, s.height / 4);

    addChild(sprite2);

    schedule(
        [&](float dt) {
            rotation.y += 1;
            sprite1->setRotation3D(rotation);
            sprite2->setRotation3D(rotation);
        },
        "update_key");
}

//------------------------------------------------------------------
//
// Sprite::getSpriteFrame() test
//
//------------------------------------------------------------------
SpriteGetSpriteFrameTest::SpriteGetSpriteFrameTest()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // Create reference sprite that's rotating based on there anchor point
    auto s1 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s1);
    s1->getTexture()->setAliasTexParameters();
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setContentSize(s1->getContentSize() * 2);
    s1->setSpriteFrame(s1->getSpriteFrame());

    // Create reference sprite that's rotating based on there anchor point
    auto s2 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s2);
    s2->setPosition(s.width * 2 / 4, s.height / 2);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s3);
    s3->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(128, 0, 64, 128)));
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setSpriteFrame(s3->getSpriteFrame());
}

//------------------------------------------------------------------
//
// Slice9 Test #1
//
//------------------------------------------------------------------
SpriteSlice9Test1::SpriteSlice9Test1()
{
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Size s = Director::getInstance()->getWinSize();

    for (int i = 2; i > 0; --i)
    {
        auto s1 = Sprite::create("Images/grossinis_sister1.png");
        addChild(s1);
        s1->setPosition(s.width * 1 / 4, s.height * i / 3);
        s1->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
        s1->setContentSize(Size(s1->getContentSize().width, 200.0f));
        auto action1 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s1->runAction(action1);

        // Create reference sprite that's rotating based on there anchor point
        auto s2 = Sprite::create("Images/grossinis_sister1.png");
        addChild(s2);
        s2->setPosition(s.width * 2 / 4, s.height * i / 3);
        s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s2->setContentSize(Size(s2->getContentSize().width, 200.0f));
        auto action2 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s2->runAction(action2);

        // Create reference sprite that's rotating based on there anchor point
        auto s3 = Sprite::create("Images/grossinis_sister1.png");
        addChild(s3);
        s3->setPosition(s.width * 3 / 4, s.height * i / 3);
        s3->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
        s3->setContentSize(Size(s3->getContentSize().width, 200.0f));
        auto action3 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s3->runAction(action3);

        if (i == 2)
        {
            s3->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
            s2->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
            s1->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
        }

        // "anchor points"
        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(s1->getPosition());
        addChild(point, 10);

        auto point2 = Sprite::create("Images/r1.png");
        point2->setScale(0.25f);
        point2->setPosition(s2->getPosition());
        addChild(point2, 10);

        auto point3 = Sprite::create("Images/r1.png");
        point3->setScale(0.25f);
        point3->setPosition(s3->getPosition());
        addChild(point3, 10);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #2
//
//------------------------------------------------------------------
SpriteSlice9Test2::SpriteSlice9Test2()
{
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    Size s = Director::getInstance()->getWinSize();

    for (int i = 2; i > 0; i--)
    {
        // Create reference sprite that's rotating based on there anchor point
        auto s1 = Sprite::createWithSpriteFrameName("grossini.png");
        addChild(s1);
        s1->setPosition(s.width * 1 / 4, s.height * i / 3);
        s1->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
        s1->setContentSize(Size(80.0f, s1->getContentSize().height));
        auto action1 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s1->runAction(action1);

        // Create reference sprite that's rotating based on there anchor point
        auto s2 = Sprite::createWithSpriteFrameName("grossini.png");
        addChild(s2);
        s2->setPosition(s.width * 2 / 4, s.height * i / 3);
        s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s2->setContentSize(Size(80.0f, s2->getContentSize().height));
        auto action2 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s2->runAction(action2);

        // Create reference sprite that's rotating based on there anchor point
        auto s3 = Sprite::createWithSpriteFrameName("grossini.png");
        addChild(s3);
        s3->setPosition(s.width * 3 / 4, s.height * i / 3);
        s3->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
        s3->setContentSize(Size(80.0f, s3->getContentSize().height));
        auto action3 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s3->runAction(action3);

        if (i == 2)
        {
            s3->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
            s2->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
            s1->setCenterRectNormalized(Rect(0.4f, 0.4f, 0.2f, 0.2f));
        }

        // "anchor points"
        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(s1->getPosition());
        addChild(point, 10);

        auto point2 = Sprite::create("Images/r1.png");
        point2->setScale(0.25f);
        point2->setPosition(s2->getPosition());
        addChild(point2, 10);

        auto point3 = Sprite::create("Images/r1.png");
        point3->setScale(0.25f);
        point3->setPosition(s3->getPosition());
        addChild(point3, 10);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #3
//
//------------------------------------------------------------------
SpriteSlice9Test3::SpriteSlice9Test3()
{
    Size s = Director::getInstance()->getWinSize();

    for (int i = 2; i > 0; --i)
    {
        // Create reference sprite that's rotating based on there anchor point
        auto s1 = Sprite::create("ccb/scale-9-demo.png");
        addChild(s1);
        s1->setPosition(s.width * 1 / 4, s.height * i / 3);
        s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s1->setContentSize(s1->getContentSize());
        auto action1 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s1->runAction(action1);

        // Create reference sprite that's rotating based on there anchor point
        auto s2 = Sprite::create("ccb/scale-9-demo.png");
        addChild(s2);
        s2->setPosition(s.width * 2 / 4, s.height * i / 3);
        s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s2->setContentSize(s2->getContentSize() * 2);
        auto action2 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s2->runAction(action2);

        // Create reference sprite that's rotating based on there anchor point
        auto s3 = Sprite::create("ccb/scale-9-demo.png");
        addChild(s3);
        s3->setPosition(s.width * 3 / 4, s.height * i / 3);
        s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s3->setContentSize(s3->getContentSize() * 3);
        auto action3 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s3->runAction(action3);

        // enable slice 9, only in the first row
        if (i == 2)
        {
            s1->setCenterRectNormalized(Rect(0.4, 0.4, 0.2, 0.2));
            s2->setCenterRectNormalized(Rect(0.4, 0.4, 0.2, 0.2));
            s3->setCenterRectNormalized(Rect(0.4, 0.4, 0.2, 0.2));
        }

        // "anchor points"
        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.25f);
        point->setPosition(s1->getPosition());
        addChild(point, 10);

        auto point2 = Sprite::create("Images/r1.png");
        point2->setScale(0.25f);
        point2->setPosition(s2->getPosition());
        addChild(point2, 10);

        auto point3 = Sprite::create("Images/r1.png");
        point3->setScale(0.25f);
        point3->setPosition(s3->getPosition());
        addChild(point3, 10);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #4
//
//------------------------------------------------------------------
SpriteSlice9Test4::SpriteSlice9Test4()
{
    Size s = Director::getInstance()->getWinSize();

    for (int i = 2; i > 0; --i)
    {
        // Create reference sprite that's rotating based on there anchor point
        auto s1 = Sprite::create("ccs-res/cocosui/button.png");
        addChild(s1);
        s1->setPosition(s.width * 1 / 4, s.height * i / 3);
        s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s1->setContentSize(s1->getContentSize() * 2);
        auto action1 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s1->runAction(action1);

        // Create reference sprite that's rotating based on there anchor point
        auto s2 = Sprite::create("ccs-res/cocosui/button.png");
        addChild(s2);
        s2->setPosition(s.width * 2 / 4, s.height * i / 3);
        s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s2->setContentSize(s2->getContentSize() * 3);
        auto action2 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s2->runAction(action2);

        // Create reference sprite that's rotating based on there anchor point
        auto s3 = Sprite::create("ccs-res/cocosui/button.png");
        addChild(s3);
        s3->setPosition(s.width * 3 / 4, s.height * i / 3);
        s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
        s3->setContentSize(s3->getContentSize() * 4);
        auto action3 = RepeatForever::create(RotateBy::create(5.0f, 360.0f));
        s3->runAction(action3);

        // enable slice 9, only in the first row
        if (i == 2)
        {
            s1->setCenterRect(AX_RECT_PIXELS_TO_POINTS(Rect(6, 14, 2, 4)));
            s2->setCenterRect(AX_RECT_PIXELS_TO_POINTS(Rect(6, 14, 2, 4)));
            s3->setCenterRect(AX_RECT_PIXELS_TO_POINTS(Rect(6, 14, 2, 4)));
        }

        // "anchor points"
        auto point = Sprite::create("Images/r1.png");
        point->setScale(0.1f);
        point->setPosition(s1->getPosition());
        addChild(point, 10);

        auto point2 = Sprite::create("Images/r1.png");
        point2->setScale(0.1f);
        point2->setPosition(s2->getPosition());
        addChild(point2, 10);

        auto point3 = Sprite::create("Images/r1.png");
        point3->setScale(0.1f);
        point3->setPosition(s3->getPosition());
        addChild(point3, 10);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #5
//
//------------------------------------------------------------------
SpriteSlice9Test5::SpriteSlice9Test5()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // Create reference sprite that's rotating based on there anchor point
    auto s1 = Sprite::create("Images/grossinis_heads.png");
    addChild(s1);
    s1->getTexture()->setAliasTexParameters();
    s1->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(0, 0, 64, 128)));
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setContentSize(Size(s.width / 3, s.height));
    s1->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[0] = s1;

    // Create reference sprite that's rotating based on there anchor point
    auto s2 = Sprite::create("Images/grossinis_heads.png");
    addChild(s2);
    s2->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(64, 0, 64, 128)));
    s2->setPosition(s.width * 2 / 4, s.height / 2);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setContentSize(Size(s.width / 3, s.height));
    s2->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[1] = s2;

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::create("Images/grossinis_heads.png");
    addChild(s3);
    s3->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(128, 0, 64, 128)));
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setContentSize(Size(s.width / 3, s.height));
    s3->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[2] = s3;

    scheduleUpdate();

    _elapsed = 0;
}

void SpriteSlice9Test5::update(float dt)
{
    _elapsed += dt;

    float angle = _elapsed;

    // cap the value between 0 and 0.8
    float x  = ((cos(angle) + sin(angle * 3)) + 2) / 5.0f;
    float y1 = (sin(angle) + 1) / 2.5;
    float y2 = (sin(angle + M_PI_2) + 1) / 2.5;
    float y  = y1;
    for (int i = 0; i < 3; ++i)
    {
        if (i == 1)
        {
            x = 0.8 - x;
            y = y2;
        }
        else if (i == 2)
        {
            y = 0.8 - y;
        }

        Rect rect(x, y, 0.2, 0.2);
        _sprites[i]->setCenterRectNormalized(rect);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #6
//
//------------------------------------------------------------------
SpriteSlice9Test6::SpriteSlice9Test6()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // Create reference sprite that's rotating based on there anchor point
    auto s1 = Sprite::create("Images/grossinis_heads.png");
    addChild(s1);
    s1->getTexture()->setAliasTexParameters();
    s1->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(0, 0, 64, 128)));
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setContentSize(Size(s.width / 3, s.height));
    s1->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[0] = s1;

    // Create reference sprite that's rotating based on there anchor point
    auto s2 = Sprite::create("Images/grossinis_heads.png");
    addChild(s2);
    s2->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(64, 0, 64, 128)));
    s2->setPosition(s.width * 2 / 4, s.height / 2);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setContentSize(Size(s.width / 3, s.height));
    s2->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[1] = s2;

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::create("Images/grossinis_heads.png");
    addChild(s3);
    s3->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(128, 0, 64, 128)));
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setContentSize(Size(s.width / 3, s.height));
    s3->setCenterRectNormalized(Rect(0, 0, 1, 1));
    _sprites[2] = s3;

    scheduleUpdate();

    _elapsed = 0;
}

void SpriteSlice9Test6::update(float dt)
{
    _elapsed += dt;

    float angle = _elapsed;

    // cap the value between 0 and 1
    float x  = ((cos(angle * 2) - sin(angle / 2)) + 2) / 4;
    float y1 = (sin(angle) + 1) / 2;
    float y2 = (sin(angle + M_PI_2) + 1) / 2;
    float y  = y1;
    for (int i = 0; i < 3; ++i)
    {
        if (i == 1)
        {
            x = 1 - x;
            y = y2;
        }
        else if (i == 2)
        {
            y = 1 - y;
        }

        Rect rect((1 - x) / 2, (1 - y) / 2, x, y);
        _sprites[i]->setCenterRectNormalized(rect);
    }
}

//------------------------------------------------------------------
//
// Slice9 Test #7
//
//------------------------------------------------------------------
SpriteSlice9Test7::SpriteSlice9Test7()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // Create reference sprite that's rotating based on there anchor point
    auto s1 = Sprite::create("Images/grossinis_heads.png");
    addChild(s1);
    s1->getTexture()->setAliasTexParameters();
    s1->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(0, 0, 64, 128)));
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setContentSize(Size(s.width / 3, s.height));
    s1->setCenterRectNormalized(Rect(0, 0, 0.5, 0.5));

    // Create reference sprite that's rotating based on there anchor point
    auto s2 = Sprite::create("Images/grossinis_heads.png");
    addChild(s2);
    s2->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(64, 0, 64, 128)));
    s2->setPosition(s.width * 2 / 4, s.height / 2);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setContentSize(Size(s.width / 3, s.height));
    s2->setCenterRectNormalized(Rect(0.25, 0.25, 0.5, 0.5));

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::create("Images/grossinis_heads.png");
    addChild(s3);
    s3->setTextureRect(AX_RECT_PIXELS_TO_POINTS(Rect(128, 0, 64, 128)));
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setContentSize(Size(s.width / 3, s.height));
    s3->setCenterRectNormalized(Rect(0.5, 0.5, 0.5, 0.5));
}

//------------------------------------------------------------------
//
// Slice9 Test #8
//
//------------------------------------------------------------------
SpriteSlice9Test8::SpriteSlice9Test8()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    //
    // flip BEFORE contentSize
    //
    auto s1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    addChild(s1);
    s1->setPosition(s.width / 2 - s.width / 3, s.height * 2 / 3);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s1->setFlippedX(true);
    s1->setContentSize(s1->getContentSize() * 2);

    auto s2 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s2);
    s2->setPosition(s.width * 2 / 4, s.height * 2 / 3);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s2->setFlippedX(true);
    s2->setFlippedY(true);
    s2->setContentSize(s2->getContentSize() * 2);

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    addChild(s3);
    s3->setPosition(s.width / 2 + s.width / 3, s.height * 2 / 3);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s3->setFlippedY(true);
    s3->setContentSize(s3->getContentSize() * 2);

    //
    // flip AFTER contentSize
    //
    auto s4 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    addChild(s4);
    s4->setPosition(s.width / 2 - s.width / 3, s.height * 1 / 3);
    s4->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s4->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s4->setFlippedX(true);
    s4->setContentSize(s4->getContentSize() * 2);

    auto s5 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s5);
    s5->setPosition(s.width * 2 / 4, s.height * 1 / 3);
    s5->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s5->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s5->setFlippedX(true);
    s5->setFlippedY(true);
    s5->setContentSize(s5->getContentSize() * 2);

    // Create reference sprite that's rotating based on there anchor point
    auto s6 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    addChild(s6);
    s6->setPosition(s.width / 2 + s.width / 3, s.height * 1 / 3);
    s6->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s6->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s6->setFlippedY(true);
    s6->setContentSize(s6->getContentSize() * 2);
}

//------------------------------------------------------------------
//
// Slice9 Test #9
//
//------------------------------------------------------------------
SpriteSlice9Test9::SpriteSlice9Test9()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini_family.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("animations/grossini.plist");

    // flipped BEFORE content size
    auto s1 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    addChild(s1);
    s1->setPosition(s.width / 2 - s.width / 3, s.height * 2 / 3);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setCenterRectNormalized(Rect(2 / 3.f, 2 / 3.f, 1 / 3.f, 1 / 3.f));
    s1->setFlippedX(true);
    s1->setContentSize(s1->getContentSize() * 2);

    auto s2 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s2);
    s2->setPosition(s.width * 2 / 4, s.height * 2 / 3);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 2 / 3.f, 2 / 3.f));
    s2->setFlippedX(true);
    s2->setFlippedY(true);
    s2->setContentSize(s2->getContentSize() * 2);

    auto s3 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    addChild(s3);
    s3->setPosition(s.width / 2 + s.width / 3, s.height * 2 / 3);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setCenterRectNormalized(Rect(0.1f, 0.1f, 0.8f, 0.8f));
    s3->setFlippedY(true);
    s3->setContentSize(s3->getContentSize() * 2);

    // flipped AFTER content size
    auto s4 = Sprite::createWithSpriteFrameName("grossinis_sister1.png");
    addChild(s4);
    s4->setPosition(s.width / 2 - s.width / 3, s.height * 1 / 3);
    s4->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s4->setCenterRectNormalized(Rect(2 / 3.f, 2 / 3.f, 1 / 3.f, 1 / 3.f));
    s4->setContentSize(s4->getContentSize() * 2);
    s4->setFlippedX(true);

    auto s5 = Sprite::createWithSpriteFrameName("grossini.png");
    addChild(s5);
    s5->setPosition(s.width * 2 / 4, s.height * 1 / 3);
    s5->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s5->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 2 / 3.f, 2 / 3.f));
    s5->setContentSize(s5->getContentSize() * 2);
    s5->setFlippedX(true);
    s5->setFlippedY(true);

    auto s6 = Sprite::createWithSpriteFrameName("grossinis_sister2.png");
    addChild(s6);
    s6->setPosition(s.width / 2 + s.width / 3, s.height * 1 / 3);
    s6->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s6->setCenterRectNormalized(Rect(0.1f, 0.1f, 0.8f, 0.8f));
    s6->setContentSize(s6->getContentSize() * 2);
    s6->setFlippedY(true);
}

//------------------------------------------------------------------
//
// Slice9 Test #10
//
//------------------------------------------------------------------
SpriteSlice9Test10::SpriteSlice9Test10()
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("Images/blocks9ss.plist");

    auto s1 = Sprite::createWithSpriteFrameName("blocks9ss/blocks9r.png");
    addChild(s1);
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s1->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s1->setContentSize(s1->getContentSize() * 1.5);
    s1->setFlippedX(true);

    auto s2 = Sprite::createWithSpriteFrameName("blocks9ss/blocks9r.png");
    addChild(s2);
    s2->setPosition(s.width * 2 / 4, s.height / 2);
    s2->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s2->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s2->setContentSize(s2->getContentSize() * 1.5);

    // Create reference sprite that's rotating based on there anchor point
    auto s3 = Sprite::createWithSpriteFrameName("blocks9ss/blocks9r.png");
    addChild(s3);
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2);
    s3->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    s3->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s3->setContentSize(s3->getContentSize() * 1.5);
    s3->setFlippedY(true);
}

//------------------------------------------------------------------
//
// Issue 17119
//
//------------------------------------------------------------------
Issue17119::Issue17119() : _accum(0)
{
    Size s = Director::getInstance()->getVisibleSize();

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("Images/issue_17119.plist");
    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("Images/blocks9ss.plist");

    auto s1 = Sprite::createWithSpriteFrameName("issue_17119/firstPic.png");
    addChild(s1);
    s1->setPosition(s.width / 2 - s.width / 3, s.height / 2);
    s1->setScale(0.25f);
    auto p1 = Sprite::create("Images/r1.png");
    p1->setScale(0.25f);
    p1->setPosition(s1->getPosition());
    addChild(p1, 10);

    auto s2 = Sprite::createWithSpriteFrameName("blocks9ss/blocks9r.png");
    addChild(s2);
    s2->setPosition(s.width / 2, s.height / 2);
    s2->setCenterRectNormalized(Rect(1 / 3.f, 1 / 3.f, 1 / 3.f, 1 / 3.f));
    s2->setContentSize(s2->getContentSize() * 1.5);
    auto p2 = Sprite::create("Images/r1.png");
    p2->setScale(0.25f);
    p2->setPosition(s2->getPosition());
    addChild(p2, 10);

    auto s3 = Sprite::create("Images/grossini.png");
    addChild(s3);
    s3->setPosition(s.width / 2 + s.width / 3, s.height / 2 + s.height / 3);
    s3->setContentSize(s3->getContentSize() * 1.5);
    auto p3 = Sprite::create("Images/r1.png");
    p3->setScale(0.25f);
    p3->setPosition(s3->getPosition());
    addChild(p3, 10);

    auto s4 = Sprite::create("Images/grossini.png");
    addChild(s4);
    s4->setPosition(s.width / 2 + s.width / 3, s.height / 2 - s.height / 3);
    s4->setContentSize(s2->getContentSize() * 1.5);
    s4->setStretchEnabled(false);
    auto p4 = Sprite::create("Images/r1.png");
    p4->setScale(0.25f);
    p4->setPosition(s3->getPosition());
    addChild(p4, 10);

    _s1 = s1;
    _s2 = s2;
    _s3 = s3;
    _s4 = s4;
    scheduleUpdate();
}

void Issue17119::update(float dt)
{
    _accum += dt;
    if (_accum > 0.5)
    {
        _accum       = 0;
        auto flipped = _s1->isFlippedX();
        _s1->setFlippedX(!flipped);
        _s2->setFlippedX(!flipped);
        _s3->setFlippedX(!flipped);
        _s4->setFlippedX(!flipped);
    }
}