C++ CCParticleSystem::getTotalParticles方法代码示例

// override removeChild:
void  CCParticleBatchNode::removeChild(CCNode* child, bool cleanup)
{
    // explicit nil handling
    if (child == NULL)
    {
        return;
    }
    
    CCAssert( dynamic_cast<CCParticleSystem*>(child) != NULL, "CCParticleBatchNode only supports CCQuadParticleSystems as children");
    CCAssert(m_pChildren->containsObject(child), "CCParticleBatchNode doesn't contain the sprite. Can't remove it");

    CCParticleSystem* pChild = (CCParticleSystem*)child;
    CCNode::removeChild(pChild, cleanup);

    // remove child helper
    m_pTextureAtlas->removeQuadsAtIndex(pChild->getAtlasIndex(), pChild->getTotalParticles());

    // after memmove of data, empty the quads at the end of array
    m_pTextureAtlas->fillWithEmptyQuadsFromIndex(m_pTextureAtlas->getTotalQuads(), pChild->getTotalParticles());

    // particle could be reused for self rendering
    pChild->setBatchNode(NULL);

    updateAllAtlasIndexes();
}

void ParticlePerformTest4::doTest()
{
    CCSize s = CCDirector::sharedDirector()->getWinSize();
    CCParticleSystem *particleSystem = (CCParticleSystem*) getChildByTag(kTagParticleSystem);

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

    // gravity
    particleSystem->setGravity(ccp(0,-90));

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

    // radial
    particleSystem->setRadialAccel(0);
    particleSystem->setRadialAccelVar(0);

    // speed of particles
    particleSystem->setSpeed(180);
    particleSystem->setSpeedVar(50);

    // emitter position
    particleSystem->setPosition(ccp(s.width/2, 100));
    particleSystem->setPosVar(ccp(s.width/2,0));

    // life of particles
    particleSystem->setLife(2.0f);
    particleSystem->setLifeVar(1);

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

    // color of particles
    ccColor4F startColor = {0.5f, 0.5f, 0.5f, 1.0f};
    particleSystem->setStartColor(startColor);

    ccColor4F startColorVar = {0.5f, 0.5f, 0.5f, 1.0f};
    particleSystem->setStartColorVar(startColorVar);

    ccColor4F endColor = {0.1f, 0.1f, 0.1f, 0.2f};
    particleSystem->setEndColor(endColor);

    ccColor4F endColorVar = {0.1f, 0.1f, 0.1f, 0.2f};    
    particleSystem->setEndColorVar(endColorVar);

    // size, in pixels
    particleSystem->setEndSize(64.0f);
    particleSystem->setStartSize(64.0f);
    particleSystem->setEndSizeVar(0);
    particleSystem->setStartSizeVar(0);

    // additive
    particleSystem->setBlendAdditive(false);

}

// Reorder will be done in this function, no "lazy" reorder to particles
void CCParticleBatchNode::reorderChild(CCNode * child, int zOrder)
{

    CCAssert( child != NULL, "Child must be non-NULL");
    CCAssert( dynamic_cast<CCParticleSystem*>(child) != NULL, "CCParticleBatchNode only supports CCQuadParticleSystems as children");
    CCAssert( m_pChildren->containsObject(child), "Child doesn't belong to batch" );

    CCParticleSystem* pChild = (CCParticleSystem*)(child);

    if( zOrder == child->getZOrder() )
    {
        return;
    }

    // no reordering if only 1 child
    if( m_pChildren->count() > 1)
    {
        unsigned int newIndex = 0, oldIndex = 0;

        getCurrentIndex(&oldIndex, &newIndex, pChild, zOrder);

        if( oldIndex != newIndex )
        {

            // reorder m_pChildren->array
            pChild->retain();
            m_pChildren->removeObjectAtIndex(oldIndex);
            m_pChildren->insertObject(pChild, newIndex);
            pChild->release();

            // save old altasIndex
            unsigned int oldAtlasIndex = pChild->getAtlasIndex();

            // update atlas index
            updateAllAtlasIndexes();

            // Find new AtlasIndex
            unsigned int newAtlasIndex = 0;
            for( unsigned int i=0; i < m_pChildren->count(); i++)
            {
                CCParticleSystem* pNode = (CCParticleSystem*)m_pChildren->objectAtIndex(i);
                if( pNode == pChild )
                {
                    newAtlasIndex = pChild->getAtlasIndex();
                    break;
                }
            }

            // reorder textureAtlas quads
            m_pTextureAtlas->moveQuadsFromIndex(oldAtlasIndex, pChild->getTotalParticles(), newAtlasIndex);

            pChild->updateWithNoTime();
        }
    }

    pChild->setZOrder(zOrder);
}

