void CBox::SetBox(const Vector& xPos, float fSize, float fParticleMass, int iRigidity) { Allocate(4); SetRigidity(iRigidity); float fRad = fSize * (float) sqrt(2.0f) / 2.0f; float s = fSize / 2.0f; Vector Corners[4] = { Vector(-s, -s), Vector(s, -s), Vector(s, s), Vector(-s, s) }; Corners[0] += xPos; Corners[1] += xPos; Corners[2] += xPos; Corners[3] += xPos; //----------------------------------------------------------- // simple square box body Some masses will be set to < 0.0f, // marking the particle as unmovable. //----------------------------------------------------------- AddParticle(CParticle(Corners[0], fRad, fParticleMass)); AddParticle(CParticle(Corners[1], fRad, fParticleMass)); AddParticle(CParticle(Corners[2], fRad, fParticleMass)); AddParticle(CParticle(Corners[3], fRad, fParticleMass)); SetRigidBodyConstraints(); }
CMuzzleFlashParticleSystem::CMuzzleFlashParticleSystem(vec3_t vPosition, vec3_t vDirection, int iType) : CParticleSystem() { m_vPosition = vPosition; m_vDirection = vDirection; m_iStartingParticles = 1; m_flSystemMaxAge = 1; /* if (iType == MUZZ_AK) pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_AK)); else if (iType == MUZZ_DEAGLE) pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_DEAGLE)); else if (iType == MUZZ_M16) pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_M16)); else if (iType == MUZZ_M4A1) pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_M4A1)); else if (iType == MUZZ_M249) pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_M249)); else pParticleTexture = LoadTGA(NULL, const_cast<char*>(MUZZ_PARTICLE_GEN)); */ int n = StartingParticles(); for(int i = 0; i < n; i++) { CParticle *pParticle = new CMuzzleFlashParticle(m_vPosition, m_vDirection, pParticleTexture); AddParticle(pParticle); } }
//This is where little baby particles are made bool CFireworksParticleSystem::InitFrame() { static frames = 0; CParticle p; p.X = m_dDefaultOrigin; p.span = m_dDefaultSpan; p.lifepan = m_dDefaultLifespan; p.mass = m_dDefaultMass; p.persistance = m_dDefaultPersistance; p.alpha = m_dParticleAlpha; Point3d colorRand = Point3d(frand()-0.5, frand()-0.5, frand()-0.5) * m_dColorRandomness; p.color = m_pParticleColor;// + colorRand; p.color2 = m_pParticleColor2;// + colorRand; p.shape = m_particleShape; p.size = m_pParticleSize + Point3d(frand()-0.5, frand()-0.5, frand()-0.5) * m_dParticleSizeRand; p.type = 1+round(frand()*2); static Point3d az(2.0,2.0,2.0); if (frames == m_nParticlesPerFrame) { frames = 0; if (frand() < 0.7) { p.V = Point3d(0+frand()*M_PI/10, 0+frand()*M_PI/10, -1-frand()*M_PI/10); //9 degree freedom in every axis rotation p.V *= 20 + (frand()-0.5)*6; AddParticle(p); } } else frames++; return true; }
bool SnowParticle::Init() { //创建顶点数据 if (FAILED(m_device->CreateVertexBuffer(m_numSnow * sizeof(POINTVERTEX), D3DUSAGE_POINTS | D3DUSAGE_WRITEONLY, D3DFVF_POINTVERTEX, D3DPOOL_MANAGED, &m_vb, 0))) return false; //加载纹理 std::string resoursePath = Resourse::GetResoursePath(); IDirect3DTexture9 *tex = 0; for (std::vector<std::string>::iterator it = m_textureNames.begin(); it != m_textureNames.end(); it++) { if (FAILED(D3DXCreateTextureFromFile(m_device, Convert::str2Wstr(resoursePath + *it).c_str(), &tex))) return false; m_snowTextures.push_back(tex); } for (int i = 0; i < m_numSnow; i++) { AddParticle(); } return true; }
void FireParticleEmitter::UpdateParticles(float dt) { static float accumulatedTime = 0.0f; m_numAlive = 0; for (unsigned int i = 0; i < m_particles.size(); i++) { m_particles[i].Update(dt); // Count the number of alive particles if (m_particles[i].IsAlive()) m_numAlive++; } accumulatedTime += dt; // Check if there are no more alive particles -- if so, clear if (m_active && m_particles.size() > 0 && m_numAlive == 0) { Clear(); return; } // Add a particle every 100 ms, up to the total number of particles to be added if (accumulatedTime > 0.1f && m_particles.size() < (unsigned int) m_numTotalParticles) { AddParticle(); accumulatedTime -= 0.1f; } }
//------------------------------------------------------------------------ // Purpose : Update Particle System //------------------------------------------------------------------------ void ParticleSystem::Update(float dt) { m_fTime += dt; // Rebuild the dead & alive list m_DeadParticles.resize(0); m_AliveParticles.resize(0); // for each particle for (int i = 0 ; i <m_iMaxParticles ; i++) { // Check if particle is dead/alive? if ((m_fTime - m_Particles[i].initialTime) > m_Particles[i].lifeTime) { m_DeadParticles.push_back(&m_Particles[i]); } else { m_AliveParticles.push_back(&m_Particles[i]); } } // negative or zero value for m_fTimePerParticle indicates not to emit any particle if(m_fTimePerParticle > 0.0f) { // Emit particle static float accumTime = 0.0f; accumTime += dt; while (accumTime >= m_fTimePerParticle) { AddParticle(); accumTime -= m_fTimePerParticle; } } }
ParticleProcessor::ParticleProcessor() { _liveParticles = 0; _particleRadius = INITIAL_PARTICLE_RADIUS; _iterationCount = INITIAL_ITERATION_COUNT; _particleList.reserve(INITIAL_PARTICLE_COUNT); Vector2 resolution = utils::GetInputResolution(); int particleCount = INITIAL_PARTICLE_COUNT; int currentParticle = 0; Vector2 currentPos = Vector2(INITIAL_PARTICLE_RADIUS * 1.7, INITIAL_PARTICLE_RADIUS); while (currentParticle < particleCount) { currentPos.x += INITIAL_PARTICLE_RADIUS * 2; if (currentPos.x > resolution.x - INITIAL_PARTICLE_RADIUS) { currentPos.x = INITIAL_PARTICLE_RADIUS; currentPos.y += INITIAL_PARTICLE_RADIUS * 2; } Particle p(currentPos); p.radius = INITIAL_PARTICLE_RADIUS; AddParticle(p); currentParticle++; } _spatialHash = new ParticleSpatialHash(resolution.x, resolution.y, HASH_SIDE_SIZE); _spatialHash->Delegate(this); _timer = 0; _timerCounter = 0; _lastPrintTime = utils::GetTime(); }
void PARTICLE::ProbAddParticle(VERTEX pos, float probability) { float roll = randf(0,1); if (probability > roll) { AddParticle(pos); } }
void SkillAnimPanel::AddParticlesAroundPanel(vgui::Panel* pPanel) { if (!pPanel) return; // find the target panel's location relative to ours int mx, my; mx = my = 0; LocalToScreen(mx, my); int px, py; px = py = 0; pPanel->LocalToScreen(px, py); int x = px - mx; int y = py - my; x += asw_skill_particle_inset.GetInt(); y += asw_skill_particle_inset.GetInt(); int width = pPanel->GetWide() - (asw_skill_particle_inset.GetInt() * 2); int height = pPanel->GetTall() - (asw_skill_particle_inset.GetInt() * 2); const int particles_per_edge = asw_skill_particle_count.GetInt(); // future todo? could make this scale with wider panels float x_interval = float(width) / float(particles_per_edge); float y_interval = float(height) / float(particles_per_edge); float speed = asw_skill_particle_speed.GetFloat(); for (int i=0;i<particles_per_edge;i++) { float sidespeed = ((particles_per_edge * 0.5f) - i) / (particles_per_edge * 0.5) * speed; // top edge AddParticle(x + i * x_interval, y, -sidespeed, -speed); // bottom edge AddParticle(x + i * x_interval, y + height, -sidespeed, speed); // left edge AddParticle(x, y + i * y_interval, -speed, -sidespeed); // right edge AddParticle(x + width, y + i * y_interval, speed, -sidespeed); } }
//----------------------------------------------------------------------------- // Purpose: // Input : fTimeDelta - //----------------------------------------------------------------------------- void C_EntityParticleTrail::Update( float fTimeDelta ) { float tempDelta = fTimeDelta; studiohdr_t *pStudioHdr; mstudiohitboxset_t *set; matrix3x4_t *hitboxbones[MAXSTUDIOBONES]; C_BaseEntity *pMoveParent = GetMoveParent(); if ( !pMoveParent ) return; C_BaseAnimating *pAnimating = pMoveParent->GetBaseAnimating(); if (!pAnimating) goto trailNoHitboxes; if ( !pAnimating->HitboxToWorldTransforms( hitboxbones ) ) goto trailNoHitboxes; pStudioHdr = modelinfo->GetStudiomodel( pAnimating->GetModel() ); if (!pStudioHdr) goto trailNoHitboxes; set = pStudioHdr->pHitboxSet( pAnimating->GetHitboxSet() ); if ( !set ) goto trailNoHitboxes; //Add new particles while ( m_teParticleSpawn.NextEvent( tempDelta ) ) { int nHitbox = random->RandomInt( 0, set->numhitboxes - 1 ); mstudiobbox_t *pBox = set->pHitbox(nHitbox); AddParticle( tempDelta, pBox->bbmin, pBox->bbmax, *hitboxbones[pBox->bone] ); } return; trailNoHitboxes: while ( m_teParticleSpawn.NextEvent( tempDelta ) ) { AddParticle( tempDelta, pMoveParent->CollisionProp()->OBBMins(), pMoveParent->CollisionProp()->OBBMaxs(), pMoveParent->EntityToWorldTransform() ); } }
void ExplisonScreen::StartExp() { schedule(schedule_selector(ExplisonScreen::setBody),0.05); removeExplosion(); auto layer = UIController::getInstance()->getEffectsLayer(); EffectsManager::addParticle("particla/FullScreenExpl/FullScreenExpl.plist",layer, Vec2(m_WinSize.width*0.5,m_WinSize.height*0.5),true,m_duration); StartExpMusic(); AddParticle(); }
void ParticleSystem::AddTime(double time) { if(liveParticles > 0) { for(int i = 0;i < liveParticles;i++) { if(cpuData[i].currentLifeTime + time >= cpuData[i].lifeTime) { KillParticle(i); if(i == liveParticles) break; } ParticleCPUData & cdata = cpuData[i]; ParticleGPUData & gdata = gpuData[i]; cdata.currentLifeTime += time; float lifeTimeFactor = ((cdata.lifeTime - cdata.currentLifeTime) / cdata.lifeTime); if(useSizeOverLife) gdata.size = lifeTimeFactor* cdata.size; else gdata.size = cdata.size; Vector3 currentVelocity; if(useVelocityOverLife) currentVelocity = cdata.velocity * lifeTimeFactor; else currentVelocity = cdata.velocity; gdata.worldPos = gdata.worldPos + currentVelocity; if(useOpacityOverLife) gdata.opacityFactor = lifeTimeFactor; else gdata.opacityFactor = 1.0f; } } if(addParticles) if(currentSpawnTime + time >= spawnTime && liveParticles < maxParticles) { unsigned int spownCount = minSpawnParitcles + rand() % (maxSpawnParticles - minSpawnParitcles); if(liveParticles + spownCount > maxParticles) spownCount = maxParticles - liveParticles; for(unsigned int i = 0;i < spownCount;i++) { AddParticle(); } currentSpawnTime = 0; } else currentSpawnTime += time; }
void CreateSpurtParticles( void ) { SimpleParticle *pParticle; // PMaterialHandle hMaterial = GetPMaterial( "particle/particle_smokegrenade" ); Vector vecOrigin = m_vSortOrigin; IClientRenderable *pRenderable = ClientEntityList().GetClientRenderableFromHandle(m_hEntity); if ( pRenderable && m_nAttachmentIndex ) { QAngle tmp; pRenderable->GetAttachment( m_nAttachmentIndex, vecOrigin, tmp ); SetSortOrigin( vecOrigin ); } // Smoke int numParticles = RandomInt( 1,2 ); for ( int i = 0; i < numParticles; i++ ) { pParticle = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), g_Mat_DustPuff[0], vecOrigin ); if ( pParticle == NULL ) break; pParticle->m_flLifetime = 0.0f; pParticle->m_flDieTime = RandomFloat( 0.5, 1.0 ); // Random velocity around the angles forward Vector vecVelocity; vecVelocity.Random( -0.1f, 0.1f ); vecVelocity += m_vecSpurtForward; VectorNormalize( vecVelocity ); vecVelocity *= RandomFloat( 160.0f, 640.0f ); pParticle->m_vecVelocity = vecVelocity; // Randomize the color a little int color[3][2]; for( int i = 0; i < 3; ++i ) { color[i][0] = MAX( 0, m_SpurtColor[i] - 64 ); color[i][1] = MIN( 255, m_SpurtColor[i] + 64 ); } pParticle->m_uchColor[0] = random->RandomInt( color[0][0], color[0][1] ); pParticle->m_uchColor[1] = random->RandomInt( color[1][0], color[1][1] ); pParticle->m_uchColor[2] = random->RandomInt( color[2][0], color[2][1] ); pParticle->m_uchStartAlpha = m_SpurtColor[3]; pParticle->m_uchEndAlpha = 0; pParticle->m_uchStartSize = RandomInt( 50, 60 ); pParticle->m_uchEndSize = pParticle->m_uchStartSize*3; pParticle->m_flRoll = RandomFloat( 0, 360 ); pParticle->m_flRollDelta = RandomFloat( -4.0f, 4.0f ); } m_flLastParticleSpawnTime = gpGlobals->curtime + m_flSpawnRate; }
Snow::Snow(BoundingBox* pBox, int iNumParticles) { m_BBox = *pBox; m_Size = 0.25f; m_vbSize = 2048; m_vbOffset = 0; m_vbBatchSize = 512; for (int i = 0; i < iNumParticles;i++) { AddParticle(); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_SignalFlare::RestoreResources( void ) { if ( m_pParticle[0] == NULL ) { m_pParticle[0] = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), GetPMaterial( "effects/redflare" ), GetAbsOrigin() ); if ( m_pParticle[0] != NULL ) { m_pParticle[0]->m_uchColor[0] = m_pParticle[0]->m_uchColor[1] = m_pParticle[0]->m_uchColor[2] = 0; m_pParticle[0]->m_flRoll = random->RandomInt( 0, 360 ); m_pParticle[0]->m_flRollDelta = random->RandomFloat( 1.0f, 4.0f ); m_pParticle[0]->m_flLifetime = 0.0f; m_pParticle[0]->m_flDieTime = 10.0f; } else { assert(0); } } if ( m_pParticle[1] == NULL ) { m_pParticle[1] = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), GetPMaterial( "effects/yellowflare_noz" ), GetAbsOrigin() ); if ( m_pParticle[1] != NULL ) { m_pParticle[1]->m_uchColor[0] = m_pParticle[1]->m_uchColor[1] = m_pParticle[1]->m_uchColor[2] = 0; m_pParticle[1]->m_flRoll = random->RandomInt( 0, 360 ); m_pParticle[1]->m_flRollDelta = random->RandomFloat( 1.0f, 4.0f ); m_pParticle[1]->m_flLifetime = 0.0f; m_pParticle[1]->m_flDieTime = 10.0f; } else { assert(0); } } }
// updates the spark system and adds more particles after creation void CSparkParticleSystem::UpdateSystem( void ) { CParticleSystem::UpdateSystem(); m_flParticleCreationTime += TimeSinceLastDraw(); // creates the specified amount of new particles, //during the first few moments of this systems life while(m_flParticleCreationTime > 0 && m_flSystemsAge < SPARK_PARTICLE_CREATION_TIME) { CParticle *pParticle = new CSparkParticle(m_vPosition, m_vDirection, pParticleTexture); AddParticle(pParticle); m_flParticleCreationTime -= (A_SECOND / NewParticlesCreationDelay()); } }
void GameBase::Explode(GameObject *obj,GameColor color) { unsigned int i; GameParticle *gp; PlaySound(SOUND_EXPLODE); for(i=0;i<32;++i) { gp=AddParticle(obj->m_x,obj->m_y,Rand(0.0f,1.0f),Rand(2.0f,6.0f)); if(!gp) return; gp->m_color=color; } }
// creates a flintlock smoke particle system CFlintlockSmokeParticleSystem::CFlintlockSmokeParticleSystem(vec3_t vPosition) : CParticleSystem() { m_vPosition = vPosition; m_iStartingParticles = STARTING_FLINKLOCK_SMOKE_PARTICLES; m_flSystemMaxAge = FLINTLOCK_SMOKE_SYSTEM_LIFE; pParticleTexture = LoadTGA(NULL, const_cast<char*>(FLINTLOCK_SMOKE_PARTICLE)); int n = StartingParticles(); for(int i = 0; i < n; i++) { CParticle *pParticle = new CFlintParticle(vPosition, pParticleTexture); AddParticle(pParticle); } }
void ModuleParticles::OnCollision(Collider* c1, Collider* c2) { for (uint i = 0; i < MAX_ACTIVE_PARTICLES; ++i) { // Always destroy particles that collide if (active[i] != nullptr && active[i]->collider_box == c1) { if (active[i]->end_particle!=nullptr)AddParticle(*active[i]->end_particle, active[i]->position.x - 5, active[i]->position.y, COLLIDER_NONE, nullrect); active[i]->collider_box->to_delete = true; delete active[i]; active[i] = nullptr; break; } } }
//-------------------------------------------------------------------- AEvent::AEvent(const AEvent& aev) //-------------------------------------------------------------------- { AEventHeader(aev.GetEvtNum(),aev.GetTrueEventEnergy(),aev.GetRecEventEnergy()); // SetTrueEventEnergy(aev.GetTrueEventEnergy()); // SetRecEventEnergy(aev.GetRecEventEnergy()); // SetEvtNum(aev.GetEvtNum()); ClearEvent(); for (auto part : aev.GetParticles()) { AddParticle(part); } }
// creates a flintlock smoke particle system CBrownSmokeParticleSystem::CBrownSmokeParticleSystem(vec3_t vPosition, vec3_t vDirection) : CParticleSystem() { m_vPosition = vPosition; m_vDirection = vDirection; m_iStartingParticles = STARTING_BROWN_SMOKE_PARTICLES; m_flSystemMaxAge = BROWN_SMOKE_SYSTEM_LIFE; pParticleTexture = LoadTGA(NULL, const_cast<char*>(BROWN_SMOKE_PARTICLE)); int n = StartingParticles(); for(int i = 0; i < n; i++) { CParticle *pParticle = new CWhiteSmokeParticle(m_vPosition, m_vDirection, pParticleTexture); AddParticle(pParticle); } }
void FireParticleEmitter::Initialise(MVector3f fireStart, MVector3f fireDirection, int numTotalParticles, float width, float height) { // We're going to launch a set of particles along a ray that starts at smokeTrailStart and is directed along smokeTrailDirection m_start = fireStart; m_direction = fireDirection; m_direction.Normalize(); m_direction *= 2.0f; m_width = width; m_height = height; m_numTotalParticles = numTotalParticles; m_active = true; for(int i = 0; i <= numTotalParticles; i++){ AddParticle(); } }
// creates a spark particle system CSparkParticleSystem::CSparkParticleSystem(vec3_t vPosition, vec3_t vDirection) : CParticleSystem() { m_vPosition = vPosition; m_vDirection = vDirection; m_flNewParticles = NEW_SPARK_PARTICLES_SECOND; m_iStartingParticles = STARTING_SPARK_PARTICLES; m_flSystemMaxAge = SPARK_SYSTEM_LIFE; pParticleTexture = LoadTGA(NULL, const_cast<char*>(SPARK_PARTICLE)); int n = StartingParticles(); for(int i = 0; i < n; i++) { CParticle *pParticle = new CSparkParticle(m_vPosition, m_vDirection, pParticleTexture); AddParticle(pParticle); } }
/* * * @author Michael McQuarrie * @param _fDeltaTick * @return void */ void CFlagParticleEmitter::Process(float32 _fDeltaTick) { m_vec3Origin = m_pFlag->GetPosition(); if (m_dwVertexBufferSize > m_vecParticles.size()) { m_fSpawnTimer += _fDeltaTick; if (m_fSpawnTimer > m_fEmitRate) { m_fSpawnTimer = 0.0f; //Adding particles to the emitter AddParticle(); } } //Check if particles are still alive for(std::vector<TParticle>::iterator iter = m_vecParticles.begin(); iter != m_vecParticles.end(); ++iter) { if(iter->bAlive) { //Adding the velocity to move the particles iter->vec3Position += iter->vec3Velocity * _fDeltaTick * 5.0f; iter->colour.a = 1.0f - iter->fLifeTime; //Adding to the life counter iter->fLifeTime += _fDeltaTick; if(iter->fAge <= iter->fLifeTime) { m_fSpawnTimer += _fDeltaTick; if (m_fSpawnTimer >= m_fEmitRate) { m_fSpawnTimer = 0.0f; iter->fLifeTime = 0.0f; Resetparticle(&(*iter)); } } } } CTotalCubeDomination::GetInstance().GetRenderer()->AddToAllViewports(this, RENDERTYPE_3DCOORDS | RENDERTYPE_ALPHABLEND); //Lastly Remove the dead particles CheckAlive(); }
ECHARM_beam_H8_pencil::ECHARM_beam_H8_pencil(double angx_zero,double angx_sigma = 0.){ ECHARM_particle* proton = new ECHARM_particle(+1,cProtonMass); AddParticle(proton,1.); if(angx_sigma != 0.){ fDistrMomentumX = new ECHARM_distribution_box(angx_zero*400.*GeV,angx_sigma*400.*GeV); } else{ fDistrMomentumX = new ECHARM_distribution_const(angx_zero*400.*GeV); } fDistrMomentumY = new ECHARM_distribution_const(0.); fDistrMomentumZ = new ECHARM_distribution_const(400.*GeV); }
// updates a barrel smoke particle system void CBarrelSmokeParticleSystem::UpdateSystem( void ) { CParticleSystem::UpdateSystem(); m_flParticleCreationTime += TimeSinceLastDraw(); int i = 0; int n = NUM_DIFFERENT_BARREL_PARTICLES; // creates the specified amount of new particles, // during the first few moments of this systems life while(m_flParticleCreationTime > 0 && m_flSystemsAge < BARREL_SMOKE_PARTICLE_CREATION_TIME) { CParticle *pParticle = new CBarrelParticle(m_vPosition, m_vDirection, pParticleTextures[i % n]); AddParticle(pParticle); m_flParticleCreationTime -= (A_SECOND / NewParticlesCreationDelay()); } }
// creates a grass particle system CGrassParticleSystem::CGrassParticleSystem( char *sParticleDefinition, particle_system_management *pSysDetails) : CParticleSystem() { m_sParticleFile = sParticleDefinition; m_iID = pSysDetails->iID; // only do stuff on succesful if(LoadParticleDefinition(pSysDetails)) { m_flNewParticles = 0; // loop through all particle grass types adding them in for(unsigned int i = 0; i < m_cGrassTypes.size(); i++) { grass_particle_types *pGrassType = m_cGrassTypes[i]; pGrassType->pParticleTexture = LoadTGA(NULL, pGrassType->pSystem->sParticleTexture); pGrassType->pSystem->iId = m_iID; if(pGrassType->pParticleTexture == NULL) continue; // add all the starting particles we were asked to float flGrassPercentage = (CVAR_GET_FLOAT("cl_grassamount")/100); if (flGrassPercentage < 0) flGrassPercentage = 0; if (flGrassPercentage > 50) flGrassPercentage = 50; int iParticles = (int)(pGrassType->pSystem->iCount * flGrassPercentage); for(int j = 0; j < iParticles; j++) { // randomize this particle's position Vector vOrigin; vOrigin.x = gEngfuncs.pfnRandomFloat(pSysDetails->vAbsMin.x, pSysDetails->vAbsMax.x); vOrigin.y = gEngfuncs.pfnRandomFloat(pSysDetails->vAbsMin.y, pSysDetails->vAbsMax.y); vOrigin.z = gEngfuncs.pfnRandomFloat(pSysDetails->vAbsMin.z, pSysDetails->vAbsMax.z); pGrassType->pSystem->vPostion = vOrigin; pGrassType->pSystem->Yaw = gEngfuncs.pfnRandomFloat( 0.0, 360.0 ); AddParticle(new CGrassParticle(pGrassType->pSystem, pGrassType->pParticleTexture), pGrassType); } } } else { m_flSystemMaxAge = 0.01; } }
void CreateSpurtParticles( void ) { SimpleParticle *pParticle; PMaterialHandle hMaterial = GetPMaterial( "particle/particle_smokegrenade" ); // Smoke int numParticles = RandomInt( 1,2 ); for ( int i = 0; i < numParticles; i++ ) { pParticle = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), hMaterial, m_vSortOrigin ); if ( pParticle == NULL ) break; pParticle->m_flLifetime = 0.0f; pParticle->m_flDieTime = RandomFloat( 0.5, 1.0 ); // Random velocity around the angles forward Vector vecVelocity; vecVelocity.Random( -0.1f, 0.1f ); vecVelocity += m_vecSpurtForward; VectorNormalize( vecVelocity ); vecVelocity *= RandomFloat( 16.0f, 64.0f ); pParticle->m_vecVelocity = vecVelocity; // Randomize the color a little int color[3][2]; for( int i = 0; i < 3; ++i ) { color[i][0] = max( 0, m_SpurtColor[i] - 64 ); color[i][1] = min( 255, m_SpurtColor[i] + 64 ); } pParticle->m_uchColor[0] = random->RandomInt( color[0][0], color[0][1] ); pParticle->m_uchColor[1] = random->RandomInt( color[1][0], color[1][1] ); pParticle->m_uchColor[2] = random->RandomInt( color[2][0], color[2][1] ); pParticle->m_uchStartAlpha = m_SpurtColor[3]; pParticle->m_uchEndAlpha = 0; pParticle->m_uchStartSize = RandomInt( 1, 2 ); pParticle->m_uchEndSize = pParticle->m_uchStartSize*3; pParticle->m_flRoll = RandomFloat( 0, 360 ); pParticle->m_flRollDelta = RandomFloat( -4.0f, 4.0f ); } m_flLastParticleSpawnTime = gpGlobals->curtime + m_flSpawnRate; }
void ModuleParticles::OnCollision(Collider* c1, Collider* c2) { for (uint i = 0; i < MAX_ACTIVE_PARTICLES; ++i) { // Always destroy particles that collide if (active[i] != nullptr && active[i]->collider == c1) { AddParticle(bullet_collision, active[i]->position.x, active[i]->position.y); //AddParticle(explosion, active[i]->position.x, active[i]->position.y); if (App->player->player_collider == c2) App->player->Collision(); delete active[i]; active[i] = nullptr; break; } } }
// Always destroy particles that collide void ModuleParticles::OnCollision(Collider* c1, Collider* c2) { AddParticle(explosion, c1->rect.x, c1->rect.y); p2List_item<Particle*>* tmp = active.getFirst(); while(tmp != NULL) { if(tmp->data->collider == c1 ) { delete tmp->data; active.del(tmp); break; } tmp = tmp->next; } }