void EntityManager::MakeExplosion(glm::vec3 pos, int num, float mag, glm::vec3 vel) {
AudioInstance->playSound(Resources::get().explosionSound);
for (int i = 0; i < num; ++i) {
SpawnParticle(SPARK, pos, vel, mag * 5.0f);
SpawnParticle(FIRE, pos, vel, mag * 4.0f);
}
}
void ABaseWeapon::Instant_Fire()
{
const int32 RandomSeed = FMath::Rand();
FRandomStream WeaponRandomStream(RandomSeed);
const float CurrentSpread = WeaponConfig.WeaponSpread;
const float SpreadCone = FMath::DegreesToRadians(WeaponConfig.WeaponSpread * 0.5);
const FVector AimDir = MyPawn->GetActorForwardVector();
const FVector StartTrace = MyPawn->GetActorLocation();
const FVector ShootDir = WeaponRandomStream.VRandCone(AimDir, SpreadCone, SpreadCone);
FVector EndTrace;
if (Target)
{
FVector TargetDir = (MyPawn->GetActorLocation() - Target->GetActorLocation());
TargetDir.Normalize();
FVector ShootDir2 = WeaponRandomStream.VRandCone(-TargetDir, SpreadCone, SpreadCone);
EndTrace = StartTrace + ShootDir2 * WeaponConfig.WeaponRange;
}
else
{
EndTrace = StartTrace + ShootDir * WeaponConfig.WeaponRange;
}
const FHitResult Impact = WeaponTrace(StartTrace, EndTrace);
SpawnParticle(EndTrace);
HitActor = Cast<AActor>(Impact.GetActor());
//DrawDebugLine(GetWorld(), StartTrace, EndTrace, FColor::Red, false, 1.0f);
if (HitActor)
{
Server_DealDamage(Impact, ShootDir, WeaponConfig);
}
}
void ALivingBomb::Explode()
{
ClientDestroyTerrain(GetActorLocation(), 7.0f);
TArray<AActor*> overlap;
GetOverlappingActors(overlap);
for (AActor* actor : overlap)
{
ATotemCharacter* shaman = Cast<ATotemCharacter>(actor);
if (shaman)
{
if (shaman->GetController() != GetOwner())
{
ATotemPlayerController* own = Cast<ATotemPlayerController>(GetOwner());
if (own)
{
shaman->ReduceHealth(ExplosionDamage, own, AbilityType::FIRE, FName("LivingBomb"));
}
}
}
ABaseTotem* BaseTotem = Cast<ABaseTotem>(actor);
if (BaseTotem && !BaseTotem->IsPendingKill())
{
ATotemPlayerController* TotemPlayerController = Cast<ATotemPlayerController>(GetOwner());
if (TotemPlayerController)
{
BaseTotem->ReduceHealth(ExplosionDamage, TotemPlayerController);
}
}
}
SpawnParticle();
}
// Updates the emitter
// Changes its position, emits new particles
void Update(ExampleClock& clock)
{
assert(positions.size() == directions.size());
assert(positions.size() == ages.size());
assert(positions.size() == ids.size());
double time_diff = clock.Interval().Seconds();
double drag = 0.1 * time_diff;
if(drag > 1.0) drag = 1.0;
// go through the existing particles
for(std::size_t i=0, n=positions.size(); i!=n; ++i)
{
// update the age
ages[i] += time_diff / lifetime;
// if the particle is "too old"
if(ages[i] > 1.0)
{
// try to spawn a new one in its place
SpawnParticle(
clock.Now().Seconds(),
positions[i],
directions[i],
ages[i],
ids[i]
);
}
else
{
// otherwise just update its motion
directions[i] *= (1.0 - drag);
positions[i] += directions[i] * time_diff;
}
}
Vec3f position;
Vec3f direction;
float age;
int id;
// spawn new particles if necessary
while(SpawnParticle(clock.Now().Seconds(), position, direction, age, id))
{
positions.push_back(position);
directions.push_back(direction);
ages.push_back(age);
ids.push_back(id);
}
}
void SpawnerParticle::Update(float frametime) {
DoPhysics(frametime);
if (lifetime > fuseTime && particles == NULL) {
Explode();
}
else if (particles != NULL) {
if (particles->Count() < maxParticles && lifetime < (maxLifetime - 2.0f))
SpawnParticle();
particles->Update(frametime);
}
}
void ParticleSystem::Update( float dt, Vec3 pos )
{
camPos = pos;
numDead = 0;
if (particles.size() && running)
{
for (std::list<Particle>::iterator i = particles.begin(); i != particles.end(); i++)
{
if (initLife <= 0.0 || i->lifespan > 0.0f)
UpdateParticle(dt, &*i);
else if (initRespawn <= 0.0f || i->numlives > 0)
SpawnParticle(&*i);
else
{
numDead++;
}
}
}
}
/*!****************************************************************************
@Function RenderScene
@Return bool true if no error occured
@Description Main rendering loop function of the program. The shell will
call this function every frame.
eglSwapBuffers() will be performed by PVRShell automatically.
PVRShell will also manage important OS events.
Will also manage relevent OS events. The user has access to
these events through an abstraction layer provided by PVRShell.
******************************************************************************/
bool OGLESParticles::RenderScene()
{
int i;
PVRTMat4 mRotY;
// Clear colour and depth buffers
myglClearColor(f2vt(0.0f), f2vt(0.0f), f2vt(0.0f), f2vt(1.0f));
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Enables depth testing
glEnable(GL_DEPTH_TEST);
// Modify per-frame variables controlling the particle mouvements.
float fSpeedCtrl = (float) (PVRTFSIN(m_fRot*0.01f)+1.0f)/2.0f;
float fStopNo = 0.8f;
float fStep = 0.1f;
if(fSpeedCtrl > fStopNo)
fStep = 0.0f;
// Generate particles as needed.
if((m_i32NumParticles < (int) g_ui32MaxParticles) && (fSpeedCtrl <= fStopNo))
{
int num_to_gen = (int) (RandPositiveFloat()*(g_ui32MaxParticles/100.0));
if(num_to_gen == 0)
num_to_gen = 1;
for(i = 0; (i < num_to_gen) && (m_i32NumParticles < (int) g_ui32MaxParticles); ++i)
SpawnParticle(&m_Particles[m_i32NumParticles++]);
}
// Build rotation matrix around axis Y.
mRotY = PVRTMat4::RotationY(f2vt((m_fRot2*PVRT_PIf)/180.0f));
for(i = 0; i < m_i32NumParticles; ++i)
{
// Transform particle with rotation matrix
m_sParticleVTXPSBuf[i].x = VERTTYPEMUL(mRotY.f[ 0], m_Particles[i].m_fPosition.x) +
VERTTYPEMUL(mRotY.f[ 4], m_Particles[i].m_fPosition.y) +
VERTTYPEMUL(mRotY.f[ 8], m_Particles[i].m_fPosition.z) +
mRotY.f[12];
m_sParticleVTXPSBuf[i].y = VERTTYPEMUL(mRotY.f[ 1], m_Particles[i].m_fPosition.x) +
VERTTYPEMUL(mRotY.f[ 5], m_Particles[i].m_fPosition.y) +
VERTTYPEMUL(mRotY.f[ 9], m_Particles[i].m_fPosition.z) +
mRotY.f[13];
m_sParticleVTXPSBuf[i].z = VERTTYPEMUL(mRotY.f[ 2], m_Particles[i].m_fPosition.x) +
VERTTYPEMUL(mRotY.f[ 6], m_Particles[i].m_fPosition.y) +
VERTTYPEMUL(mRotY.f[10], m_Particles[i].m_fPosition.z) +
mRotY.f[14];
m_sParticleVTXPSBuf[i].fSize = m_Particles[i].m_fSize;
m_sNormalColour[i].r = vt2b(m_Particles[i].m_fColour.x);
m_sNormalColour[i].g = vt2b(m_Particles[i].m_fColour.y);
m_sNormalColour[i].b = vt2b(m_Particles[i].m_fColour.z);
m_sNormalColour[i].a = (unsigned char)255;
m_sReflectColour[i].r = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.x, g_fFactor));
m_sReflectColour[i].g = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.y, g_fFactor));
m_sReflectColour[i].b = vt2b(VERTTYPEMUL(m_Particles[i].m_fColour.z, g_fFactor));
m_sReflectColour[i].a = (unsigned char)255;
}
glBindBuffer(GL_ARRAY_BUFFER, m_i32VertVboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(SVtxPointSprite)*m_i32NumParticles, m_sParticleVTXPSBuf,GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, m_i32ColAVboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(SColors)*m_i32NumParticles, m_sNormalColour,GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, m_i32ColBVboID);
glBufferData(GL_ARRAY_BUFFER, sizeof(SColors)*m_i32NumParticles, m_sReflectColour,GL_DYNAMIC_DRAW);
// clean up render states
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
// Draw floor.
// Save modelview matrix
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
myglRotate(f2vt(-m_fRot), f2vt(0.0f), f2vt(1.0f), f2vt(0.0f));
// setup render states
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
// Set texture and texture environment
glBindTexture(GL_TEXTURE_2D, m_ui32FloorTexName);
glBlendFunc(GL_ONE, GL_ONE);
// Render floor
RenderFloor();
// clean up render states
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
glPopMatrix();
// Render particles reflections.
// set up render states
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
myglTexEnv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_2D, m_ui32TexName);
// Set model view matrix
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
myglScale(f2vt(1.0f), f2vt(-1.0f), f2vt(1.0f));
myglTranslate(f2vt(0.0f), f2vt(0.01f), f2vt(0.0f));
glEnable(GL_POINT_SPRITE_OES);
if(((int)(m_i32NumParticles * 0.5f)) > 0)
RenderParticle(((int)(m_i32NumParticles*0.5f)),true);
glPopMatrix();
// Render particles.
// Sets the model view matrix
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
if(m_i32NumParticles > 0)
RenderParticle(m_i32NumParticles,false);
glPopMatrix();
glDisable(GL_POINT_SPRITE_OES);
PVRTVec3 Force = PVRTVec3(f2vt(0.0f), f2vt(0.0f), f2vt(0.0f));
Force.x = f2vt(1000.0f*(float)PVRTFSIN(m_fRot*0.01f));
for(i = 0; i < m_i32NumParticles; ++i)
{
/*
Move the particle.
If the particle exceeds its lifetime, create a new one in its place.
*/
if(m_Particles[i].Step(f2vt(fStep), Force))
SpawnParticle(&m_Particles[i]);
}
// clean up render states
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
// Increase rotation angles
m_fRot += 1;
m_fRot2 = m_fRot + 36;
// Unbinds the vertex buffer if we are using OpenGL ES 1.1
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Display info text.
m_Print3D.DisplayDefaultTitle("Particles", "Using point sprites", ePVRTPrint3DSDKLogo);
m_Print3D.Flush();
return true;
}
void CSystemInstance::Simulate()
{
double flGameTime = GameServer()->GetGameTime();
double flFrameTime = GameServer()->GetFrameTime();
if (m_hFollow != NULL)
{
m_vecOrigin = m_hFollow->BaseGetRenderOrigin();
m_vecInheritedVelocity = m_hFollow->GetGlobalVelocity();
}
for (size_t i = 0; i < m_aParticles.size(); i++)
{
CParticle* pParticle = &m_aParticles[i];
if (!pParticle->m_bActive)
continue;
float flLifeTime = (float)(flGameTime - pParticle->m_flSpawnTime);
if (flLifeTime > m_pSystem->GetLifeTime())
{
pParticle->m_bActive = false;
m_iNumParticlesAlive--;
continue;
}
pParticle->m_vecOrigin += pParticle->m_vecVelocity * (float)flFrameTime;
pParticle->m_vecVelocity += m_pSystem->GetGravity() * (float)flFrameTime;
pParticle->m_vecVelocity *= (1-((1-m_pSystem->GetDrag()) * (float)flFrameTime));
if (m_pSystem->GetRandomAngleVelocity())
pParticle->m_angAngles = (pParticle->m_angAngles + pParticle->m_angAngleVelocity*(float)GameServer()->GetFrameTime());
float flLifeTimeRamp = flLifeTime / m_pSystem->GetLifeTime();
float flFadeIn = 1;
float flFadeOut = 1;
if (flLifeTimeRamp < m_pSystem->GetFadeIn())
flFadeIn = RemapVal(flLifeTimeRamp, 0, m_pSystem->GetFadeIn(), 0, 1);
if (flLifeTimeRamp > 1-m_pSystem->GetFadeOut())
flFadeOut = RemapVal(flLifeTimeRamp, 1-m_pSystem->GetFadeOut(), 1, 1, 0);
pParticle->m_flAlpha = flFadeIn * flFadeOut * m_pSystem->GetAlpha();
pParticle->m_flRadius = RemapVal(flLifeTimeRamp, 0, 1, m_pSystem->GetStartRadius(), m_pSystem->GetEndRadius());
}
if (!m_bStopped && m_pSystem->IsRenderable())
{
while (flGameTime - m_flLastEmission > m_pSystem->GetEmissionRate())
{
SpawnParticle();
if (m_pSystem->GetEmissionMax() && m_iTotalEmitted >= m_pSystem->GetEmissionMax())
break;
m_flLastEmission += m_pSystem->GetEmissionRate();
}
}
for (size_t i = 0; i < m_apChildren.size(); i++)
m_apChildren[i]->Simulate();
if (m_pSystem->GetEmissionMax() && m_iTotalEmitted >= m_pSystem->GetEmissionMax() || !m_pSystem->IsRenderable())
m_bStopped = true;
}