//rebuild atlas indexes
void CCParticleBatchNode::updateAllAtlasIndexes()
{
    CCObject *pObj = NULL;
    unsigned int index = 0;

    CCARRAY_FOREACH(m_pChildren,pObj)
    {
        CCParticleSystem* child = (CCParticleSystem*)pObj;
        child->setAtlasIndex(index);
        index += child->getTotalParticles();
    }

void CCParticleBatchNode::addChild(CCNode * child, int zOrder, int tag)
{
    CCAssert( child != NULL, "Argument must be non-NULL");
    CCAssert( dynamic_cast<CCParticleSystem*>(child) != NULL, "CCParticleBatchNode only supports CCQuadParticleSystems as children");
    CCParticleSystem* pChild = (CCParticleSystem*)child;
    CCAssert( pChild->getTexture()->getName() == m_pTextureAtlas->getTexture()->getName(), "CCParticleSystem is not using the same texture id");
    // If this is the 1st children, then copy blending function
    if( m_pChildren->count() == 0 ) 
    {
        setBlendFunc(pChild->getBlendFunc());
    }

    CCAssert( m_tBlendFunc.src  == pChild->getBlendFunc().src && m_tBlendFunc.dst  == pChild->getBlendFunc().dst, "Can't add a PaticleSystem that uses a different blending function");

    //no lazy sorting, so don't call super addChild, call helper instead
    unsigned int pos = addChildHelper(pChild,zOrder,tag);

    //get new atlasIndex
    unsigned int atlasIndex = 0;

    if (pos != 0) 
    {
        CCParticleSystem* p = (CCParticleSystem*)m_pChildren->objectAtIndex(pos-1);
        atlasIndex = p->getAtlasIndex() + p->getTotalParticles();

    }
    else
    {
        atlasIndex = 0;
    }

    insertChild(pChild, atlasIndex);

    // update quad info
    pChild->setBatchNode(this);
}

void TestParticle::initSnow()
{
	CCParticleSystem *emitter = CCParticleSnow::create();
	emitter->retain();
	addChild(emitter, 10);

	CCPoint p = emitter->getPosition();
	emitter->setPosition( ccp( p.x, p.y-110) );
	emitter->setLife(3);
	emitter->setLifeVar(1);

	// gravity
	emitter->setGravity(ccp(0,-10));

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


	ccColor4F startColor = emitter->getStartColor();
	startColor.r = 0.9f;
	startColor.g = 0.9f;
	startColor.b = 0.9f;
	emitter->setStartColor(startColor);

	ccColor4F startColorVar = emitter->getStartColorVar();
	startColorVar.b = 0.1f;
	emitter->setStartColorVar(startColorVar);

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

	emitter->setTexture( CCTextureCache::sharedTextureCache()->addImage("snow.png"));

	emitter->setPosition(ccp(0,480));
	emitter->release();
}

void TestParticle::initRotFlower()
{
	CCParticleSystem *emitter = new CCParticleSystemQuad();
	emitter->initWithTotalParticles(300);
	//emitter->autorelease();
	addChild(emitter);
	////emitter->release();    // win32 : Remove this line
	emitter->setTexture( CCTextureCache::sharedTextureCache()->addImage("stars2.png"));

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

	// gravity
	emitter->setGravity(CCPointZero);

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

	emitter->setSpeed(160);
	emitter->setSpeedVar(20);

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

	// tagential
	emitter->setTangentialAccel(30);
	emitter->setTangentialAccelVar(0);

	// emitter position
	emitter->setPosition( ccp(160,240) );
	emitter->setPosVar(CCPointZero);

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

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

	ccColor4F startColor = {0.5f, 0.5f, 0.5f, 1.0f};
	emitter->setStartColor(startColor);

	ccColor4F startColorVar = {0.5f, 0.5f, 0.5f, 1.0f};
	emitter->setStartColorVar(startColorVar);

	ccColor4F endColor = {0.1f, 0.1f, 0.1f, 0.2f};
	emitter->setEndColor(endColor);

	ccColor4F 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(kParticleStartSizeEqualToEndSize);

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

	// additive
	emitter->setBlendAdditive(false);

	emitter->setPosition(ccp(size.width/6*5,size.height-250));
	emitter->release();

}