Exemple #1
0
bool Emitter::update( float timeStep )
{
	if ( emissionPolicy->shouldEmit( timeStep ) )
	{
		VALIDATE( emitParticle() );

		while ( emissionPolicy->shouldEmitAgain( timeStep ) )
		{
			VALIDATE( emitParticle() );
		}
	}

	core::List< emitter::Particle* >::Iterator particleIter = particles.begin();
	for ( ; particleIter != particles.end() ; )
	{
		if ( !( *particleIter )->update( timeStep ) )
		{
			particleIter = particles.erase( particleIter );
			particlePool.free( *particleIter );
		}
		else
		{
			++particleIter;
		}
	}

	return true;
}
	void ParticleEffect::update(float elapsedTime){
		if( enabled ){
			if( emitRate > 0.0f ){
				fxTimer += elapsedTime;
				int toAdd;
				if( particles.empty() ) toAdd = 1+(int)(emitRate*elapsedTime);
				else{ //Use the time that the last particle emitted has lived
					toAdd = (int)(fxTimer*emitRate);
					//instead of setting fxTimer to zero, leave the part of fxTimer that got rounded down
					//so that it is used for the next loop
					fxTimer -= ((float)toAdd)/emitRate;
				}
				for( int i = 0; i < toAdd; ++i ){
					emitParticle();
				}
			}
		}

		for( std::vector<Particle>::iterator part = particles.begin(); part != particles.end(); ){
			part->timeLeft -= elapsedTime;
			if( part->timeLeft <= 0.0f ){
				part = particles.erase(part);
				continue;
			}
			part->position += part->movement * elapsedTime;
			part->size += sizeSpeed * elapsedTime;

			++part;
		}
		return;
	}
void ParticleComponent::emitParticles(std::size_t particleAmount)
{
	for (std::size_t i = 0; i < particleAmount; ++i)
	{
		emitParticle();
	}
}
//erzeugt n Partikel zu Beginn
void ParticleExplosionNode2::emitParticles()
{
    for ( unsigned int i = 0; i < nParticles; ++i )
    {
        emitParticle(particles[i]);
    }

}
Exemple #5
0
void ParticleSystemEngine::emitParticle( float x,
                                         float y,
                                         float z,
                                         float sz,
                                         float angle,
                                         ParticleSystemDeclaration::Orign orign,
                                         Tempest::Color & color ) {
  emitParticle(raw, x, y, z, sz, angle, orign, color );
  }
GLuint CC3ParticleEmitter::emitParticles( GLuint count )
{
	GLuint emitCount = 0;
	for ( GLuint i = 0; i < count; i++ ) 
	{
		if ( emitParticle() ) 
			emitCount++;
	}

	return emitCount;
}
/**
 * Template method that checks if its time to emit a particle,
 * and if so, invokes the emitParticle method to emit the particle.
 */
