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]); } }
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; }