void CPlayerViewProxy::OnBind( void *pC_BaseEntity )
{
if (!pC_BaseEntity)
return;
// Find the view angle between the player and this entity....
C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
C_BaseEntity* pPlayer = C_BasePlayer::GetLocalPlayer();
if (!pPlayer)
return;
Vector delta;
VectorSubtract( pEntity->WorldSpaceCenter(), pPlayer->WorldSpaceCenter(), delta );
VectorNormalize( delta );
Vector forward;
AngleVectors( pPlayer->GetAbsAngles(), &forward );
Assert( m_pResult );
SetFloatResult( DotProduct( forward, delta ) * m_Factor );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
//-----------------------------------------------------------------------------
// 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 );
}
}
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// 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 );
}
}
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 );
}
}
}
//-----------------------------------------------------------------------------
// 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_ParticleSmokeGrenade::UpdateSmokeTrail( float fTimeDelta )
{
C_BaseEntity *pAimEnt = GetFollowedEntity();
if ( pAimEnt )
{
Vector forward, right, up;
// Update the smoke particle color.
if(m_CurrentStage == 0)
{
m_SmokeTrail.m_StartColor = EngineGetLightForPoint(GetAbsOrigin()) * 0.5f;
m_SmokeTrail.m_EndColor = m_SmokeTrail.m_StartColor;
}
// Spin the smoke trail.
AngleVectors(pAimEnt->GetAbsAngles(), &forward, &right, &up);
m_SmokeTrail.m_VelocityOffset = forward * 30 + GetAbsVelocity();
m_SmokeTrail.SetLocalOrigin( GetAbsOrigin() );
m_SmokeTrail.Update(fTimeDelta);
}
}
//-----------------------------------------------------------------------------
// 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 );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// 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;
}
//-----------------------------------------------------------------------------
// 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 C_ParticleSmokeGrenade::Update(float fTimeDelta)
{
m_LifetimeCounter += fTimeDelta;
// Update the smoke trail.
C_BaseEntity *pAimEnt = GetFollowedEntity();
if ( pAimEnt )
{
Vector forward, right, up;
// Update the smoke particle color.
if(m_CurrentStage == 0)
{
m_SmokeTrail.m_StartColor = EngineGetLightForPoint(GetAbsOrigin()) * 0.5f;
m_SmokeTrail.m_EndColor = m_SmokeTrail.m_StartColor;
}
// Spin the smoke trail.
AngleVectors(pAimEnt->GetAbsAngles(), &forward, &right, &up);
m_SmokeTrail.m_VelocityOffset = forward * 30 + GetAbsVelocity();
m_SmokeTrail.SetLocalOrigin( GetAbsOrigin() );
m_SmokeTrail.Update(fTimeDelta);
}
// Update our fade alpha.
if(m_LifetimeCounter < m_FadeStartTime)
{
m_FadeAlpha = 1;
}
else if(m_LifetimeCounter < m_FadeEndTime)
{
float fadePercent = (m_LifetimeCounter - m_FadeStartTime) / (m_FadeEndTime - m_FadeStartTime);
m_FadeAlpha = cos(fadePercent * 3.14159) * 0.5 + 0.5;
}
else
{
m_FadeAlpha = 0;
}
// Scale by the amount the sphere has grown.
m_FadeAlpha *= m_ExpandRadius / SMOKESPHERE_MAX_RADIUS;
if(m_CurrentStage == 1)
{
// Update the expanding sphere.
m_ExpandTimeCounter += fTimeDelta;
if(m_ExpandTimeCounter > SMOKESPHERE_EXPAND_TIME)
m_ExpandTimeCounter = SMOKESPHERE_EXPAND_TIME;
m_ExpandRadius = SMOKESPHERE_MAX_RADIUS * (float)sin(m_ExpandTimeCounter * 3.14159265358 * 0.5 / SMOKESPHERE_EXPAND_TIME);
// Add our influence to the global smoke fog alpha.
float testDist = (EngineGetVecRenderOrigin() - m_SmokeBasePos).Length();
float fadeEnd = m_ExpandRadius * 0.75;
if(testDist < fadeEnd)
{
EngineGetSmokeFogOverlayAlpha() += 1 - testDist / fadeEnd;
}
// This is used to randomize the direction it chooses to move a particle in.
int offsetLookup[3] = {-1,0,1};
// Update all the moving traders and establish new ones.
int nTotal = m_xCount * m_yCount * m_zCount;
for(int i=0; i < nTotal; i++)
{
SmokeParticleInfo *pInfo = &m_SmokeParticleInfos[i];
if(!pInfo->m_pParticle)
continue;
if(pInfo->m_TradeIndex == -1)
{
pInfo->m_pParticle->m_FadeAlpha = pInfo->m_FadeAlpha;
pInfo->m_pParticle->m_Color[0] = pInfo->m_Color[0];
pInfo->m_pParticle->m_Color[1] = pInfo->m_Color[1];
pInfo->m_pParticle->m_Color[2] = pInfo->m_Color[2];
// Is there an adjacent one that's not trading?
int x, y, z;
GetParticleInfoXYZ(i, x, y, z);
int xCountOffset = rand();
int yCountOffset = rand();
int zCountOffset = rand();
bool bFound = false;
for(int xCount=0; xCount < 3 && !bFound; xCount++)
{
for(int yCount=0; yCount < 3 && !bFound; yCount++)
{
for(int zCount=0; zCount < 3; zCount++)
{
int testX = x + offsetLookup[(xCount+xCountOffset) % 3];
int testY = y + offsetLookup[(yCount+yCountOffset) % 3];
int testZ = z + offsetLookup[(zCount+zCountOffset) % 3];
if(testX == x && testY == y && testZ == z)
continue;
if(IsValidXYZCoords(testX, testY, testZ))
{
SmokeParticleInfo *pOther = GetSmokeParticleInfo(testX, testY, testZ);
if(pOther->m_pParticle && pOther->m_TradeIndex == -1)
{
// Ok, this one is looking to trade also.
pInfo->m_TradeIndex = GetSmokeParticleIndex(testX, testY, testZ);
pOther->m_TradeIndex = i;
pInfo->m_TradeClock = pOther->m_TradeClock = 0;
pInfo->m_TradeDuration = FRand(TRADE_DURATION_MIN, TRADE_DURATION_MAX);
bFound = true;
break;
}
}
}
}
}
}
else
{
SmokeParticleInfo *pOther = &m_SmokeParticleInfos[pInfo->m_TradeIndex];
assert(pOther->m_TradeIndex == i);
// This makes sure the trade only gets updated once per frame.
if(pInfo < pOther)
{
// Increment the trade clock..
pInfo->m_TradeClock = (pOther->m_TradeClock += fTimeDelta);
int x, y, z;
GetParticleInfoXYZ(i, x, y, z);
Vector myPos = GetSmokeParticlePos(x, y, z);
int otherX, otherY, otherZ;
GetParticleInfoXYZ(pInfo->m_TradeIndex, otherX, otherY, otherZ);
Vector otherPos = GetSmokeParticlePos(otherX, otherY, otherZ);
// Is the trade finished?
if(pInfo->m_TradeClock >= pInfo->m_TradeDuration)
{
pInfo->m_TradeIndex = pOther->m_TradeIndex = -1;
pInfo->m_pParticle->m_Pos = otherPos;
pOther->m_pParticle->m_Pos = myPos;
SmokeGrenadeParticle *temp = pInfo->m_pParticle;
pInfo->m_pParticle = pOther->m_pParticle;
pOther->m_pParticle = temp;
}
else
{
// Ok, move them closer.
float percent = (float)cos(pInfo->m_TradeClock * 2 * 1.57079632f / pInfo->m_TradeDuration);
percent = percent * 0.5 + 0.5;
pInfo->m_pParticle->m_FadeAlpha = pInfo->m_FadeAlpha + (pOther->m_FadeAlpha - pInfo->m_FadeAlpha) * (1 - percent);
pOther->m_pParticle->m_FadeAlpha = pInfo->m_FadeAlpha + (pOther->m_FadeAlpha - pInfo->m_FadeAlpha) * percent;
InterpColor(pInfo->m_pParticle->m_Color, pInfo->m_Color, pOther->m_Color, 1-percent);
InterpColor(pOther->m_pParticle->m_Color, pInfo->m_Color, pOther->m_Color, percent);
pInfo->m_pParticle->m_Pos = myPos + (otherPos - myPos) * (1 - percent);
pOther->m_pParticle->m_Pos = myPos + (otherPos - myPos) * percent;
}
}
}
}
}
}