void CC3ParticleEmitter::checkEmission( GLfloat dt )
{
	if ( !m_isEmitting ) 
		return;

	m_timeSinceEmission += dt;
	while ( !isFull() && (m_timeSinceEmission >= m_emissionInterval) ) 
	{
		m_timeSinceEmission -= m_emissionInterval;
		emitParticle();
	}
}
void ParticleExplosionNode2::updateParticles(float deltaTime){

    for ( unsigned int i = 0; i < particles.size(); ++i )
       {
           Particle& particle = particles[i];

           particle.time += deltaTime;
           if ( particle.time > particle.lifeTime)
           {
                   emitParticle(particle);
           }

           float lifeRatio = particle.time/ particle.lifeTime;
           particle.velocity+= ( force * 0.01);
           particle.pos += ( particle.velocity * 0.1);
           particle.alpha=  lifeRatio ;
           particle.rotate= lerp(0.0f, 720.0f, lifeRatio );
           particle.size = lerp( 1.0f, 0.0f, lifeRatio );
       }

       buildVertexBuffer();
}
CC3Particle* CC3ParticleEmitter::emitParticle()
{
	CC3Particle* particle = acquireParticle();
	return emitParticle( particle ) ? particle : NULL;
}
void QSGCustomEmitter::emitWindow(int timeStamp)
{
    if (m_system == 0)
        return;
    if ((!m_emitting || !m_particlesPerSecond)&& !m_burstLeft && m_burstQueue.isEmpty()){
        m_reset_last = true;
        return;
    }

    if (m_reset_last) {
        m_last_emitter = m_last_last_emitter = QPointF(x(), y());
        m_last_timestamp = timeStamp/1000.;
        m_last_emission = m_last_timestamp;
        m_reset_last = false;
    }

    if (m_burstLeft){
        m_burstLeft -= timeStamp - m_last_timestamp * 1000.;
        if (m_burstLeft < 0){
            if (!m_emitting)
                timeStamp += m_burstLeft;
            m_burstLeft = 0;
        }
    }

    qreal time = timeStamp / 1000.;

    qreal particleRatio = 1. / m_particlesPerSecond;
    qreal pt = m_last_emission;

    qreal opt = pt; // original particle time
    qreal dt = time - m_last_timestamp; // timestamp delta...
    if (!dt)
        dt = 0.000001;

    // emitter difference since last...
    qreal dex = (x() - m_last_emitter.x());
    qreal dey = (y() - m_last_emitter.y());

    qreal sizeAtEnd = m_particleEndSize >= 0 ? m_particleEndSize : m_particleSize;
    qreal emitter_x_offset = m_last_emitter.x() - x();
    qreal emitter_y_offset = m_last_emitter.y() - y();
    if (!m_burstQueue.isEmpty() && !m_burstLeft && !m_emitting)//'outside time' emissions only
        pt = time;
    while (pt < time || !m_burstQueue.isEmpty()) {
        //int pos = m_last_particle % m_particle_count;
        QSGParticleData* datum = m_system->newDatum(m_system->m_groupIds[m_particle]);
        if (datum){//actually emit(otherwise we've been asked to skip this one)
            datum->e = this;//###useful?
            qreal t = 1 - (pt - opt) / dt;


            // Particle timestamp
            datum->t = pt;
            datum->lifeSpan = //TODO:Promote to base class?
                    (m_particleDuration
                     + ((rand() % ((m_particleDurationVariation*2) + 1)) - m_particleDurationVariation))
                    / 1000.0;

            // Particle position
            QRectF boundsRect;
            if (!m_burstQueue.isEmpty()){
                boundsRect = QRectF(m_burstQueue.first().second.x() - x(), m_burstQueue.first().second.y() - y(),
                        width(), height());
            } else {
                boundsRect = QRectF(emitter_x_offset + dex * (pt - opt) / dt, emitter_y_offset + dey * (pt - opt) / dt
                              , width(), height());
            }
            QPointF newPos = effectiveExtruder()->extrude(boundsRect);
            datum->x = newPos.x();
            datum->y = newPos.y();

            // Particle speed
            const QPointF &speed = m_speed->sample(newPos);
            datum->vx = speed.x();
            datum->vy = speed.y();

            // Particle acceleration
            const QPointF &accel = m_acceleration->sample(newPos);
            datum->ax = accel.x();
            datum->ay = accel.y();

            // Particle size
            float sizeVariation = -m_particleSizeVariation
                    + rand() / float(RAND_MAX) * m_particleSizeVariation * 2;

            float size = qMax((qreal)0.0 , m_particleSize + sizeVariation);
            float endSize = qMax((qreal)0.0 , sizeAtEnd + sizeVariation);

            datum->size = size;
            datum->endSize = endSize;

            emitParticle(datum->v8Value());//A chance for arbitrary JS changes

            m_system->emitParticle(datum);
        }
        if (m_burstQueue.isEmpty()){
            pt += particleRatio;
        }else{
            m_burstQueue.first().first--;
            if (m_burstQueue.first().first <= 0)
                m_burstQueue.pop_front();
        }
    }
    m_last_emission = pt;

    m_last_last_last_emitter = m_last_last_emitter;
    m_last_last_emitter = m_last_emitter;
    m_last_emitter = QPointF(x(), y());
    m_last_timestamp = time;
}