axmol/tests/cpp-tests/Classes/ParticleTest/ParticleTest.cpp

/****************************************************************************
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
 
 http://www.cocos2d-x.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/

#include "ParticleTest.h"
#include "../testResource.h"
#include "editor-support/cocostudio/CocosStudioExtension.h"

USING_NS_CC;

enum {
    kTagParticleCount = 1,
};

//------------------------------------------------------------------
//
// DemoFirework
//
//------------------------------------------------------------------
void DemoFirework::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleFireworks::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );

    setEmitterPosition();
}

std::string DemoFirework::subtitle() const
{
    return "ParticleFireworks";
}


//------------------------------------------------------------------
//
// DemoFire
//
//------------------------------------------------------------------
void DemoFire::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleFire::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );//.pvr");
    auto p = _emitter->getPosition();
    _emitter->setPosition( Vec2(p.x, 100) );

    setEmitterPosition();
}

std::string DemoFire::subtitle() const
{
    return "ParticleFire";
}

//------------------------------------------------------------------
//
// DemoSun
//
//------------------------------------------------------------------
void DemoSun::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSun::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    setEmitterPosition();
}

std::string DemoSun::subtitle() const
{
    return "ParticleSun";
}

//------------------------------------------------------------------
//
// DemoPause
//
//------------------------------------------------------------------
void DemoPause::onEnter()
{
    ParticleDemo::onEnter();
    
    _emitter = ParticleSmoke::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);
    
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );
    
    setEmitterPosition();
    schedule(CC_SCHEDULE_SELECTOR(DemoPause::pauseEmitter), 2.0f);


}
void DemoPause::pauseEmitter(float time)
{
    if (_emitter->isPaused())
    {
        _emitter->resumeEmissions();
    }
    else
    {
        _emitter->pauseEmissions();
    }
}

std::string DemoPause::subtitle() const
{
    return "Pause Particle";
}

//------------------------------------------------------------------
//
// DemoGalaxy
//
//------------------------------------------------------------------
void DemoGalaxy::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleGalaxy::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    setEmitterPosition();
}

std::string DemoGalaxy::subtitle() const
{
    return "ParticleGalaxy";
}

//------------------------------------------------------------------
//
// DemoFlower
//
//------------------------------------------------------------------
void DemoFlower::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleFlower::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );

    setEmitterPosition();
}

std::string DemoFlower::subtitle() const
{
    return "ParticleFlower";
}

//------------------------------------------------------------------
//
// DemoBigFlower
//
//------------------------------------------------------------------
void DemoBigFlower::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSystemQuad::createWithTotalParticles(50);
    _emitter->retain();

    _background->addChild(_emitter, 10);
    ////_emitter->release();    // win32 :  use this line or remove this line and use autorelease()
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );

    _emitter->setDuration(-1);

    // gravity
    _emitter->setGravity(Vec2::ZERO);

    // angle
    _emitter->setAngle(90);
    _emitter->setAngleVar(360);

    // speed of particles
    _emitter->setSpeed(160);
    _emitter->setSpeedVar(20);

    // radial
    _emitter->setRadialAccel(-120);
    _emitter->setRadialAccelVar(0);

    // tangential
    _emitter->setTangentialAccel(30);
    _emitter->setTangentialAccelVar(0);

    // emitter position
    _emitter->setPosition( Vec2(160,240) );
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(4);
    _emitter->setLifeVar(1);

    // spin of particles
    _emitter->setStartSpin(0);
    _emitter->setStartSizeVar(0);
    _emitter->setEndSpin(0);
    _emitter->setEndSpinVar(0);

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(80.0f);
    _emitter->setStartSizeVar(40.0f);
    _emitter->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

    // emits per second
    _emitter->setEmissionRate(_emitter->getTotalParticles()/_emitter->getLife());

    // additive
    _emitter->setBlendAdditive(true);

    setEmitterPosition();
}

std::string DemoBigFlower::subtitle() const
{
    return "ParticleBigFlower";
}

//------------------------------------------------------------------
//
// DemoRotFlower
//
//------------------------------------------------------------------
void DemoRotFlower::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSystemQuad::createWithTotalParticles(300);
    _emitter->retain();

    _background->addChild(_emitter, 10);
    ////_emitter->release();    // win32 : Remove this line
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars2) );

    // duration
    _emitter->setDuration(-1);

    // gravity
    _emitter->setGravity(Vec2::ZERO);

    // angle
    _emitter->setAngle(90);
    _emitter->setAngleVar(360);

    // speed of particles
    _emitter->setSpeed(160);
    _emitter->setSpeedVar(20);

    // radial
    _emitter->setRadialAccel(-120);
    _emitter->setRadialAccelVar(0);

    // tangential
    _emitter->setTangentialAccel(30);
    _emitter->setTangentialAccelVar(0);

    // emitter position
    _emitter->setPosition( Vec2(160,240) );
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(3);
    _emitter->setLifeVar(1);

    // spin of particles
    _emitter->setStartSpin(0);
    _emitter->setStartSpinVar(0);
    _emitter->setEndSpin(0);
    _emitter->setEndSpinVar(2000);

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(30.0f);
    _emitter->setStartSizeVar(00.0f);
    _emitter->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

    // emits per second
    _emitter->setEmissionRate(_emitter->getTotalParticles()/_emitter->getLife());

    // additive
    _emitter->setBlendAdditive(false);

    setEmitterPosition();
}

std::string DemoRotFlower::subtitle() const
{
    return "ParticleRotFlower";
}

//------------------------------------------------------------------
//
// DemoMeteor
//
//------------------------------------------------------------------
void DemoMeteor::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleMeteor::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    setEmitterPosition();
}

std::string DemoMeteor::subtitle() const
{
    return "ParticleMeteor";
}

//------------------------------------------------------------------
//
// DemoSpiral
//
//------------------------------------------------------------------
void DemoSpiral::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSpiral::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    setEmitterPosition();
}

std::string DemoSpiral::subtitle() const
{
    return "ParticleSpiral";
}

//------------------------------------------------------------------
//
// DemoExplosion
//
//------------------------------------------------------------------
void DemoExplosion::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleExplosion::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );

    _emitter->setAutoRemoveOnFinish(true);

    setEmitterPosition();
}

std::string DemoExplosion::subtitle() const
{
    return "ParticleExplosion";
}

//------------------------------------------------------------------
//
// DemoSmoke
//
//------------------------------------------------------------------
void DemoSmoke::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSmoke::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    auto p = _emitter->getPosition();
    _emitter->setPosition( Vec2( p.x, 100) );

    setEmitterPosition();
}

std::string DemoSmoke::subtitle() const
{
    return "ParticleSmoke";
}

//------------------------------------------------------------------
//
// DemoSnow
//
//------------------------------------------------------------------
void DemoSnow::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSnow::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    auto p = _emitter->getPosition();
    _emitter->setPosition( Vec2( p.x, p.y-110) );
    _emitter->setLife(3);
    _emitter->setLifeVar(1);

    // gravity
    _emitter->setGravity(Vec2(0,-10));

    // speed of particles
    _emitter->setSpeed(130);
    _emitter->setSpeedVar(30);


    Color4F startColor = _emitter->getStartColor();
    startColor.r = 0.9f;
    startColor.g = 0.9f;
    startColor.b = 0.9f;
    _emitter->setStartColor(startColor);

    Color4F startColorVar = _emitter->getStartColorVar();
    startColorVar.b = 0.1f;
    _emitter->setStartColorVar(startColorVar);

    _emitter->setEmissionRate(_emitter->getTotalParticles()/_emitter->getLife());

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_snow) );

    setEmitterPosition();
}

std::string DemoSnow::subtitle() const
{
    return "ParticleSnow";
}

//------------------------------------------------------------------
//
// DemoRain
//
//------------------------------------------------------------------
void DemoRain::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleRain::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    auto p = _emitter->getPosition();
    _emitter->setPosition( Vec2( p.x, p.y-100) );
    _emitter->setLife(4);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    setEmitterPosition();
}

std::string DemoRain::subtitle() const
{
    return "ParticleRain";
}

//------------------------------------------------------------------
//
// DemoModernArt
//
//------------------------------------------------------------------
void DemoModernArt::onEnter()
{
    ParticleDemo::onEnter();

//FIXME: If use ParticleSystemPoint, bada 1.0 device will crash.
//  Crash place: ParticleSystemPoint.cpp Line 149, function: glDrawArrays(GL_POINTS, 0, _particleIdx);
    _emitter = ParticleSystemQuad::createWithTotalParticles(1000);
    _emitter->retain();

    _background->addChild(_emitter, 10);
    ////_emitter->release();

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

    // duration
    _emitter->setDuration(-1);

    // gravity
    _emitter->setGravity(Vec2(0,0));

    // angle
    _emitter->setAngle(0);
    _emitter->setAngleVar(360);

    // radial
    _emitter->setRadialAccel(70);
    _emitter->setRadialAccelVar(10);

    // tangential
    _emitter->setTangentialAccel(80);
    _emitter->setTangentialAccelVar(0);

    // speed of particles
    _emitter->setSpeed(50);
    _emitter->setSpeedVar(10);

    // emitter position
    _emitter->setPosition( Vec2( s.width/2, s.height/2) );
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(2.0f);
    _emitter->setLifeVar(0.3f);

    // emits per frame
    _emitter->setEmissionRate(_emitter->getTotalParticles()/_emitter->getLife());

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(1.0f);
    _emitter->setStartSizeVar(1.0f);
    _emitter->setEndSize(32.0f);
    _emitter->setEndSizeVar(8.0f);

    // texture
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    // additive
    _emitter->setBlendAdditive(false);

    setEmitterPosition();
}

std::string DemoModernArt::subtitle() const
{
    return "Varying size";
}

//------------------------------------------------------------------
//
// DemoRing
//
//------------------------------------------------------------------
void DemoRing::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleFlower::create();
    _emitter->retain();

    _background->addChild(_emitter, 10);

    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );
    _emitter->setLifeVar(0);
    _emitter->setLife(10);
    _emitter->setSpeed(100);
    _emitter->setSpeedVar(0);
    _emitter->setEmissionRate(10000);

    setEmitterPosition();
}

std::string DemoRing::subtitle() const
{
    return "Ring Demo";
}

//------------------------------------------------------------------
//
// ParallaxParticle
//
//------------------------------------------------------------------
void ParallaxParticle::onEnter()
{
    ParticleDemo::onEnter();

    _background->getParent()->removeChild(_background, true);
    _background = nullptr;

    auto p = ParallaxNode::create();
    addChild(p, 5);

    auto p1 = Sprite::create(s_back3);
    auto p2 = Sprite::create(s_back3);

    p->addChild( p1, 1, Vec2(0.5f,1), Vec2(0,250) );
    p->addChild(p2, 2, Vec2(1.5f,1), Vec2(0,50) );

    _emitter = ParticleFlower::create();
    _emitter->retain();
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    p1->addChild(_emitter, 10);
    _emitter->setPosition( Vec2(250,200) );

    auto par = ParticleSun::create();
    p2->addChild(par, 10);
    par->setTexture( Director::getInstance()->getTextureCache()->addImage(s_fire) );

    auto move = MoveBy::create(4, Vec2(300,0));
    auto move_back = move->reverse();
    auto seq = Sequence::create( move, move_back, nullptr);
    p->runAction(RepeatForever::create(seq));
}

std::string ParallaxParticle::subtitle() const
{
    return "Parallax + Particles";
}

//------------------------------------------------------------------
//
// RadiusMode1
//
//------------------------------------------------------------------
void RadiusMode1::onEnter()
{
    ParticleDemo::onEnter();

	_color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::createWithTotalParticles(200);
    _emitter->retain();
    addChild(_emitter, 10);
    _emitter->setTexture(Director::getInstance()->getTextureCache()->addImage("Images/stars-grayscale.png"));

    // duration
    _emitter->setDuration(ParticleSystem::DURATION_INFINITY);

    // radius mode
    _emitter->setEmitterMode(ParticleSystem::Mode::RADIUS);

    // radius mode: start and end radius in pixels
    _emitter->setStartRadius(0);
    _emitter->setStartRadiusVar(0);
    _emitter->setEndRadius(160);
    _emitter->setEndRadiusVar(0);

    // radius mode: degrees per second
    _emitter->setRotatePerSecond(180);
    _emitter->setRotatePerSecondVar(0);


    // angle
    _emitter->setAngle(90);
    _emitter->setAngleVar(0);

    // emitter position
    auto size = Director::getInstance()->getWinSize();
    _emitter->setPosition(Vec2(size.width/2, size.height/2));
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(5);
    _emitter->setLifeVar(0);

    // spin of particles
    _emitter->setStartSpin(0);
    _emitter->setStartSpinVar(0);
    _emitter->setEndSpin(0);
    _emitter->setEndSpinVar(0);

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(32);
    _emitter->setStartSizeVar(0);
    _emitter->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

    // emits per second
    _emitter->setEmissionRate(_emitter->getTotalParticles() / _emitter->getLife());

    // additive
    _emitter->setBlendAdditive(false);
}

std::string RadiusMode1::subtitle() const
{
    return "Radius Mode: Spiral";
}

//------------------------------------------------------------------
//
// RadiusMode2
//
//------------------------------------------------------------------
void RadiusMode2::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::createWithTotalParticles(200);
    _emitter->retain();
    addChild(_emitter, 10);
    _emitter->setTexture(Director::getInstance()->getTextureCache()->addImage("Images/stars-grayscale.png"));

    // duration
    _emitter->setDuration(ParticleSystem::DURATION_INFINITY);

    // radius mode
    _emitter->setEmitterMode(ParticleSystem::Mode::RADIUS);

    // radius mode: start and end radius in pixels
    _emitter->setStartRadius(100);
    _emitter->setStartRadiusVar(0);
    _emitter->setEndRadius(ParticleSystem::START_RADIUS_EQUAL_TO_END_RADIUS);
    _emitter->setEndRadiusVar(0);

    // radius mode: degrees per second
    _emitter->setRotatePerSecond(45);
    _emitter->setRotatePerSecondVar(0);


    // angle
    _emitter->setAngle(90);
    _emitter->setAngleVar(0);

    // emitter position
    auto size = Director::getInstance()->getWinSize();
    _emitter->setPosition(Vec2(size.width/2, size.height/2));
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(4);
    _emitter->setLifeVar(0);

    // spin of particles
    _emitter->setStartSpin(0);
    _emitter->setStartSpinVar(0);
    _emitter->setEndSpin(0);
    _emitter->setEndSpinVar(0);

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(32);
    _emitter->setStartSizeVar(0);
    _emitter->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

    // emits per second
    _emitter->setEmissionRate(_emitter->getTotalParticles() / _emitter->getLife());

    // additive
    _emitter->setBlendAdditive(false);
}

std::string RadiusMode2::subtitle() const
{
    return "Radius Mode: Semi Circle";
}

//------------------------------------------------------------------
//
// Issue704
//
//------------------------------------------------------------------
void Issue704::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::createWithTotalParticles(100);
    _emitter->retain();
    addChild(_emitter, 10);
    _emitter->setTexture(Director::getInstance()->getTextureCache()->addImage("Images/fire.png"));

    // duration
    _emitter->setDuration(ParticleSystem::DURATION_INFINITY);

    // radius mode
    _emitter->setEmitterMode(ParticleSystem::Mode::RADIUS);

    // radius mode: start and end radius in pixels
    _emitter->setStartRadius(50);
    _emitter->setStartRadiusVar(0);
    _emitter->setEndRadius(ParticleSystem::START_RADIUS_EQUAL_TO_END_RADIUS);
    _emitter->setEndRadiusVar(0);

    // radius mode: degrees per second
    _emitter->setRotatePerSecond(0);
    _emitter->setRotatePerSecondVar(0);


    // angle
    _emitter->setAngle(90);
    _emitter->setAngleVar(0);

    // emitter position
    auto size = Director::getInstance()->getWinSize();
    _emitter->setPosition(Vec2(size.width/2, size.height/2));
    _emitter->setPosVar(Vec2::ZERO);

    // life of particles
    _emitter->setLife(5);
    _emitter->setLifeVar(0);

    // spin of particles
    _emitter->setStartSpin(0);
    _emitter->setStartSpinVar(0);
    _emitter->setEndSpin(0);
    _emitter->setEndSpinVar(0);

    // color of particles
    Color4F startColor(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColor(startColor);

    Color4F startColorVar(0.5f, 0.5f, 0.5f, 1.0f);
    _emitter->setStartColorVar(startColorVar);

    Color4F endColor(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColor(endColor);

    Color4F endColorVar(0.1f, 0.1f, 0.1f, 0.2f);
    _emitter->setEndColorVar(endColorVar);

    // size, in pixels
    _emitter->setStartSize(16);
    _emitter->setStartSizeVar(0);
    _emitter->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

    // emits per second
    _emitter->setEmissionRate(_emitter->getTotalParticles() / _emitter->getLife());

    // additive
    _emitter->setBlendAdditive(false);

    auto rot = RotateBy::create(16, 360);
    _emitter->runAction(RepeatForever::create(rot));
}

std::string Issue704::title() const
{
    return "Issue 704. Free + Rot";
}

std::string Issue704::subtitle() const
{
    return "Emitted particles should not rotate";
}

//------------------------------------------------------------------
//
// Issue870
//
//------------------------------------------------------------------
void Issue870::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::create("Particles/SpinningPeas.plist");
    _emitter->setTextureWithRect(Director::getInstance()->getTextureCache()->addImage("Images/particles.png"), Rect(0,0,32,32));
    addChild(_emitter, 10);
    _emitter->retain();

    _index = 0;
    schedule(CC_SCHEDULE_SELECTOR(Issue870::updateQuads), 2.0f);
}

void Issue870::updateQuads(float dt)
{
    _index = (_index + 1) % 4;
    auto rect = Rect(_index * 32, 0, 32, 32);
    auto system = (ParticleSystemQuad*)_emitter;
    system->setTextureWithRect(_emitter->getTexture(), rect);
}

std::string Issue870::title() const
{
    return "Issue 870. SubRect";
}

std::string Issue870::subtitle() const
{
    return "Every 2 seconds the particle should change";
}

//------------------------------------------------------------------
//
// DemoParticleFromFile
//
//------------------------------------------------------------------
void DemoParticleFromFile::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    std::string filename = "Particles/" + _title + ".plist";
    _emitter = ParticleSystemQuad::create(filename);
    _emitter->retain();
    addChild(_emitter, 10);

    setEmitterPosition();
}

//------------------------------------------------------------------
//
// ParticleDemo
//
//------------------------------------------------------------------

enum
{
    IDC_NEXT = 100,
    IDC_BACK,
    IDC_RESTART,
    IDC_TOGGLE
};

ParticleTests::ParticleTests()
{
    ADD_TEST_CASE(ParticleReorder);
    ADD_TEST_CASE(ParticleBatchHybrid);
    ADD_TEST_CASE(ParticleBatchMultipleEmitters);
    ADD_TEST_CASE(DemoFlower);
    ADD_TEST_CASE(DemoGalaxy);
    ADD_TEST_CASE(DemoFirework);
    ADD_TEST_CASE(DemoSpiral);
    ADD_TEST_CASE(DemoSun);
    ADD_TEST_CASE(DemoMeteor);
    ADD_TEST_CASE(DemoFire);
    ADD_TEST_CASE(DemoSmoke);
    ADD_TEST_CASE(DemoExplosion);
    ADD_TEST_CASE(DemoSnow);
    ADD_TEST_CASE(DemoRain);
    ADD_TEST_CASE(DemoBigFlower);
    ADD_TEST_CASE(DemoRotFlower);
    ADD_TEST_CASE(DemoModernArt);
    ADD_TEST_CASE(DemoRing);
    ADD_TEST_CASE(ParallaxParticle);
    ADD_TEST_CASE(DemoPause);
    addTestCase("BoilingFoam", [](){return DemoParticleFromFile::create("BoilingFoam");});
    addTestCase("BurstPipe", [](){return DemoParticleFromFile::create("BurstPipe"); });
    addTestCase("Comet", [](){return DemoParticleFromFile::create("Comet"); });
    addTestCase("debian", [](){return DemoParticleFromFile::create("debian"); });
    addTestCase("ExplodingRing", [](){return DemoParticleFromFile::create("ExplodingRing"); });
    addTestCase("LavaFlow", [](){return DemoParticleFromFile::create("LavaFlow"); });
    addTestCase("SpinningPeas", [](){return DemoParticleFromFile::create("SpinningPeas"); });
    addTestCase("SpookyPeas", [](){return DemoParticleFromFile::create("SpookyPeas"); });
    addTestCase("Upsidedown", [](){return DemoParticleFromFile::create("Upsidedown"); });
    addTestCase("Flower", [](){return DemoParticleFromFile::create("Flower"); });
    addTestCase("Spiral", [](){return DemoParticleFromFile::create("Spiral"); });
    addTestCase("Galaxy", [](){return DemoParticleFromFile::create("Galaxy"); });
    addTestCase("Phoenix", [](){return DemoParticleFromFile::create("Phoenix"); });
    addTestCase("lines", [](){return DemoParticleFromFile::create("lines"); });
    addTestCase("ButterFly", [](){return DemoParticleFromFile::create("ButterFly"); });
    addTestCase("ButterFlyYFlipped", [](){return DemoParticleFromFile::create("ButterFlyYFlipped"); });
    ADD_TEST_CASE(RadiusMode1);
    ADD_TEST_CASE(RadiusMode2);
    ADD_TEST_CASE(Issue704);
    ADD_TEST_CASE(Issue870);
    ADD_TEST_CASE(Issue1201);

    ADD_TEST_CASE(MultipleParticleSystems);
    ADD_TEST_CASE(MultipleParticleSystemsBatched);
    ADD_TEST_CASE(AddAndDeleteParticleSystems);
    ADD_TEST_CASE(ReorderParticleSystems);
    ADD_TEST_CASE(PremultipliedAlphaTest);
    ADD_TEST_CASE(PremultipliedAlphaTest2);
    ADD_TEST_CASE(Issue3990);
    ADD_TEST_CASE(ParticleAutoBatching);
    ADD_TEST_CASE(ParticleVisibleTest);
    ADD_TEST_CASE(ParticleResetTotalParticles);

    ADD_TEST_CASE(ParticleIssue12310);
    ADD_TEST_CASE(ParticleSpriteFrame);
}

ParticleDemo::~ParticleDemo(void)
{
    CC_SAFE_RELEASE(_emitter);
}

void ParticleDemo::onEnter(void)
{
    TestCase::onEnter();

    MenuItemFont::setFontSize(32);

	_color = LayerColor::create( Color4B(127,127,127,255) );
	this->addChild(_color);

    _emitter = nullptr;

    auto listener = EventListenerTouchAllAtOnce::create();
    listener->onTouchesBegan = CC_CALLBACK_2(ParticleDemo::onTouchesBegan, this);
    listener->onTouchesMoved = CC_CALLBACK_2(ParticleDemo::onTouchesMoved, this);
    listener->onTouchesEnded = CC_CALLBACK_2(ParticleDemo::onTouchesEnded, this);
    _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);

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

    auto item4 = MenuItemToggle::createWithCallback( CC_CALLBACK_1(ParticleDemo::toggleCallback, this),
                                                               MenuItemFont::create( "Free Movement" ),
                                                               MenuItemFont::create( "Relative Movement" ),
                                                               MenuItemFont::create( "Grouped Movement" ),
                                                               nullptr );

    auto menu = Menu::create(item4, nullptr);

    menu->setPosition( Vec2::ZERO );
    item4->setPosition( Vec2( VisibleRect::left().x, VisibleRect::bottom().y+ 100) );
    item4->setAnchorPoint( Vec2(0,0) );

    addChild( menu, 100 );

    auto labelAtlas = LabelAtlas::create("0000", "fps_images.png", 12, 32, '.');
    addChild(labelAtlas, 100, kTagParticleCount);
    labelAtlas->setPosition(Vec2(s.width-66,50));

    // moving background
    _background = Sprite::create(s_back3);
    addChild(_background, 5);
    _background->setPosition( Vec2(s.width/2, s.height-180) );

    auto move = MoveBy::create(4, Vec2(300,0) );
    auto move_back = move->reverse();
    auto seq = Sequence::create( move, move_back, nullptr);
    _background->runAction( RepeatForever::create(seq) );


    scheduleUpdate();
}

std::string ParticleDemo::title() const
{
    return "Particle Demo";
}

std::string ParticleDemo::subtitle() const
{
    return "No title";
}

void ParticleDemo::onTouchesBegan(const std::vector<Touch*>& touches, Event  *event)
{
    onTouchesEnded(touches, event);
}

void ParticleDemo::onTouchesMoved(const std::vector<Touch*>& touches, Event  *event)
{
    return onTouchesEnded(touches, event);
}

void ParticleDemo::onTouchesEnded(const std::vector<Touch*>& touches, Event  *event)
{
    auto touch = touches[0];

    auto location = touch->getLocation();

    auto pos = Vec2::ZERO;
    if (_background)
    {
        pos = _background->convertToWorldSpace(Vec2::ZERO);
    }

    if (_emitter != nullptr)
    {
        _emitter->setPosition(location -pos);
    }
}

void ParticleDemo::update(float dt)
{
    if (_emitter)
    {
        auto atlas = (LabelAtlas*)getChildByTag(kTagParticleCount);
        char str[5] = {0};
        sprintf(str, "%04d", _emitter->getParticleCount());
        atlas->setString(str);
    }
}

void ParticleDemo::toggleCallback(Ref* sender)
{
    if (_emitter != nullptr)
    {
        if (_emitter->getPositionType() == ParticleSystem::PositionType::GROUPED)
            _emitter->setPositionType(ParticleSystem::PositionType::FREE);
        else if (_emitter->getPositionType() == ParticleSystem::PositionType::FREE)
            _emitter->setPositionType(ParticleSystem::PositionType::RELATIVE);
        else if (_emitter->getPositionType() == ParticleSystem::PositionType::RELATIVE)
            _emitter->setPositionType(ParticleSystem::PositionType::GROUPED );
    }
}

void ParticleDemo::setEmitterPosition()
{
    auto s = Director::getInstance()->getWinSize();
    if (_emitter != nullptr)
    {
        _emitter->setPosition( Vec2(s.width / 2, s.height / 2) );
    }
}

// ParticleBatchHybrid

void ParticleBatchHybrid::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::create("Particles/LavaFlow.plist");
    _emitter->retain();
    auto batch = ParticleBatchNode::createWithTexture(_emitter->getTexture());

    batch->addChild(_emitter);

    addChild(batch, 10);

     schedule(CC_SCHEDULE_SELECTOR(ParticleBatchHybrid::switchRender), 2.0f);

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

     _parent1 = batch;
     _parent2 = node;
}

void ParticleBatchHybrid::switchRender(float dt)
{
     bool usingBatch = ( _emitter->getBatchNode() != nullptr );
     _emitter->removeFromParentAndCleanup(false);

     auto newParent = (usingBatch ? _parent2  : _parent1 );
     newParent->addChild(_emitter);

     log("Particle: Using new parent: %s", usingBatch ? "CCNode" : "CCParticleBatchNode");
}

std::string ParticleBatchHybrid::title() const
{
    return "Particle Batch";
}

std::string ParticleBatchHybrid::subtitle() const
{
    return "Hybrid: batched and non batched every 2 seconds";
}

// ParticleBatchMultipleEmitters

void ParticleBatchMultipleEmitters::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    auto emitter1 = ParticleSystemQuad::create("Particles/LavaFlow.plist");
    emitter1->setStartColor(Color4F(1,0,0,1));
    auto emitter2 = ParticleSystemQuad::create("Particles/LavaFlow.plist");
    emitter2->setStartColor(Color4F(0,1,0,1));
    auto emitter3 = ParticleSystemQuad::create("Particles/LavaFlow.plist");
    emitter3->setStartColor(Color4F(0,0,1,1));

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

    emitter1->setPosition(Vec2( s.width/1.25f, s.height/1.25f));
    emitter2->setPosition(Vec2( s.width/2, s.height/2));
    emitter3->setPosition(Vec2( s.width/4, s.height/4));

    auto batch = ParticleBatchNode::createWithTexture(emitter1->getTexture());

    batch->addChild(emitter1, 0);
    batch->addChild(emitter2, 0);
    batch->addChild(emitter3, 0);

    addChild(batch, 10);
}

std::string ParticleBatchMultipleEmitters::title() const
{
    return "Particle Batch";
}

std::string ParticleBatchMultipleEmitters::subtitle() const
{
    return "Multiple emitters. One Batch";
}

// ParticleReorder

void ParticleReorder::onEnter()
{
    ParticleDemo::onEnter();

    _order = 0;
    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    auto ignore = ParticleSystemQuad::create("Particles/SmallSun.plist");
    auto parent1 = Node::create();
    auto parent2 = ParticleBatchNode::createWithTexture(ignore->getTexture());
    ignore->unscheduleUpdate();

    for( unsigned int i=0; i<2;i++)
    {
        auto parent = ( i==0 ? parent1 : parent2 );

        auto emitter1 = ParticleSystemQuad::create("Particles/SmallSun.plist");
        emitter1->setStartColor(Color4F(1,0,0,1));
        emitter1->setBlendAdditive(false);
        auto emitter2 = ParticleSystemQuad::create("Particles/SmallSun.plist");
        emitter2->setStartColor(Color4F(0,1,0,1));
        emitter2->setBlendAdditive(false);
        auto emitter3 = ParticleSystemQuad::create("Particles/SmallSun.plist");
        emitter3->setStartColor(Color4F(0,0,1,1));
        emitter3->setBlendAdditive(false);

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

        int neg = (i==0 ? 1 : -1 );

        emitter1->setPosition(Vec2( s.width/2-30,    s.height/2+60*neg));
        emitter2->setPosition(Vec2( s.width/2,        s.height/2+60*neg));
        emitter3->setPosition(Vec2( s.width/2+30,    s.height/2+60*neg));

        parent->addChild(emitter1, 0, 1);
        parent->addChild(emitter2, 0, 2);
        parent->addChild(emitter3, 0, 3);

        addChild(parent, 10, 1000+i);
    }

    schedule(CC_SCHEDULE_SELECTOR(ParticleReorder::reorderParticles), 1.0f);
}

std::string ParticleReorder::title() const
{
    return "Reordering particles";
}

std::string ParticleReorder::subtitle() const
{
    return "Reordering particles with and without batches batches";
}

void ParticleReorder::reorderParticles(float dt)
{
    for( int i=0; i<2;i++) {
        auto parent = getChildByTag(1000+i);

        auto child1 = parent->getChildByTag(1);
        auto child2 = parent->getChildByTag(2);
        auto child3 = parent->getChildByTag(3);

        if( _order % 3 == 0 ) {
            parent->reorderChild(child1, 1);
            parent->reorderChild(child2, 2);
            parent->reorderChild(child3, 3);

        } else if (_order % 3 == 1 ) {
            parent->reorderChild(child1, 3);
            parent->reorderChild(child2, 1);
            parent->reorderChild(child3, 2);

        } else if (_order % 3 == 2 ) {
            parent->reorderChild(child1, 2);
            parent->reorderChild(child2, 3);
            parent->reorderChild(child3, 1);
        }
    }

    _order++;
}

class RainbowEffect : public ParticleSystemQuad
{
public:
    bool init()override;
    virtual bool initWithTotalParticles(int numberOfParticles) override;
    virtual void update(float dt) override;
};

bool RainbowEffect::init()
{
    return initWithTotalParticles(150);
}

bool RainbowEffect::initWithTotalParticles(int numberOfParticles)
{
    if( ParticleSystemQuad::initWithTotalParticles(numberOfParticles) )
    {
        // additive
        setBlendAdditive(false);

        // duration
        setDuration(ParticleSystem::DURATION_INFINITY);

        // Gravity Mode
        setEmitterMode(ParticleSystem::Mode::GRAVITY);

        // Gravity Mode: gravity
        setGravity(Vec2(0,0));

        // Gravity mode: radial acceleration
        setRadialAccel(0);
        setRadialAccelVar(0);

        // Gravity mode: speed of particles
        setSpeed(120);
        setSpeedVar(0);


        // angle
        setAngle(180);
        setAngleVar(0);

        // emitter position
        auto winSize = Director::getInstance()->getWinSize();
        setPosition(Vec2(winSize.width/2, winSize.height/2));
        setPosVar(Vec2::ZERO);

        // life of particles
        setLife(0.5f);
        setLifeVar(0);

        // size, in pixels
        setStartSize(25.0f);
        setStartSizeVar(0);
        setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

        // emits per seconds
        setEmissionRate(getTotalParticles()/getLife());

        // color of particles
        setStartColor(Color4F(Color4B(50, 50, 50, 50)));
        setEndColor(Color4F(Color4B(0, 0, 0, 0)));

        _startColorVar.r = 0.0f;
        _startColorVar.g = 0.0f;
        _startColorVar.b = 0.0f;
        _startColorVar.a = 0.0f;
        _endColorVar.r = 0.0f;
        _endColorVar.g = 0.0f;
        _endColorVar.b = 0.0f;
        _endColorVar.a = 0.0f;

        setTexture(Director::getInstance()->getTextureCache()->addImage("Images/particles.png"));
        return true;
    }

    return false;
}

void RainbowEffect::update(float dt)
{
    _emitCounter = 0;
    ParticleSystemQuad::update(dt);
}


void Issue1201::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    RainbowEffect *particle = new (std::nothrow) RainbowEffect();
    particle->initWithTotalParticles(50);

    addChild(particle);

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

    particle->setPosition(Vec2(s.width/2, s.height/2));

    _emitter = particle;
}

std::string Issue1201::title() const
{
    return "Issue 1201. Unfinished";
}

std::string Issue1201::subtitle() const
{
    return "Unfinished test. Ignore it";
}

void MultipleParticleSystems::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    Director::getInstance()->getTextureCache()->addImage("Images/particles.png");

    for (int i = 0; i<5; i++) {
        auto particleSystem = ParticleSystemQuad::create("Particles/SpinningPeas.plist");

        particleSystem->setPosition(Vec2(i*50 ,i*50));

        particleSystem->setPositionType(ParticleSystem::PositionType::GROUPED);
        addChild(particleSystem);
    }

    _emitter = nullptr;

}

std::string MultipleParticleSystems::title() const
{
    return "Multiple particle systems";
}

std::string MultipleParticleSystems::subtitle() const
{
    return "v1.1 test: FPS should be lower than next test";
}

void MultipleParticleSystems::update(float dt)
{
    auto atlas = (LabelAtlas*) getChildByTag(kTagParticleCount);

    unsigned int count = 0; 
    
    for(const auto &child : _children) {
        auto item = dynamic_cast<ParticleSystem*>(child);
        if (item != nullptr)
        {
            count += item->getParticleCount();
        }
    }

    char str[100] = {0};
    sprintf(str, "%4d", count);
    atlas->setString(str);
}

// MultipleParticleSystemsBatched

void MultipleParticleSystemsBatched::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    ParticleBatchNode *batchNode = ParticleBatchNode::createWithTexture(nullptr, 3000);

    addChild(batchNode, 1, 2);

    for (int i = 0; i<5; i++) {

        auto particleSystem = ParticleSystemQuad::create("Particles/SpinningPeas.plist");

        particleSystem->setPositionType(ParticleSystem::PositionType::GROUPED);
        particleSystem->setPosition(Vec2(i*50 ,i*50));

        batchNode->setTexture(particleSystem->getTexture());
        batchNode->addChild(particleSystem);
    }

    _emitter = nullptr;
}

void MultipleParticleSystemsBatched::update(float dt)
{
    auto atlas = (LabelAtlas*) getChildByTag(kTagParticleCount);

    int count = 0;

    auto batchNode = getChildByTag(2);
    for(const auto &child : batchNode->getChildren()) {
        auto item = dynamic_cast<ParticleSystem*>(child);
        if (item != nullptr)
        {
            count += item->getParticleCount();
        }
    }

    char str[50] = {0};
    sprintf(str, "%4d", count);
    atlas->setString(str);
}

std::string MultipleParticleSystemsBatched::title() const
{
    return "Multiple particle systems batched";
}

std::string MultipleParticleSystemsBatched::subtitle() const
{
    return "v1.1 test: should perform better than previous test";
}

// AddAndDeleteParticleSystems

void AddAndDeleteParticleSystems::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

    //adds the texture inside the plist to the texture cache
    _batchNode = ParticleBatchNode::createWithTexture((Texture2D*)nullptr, 16000);

    addChild(_batchNode, 1, 2);

    for (int i = 0; i<6; i++) {

        auto particleSystem = ParticleSystemQuad::create("Particles/Spiral.plist");
        _batchNode->setTexture(particleSystem->getTexture());

        particleSystem->setPositionType(ParticleSystem::PositionType::GROUPED);
        particleSystem->setTotalParticles(200);

        particleSystem->setPosition(Vec2(i*15 +100,i*15+100));

        unsigned int randZ = rand() % 100;
        _batchNode->addChild(particleSystem, randZ, -1);

    }

    schedule(CC_SCHEDULE_SELECTOR(AddAndDeleteParticleSystems::removeSystem), 0.5f);
    _emitter = nullptr;

}

void AddAndDeleteParticleSystems::removeSystem(float dt)
{
    ssize_t nChildrenCount = _batchNode->getChildren().size();
    if (nChildrenCount > 0) 
    {
        CCLOG("remove random system");
        unsigned int uRand = rand() % (nChildrenCount - 1);
        _batchNode->removeChild(_batchNode->getChildren().at(uRand), true);

        auto particleSystem = ParticleSystemQuad::create("Particles/Spiral.plist");
        //add new

        particleSystem->setPositionType(ParticleSystem::PositionType::GROUPED);
        particleSystem->setTotalParticles(200);

        particleSystem->setPosition(Vec2(rand() % 300 ,rand() % 400));

        CCLOG("add a new system");
        unsigned int randZ = rand() % 100;
        _batchNode->addChild(particleSystem, randZ, -1);
    }
}

void AddAndDeleteParticleSystems::update(float dt)
{
    auto atlas = (LabelAtlas*) getChildByTag(kTagParticleCount);

    int count = 0;

    auto batchNode = getChildByTag(2);
    for(const auto &child : batchNode->getChildren()) {
        auto item = dynamic_cast<ParticleSystem*>(child);
        if (item != nullptr)
        {
            count += item->getParticleCount();
        }
    }

    char str[100] = {0};
    sprintf(str, "%4d", count);
    atlas->setString(str);
}

std::string AddAndDeleteParticleSystems::title() const
{
    return "Add and remove Particle System";
}

std::string AddAndDeleteParticleSystems::subtitle() const
{
    return "v1.1 test: every 2 sec 1 system disappear, 1 appears";
}

// ReorderParticleSystems

void ReorderParticleSystems::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background ,true);
    _background = nullptr;

    _batchNode = ParticleBatchNode::create("Images/stars-grayscale.png" ,3000);

    addChild(_batchNode, 1, 2);


    for (int i = 0; i<3; i++) {

        auto particleSystem = ParticleSystemQuad::createWithTotalParticles(200);
        particleSystem->retain();
        particleSystem->setTexture(_batchNode->getTexture());

        // duration
        particleSystem->setDuration(ParticleSystem::DURATION_INFINITY);

        // radius mode
        particleSystem->setEmitterMode(ParticleSystem::Mode::RADIUS);

        // radius mode: 100 pixels from center
        particleSystem->setStartRadius(100);
        particleSystem->setStartRadiusVar(0);
        particleSystem->setEndRadius(ParticleSystem::START_RADIUS_EQUAL_TO_END_RADIUS);
        particleSystem->setEndRadiusVar(0);    // not used when start == end

        // radius mode: degrees per second
        // 45 * 4 seconds of life = 180 degrees
        particleSystem->setRotatePerSecond(45);
        particleSystem->setRotatePerSecondVar(0);


        // angle
        particleSystem->setAngle(90);
        particleSystem->setAngleVar(0);

        // emitter position
        particleSystem->setPosVar(Vec2::ZERO);

        // life of particles
        particleSystem->setLife(4);
        particleSystem->setLifeVar(0);

        // spin of particles
        particleSystem->setStartSpin(0);
        particleSystem->setStartSpinVar(0);
        particleSystem->setEndSpin(0);
        particleSystem->setEndSpinVar(0);

        // color of particles
        float color[3] = {0,0,0};
        color[i] = 1;
        Color4F startColor(color[0], color[1], color[2], 1.0f);
        particleSystem->setStartColor(startColor);

        Color4F startColorVar(0, 0, 0, 0);
        particleSystem->setStartColorVar(startColorVar);

        Color4F endColor = startColor;
        particleSystem->setEndColor(endColor);

        Color4F endColorVar = startColorVar;
        particleSystem->setEndColorVar(endColorVar);

        // size, in pixels
        particleSystem->setStartSize(32);
        particleSystem->setStartSizeVar(0);
        particleSystem->setEndSize(ParticleSystem::START_SIZE_EQUAL_TO_END_SIZE);

        // emits per second
        particleSystem->setEmissionRate(particleSystem->getTotalParticles()/particleSystem->getLife());

        // additive

        particleSystem->setPosition(Vec2(i*10+120 ,200));


        _batchNode->addChild(particleSystem);
        particleSystem->setPositionType(ParticleSystem::PositionType::FREE);

        particleSystem->release();

        //[pBNode addChild:particleSystem z:10 tag:0);

    }

    schedule(CC_SCHEDULE_SELECTOR(ReorderParticleSystems::reorderSystem), 2.0f);
    _emitter = nullptr;

}

void ReorderParticleSystems::reorderSystem(float time)
{
    auto system = static_cast<ParticleSystem*>(_batchNode->getChildren().at(1));
    _batchNode->reorderChild(system, system->getLocalZOrder() - 1);     
}


void ReorderParticleSystems::update(float dt)
{
    auto atlas = static_cast<LabelAtlas*>(getChildByTag(kTagParticleCount));

    int count = 0;

    auto batchNode = getChildByTag(2);
    for(const auto &child : batchNode->getChildren()) {
        auto item = dynamic_cast<ParticleSystem*>(child);
        if (item != nullptr)
        {
            count += item->getParticleCount();
        }
    }
    char str[100] = {0};
    sprintf(str, "%4d", count);
    atlas->setString(str);
}

std::string ReorderParticleSystems::title() const
{
    return "reorder systems";
}

std::string ReorderParticleSystems::subtitle() const
{
    return "changes every 2 seconds";
}

// PremultipliedAlphaTest

std::string PremultipliedAlphaTest::title() const
{
    return "premultiplied alpha and readd child test";
}

std::string PremultipliedAlphaTest::subtitle() const
{
    return "no black halo, particles should fade out\n animation should be normal";
}

void PremultipliedAlphaTest::readdParticle(float delta)
{
    if (_hasEmitter)
    {
        _emitter->removeFromParent();
    }
    else
    {
        this->addChild(_emitter);
    }
    
    _hasEmitter = !_hasEmitter;
}

void PremultipliedAlphaTest::onEnter()
{
    ParticleDemo::onEnter();

	_color->setColor(Color3B::BLUE);
    this->removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::create("Particles/BoilingFoam.plist");
    _emitter->retain();
    // Particle Designer "normal" blend func causes black halo on premul textures (ignores multiplication)
    //this->emitter.blendFunc = (BlendFunc){ GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA };

    // Cocos2d "normal" blend func for premul causes alpha to be ignored (oversaturates colors)
    _emitter->setBlendFunc( BlendFunc::ALPHA_PREMULTIPLIED );

    CCASSERT(_emitter->isOpacityModifyRGB(), "Particle texture does not have premultiplied alpha, test is useless");

    // Toggle next line to see old behavior
    //	this->emitter.opacityModifyRGB = NO;

    _emitter->setStartColor(Color4F(1.0f, 1.0f, 1.0f, 1.0f));
    _emitter->setEndColor(Color4F(1.0f, 1.0f, 1.0f, 0.0f));
    _emitter->setStartColorVar(Color4F(0.0f, 0.0f, 0.0f, 0.0f));
    _emitter->setEndColorVar(Color4F(0.0f, 0.0f, 0.0f, 0.0f));

    this->addChild(_emitter, 10);
    _hasEmitter = true;
    
    schedule(CC_SCHEDULE_SELECTOR(PremultipliedAlphaTest::readdParticle), 1.0f);
}

// PremultipliedAlphaTest2

void PremultipliedAlphaTest2::onEnter()
{
    ParticleDemo::onEnter();

	_color->setColor(Color3B::BLACK);
    this->removeChild(_background, true);
    _background = nullptr;

    _emitter = ParticleSystemQuad::create("Particles/TestPremultipliedAlpha.plist");
    _emitter->retain();
    this->addChild(_emitter ,10);
}

std::string PremultipliedAlphaTest2::title() const
{
    return "premultiplied alpha 2";
}

std::string PremultipliedAlphaTest2::subtitle() const
{
    return "Arrows should be faded";
}


// Issue3990

void Issue3990::onEnter()
{
    ParticleDemo::onEnter();
    
	_color->setColor(Color3B::BLACK);
    this->removeChild(_background, true);
    _background = nullptr;
    
    _emitter = ParticleSystemQuad::create("Particles/Spiral.plist");
    
    _emitter->setPositionType(ParticleSystem::PositionType::GROUPED);
    _emitter->setTotalParticles(1000);
    _emitter->setEmissionRate(_emitter->getTotalParticles() / _emitter->getLife());
    _emitter->setPosition(VisibleRect::center());
    
    _emitter->retain();
    this->addChild(_emitter ,10);
}

std::string Issue3990::title() const
{
    return "Issue3990, setTotalParticle should work";
}

std::string Issue3990::subtitle() const
{
    return "Show '998' or '999' at bottom right side";
}


// ParticleVisibleTest
void ParticleVisibleTest::onEnter()
{
    ParticleDemo::onEnter();
    
    _emitter = ParticleFireworks::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);
    
    _emitter->setTexture( Director::getInstance()->getTextureCache()->addImage(s_stars1) );
    
    schedule(CC_SCHEDULE_SELECTOR(ParticleVisibleTest::callback), 1);
    
    setEmitterPosition();
}

std::string ParticleVisibleTest::title() const
{
    return "Issue4573";
}

std::string ParticleVisibleTest::subtitle() const
{
    return "Visible enable/disable";
}

void ParticleVisibleTest::callback(float delta)
{
    _emitter->setVisible(!_emitter->isVisible());
}

//
// ParticleAutoBatching
//
void ParticleAutoBatching::onEnter()
{
    ParticleDemo::onEnter();

	_color->setColor(Color3B::BLACK);
    this->removeChild(_background, true);
    _background = nullptr;

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

    for(int i=0; i<10; i++) {
        auto particle = ParticleSystemQuad::create("Particles/SmallSun.plist");
        particle->setTotalParticles(100);
        particle->setPosition(Vec2(i*s.width/11, s.height/2));
        this->addChild(particle ,10);
    }
}

std::string ParticleAutoBatching::title() const
{
    return "AutoBatching";
}

std::string ParticleAutoBatching::subtitle() const
{
    return "All 10 particles should be drawin in one batch";
}


//
// ParticleResetTotalParticles
//
void ParticleResetTotalParticles::onEnter()
{
    ParticleDemo::onEnter();
    
    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;
    
    auto p = ParticleFire::createWithTotalParticles(10);
    this->addChild(p);
    
    auto add = MenuItemFont::create("add 10 particles",
                                    [p](Ref*)->void
                                    {
                                        p->setTotalParticles(p->getTotalParticles() + 10 );
                                    });
    add->setFontSizeObj(20);
    add->setPosition(Vec2(0, 25));
    
    auto remove = MenuItemFont::create("remove 10 particles",
                                       [p](Ref*)->void
                                       {
                                           int count = p->getTotalParticles() - 10;
                                           if (count < 0) { count = 0; }
                                           p->setTotalParticles(count);
                                       });
    remove->setPosition(Vec2(0, -25));
    remove->setFontSizeObj(20);
    
    auto menu = Menu::create(add, remove, nullptr);
    menu->setPosition(Vec2(VisibleRect::center()));
    this->addChild(menu);
    
}

std::string ParticleResetTotalParticles::title() const
{
    return "reset total particles";
}

std::string ParticleResetTotalParticles::subtitle() const
{
    return "it should work as well";
}

void ParticleIssue12310::onEnter()
{
    ParticleDemo::onEnter();

    _color->setColor(Color3B::BLACK);
    removeChild(_background, true);
    _background = nullptr;

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

    auto particle = ParticleSystemQuad::create("Particles/BoilingFoam.plist");
    particle->setPosition(Vec2(winSize.width * 0.35f, winSize.height * 0.5f));
    addChild(particle);

    _emitter = particle;
    _emitter->retain();

    auto particle2 = ParticleSystemQuad::create("Particles/BoilingFoamStar.plist");
    particle2->setPosition(Vec2(winSize.width * 0.65f, winSize.height * 0.5f));
    addChild(particle2);
}

std::string ParticleIssue12310::subtitle() const
{
    return "You should see two Particle Emitters using different texture.";
}

//------------------------------------------------------------------
//
// ParticleSpriteFrame
//
//------------------------------------------------------------------
void ParticleSpriteFrame::onEnter()
{
    ParticleDemo::onEnter();

    _emitter = ParticleSmoke::create();
    _emitter->retain();
    _background->addChild(_emitter, 10);

    SpriteFrameCache::getInstance()->addSpriteFramesWithFile("Particles/SpriteFrame.plist");

    _emitter->setDisplayFrame( SpriteFrameCache::getInstance()->getSpriteFrameByName("dot.png") );

    setEmitterPosition();
}

std::string ParticleSpriteFrame::title() const
{
    return "Particle from SpriteFrame";
}

std::string ParticleSpriteFrame::subtitle() const
{
    return "Should not use entire texture atlas";
}