//-----------------------------------------------------------------------------
// 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 );
}
}
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
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 );
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
}
// Actual work code
IterationRetval_t CASW_MarineAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsNPC() )
{
return ITERATION_CONTINUE;
}
if ( pEnt->IsNPC() )
{
C_AI_BaseNPC *pNPC = (C_AI_BaseNPC *)pEnt;
if ( !pNPC->ShouldAvoidObstacle() )
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
#ifdef TF2_CLIENT_DLL
// If it's solid to player movement, don't steer around it since we'll just bump into it
if ( pEnt->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT )
return ITERATION_CONTINUE;
#endif
C_ASW_Marine *pMarine = m_pLocal->GetMarine();
if (!pMarine)
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - pMarine->GetAbsOrigin();
//if ( deltaPos.LengthSqr() > m_flRadiusSquared )
//return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
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 );
}
}
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 );
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
}
}
//-----------------------------------------------------------------------------
// Returns the attachment render origin + origin
//-----------------------------------------------------------------------------
void C_VGuiScreen::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pOrigin, QAngle *pAngles )
{
C_BaseEntity *pEnt = pAttachedTo->GetBaseEntity();
const char* panelName = PanelName();
vgui::Panel panel = m_PanelWrapper.GetPanel();
if ( Q_strcmp(panelName, "health_screen") == 0 )
{
QAngle weapAngles = pEnt->GetAbsAngles();
Vector weapForward, weapRight, weapUp;
AngleVectors(weapAngles, &weapForward, &weapRight, &weapUp);
VMatrix worldFromPanel;
AngleMatrix(weapAngles, worldFromPanel.As3x4());
MatrixRotate(worldFromPanel, Vector(0, 0, 1), 180.f);
MatrixRotate(worldFromPanel, Vector(1, 0, 0), -90.f);
MatrixAngles(worldFromPanel.As3x4(), *pAngles);
// move it right and over
*pOrigin = pEnt->GetAbsOrigin() + weapRight*1.75 + weapUp*2.3 + weapForward*5;
return;
}
//todo: set alpha per view ... m_PanelWrapper.GetPanel()->SetAlpha(200);
if (pEnt && (m_nAttachmentIndex > 0))
{
{
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );
pEnt->GetAttachment( m_nAttachmentIndex, *pOrigin, *pAngles );
}
if ( IsAttachedToViewModel() )
{
FormatViewModelAttachment( *pOrigin, true );
}
}
else
{
BaseClass::GetAimEntOrigin( pAttachedTo, pOrigin, pAngles );
}
// Msg("%s origin %.1f %.1f %.1f angles %.1f %.1f %.1f \n", PanelName(), pOrigin->x, pOrigin->y, pOrigin->z, pAngles->x, pAngles->y, pAngles->z);
}
void C_HLTVCamera::CalcFixedView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
eyeOrigin = m_vCamOrigin;
eyeAngles = m_aCamAngle;
fov = m_flFOV;
if ( m_iTraget1 == 0 )
return;
C_BaseEntity * target = ClientEntityList().GetBaseEntity( m_iTraget1 );
if ( target && target->IsAlive() )
{
// if we're chasing a target, change viewangles
QAngle angle;
VectorAngles( (target->GetAbsOrigin()+VEC_VIEW) - m_vCamOrigin, angle );
SmoothCameraAngle( angle );
}
}
// Actual work code
IterationRetval_t CPlayerAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsNPC() )
{
return ITERATION_CONTINUE;
}
if ( pEnt->IsNPC() )
{
C_AI_BaseNPC *pNPC = (C_AI_BaseNPC *)pEnt;
if ( !pNPC->ShouldAvoidObstacle() )
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - m_pLocal->GetAbsOrigin();
if ( deltaPos.LengthSqr() > m_flRadiusSquared )
return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
void C_ColorCorrection::ClientThink()
{
if ( m_CCHandle == INVALID_CLIENT_CCHANDLE )
return;
if ( mat_colcorrection_disableentities.GetInt() )
{
// Allow the colorcorrectionui panel (or user) to turn off color-correction entities
g_pColorCorrectionMgr->SetColorCorrectionWeight( m_CCHandle, 0.0f );
return;
}
if( !m_bEnabled && m_flCurWeight == 0.0f )
{
g_pColorCorrectionMgr->SetColorCorrectionWeight( m_CCHandle, 0.0f );
return;
}
C_BaseEntity *pPlayer = C_BasePlayer::GetLocalPlayer();
if( !pPlayer )
return;
Vector playerOrigin = pPlayer->GetAbsOrigin();
float weight = 0;
if ( ( m_minFalloff != -1 ) && ( m_maxFalloff != -1 ) && m_minFalloff != m_maxFalloff )
{
float dist = (playerOrigin - m_vecOrigin).Length();
weight = (dist-m_minFalloff) / (m_maxFalloff-m_minFalloff);
if ( weight<0.0f ) weight = 0.0f;
if ( weight>1.0f ) weight = 1.0f;
}
g_pColorCorrectionMgr->SetColorCorrectionWeight( m_CCHandle, m_flCurWeight * ( 1.0 - weight ) );
BaseClass::ClientThink();
}
void C_ASW_Shaman::UpdateEffects()
{
if ( !m_hHealingTarget.Get() || GetHealth() <= 0 )
{
if ( m_pHealEffect )
{
m_pHealEffect->StopEmission();
m_pHealEffect = NULL;
}
return;
}
if ( m_pHealEffect )
{
if ( m_pHealEffect->GetControlPointEntity( 1 ) != m_hHealingTarget.Get() )
{
m_pHealEffect->StopEmission();
m_pHealEffect = NULL;
}
}
if ( !m_pHealEffect )
{
m_pHealEffect = ParticleProp()->Create( "shaman_heal_attach", PATTACH_POINT_FOLLOW, "nozzle" ); // "heal_receiver"
}
Assert( m_pHealEffect );
if ( m_pHealEffect->GetControlPointEntity( 1 ) == NULL )
{
C_BaseEntity *pTarget = m_hHealingTarget.Get();
Vector vOffset( 0.0f, 0.0f, pTarget->WorldSpaceCenter().z - pTarget->GetAbsOrigin().z );
ParticleProp()->AddControlPoint( m_pHealEffect, 1, pTarget, PATTACH_ABSORIGIN_FOLLOW, NULL, vOffset );
m_pHealEffect->SetControlPointOrientation( 0, pTarget->Forward(), -pTarget->Left(), pTarget->Up() );
}
}
// Actual work code
IterationRetval_t CPlayerAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
{
if ( !m_pLocal )
return ITERATION_STOP;
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
if ( pEnt == m_pLocal )
return ITERATION_CONTINUE;
if ( !pEnt->IsPlayer() &&
!pEnt->IsBaseObject() )
{
return ITERATION_CONTINUE;
}
// Ignore vehicles, since they have vcollide collisions that's push me away
if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
return ITERATION_CONTINUE;
// If it's solid to player movement, don't steer around it since we'll just bump into it
if ( pEnt->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT )
return ITERATION_CONTINUE;
Vector deltaPos = pEnt->GetAbsOrigin() - m_pLocal->GetAbsOrigin();
if ( deltaPos.LengthSqr() > m_flRadiusSquared )
return ITERATION_CONTINUE;
CHandle< C_BaseEntity > h;
h = pEnt;
m_Objects.AddToTail( h );
return ITERATION_CONTINUE;
}
//Actual work code
IterationRetval_t EnumElement( IHandleEntity *pHandleEntity )
{
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
if ( pEnt == NULL )
return ITERATION_CONTINUE;
C_BaseAnimating *pModel = static_cast< C_BaseAnimating * >( pEnt );
if ( pModel == NULL )
return ITERATION_CONTINUE;
trace_t tr;
enginetrace->ClipRayToEntity( m_rayShot, MASK_SHOT, pModel, &tr );
IPhysicsObject *pPhysicsObject = NULL;
//Find the real object we hit.
if( tr.physicsbone >= 0 )
{
if ( pModel->m_pRagdoll )
{
CRagdoll *pCRagdoll = dynamic_cast < CRagdoll * > ( pModel->m_pRagdoll );
if ( pCRagdoll )
{
ragdoll_t *pRagdollT = pCRagdoll->GetRagdoll();
if ( tr.physicsbone < pRagdollT->listCount )
{
pPhysicsObject = pRagdollT->list[tr.physicsbone].pObject;
}
}
}
}
if ( pPhysicsObject == NULL )
return ITERATION_CONTINUE;
if ( tr.fraction < 1.0 )
{
IPhysicsObject *pReference = GetWorldPhysObject();
if ( pReference == NULL || pPhysicsObject == NULL )
return ITERATION_CONTINUE;
float flMass = pPhysicsObject->GetMass();
pPhysicsObject->SetMass( flMass * 2 );
constraint_ballsocketparams_t ballsocket;
ballsocket.Defaults();
pReference->WorldToLocal( &ballsocket.constraintPosition[0], m_vWorld );
pPhysicsObject->WorldToLocal( &ballsocket.constraintPosition[1], tr.endpos );
physenv->CreateBallsocketConstraint( pReference, pPhysicsObject, NULL, ballsocket );
//Play a sound
CPASAttenuationFilter filter( pEnt );
EmitSound_t ep;
ep.m_nChannel = CHAN_VOICE;
ep.m_pSoundName = "Weapon_Crossbow.BoltSkewer";
ep.m_flVolume = 1.0f;
ep.m_SoundLevel = SNDLVL_NORM;
ep.m_pOrigin = &pEnt->GetAbsOrigin();
C_BaseEntity::EmitSound( filter, SOUND_FROM_WORLD, ep );
return ITERATION_STOP;
}
return ITERATION_CONTINUE;
}
//-----------------------------------------------------------------------------
// Sets up the view parameters
//-----------------------------------------------------------------------------
void CViewRender::SetUpViews()
{
VPROF("CViewRender::SetUpViews");
// Initialize view structure with default values
float farZ = GetZFar();
// Set up the mono/middle view.
CViewSetup &view = m_View;
view.zFar = farZ;
view.zFarViewmodel = farZ;
// UNDONE: Make this farther out?
// closest point of approach seems to be view center to top of crouched box
view.zNear = GetZNear();
view.zNearViewmodel = 1;
view.fov = default_fov.GetFloat();
view.m_bOrtho = false;
view.m_bViewToProjectionOverride = false;
view.m_eStereoEye = STEREO_EYE_MONO;
// Enable spatial partition access to edicts
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
// You in-view weapon aim.
bool bCalcViewModelView = false;
Vector ViewModelOrigin;
QAngle ViewModelAngles;
if ( engine->IsHLTV() )
{
HLTVCamera()->CalcView( view.origin, view.angles, view.fov );
}
#if defined( REPLAY_ENABLED )
else if ( g_pEngineClientReplay->IsPlayingReplayDemo() )
{
ReplayCamera()->CalcView( view.origin, view.angles, view.fov );
}
#endif
else
{
// FIXME: Are there multiple views? If so, then what?
// FIXME: What happens when there's no player?
if (pPlayer)
{
pPlayer->CalcView( view.origin, view.angles, view.zNear, view.zFar, view.fov );
// If we are looking through another entities eyes, then override the angles/origin for view
int viewentity = render->GetViewEntity();
if ( !g_nKillCamMode && (pPlayer->entindex() != viewentity) )
{
C_BaseEntity *ve = cl_entitylist->GetEnt( viewentity );
if ( ve )
{
VectorCopy( ve->GetAbsOrigin(), view.origin );
VectorCopy( ve->GetAbsAngles(), view.angles );
}
}
// There is a viewmodel.
bCalcViewModelView = true;
ViewModelOrigin = view.origin;
ViewModelAngles = view.angles;
}
else
{
view.origin.Init();
view.angles.Init();
}
// Even if the engine is paused need to override the view
// for keeping the camera control during pause.
g_pClientMode->OverrideView( &view );
}
// give the toolsystem a chance to override the view
ToolFramework_SetupEngineView( view.origin, view.angles, view.fov );
if ( engine->IsPlayingDemo() )
{
if ( cl_demoviewoverride.GetFloat() > 0.0f )
{
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
CalcDemoViewOverride( view.origin, view.angles );
}
else
{
s_DemoView = view.origin;
s_DemoAngle = view.angles;
}
}
//Find the offset our current FOV is from the default value
float fDefaultFov = default_fov.GetFloat();
float flFOVOffset = fDefaultFov - view.fov;
//Adjust the viewmodel's FOV to move with any FOV offsets on the viewer's end
view.fovViewmodel = g_pClientMode->GetViewModelFOV() - flFOVOffset;
if ( UseVR() )
{
// Let the headtracking read the status of the HMD, etc.
// This call can go almost anywhere, but it needs to know the player FOV for sniper weapon zoom, etc
if ( flFOVOffset == 0.0f )
{
g_ClientVirtualReality.ProcessCurrentTrackingState ( 0.0f );
}
else
{
g_ClientVirtualReality.ProcessCurrentTrackingState ( view.fov );
}
HeadtrackMovementMode_t hmmOverrideMode = g_pClientMode->ShouldOverrideHeadtrackControl();
g_ClientVirtualReality.OverrideView( &m_View, &ViewModelOrigin, &ViewModelAngles, hmmOverrideMode );
// left and right stereo views should default to being the same as the mono/middle view
m_ViewLeft = m_View;
m_ViewRight = m_View;
m_ViewLeft.m_eStereoEye = STEREO_EYE_LEFT;
m_ViewRight.m_eStereoEye = STEREO_EYE_RIGHT;
g_ClientVirtualReality.OverrideStereoView( &m_View, &m_ViewLeft, &m_ViewRight );
}
else
{
// left and right stereo views should default to being the same as the mono/middle view
m_ViewLeft = m_View;
m_ViewRight = m_View;
m_ViewLeft.m_eStereoEye = STEREO_EYE_LEFT;
m_ViewRight.m_eStereoEye = STEREO_EYE_RIGHT;
}
if ( bCalcViewModelView )
{
Assert ( pPlayer != NULL );
pPlayer->CalcViewModelView ( ViewModelOrigin, ViewModelAngles );
}
// Disable spatial partition access
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, true );
// Enable access to all model bones
C_BaseAnimating::PopBoneAccess( "OnRenderStart->CViewRender::SetUpView" ); // pops the (true, false) bone access set in OnRenderStart
C_BaseAnimating::PushAllowBoneAccess( true, true, "CViewRender::SetUpView->OnRenderEnd" ); // pop is in OnRenderEnd()
// Compute the world->main camera transform
// This is only done for the main "middle-eye" view, not for the various other views.
ComputeCameraVariables( view.origin, view.angles,
&g_vecVForward, &g_vecVRight, &g_vecVUp, &g_matCamInverse );
// set up the hearing origin...
AudioState_t audioState;
audioState.m_Origin = view.origin;
audioState.m_Angles = view.angles;
audioState.m_bIsUnderwater = pPlayer && pPlayer->AudioStateIsUnderwater( view.origin );
ToolFramework_SetupAudioState( audioState );
// TomF: I wonder when the audio tools modify this, if ever...
Assert ( view.origin == audioState.m_Origin );
Assert ( view.angles == audioState.m_Angles );
view.origin = audioState.m_Origin;
view.angles = audioState.m_Angles;
engine->SetAudioState( audioState );
g_vecPrevRenderOrigin = g_vecRenderOrigin;
g_vecPrevRenderAngles = g_vecRenderAngles;
g_vecRenderOrigin = view.origin;
g_vecRenderAngles = view.angles;
#ifdef DBGFLAG_ASSERT
s_DbgSetupOrigin = view.origin;
s_DbgSetupAngles = view.angles;
#endif
}
void CASWHudCrosshair::OnThink()
{
C_ASW_Player* pPlayer = C_ASW_Player::GetLocalASWPlayer();
if ( !pPlayer )
return;
PaintReloadProgressBar();
C_ASW_Marine *pMarine = pPlayer->GetViewMarine();
bool bControllingTurret = (pMarine && pMarine->IsControllingTurret());
if (!bControllingTurret)
return;
C_ASW_Remote_Turret *pTurret = pMarine->GetRemoteTurret();
if (!pTurret)
return;
Vector vecWeaponPos = pTurret->GetAbsOrigin();
QAngle angWeapon = pTurret->EyeAngles();
Vector vecWeaponDir;
AngleVectors(angWeapon, &vecWeaponDir);
// increase lock time of all targets and discard out of range/facing ones
for (int k=0;k<ASW_MAX_TURRET_TARGETS;k++)
{
C_BaseEntity *pEnt = m_TurretTarget[k].Get();
if (pEnt)
{
// validate the target
bool bValid = true;
Vector diff = pEnt->GetAbsOrigin() - vecWeaponPos;
if (diff.Length() > ASW_TURRET_TARGET_RANGE || !pEnt->ShouldDraw())
{
bValid = false;
}
else
{
diff.NormalizeInPlace();
float flDot = diff.Dot(vecWeaponDir);
if (flDot < asw_turret_dot.GetFloat())
bValid = false;
}
// fade it in or out appropriately
if (bValid)
{
if (m_fTurretTargetLock[k] < 1.0f)
{
m_fTurretTargetLock[k] += gpGlobals->frametime * 2;
if (m_fTurretTargetLock[k] > 1.0f)
m_fTurretTargetLock[k] = 1.0f;
}
}
else
{
if (m_fTurretTargetLock[k] <= 0)
{
m_TurretTarget[k] = NULL;
}
else
{
m_fTurretTargetLock[k] -= gpGlobals->frametime * 2;
if (m_fTurretTargetLock[k] < 0.0f)
m_fTurretTargetLock[k] = 0.0f;
}
}
}
}
// check for adding new targets to the array
for ( int i = 0; i < IASW_Client_Aim_Target::AutoList().Count(); i++ )
{
IASW_Client_Aim_Target *pAimTarget = static_cast< IASW_Client_Aim_Target* >( IASW_Client_Aim_Target::AutoList()[ i ] );
C_BaseEntity *pEnt = pAimTarget->GetEntity();
if (!pEnt || !pAimTarget->IsAimTarget() || !pEnt->ShouldDraw())
continue;
// check he's in range
Vector vecAlienPos = pEnt->WorldSpaceCenter();
float flAlienDist = vecAlienPos.DistTo(vecWeaponPos);
if (flAlienDist > ASW_TURRET_TARGET_RANGE)
continue;
// check it's in front of us
Vector dir = vecAlienPos - vecWeaponPos;
dir.NormalizeInPlace();
if (dir.Dot(vecWeaponDir) <= asw_turret_dot.GetFloat())
continue;
// we've got a possible target, add him to the list if he's not in there already
bool bAlreadyInArray = false;
int iSpace = -1;
for (int k=0;k<ASW_MAX_TURRET_TARGETS;k++)
{
if (m_TurretTarget[k].Get() == pEnt)
{
bAlreadyInArray = true;
break;
}
if (iSpace == -1 && m_TurretTarget[k].Get() == NULL)
iSpace = k;
}
if (bAlreadyInArray)
continue;
if (iSpace != -1)
{
m_TurretTarget[iSpace] = pEnt;
m_fTurretTargetLock[iSpace] = 0;
}
}
}
//-----------------------------------------------------------------------------
// Sets up the view parameters
//-----------------------------------------------------------------------------
void CViewRender::SetUpView()
{
VPROF("CViewRender::SetUpView");
// Initialize view structure with default values
float farZ = GetZFar();
m_View.zFar = farZ;
m_View.zFarViewmodel = farZ;
// UNDONE: Make this farther out?
// closest point of approach seems to be view center to top of crouched box
m_View.zNear = GetZNear();
m_View.zNearViewmodel = 1;
m_View.fov = default_fov.GetFloat();
m_View.m_bOrtho = false;
// Enable spatial partition access to edicts
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( engine->IsHLTV() )
{
HLTVCamera()->CalcView( m_View.origin, m_View.angles, m_View.fov );
}
else
{
// FIXME: Are there multiple views? If so, then what?
// FIXME: What happens when there's no player?
if (pPlayer)
{
pPlayer->CalcView( m_View.origin, m_View.angles, m_View.zNear, m_View.zFar, m_View.fov );
// If we are looking through another entities eyes, then override the angles/origin for m_View
int viewentity = render->GetViewEntity();
if ( !g_nKillCamMode && (pPlayer->entindex() != viewentity) )
{
C_BaseEntity *ve = cl_entitylist->GetEnt( viewentity );
if ( ve )
{
VectorCopy( ve->GetAbsOrigin(), m_View.origin );
VectorCopy( ve->GetAbsAngles(), m_View.angles );
}
}
pPlayer->CalcViewModelView( m_View.origin, m_View.angles );
}
// Even if the engine is paused need to override the view
// for keeping the camera control during pause.
g_pClientMode->OverrideView( &m_View );
}
// give the toolsystem a chance to override the view
ToolFramework_SetupEngineView( m_View.origin, m_View.angles, m_View.fov );
if ( engine->IsPlayingDemo() )
{
if ( cl_demoviewoverride.GetFloat() > 0.0f )
{
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
CalcDemoViewOverride( m_View.origin, m_View.angles );
}
else
{
s_DemoView = m_View.origin;
s_DemoAngle = m_View.angles;
}
}
//Find the offset our current FOV is from the default value
float flFOVOffset = default_fov.GetFloat() - m_View.fov;
//Adjust the viewmodel's FOV to move with any FOV offsets on the viewer's end
m_View.fovViewmodel = g_pClientMode->GetViewModelFOV() - flFOVOffset;
// Disable spatical partition access
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, true );
// Enable access to all model bones
C_BaseAnimating::PopBoneAccess( "OnRenderStart->CViewRender::SetUpView" ); // pops the (true, false) bone access set in OnRenderStart
C_BaseAnimating::PushAllowBoneAccess( true, true, "CViewRender::SetUpView->OnRenderEnd" ); // pop is in OnRenderEnd()
// Compute the world->main camera transform
ComputeCameraVariables( m_View.origin, m_View.angles,
&g_vecVForward, &g_vecVRight, &g_vecVUp, &g_matCamInverse );
// set up the hearing origin...
AudioState_t audioState;
audioState.m_Origin = m_View.origin;
audioState.m_Angles = m_View.angles;
audioState.m_bIsUnderwater = pPlayer && pPlayer->AudioStateIsUnderwater( m_View.origin );
ToolFramework_SetupAudioState( audioState );
m_View.origin = audioState.m_Origin;
m_View.angles = audioState.m_Angles;
engine->SetAudioState( audioState );
g_vecPrevRenderOrigin = g_vecRenderOrigin;
g_vecPrevRenderAngles = g_vecRenderAngles;
g_vecRenderOrigin = m_View.origin;
g_vecRenderAngles = m_View.angles;
#ifdef _DEBUG
s_DbgSetupOrigin = m_View.origin;
s_DbgSetupAngles = m_View.angles;
#endif
}
//-----------------------------------------------------------------------------
// Procedurally generates the camo texture...
//-----------------------------------------------------------------------------
void CCamoMaterialProxy::GenerateCamoTexture( ITexture* pTexture, IVTFTexture *pVTFTexture )
{
if (!m_pEnt)
return;
#if 0
CamoInstanceData_t *pInstanceData;
pInstanceData = ( CamoInstanceData_t * )FindInstanceData( pEnt );
if( !pInstanceData )
{
pInstanceData = ( CamoInstanceData_t * )AllocateInstanceData( pEnt );
if( !pInstanceData )
{
return;
}
// init the instance data
}
#endif
Vector entityPosition;
entityPosition = m_pEnt->GetAbsOrigin();
QAngle entityAngles;
entityAngles = m_pEnt->GetAbsAngles();
// Get the bounding box for the entity
Vector mins, maxs;
mins = m_pEnt->WorldAlignMins();
maxs = m_pEnt->WorldAlignMaxs();
Vector traceDirection;
Vector traceEnd;
trace_t traceResult;
Vector forward, right, up;
AngleVectors( entityAngles, &forward, &right, &up );
Vector position, transformedPosition;
Vector maxsMinusMins = maxs - mins;
Vector diffuseColor[256];
Vector baseColor;
unsigned char camoPalette[256][3];
// Calculate the camo palette
//Msg( "start of loop\n" );
int i;
for( i = 0; i < m_CamoPatternNumColors; i++ )
{
GetColors( diffuseColor[i], baseColor, i,
mins, maxsMinusMins, forward, right, up, entityPosition );
#if 1
camoPalette[i][0] = diffuseColor[i][0] * baseColor[0] * 255.0f;
camoPalette[i][1] = diffuseColor[i][1] * baseColor[1] * 255.0f;
camoPalette[i][2] = diffuseColor[i][2] * baseColor[2] * 255.0f;
#endif
#if 0
camoPalette[i][0] = baseColor[0] * 255.0f;
camoPalette[i][1] = baseColor[1] * 255.0f;
camoPalette[i][2] = baseColor[2] * 255.0f;
#endif
#if 0
camoPalette[i][0] = diffuseColor[i][0] * 255.0f;
camoPalette[i][1] = diffuseColor[i][1] * 255.0f;
camoPalette[i][2] = diffuseColor[i][2] * 255.0f;
#endif
}
int width = pVTFTexture->Width();
int height = pVTFTexture->Height();
if( width != m_CamoPatternWidth || height != m_CamoPatternHeight )
{
return;
}
unsigned char *imageData = pVTFTexture->ImageData( 0, 0, 0 );
enum ImageFormat imageFormat = pVTFTexture->Format();
if( imageFormat != IMAGE_FORMAT_RGB888 )
{
return;
}
// optimize
#if 1
int x, y;
for( y = 0; y < height; y++ )
{
for( x = 0; x < width; x++ )
{
int offset = 3 * ( x + y * width );
assert( offset < width * height * 3 );
int paletteID = m_pCamoPatternImage[x + y * width];
assert( paletteID < 256 );
#if 1
imageData[offset + 0] = camoPalette[paletteID][0];
imageData[offset + 1] = camoPalette[paletteID][1];
imageData[offset + 2] = camoPalette[paletteID][2];
#else
imageData[offset] = 255;
imageData[offset + 1] = 0;
imageData[offset + 2] = 0;
#endif
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_FuncPhysicsRespawnZone::RespawnProps( void )
{
for ( int i = 0; i < m_PropList.Count(); i++ )
{
if ( m_PropList[i].hClientEntity == INVALID_CLIENTENTITY_HANDLE )
{
if ( !CanMovePropAt( m_PropList[i].vecOrigin, -Vector(32,32,32), Vector(32,32,32) ) )
continue;
// This is a crappy way to do this
C_PhysPropClientside *pEntity = C_PhysPropClientside::CreateNew();
if ( pEntity )
{
pEntity->m_spawnflags = m_PropList[i].iSpawnFlags;
pEntity->SetModelName( m_PropList[i].iszModelName );
pEntity->SetAbsOrigin( m_PropList[i].vecOrigin );
pEntity->SetAbsAngles( m_PropList[i].vecAngles );
pEntity->SetPhysicsMode( PHYSICS_MULTIPLAYER_CLIENTSIDE );
pEntity->m_nSkin = m_PropList[i].iSkin;
pEntity->m_iHealth = m_PropList[i].iHealth;
if ( pEntity->m_iHealth == 0 )
{
pEntity->m_takedamage = DAMAGE_NO;
}
if ( !pEntity->Initialize() )
{
pEntity->Release();
}
else
{
pEntity->SetRespawnZone( this );
m_PropList[i].hClientEntity = pEntity->GetClientHandle();
}
}
}
else
{
// If the prop has moved, bring it back
C_BaseEntity *pEntity = ClientEntityList().GetBaseEntityFromHandle( m_PropList[i].hClientEntity );
if ( pEntity )
{
if ( !CollisionProp()->IsPointInBounds( pEntity->WorldSpaceCenter() ) )
{
Vector vecMins, vecMaxs;
pEntity->CollisionProp()->WorldSpaceSurroundingBounds( &vecMins, &vecMaxs );
if ( !CanMovePropAt( m_PropList[i].vecOrigin, vecMins, vecMaxs ) ||
!CanMovePropAt( pEntity->GetAbsOrigin(), vecMins, vecMaxs ) )
continue;
pEntity->SetAbsOrigin( m_PropList[i].vecOrigin );
pEntity->SetAbsAngles( m_PropList[i].vecAngles );
IPhysicsObject *pPhys = pEntity->VPhysicsGetObject();
if ( pPhys )
{
pPhys->SetPosition( pEntity->GetAbsOrigin(), pEntity->GetAbsAngles(), true );
}
}
}
}
}
}
void __fastcall hkPaintTraverse(void* ecx, void* edx, unsigned int vguiPanel, bool forceRepaint, bool allowForce)
{
oPaintTraverse(ecx, vguiPanel, forceRepaint, allowForce);
static unsigned int MatSystemTopPanel;
static vgui::HFont s_HFontPlayer;
if (!MatSystemTopPanel)
{
const char* szName = ipanel()->GetName(vguiPanel);
g_pCVar->ConsoleColorPrintf(Color::Blue(), "panel: %s\n", szName);
if (_V_stricmp(szName, "MatSystemTopPanel") == 0) // MatSystemTopPanel
{
MatSystemTopPanel = vguiPanel;
engine->GetScreenSize(screenWidth, screenHeight);
s_HFontPlayer = g_pMatSurface->CreateFont();
g_pMatSurface->SetFontGlyphSet(s_HFontPlayer, "Tahoma", 14, 150, 0, 0, FONTFLAG_OUTLINE);
}
}
if (MatSystemTopPanel == vguiPanel)
{
if (GetAsyncKeyState(VK_F9) & 1)
{
name = !name;
if (name) Beep(0x367, 200);
else Beep(0x255, 200);
}
if (engine->IsInGame() && engine->IsConnected() && !engine->IsTakingScreenshot())
{
if (GetAsyncKeyState(VK_F11) & 1)
{
g_pCVar->ConsoleColorPrintf(Color::Red(), "Hello World!");
}
C_BaseEntity *pLocalEntity = (C_BaseEntity*)entitylist->GetClientEntity(engine->GetLocalPlayer());
if (!pLocalEntity)
return;
for (int i = 0; i < entitylist->GetHighestEntityIndex(); i++)
{
C_BaseEntity* pBaseEntity = (C_BaseEntity*)entitylist->GetClientEntity(i);
if (!pBaseEntity)
continue;
if (pBaseEntity->health() < 1)
continue;
if (pBaseEntity == pLocalEntity)
continue;
if (pLocalEntity->team() == pBaseEntity->team())
continue;
if (name)
{
Vector out;
if (WorldToScreen(pBaseEntity->GetAbsOrigin(), out))
{
if (name)
{
player_info_t info;
engine->GetPlayerInfo(i, &info);
DrawString(out.x - 5, out.y, Color::Red(), s_HFontPlayer, info.name);
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Sets up the view parameters
//-----------------------------------------------------------------------------
void CViewRender::SetUpView()
{
ASSERT_LOCAL_PLAYER_RESOLVABLE();
int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
m_bAllowViewAccess = true;
VPROF("CViewRender::SetUpView");
// Initialize view structure with default values
float farZ = GetZFar();
CViewSetup &view = GetView();
view.zFar = farZ;
view.zFarViewmodel = farZ;
// UNDONE: Make this farther out?
// closest point of approach seems to be view center to top of crouched box
view.zNear = GetZNear();
view.zNearViewmodel = 1;
view.fov = default_fov.GetFloat();
view.m_bOrtho = false;
// Enable spatial partition access to edicts
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, false );
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
bool bNoViewEnt = false;
if( pPlayer == NULL )
{
pPlayer = GetSplitScreenViewPlayer( nSlot );
bNoViewEnt = true;
}
if ( g_bEngineIsHLTV )
{
HLTVCamera()->CalcView( view.origin, view.angles, view.fov );
}
#if defined( REPLAY_ENABLED )
else if ( engine->IsReplay() )
{
ReplayCamera()->CalcView( view.origin, view.angles, view.fov );
}
#endif
else
{
// FIXME: Are there multiple views? If so, then what?
// FIXME: What happens when there's no player?
if (pPlayer)
{
pPlayer->CalcView( view.origin, view.angles, view.zNear, view.zFar, view.fov );
// If we are looking through another entities eyes, then override the angles/origin for GetView()
int viewentity = render->GetViewEntity();
if ( !bNoViewEnt && !g_nKillCamMode && (pPlayer->entindex() != viewentity) )
{
C_BaseEntity *ve = cl_entitylist->GetEnt( viewentity );
if ( ve )
{
VectorCopy( ve->GetAbsOrigin(), view.origin );
VectorCopy( ve->GetAbsAngles(), view.angles );
}
}
pPlayer->CalcViewModelView( view.origin, view.angles );
// Is this the proper place for this code?
if ( cl_camera_follow_bone_index.GetInt() >= -1 && input->CAM_IsThirdPerson() )
{
VectorCopy( g_cameraFollowPos, view.origin );
}
}
// Even if the engine is paused need to override the view
// for keeping the camera control during pause.
GetClientMode()->OverrideView( &GetView() );
}
// give the toolsystem a chance to override the view
ToolFramework_SetupEngineView( view.origin, view.angles, view.fov );
if ( engine->IsPlayingDemo() )
{
if ( cl_demoviewoverride.GetFloat() > 0.0f )
{
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
CalcDemoViewOverride( view.origin, view.angles );
}
else
{
s_DemoView = view.origin;
s_DemoAngle = view.angles;
}
}
// Disable spatial partition access
partition->SuppressLists( PARTITION_ALL_CLIENT_EDICTS, true );
//Find the offset our current FOV is from the default value
float flFOVOffset = default_fov.GetFloat() - view.fov;
//Adjust the viewmodel's FOV to move with any FOV offsets on the viewer's end
view.fovViewmodel = GetClientMode()->GetViewModelFOV() - flFOVOffset;
// Compute the world->main camera transform
ComputeCameraVariables( view.origin, view.angles,
&g_vecVForward[ nSlot ], &g_vecVRight[ nSlot ], &g_vecVUp[ nSlot ], &g_matCamInverse[ nSlot ] );
// set up the hearing origin...
AudioState_t audioState;
audioState.m_Origin = view.origin;
audioState.m_Angles = view.angles;
audioState.m_bIsUnderwater = pPlayer && pPlayer->AudioStateIsUnderwater( view.origin );
ToolFramework_SetupAudioState( audioState );
view.origin = audioState.m_Origin;
view.angles = audioState.m_Angles;
GetClientMode()->OverrideAudioState( &audioState );
engine->SetAudioState( audioState );
g_vecPrevRenderOrigin[ nSlot ] = g_vecRenderOrigin[ nSlot ];
g_vecPrevRenderAngles[ nSlot ] = g_vecRenderAngles[ nSlot ];
g_vecRenderOrigin[ nSlot ] = view.origin;
g_vecRenderAngles[ nSlot ] = view.angles;
#ifdef DBGFLAG_ASSERT
s_DbgSetupOrigin[ nSlot ] = view.origin;
s_DbgSetupAngles[ nSlot ] = view.angles;
#endif
m_bAllowViewAccess = false;
}
//======================================================================================================================
// PARTICLE SYSTEM DISPATCH EFFECT
//======================================================================================================================
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void StartParticleEffect( const CEffectData &data, int nSplitScreenPlayerSlot /*= -1*/ )
{
// this needs to be before using data.m_nHitBox,
// since that may be a serialized value that's past the end of the current particle system string table
if ( SuppressingParticleEffects() )
return;
// Don't crash if we're passed an invalid particle system
if ( data.m_nHitBox == 0 )
return;
if ( data.m_fFlags & PARTICLE_DISPATCH_FROM_ENTITY )
{
if ( data.m_hEntity.Get() )
{
C_BaseEntity *pEnt = C_BaseEntity::Instance( data.m_hEntity );
// commented out assert. dormant entities have their particle system spawns stopped.
//Assert( pEnt && !pEnt->IsDormant() );
if ( pEnt && !pEnt->IsDormant() )
{
if ( data.m_fFlags & PARTICLE_DISPATCH_RESET_PARTICLES )
{
pEnt->ParticleProp()->StopEmission();
}
CUtlReference<CNewParticleEffect> pEffect = pEnt->ParticleProp()->CreatePrecached( data.m_nHitBox, (ParticleAttachment_t)data.m_nDamageType, data.m_nAttachmentIndex );
if ( pEffect.IsValid() && pEffect->IsValid() )
{
if ( (ParticleAttachment_t)data.m_nDamageType == PATTACH_CUSTOMORIGIN || (ParticleAttachment_t)data.m_nDamageType == PATTACH_CUSTOMORIGIN_FOLLOW )
{
pEffect->SetDrawOnlyForSplitScreenUser( nSplitScreenPlayerSlot );
pEffect->SetSortOrigin( data.m_vOrigin );
if ( (ParticleAttachment_t)data.m_nDamageType == PATTACH_CUSTOMORIGIN_FOLLOW )
{
Vector vecCtrl1 = (data.m_vStart - pEnt->GetAbsOrigin() );
pEffect->SetControlPoint( 1, vecCtrl1 );
pEffect->SetControlPointEntity( 1, pEnt );
Vector vecCtrl0 = (data.m_vOrigin - pEnt->GetAbsOrigin() );
matrix3x4_t mat;
AngleMatrix( data.m_vAngles, mat );
pEnt->ParticleProp()->AddControlPoint( pEffect, 0, pEnt, PATTACH_CUSTOMORIGIN_FOLLOW, NULL, vecCtrl0, &mat );
}
else
{
pEffect->SetControlPoint( 0, data.m_vOrigin );
pEffect->SetControlPoint( 1, data.m_vStart );
Vector vecForward, vecRight, vecUp;
AngleVectors( data.m_vAngles, &vecForward, &vecRight, &vecUp );
pEffect->SetControlPointOrientation( 0, vecForward, vecRight, vecUp );
}
}
else if ( data.m_nOtherEntIndex > 0 )
{
C_BaseEntity *pOtherEnt = ClientEntityList().GetEnt( data.m_nOtherEntIndex );
if ( pOtherEnt )
{
pEnt->ParticleProp()->AddControlPoint( pEffect, 1, pOtherEnt, PATTACH_ABSORIGIN_FOLLOW, NULL, Vector( 0, 0, 50 ) );
}
}
}
}
}
}
else
{
CParticleSystemDefinition *pDef = g_pParticleSystemMgr->FindPrecachedParticleSystem( data.m_nHitBox );
if ( pDef )
{
CUtlReference<CNewParticleEffect> pEffect = CNewParticleEffect::CreateOrAggregate( NULL, pDef, data.m_vOrigin, NULL, nSplitScreenPlayerSlot );
if ( pEffect.IsValid() && pEffect->IsValid() )
{
pEffect->SetSortOrigin( data.m_vOrigin );
pEffect->SetControlPoint( 0, data.m_vOrigin );
pEffect->SetControlPoint( 1, data.m_vStart );
Vector vecForward, vecRight, vecUp;
AngleVectors( data.m_vAngles, &vecForward, &vecRight, &vecUp );
pEffect->SetControlPointOrientation( 0, vecForward, vecRight, vecUp );
}
}
else
{
Warning( "StartParticleEffect: Failed to find precached particle system for %d!!\n", data.m_nHitBox );
}
}
}
void CASWHudCrosshair::PaintTurretTextures()
{
// draw border in centre of screen
//int h = ScreenHeight();
//int w = h * 1.333333f;
//int x = (ScreenWidth() * 0.5f) - (w * 0.5f);
//int y = 0;
surface()->DrawSetColor(Color(255,255,255,255));
/*
int tx = YRES( 5 );
int ty = YRES( 5 );
vgui::surface()->DrawSetTextFont( m_hTurretFont );
vgui::surface()->DrawSetTextColor( 255, 255, 255, 200 );
vgui::surface()->DrawSetTextPos( tx, ty );
int nFontTall = vgui::surface()->GetFontTall( m_hTurretFont );
wchar_t szconverted[ 1024 ];
g_pVGuiLocalize->ConvertANSIToUnicode( "#asw_turret_text_top_left", szconverted, sizeof( szconverted ) );
vgui::surface()->DrawPrintText( szconverted, wcslen( szconverted ) );
ty = ScreenHeight() - nFontTall * 8 - YRES( 100 );
vgui::surface()->DrawSetTextPos( tx, ty );
g_pVGuiLocalize->ConvertANSIToUnicode( "#asw_turret_text_lower_left", szconverted, sizeof( szconverted ) );
vgui::surface()->DrawPrintText( szconverted, wcslen( szconverted ) );
*/
// draw black boxes either side
//if (m_nBlackBarTexture != -1)
//{
//surface()->DrawSetTexture(m_nBlackBarTexture);
//surface()->DrawTexturedRect(0, y, x, y + h);
//surface()->DrawTexturedRect(x + w, y, x, y + h);
//}
// draw fancy brackets over all turret targets
float fScale = (ScreenHeight() / 768.0f);
int iBSize = fScale * 32.0f;
for (int i=0;i<ASW_MAX_TURRET_TARGETS;i++)
{
C_BaseEntity *pEnt = m_TurretTarget[i];
if (!pEnt)
continue;
// distance of each bracket part from the ent
float fDist = fScale * 200.0f * (1.0f - m_fTurretTargetLock[i]);
Vector pos = (pEnt->WorldSpaceCenter() - pEnt->GetAbsOrigin()) + pEnt->GetRenderOrigin();
Vector screenPos;
debugoverlay->ScreenPosition( pos, screenPos );
surface()->DrawSetColor(Color(255,255,255,255.0f * m_fTurretTargetLock[i] ));
surface()->DrawSetTexture(m_nLeftBracketTexture);
int bx = screenPos[0] - fDist;
int by = screenPos[1] - fDist;
surface()->DrawTexturedRect(bx - iBSize, by - iBSize, bx + iBSize, by + iBSize);
surface()->DrawSetTexture(m_nRightBracketTexture);
bx = screenPos[0] + fDist;
by = screenPos[1] - fDist;
surface()->DrawTexturedRect(bx - iBSize, by - iBSize, bx + iBSize, by + iBSize);
surface()->DrawSetTexture(m_nLowerBracketTexture);
bx = screenPos[0];
by = screenPos[1] + fDist;
surface()->DrawTexturedRect(bx - iBSize, by - iBSize, bx + iBSize, by + iBSize);
}
// draw crosshair
C_ASW_Player* pPlayer = C_ASW_Player::GetLocalASWPlayer();
if ( pPlayer )
{
C_ASW_Marine *pMarine = pPlayer->GetViewMarine();
bool bControllingTurret = (pMarine && pMarine->IsControllingTurret());
if (bControllingTurret)
{
C_ASW_Remote_Turret *pTurret = pMarine->GetRemoteTurret();
if (pTurret)
{
Vector vecWeaponSrc = pTurret->GetTurretMuzzlePosition();
QAngle angFacing = pTurret->EyeAngles();
Vector vecWeaponDir;
AngleVectors(angFacing, &vecWeaponDir);
// trace along until we hit something
trace_t tr;
UTIL_TraceLine(vecWeaponSrc, vecWeaponSrc + vecWeaponDir * 1200, // fog range of the turret
MASK_SHOT, pTurret, COLLISION_GROUP_NONE, &tr);
//Msg("Tracing from %s ", VecToString(vecWeaponSrc));
//Msg("at angle %s\n", VecToString(angFacing));
Vector pos = tr.DidHit() ? tr.endpos : vecWeaponSrc + vecWeaponDir * 1200;
Vector screenPos;
debugoverlay->ScreenPosition( pos, screenPos );
// paint a crosshair at that spot
surface()->DrawSetColor(Color(255,255,255,255));
surface()->DrawSetTexture(m_nTurretCrosshair);
surface()->DrawTexturedRect(screenPos[0] - iBSize, screenPos[1] - iBSize, // shift it up a bit to match where the gun actually fires (not sure why it's not matched already!)
screenPos[0] + iBSize, screenPos[1] + iBSize);
}
}
}
// draw interlace/noise overlay
if (m_nTurretTexture!=-1)
{
surface()->DrawSetColor(Color(255,255,255,255));
surface()->DrawSetTexture(m_nTurretTexture);
surface()->DrawTexturedRect(0, 0, ScreenWidth(), ScreenHeight());
}
}
//-----------------------------------------------------------------------------
// 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 );
}
