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