//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TEWorldDecal::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEWorldDecal::PostDataUpdate" );
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
bool bNoBlood = UTIL_IsLowViolence();
bool bIsBlood = false;
if ( bNoBlood )
{
const char *pchDecalName = decalsystem->GetDecalNameForIndex( m_nIndex );
if ( pchDecalName && V_stristr( pchDecalName, "blood" ) )
{
bIsBlood = true;
}
}
if ( !( bNoBlood && bIsBlood ) )
{
effects->DecalShoot( m_nIndex, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), m_vecOrigin, 0, 0 );
}
}
}
RecordWorldDecal( &m_vecOrigin, m_nIndex );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fTimeDelta -
//-----------------------------------------------------------------------------
void C_Plasma::Update( void )
{
//Update all our parts
UpdateScale();
UpdateAnimation();
UpdateFlames();
if (m_flScaleRegister > 0.1)
{
float tempDelta = gpGlobals->frametime;
while( m_tDecalSpawn.NextEvent( tempDelta ) )
{
// Add decal to floor
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
int index = decalsystem->GetDecalIndexForName( "PlasmaGlowFade" );
if ( index >= 0 )
{
effects->DecalShoot( index, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), GetAbsOrigin(), 0, 0 );
}
}
}
}
}
void __MsgFunc_TerrainMod( const char *pszName, int iSize, void *pbuf )
{
CTerrainModParams params;
BEGIN_READ( pbuf, iSize );
unsigned char type = READ_BYTE();
params.m_vCenter.x = READ_FLOAT();
params.m_vCenter.y = READ_FLOAT();
params.m_vCenter.z = READ_FLOAT();
params.m_flRadius = RemapVal( READ_SHORT(), 0, 65535, MIN_TMOD_RADIUS, MAX_TMOD_RADIUS );
params.m_vecMin.x = READ_FLOAT();
params.m_vecMin.y = READ_FLOAT();
params.m_vecMin.z = READ_FLOAT();
params.m_vecMax.x = READ_FLOAT();
params.m_vecMax.y = READ_FLOAT();
params.m_vecMax.z = READ_FLOAT();
params.m_flStrength = READ_FLOAT();
params.m_Flags = READ_BYTE();
if( type == TMod_Suck && (params.m_Flags & CTerrainModParams::TMOD_SUCKTONORMAL) )
{
params.m_vNormal.x = READ_FLOAT();
params.m_vNormal.y = READ_FLOAT();
params.m_vNormal.z = READ_FLOAT();
}
// Apply the decal first because the place where we're applying the decal
// may not be there if we blow it out first!
Vector vPosition(0,0,0);
QAngle vAngles(0,0,0);
int iModel = 0;
C_BaseEntity *ent = cl_entitylist->GetEnt( iModel );
if( ent && type == TMod_Sphere )
{
effects->DecalShoot(
effects->Draw_DecalIndexFromName( "decals/tscorch" ),
iModel,
ent->GetModel(),
vPosition,
vAngles,
params.m_vCenter,
NULL,
0 );
}
engine->ApplyTerrainMod( (TerrainModType)type, params );
}
void TE_FootprintDecal( IRecipientFilter& filter, float delay, const Vector *origin, const Vector* right,
int entity, int index, unsigned char materialType )
{
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( entity );
if ( ent )
{
effects->DecalShoot( index, entity, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), *origin, right, 0 );
}
}
}
//-----------------------------------------------------------------------------
// Client-side effects
//-----------------------------------------------------------------------------
void TE_WorldDecal( IRecipientFilter& filter, float delay, const Vector* pos, int index )
{
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
effects->DecalShoot( index, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), *pos, 0, 0 );
}
}
RecordWorldDecal( pos, index );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TEWorldDecal::PostDataUpdate( DataUpdateType_t updateType )
{
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
effects->DecalShoot( m_nIndex, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), m_vecOrigin, 0, 0 );
}
}
RecordWorldDecal( &m_vecOrigin, m_nIndex );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : filter -
// delay -
// pos -
// player -
// entity -
//-----------------------------------------------------------------------------
void TE_PlayerDecal( IRecipientFilter& filter, float delay,
const Vector* pos, int player, int entity )
{
if ( cl_playerspraydisable.GetBool() )
return;
// No valid target?
C_BaseEntity *ent = cl_entitylist->GetEnt( entity );
if ( !ent )
return;
// Find player logo for shooter
player_info_t info;
engine->GetPlayerInfo( player, &info );
// Make sure we've got the material for this player's logo
char texname[ 512 ];
IMaterial *logo = CreateTempMaterialForPlayerLogo( player, &info, texname, 512 );
if ( !logo )
return;
ITexture *texture = materials->FindTexture( texname, TEXTURE_GROUP_DECAL );
if ( IsErrorTexture( texture ) )
{
return; // not found
}
// Update the texture used by the material if need be.
bool bFound = false;
IMaterialVar *pMatVar = logo->FindVar( "$basetexture", &bFound );
if ( bFound && pMatVar )
{
if ( pMatVar->GetTextureValue() != texture )
{
pMatVar->SetTextureValue( texture );
logo->RefreshPreservingMaterialVars();
}
}
color32 rgbaColor = { 255, 255, 255, 255 };
effects->PlayerDecalShoot(
logo,
(void *)player,
entity,
ent->GetModel(),
ent->GetAbsOrigin(),
ent->GetAbsAngles(),
*pos,
0,
0,
rgbaColor );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bool -
//-----------------------------------------------------------------------------
void C_TEBSPDecal::PostDataUpdate( DataUpdateType_t updateType )
{
C_BaseEntity *ent;
if ( ( ent = cl_entitylist->GetEnt( m_nEntity ) ) == NULL )
{
DevMsg( 1, "Decal: entity = %i", m_nEntity );
return;
}
if ( r_decals.GetInt() )
{
effects->DecalShoot( m_nIndex, m_nEntity, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), m_vecOrigin, 0, FDECAL_PERMANENT );
}
}
void C_TEFootprintDecal::PostDataUpdate( DataUpdateType_t updateType )
{
VPROF( "C_TEFootprintDecal::PostDataUpdate" );
// FIXME: Make this choose the decal based on material type
if ( r_decals.GetInt() )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( m_nEntity );
if ( ent )
{
effects->DecalShoot( m_nIndex,
m_nEntity, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), m_vecOrigin, &m_vecDirection, 0 );
}
}
}
void TE_BSPDecal( IRecipientFilter& filter, float delay,
const Vector* pos, int entity, int index )
{
C_BaseEntity *ent;
if ( ( ent = cl_entitylist->GetEnt( entity ) ) == NULL )
{
DevMsg( 1, "Decal: entity = %i", entity );
return;
}
if ( r_decals.GetInt() )
{
effects->DecalShoot( index, entity, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), *pos, 0, FDECAL_PERMANENT );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_ExtinguisherJet::AddExtinguisherDecal( trace_t &tr )
{
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent != NULL )
{
int index = decalsystem->GetDecalIndexForName( "Extinguish" );
if ( index >= 0 )
{
Vector endpos;
endpos.Random( -24.0f, 24.0f );
endpos += tr.endpos;
effects->DecalShoot( index, 0, ent->GetModel(), ent->GetAbsOrigin(), ent->GetAbsAngles(), endpos, 0, 0 );
}
}
}
void C_AR2Explosion::Start(CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs)
{
m_pParticleMgr = pParticleMgr;
if(!pParticleMgr->AddEffect(&m_ParticleEffect, this))
return;
if (!m_szMaterialName[0])
{
strcpy(m_szMaterialName, "particle/particle_noisesphere");
}
m_MaterialHandle = m_ParticleEffect.FindOrAddMaterial(m_szMaterialName);
// Precalculate stuff for the particle spawning..
#define NUM_DUSTEMITTER_SURFINFOS 128
SurfInfo surfInfos[NUM_DUSTEMITTER_SURFINFOS];
int nSurfInfos;
// Center of explosion.
Vector vCenter = GetAbsOrigin(); // HACKHACK.. when the engine bug is fixed, use origin.
#ifdef PARTICLEPROTOTYPE_APP
float surfSize = 10000;
nSurfInfos = 1;
surfInfos[0].m_Verts[0].Init(-surfSize,-surfSize,0);
surfInfos[0].m_Verts[1].Init(-surfSize,surfSize,0);
surfInfos[0].m_Verts[2].Init(surfSize, surfSize,0);
surfInfos[0].m_Verts[3].Init(surfSize,-surfSize,0);
surfInfos[0].m_nVerts = 4;
surfInfos[0].m_Plane.m_Normal.Init(0,0,1);
surfInfos[0].m_Plane.m_Dist = -3;
#else
{
nSurfInfos = 0;
C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
if ( ent )
{
nSurfInfos = engine->GetIntersectingSurfaces(
ent->GetModel(),
vCenter,
AR2_DUST_RADIUS,
true,
surfInfos,
NUM_DUSTEMITTER_SURFINFOS);
}
}
#endif
int nParticles = 0;
if(nSurfInfos > 0)
{
// For nParticles*N, generate a ray and cast it out. If it hits anything, spawn a particle there.
int nTestsPerParticle=3;
for(int i=0; i < NUM_AR2_EXPLOSION_PARTICLES; i++)
{
for(int iTest=0; iTest < nTestsPerParticle; iTest++)
{
Vector randVec = RandomVector(-1,1);
VectorNormalize( randVec );
Vector startPos = vCenter + randVec * AR2_DUST_RADIUS;
randVec = RandomVector(-1,1);
VectorNormalize( randVec );
Vector endPos = vCenter + randVec * AR2_DUST_RADIUS;
#define MAX_SURFINFO_INTERSECTIONS 4
SurfInfo *pIntersected[MAX_SURFINFO_INTERSECTIONS];
Vector vIntersections[MAX_SURFINFO_INTERSECTIONS];
int nIntersections;
nIntersections = IntersectSegmentWithSurfInfos(
startPos,
endPos,
surfInfos,
nSurfInfos,
pIntersected,
vIntersections,
MAX_SURFINFO_INTERSECTIONS);
if(nIntersections)
{
int iIntersection = rand() % nIntersections;
Vector velocity;
//velocity.Init(-1.0f + ((float)rand()/RAND_MAX) * 2.0f, -1.0f + ((float)rand()/RAND_MAX) * 2.0f, -1.0f + ((float)rand()/RAND_MAX) * 2.0f);
//velocity = velocity * FRand(m_MinSpeed, m_MaxSpeed);
Vector direction = (vIntersections[iIntersection] - vCenter );
float dist = VectorNormalize( direction );
if(dist > AR2_DUST_RADIUS)
dist = AR2_DUST_RADIUS;
static float power = 2.0f;
float falloffMul = pow(1.0f - dist / AR2_DUST_RADIUS, power);
Vector reflection = direction - 2 * DotProduct( direction, pIntersected[iIntersection]->m_Plane.m_Normal ) * pIntersected[iIntersection]->m_Plane.m_Normal;
VectorNormalize( reflection );
velocity = reflection * AR2_DUST_SPEED * falloffMul;
// velocity = velocity + (vIntersections[iIntersection] - vCenter) * falloffMul;
/*
debugoverlay->AddLineOverlay( vIntersections[iIntersection],
vIntersections[iIntersection] + reflection * 64,
128, 128, 255, false, 15.0 );
*/
#if 1
AR2ExplosionParticle *pParticle =
(AR2ExplosionParticle*)m_ParticleEffect.AddParticle( sizeof(AR2ExplosionParticle), m_MaterialHandle );
if(pParticle)
{
pParticle->m_Pos = vIntersections[iIntersection];
pParticle->m_Start = pParticle->m_Pos;
pParticle->m_Dist = 8.0;
pParticle->m_Velocity = velocity;
// sound == 13031.496062992125984251968503937ips
pParticle->m_Lifetime = -dist / 13031.5f - 0.1;
pParticle->m_Roll = FRand( 0, M_PI * 2 );
pParticle->m_RollSpeed = FRand( -1, 1 ) * 0.4;
pParticle->m_Dwell = AR2_DUST_LIFETIME + random->RandomFloat( 0, AR2_DUST_LIFETIME_DELTA );
nParticles++;
break;
}
#endif
}
}
}
}
// build interior smoke particles
for(int i=nParticles; i < NUM_AR2_EXPLOSION_PARTICLES; i++)
{
Vector randVec = RandomVector(-1,1);
VectorNormalize( randVec );
Vector endPos = vCenter + randVec * AR2_DUST_RADIUS / 4.0;
Vector direction = (endPos - vCenter );
float dist = VectorNormalize( direction ) + random->RandomFloat( 0, AR2_DUST_RADIUS / 4.0 );
if(dist > AR2_DUST_RADIUS)
dist = AR2_DUST_RADIUS;
static float power = 2.0f;
float falloffMul = pow(1.0f - dist / (AR2_DUST_RADIUS / 2), power);
Vector velocity = direction * AR2_DUST_SPEED * falloffMul;
AR2ExplosionParticle *pParticle =
(AR2ExplosionParticle*)m_ParticleEffect.AddParticle( sizeof(AR2ExplosionParticle), m_MaterialHandle );
if(pParticle)
{
pParticle->m_Pos = endPos;
pParticle->m_Start = pParticle->m_Pos;
pParticle->m_Dist = 8.0;
pParticle->m_Velocity = velocity;
// sound == 13031.496062992125984251968503937ips
pParticle->m_Lifetime = -dist / 13031.5f - 0.1;
pParticle->m_Roll = FRand( 0, M_PI * 2 );
pParticle->m_RollSpeed = FRand( -1, 1 ) * 4.0;
pParticle->m_Dwell = 0.5 * (AR2_DUST_LIFETIME + random->RandomFloat( 0, AR2_DUST_LIFETIME_DELTA ));
}
}
}
void C_Camera::CalcChaseCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
C_SDKPlayer *pLocal = C_SDKPlayer::GetLocalSDKPlayer();
C_BaseEntity *pTarget = NULL;
if ((pLocal->m_nButtons & IN_ZOOM)
&& !pLocal->IsObserver()
&& g_PR->GetTeamPosType(GetLocalPlayerIndex()) == POS_GK
&& GetMatchBall()
&& Sign(GetMatchBall()->GetLocalOrigin().y - SDKGameRules()->m_vKickOff.GetY()) == pLocal->GetTeam()->m_nForward)
{
CalcHawkEyeView(eyeOrigin, eyeAngles, fov);
return;
}
if (pLocal->IsObserver())
pTarget = GetTarget();
else
pTarget = pLocal;
if (!pTarget || !pTarget->GetBaseAnimating() && !pTarget->GetModel())
{
CalcRoamingView( eyeOrigin, eyeAngles, fov );
return;
}
eyeOrigin = pTarget->EyePosition();
eyeAngles = pTarget->EyeAngles();
const QAngle camAngles = ::input->GetCameraAngles();
Vector &camOffset = ::input->GetCameraOffset();
float dist = cl_cam_firstperson.GetBool() ? -10 : cl_cam_dist.GetFloat();
float height = cl_cam_firstperson.GetBool() ? 8 : cl_cam_height.GetFloat();
if (pLocal->IsObserver() && GetCamMode() == CAM_MODE_LOCKED_CHASE && !dynamic_cast<C_MatchBall *>(pTarget))
{
camOffset[PITCH] = eyeAngles[PITCH];
camOffset[YAW] = eyeAngles[YAW];
}
else
{
camOffset[PITCH] = camAngles[PITCH];
camOffset[YAW] = camAngles[YAW];
}
if (camOffset[PITCH] >= 0)
{
camOffset[ROLL] = dist;
}
else
{
float coeff = clamp(cos(DEG2RAD(camOffset[PITCH] + 90)), 0.001f, 1.0f);
camOffset[ROLL] = min((VEC_VIEW.z + height - 5) / coeff, dist);
}
eyeAngles[PITCH] = camOffset[PITCH];
eyeAngles[YAW] = camOffset[YAW];
eyeAngles[ROLL] = 0;
Vector camForward, camRight, camUp;
AngleVectors(eyeAngles, &camForward, &camRight, &camUp);
VectorMA(eyeOrigin, -camOffset[ROLL], camForward, eyeOrigin);
eyeOrigin.z += height;
if (!pLocal->IsObserver())
{
// Apply a smoothing offset to smooth out prediction errors.
Vector vSmoothOffset;
pLocal->GetPredictionErrorSmoothingVector( vSmoothOffset );
eyeOrigin += Vector(vSmoothOffset.x, vSmoothOffset.y, 0);
}
fov = pLocal->GetFOV();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : filter -
// delay -
// pos -
// player -
// entity -
//-----------------------------------------------------------------------------
void TE_PlayerDecal( IRecipientFilter& filter, float delay,
const Vector* pos, int player, int entity )
{
if ( cl_playerspraydisable.GetBool() )
return;
// No valid target?
C_BaseEntity *ent = cl_entitylist->GetEnt( entity );
if ( !ent )
return;
// Find player logo for shooter
player_info_t info;
engine->GetPlayerInfo( player, &info );
// Doesn't have a logo
if ( !info.customFiles[0] )
return;
IMaterial *logo = materials->FindMaterial( VarArgs("decals/playerlogo%2.2d", player), TEXTURE_GROUP_DECAL );
if ( IsErrorMaterial( logo ) )
return;
char logohex[ 16 ];
Q_binarytohex( (byte *)&info.customFiles[0], sizeof( info.customFiles[0] ), logohex, sizeof( logohex ) );
// See if logo has been downloaded.
char texname[ 512 ];
Q_snprintf( texname, sizeof( texname ), "temp/%s", logohex );
char fulltexname[ 512 ];
Q_snprintf( fulltexname, sizeof( fulltexname ), "materials/temp/%s.vtf", logohex );
if ( !filesystem->FileExists( fulltexname ) )
{
char custname[ 512 ];
Q_snprintf( custname, sizeof( custname ), "downloads/%s.dat", logohex );
// it may have been downloaded but not copied under materials folder
if ( !filesystem->FileExists( custname ) )
return; // not downloaded yet
// copy from download folder to materials/temp folder
// this is done since material system can access only materials/*.vtf files
if ( !engine->CopyFile( custname, fulltexname) )
return;
}
ITexture *texture = materials->FindTexture( texname, TEXTURE_GROUP_DECAL );
if ( IsErrorTexture( texture ) )
{
return; // not found
}
// Update the texture used by the material if need be.
bool bFound = false;
IMaterialVar *pMatVar = logo->FindVar( "$basetexture", &bFound );
if ( bFound && pMatVar )
{
if ( pMatVar->GetTextureValue() != texture )
{
pMatVar->SetTextureValue( texture );
logo->RefreshPreservingMaterialVars();
}
}
color32 rgbaColor = { 255, 255, 255, 255 };
effects->PlayerDecalShoot(
logo,
(void *)player,
entity,
ent->GetModel(),
ent->GetAbsOrigin(),
ent->GetAbsAngles(),
*pos,
0,
0,
rgbaColor );
}