void CC_PickerShader ( const CCommand &args )
{
C_BasePlayer *pPlayer = (C_BasePlayer *) C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
trace_t tr;
Vector vecAbsStart, vecAbsEnd, vecDir;
AngleVectors( pPlayer->EyeAngles(), &vecDir );
vecAbsStart = pPlayer->EyePosition();
vecAbsEnd = vecAbsStart + (vecDir * MAX_TRACE_LENGTH);
UTIL_TraceLine( vecAbsStart, vecAbsEnd, MASK_ALL, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHitWorld() )
{
IMaterial *pMaterial = materials->FindMaterial( tr.surface.name, TEXTURE_GROUP_PRECACHED );
if ( !IsErrorMaterial( pMaterial ) )
{
const char* shadername = pMaterial->GetShaderName();
Msg("Material shader name: %s\n", shadername);
}
else
{
Msg("Could not get material shader name.\n");
}
}
else
{
Msg("This command only supports world geometry.\n");
}
}
bool CClientTools::GetLocalPlayerEyePosition( Vector& org, QAngle& ang, float &fov )
{
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
if ( pl == NULL )
return false;
org = pl->EyePosition();
ang = pl->EyeAngles();
fov = pl->GetFOV();
return true;
}
bool CClientTools::GetLocalPlayerEyePosition( Vector& org, QAngle& ang, float &fov )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( 0 );
C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer();
if ( pl == NULL )
return false;
org = pl->EyePosition();
ang = pl->EyeAngles();
fov = pl->GetFOV();
return true;
}
void C_HLTVCamera::CalcInEyeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
{
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( m_iTraget1 );
if ( !pPlayer )
return;
if ( !pPlayer->IsAlive() )
{
// if dead, show from 3rd person
CalcChaseCamView( eyeOrigin, eyeAngles, fov );
return;
}
m_aCamAngle = pPlayer->EyeAngles();
m_vCamOrigin = pPlayer->GetAbsOrigin();
m_flFOV = pPlayer->GetFOV();
if ( pPlayer->GetFlags() & FL_DUCKING )
{
m_vCamOrigin += VEC_DUCK_VIEW;
}
else
{
m_vCamOrigin += VEC_VIEW;
}
eyeOrigin = m_vCamOrigin;
eyeAngles = m_aCamAngle;
fov = m_flFOV;
pPlayer->CalcViewModelView( eyeOrigin, eyeAngles);
C_BaseViewModel *pViewModel = pPlayer->GetViewModel( 0 );
if ( pViewModel )
{
Assert( pViewModel->GetOwner() == pPlayer );
pViewModel->UpdateVisibility();
}
}
//-----------------------------------------------------------------------------
// Purpose: Deal with input
//-----------------------------------------------------------------------------
void C_VGuiScreen::ClientThink( void )
{
BaseClass::ClientThink();
// FIXME: We should really be taking bob, shake, and roll into account
// but if we did, then all the inputs would be generated multiple times
// if the world was rendered multiple times (for things like water, etc.)
vgui::Panel *pPanel = m_PanelWrapper.GetPanel();
if (!pPanel)
return;
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if (!pLocalPlayer)
return;
// Generate a ray along the view direction
Vector vecEyePosition = pLocalPlayer->EyePosition();
QAngle viewAngles = pLocalPlayer->EyeAngles( );
Vector viewDir, endPos;
AngleVectors( viewAngles, &viewDir );
VectorMA( vecEyePosition, 1000.0f, viewDir, endPos );
// Compute cursor position...
Ray_t lookDir;
lookDir.Init( vecEyePosition, endPos );
float u, v;
if (!IntersectWithRay( lookDir, &u, &v, NULL ))
return;
if ( ((u < 0) || (v < 0) || (u > 1) || (v > 1)) && !m_bLooseThinkNextFrame)
return;
// This will cause our panel to grab all input!
g_pClientMode->ActivateInGameVGuiContext( pPanel );
// Convert (u,v) into (px,py)
int px = (int)(u * m_nPixelWidth + 0.5f);
int py = (int)(v * m_nPixelHeight + 0.5f);
// Generate mouse input commands
if ((px != m_nOldPx) || (py != m_nOldPy))
{
g_InputInternal->InternalCursorMoved( px, py );
m_nOldPx = px;
m_nOldPy = py;
}
if (m_nButtonPressed & IN_ATTACK)
{
g_InputInternal->InternalMousePressed(vgui::MOUSE_LEFT);
}
if (m_nButtonPressed & IN_ATTACK2)
{
g_InputInternal->InternalMousePressed(vgui::MOUSE_RIGHT);
}
if ( (m_nButtonReleased & IN_ATTACK) || m_bLooseThinkNextFrame) // for a button release on loosing focus
{
g_InputInternal->InternalMouseReleased(vgui::MOUSE_LEFT);
}
if (m_nButtonReleased & IN_ATTACK2)
{
g_InputInternal->InternalMouseReleased(vgui::MOUSE_RIGHT);
}
if ( m_bLooseThinkNextFrame == true )
{
m_bLooseThinkNextFrame = false;
SetNextClientThink( CLIENT_THINK_NEVER );
}
g_pClientMode->DeactivateInGameVGuiContext( );
}
void CSDKMapOverview::UpdatePlayers()
{
C_SDK_PlayerResource *pSDKPR = (C_SDK_PlayerResource*)GameResources();
if ( !pSDKPR )
return;
CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
if( localPlayer == NULL )
return;
MapPlayer_t *localMapPlayer = GetPlayerByUserID(localPlayer->GetUserID());
if( localMapPlayer == NULL )
return;
for ( int i = 1; i<= gpGlobals->maxClients; i++)
{
MapPlayer_t *player = &m_Players[i-1];
SDKMapPlayer_t *playerSDK = GetSDKInfoForPlayerIndex(i-1);
if ( !playerSDK )
continue;
// update from global player resources
if ( pSDKPR->IsConnected(i) )
{
player->health = pSDKPR->GetHealth( i );
if ( !pSDKPR->IsAlive( i ) )
{
// Safety actually happens after a TKPunish.
player->health = 0;
playerSDK->isDead = true;
}
if ( player->team != pSDKPR->GetTeam( i ) )
{
player->team = pSDKPR->GetTeam( i );
if( player == localMapPlayer )
player->icon = m_TeamIconsSelf[ GetIconNumberFromTeamNumber(player->team) ];
else
player->icon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];
player->color = m_TeamColors[ GetIconNumberFromTeamNumber(player->team) ];
}
}
Vector position = player->position;
QAngle angles = player->angle;
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer && !pPlayer->IsDormant() )
{
// update position of active players in our PVS
position = pPlayer->EyePosition();
angles = pPlayer->EyeAngles();
SetPlayerPositions( i-1, position, angles );
}
}
}
void CSDKMapOverview::DrawCamera()
{
C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
if (!localPlayer)
return;
if( localPlayer->GetObserverMode() == OBS_MODE_ROAMING )
{
// Instead of the programmer-art red dot, we'll draw an icon for when our camera is roaming.
int alpha = 255;
DrawIconSDK(m_cameraIconFree, m_cameraIconFree, localPlayer->GetAbsOrigin(), m_flIconSize * 3.0f, localPlayer->EyeAngles()[YAW], alpha);
}
else if( localPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
if( localPlayer->GetObserverTarget() )
{
// Fade it if it is on top of a player dot. And don't rotate it.
int alpha = 255 * 0.5f;
DrawIconSDK(m_cameraIconFirst, m_cameraIconFirst, localPlayer->GetObserverTarget()->GetAbsOrigin(), m_flIconSize * 1.5f, GetViewAngle(), alpha);
}
}
else if( localPlayer->GetObserverMode() == OBS_MODE_CHASE )
{
if( localPlayer->GetObserverTarget() )
{
// Or Draw the third-camera a little bigger. (Needs room to be off the dot being followed)
int alpha = 255;
DrawIconSDK(m_cameraIconThird, m_cameraIconThird, localPlayer->GetObserverTarget()->GetAbsOrigin(), m_flIconSize * 3.0f, localPlayer->EyeAngles()[YAW], alpha);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: First-person function call after viewmodel has been drawn
//-----------------------------------------------------------------------------
void CWeaponGravityGun::ViewModelDrawn( C_BaseViewModel *pBaseViewModel )
{
if ( !m_active )
return;
// Render our effects
C_BasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !pOwner )
return;
Vector points[3];
QAngle tmpAngle;
C_BaseEntity *pObject = m_hObject;
//if ( pObject == NULL )
// return;
pBaseViewModel->GetAttachment( 1, points[0], tmpAngle );
// a little noise 11t & 13t should be somewhat non-periodic looking
//points[1].z += 4*sin( gpGlobals->curtime*11 ) + 5*cos( gpGlobals->curtime*13 );
if ( pObject == NULL )
{
//points[2] = m_targetPosition;
trace_t tr;
TraceLine( &tr );
points[2] = tr.endpos;
}
else
{
pObject->EntityToWorldSpace(m_worldPosition, &points[2]);
}
Vector forward, right, up;
QAngle playerAngles = pOwner->EyeAngles();
AngleVectors( playerAngles, &forward, &right, &up );
Vector vecSrc = pOwner->Weapon_ShootPosition( );
points[1] = vecSrc + 0.5f * (forward * points[2].DistTo(points[0]));
IMaterial *pMat = materials->FindMaterial( "sprites/physbeam1", TEXTURE_GROUP_CLIENT_EFFECTS );
if ( pObject )
pMat = materials->FindMaterial( "sprites/physbeam", TEXTURE_GROUP_CLIENT_EFFECTS );
Vector color;
color.Init(1,1,1);
// Now draw it.
CViewSetup beamView = *view->GetPlayerViewSetup();
Frustum dummyFrustum;
render->Push3DView( beamView, 0, NULL, dummyFrustum );
float scrollOffset = gpGlobals->curtime - (int)gpGlobals->curtime;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMat );
#if 1
// HACK HACK: Munge the depth range to prevent view model from poking into walls, etc.
// Force clipped down range
pRenderContext->DepthRange( 0.1f, 0.2f );
#endif
DrawBeamQuadratic( points[0], points[1], points[2], pObject ? 13/3.0f : 13/5.0f, color, scrollOffset );
DrawBeamQuadratic( points[0], points[1], points[2], pObject ? 13/3.0f : 13/5.0f, color, -scrollOffset );
IMaterial *pMaterial = materials->FindMaterial( "sprites/physglow", TEXTURE_GROUP_CLIENT_EFFECTS );
color32 clr={0,64,255,255};
if ( pObject )
{
clr.r = 186;
clr.g = 253;
clr.b = 247;
clr.a = 255;
}
float scale = random->RandomFloat( 3, 5 ) * ( pObject ? 3 : 2 );
// Draw the sprite
pRenderContext->Bind( pMaterial );
for ( int i = 0; i < 3; i++ )
{
DrawSprite( points[2], scale, scale, clr );
}
#if 1
pRenderContext->DepthRange( 0.0f, 1.0f );
#endif
render->PopView( dummyFrustum );
// Pass this back up
BaseClass::ViewModelDrawn( pBaseViewModel );
}
//-----------------------------------------------------------------------------
// Purpose: Third-person function call to render world model
//-----------------------------------------------------------------------------
int CWeaponGravityGun::DrawModel( int flags )
{
// Only render these on the transparent pass
if ( flags & STUDIO_TRANSPARENCY )
{
if ( !m_active )
return 0;
C_BasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !pOwner )
return 0;
Vector points[3];
QAngle tmpAngle;
C_BaseEntity *pObject = m_hObject;
//if ( pObject == NULL )
// return 0;
GetAttachment( 1, points[0], tmpAngle );
// a little noise 11t & 13t should be somewhat non-periodic looking
//points[1].z += 4*sin( gpGlobals->curtime*11 ) + 5*cos( gpGlobals->curtime*13 );
if ( pObject == NULL )
{
//points[2] = m_targetPosition;
trace_t tr;
TraceLine( &tr );
points[2] = tr.endpos;
}
else
{
pObject->EntityToWorldSpace( m_worldPosition, &points[2] );
}
Vector forward, right, up;
QAngle playerAngles = pOwner->EyeAngles();
AngleVectors( playerAngles, &forward, &right, &up );
if ( pObject == NULL )
{
Vector vecDir = points[2] - points[0];
VectorNormalize( vecDir );
points[1] = points[0] + 0.5f * (vecDir * points[2].DistTo(points[0]));
}
else
{
Vector vecSrc = pOwner->Weapon_ShootPosition( );
points[1] = vecSrc + 0.5f * (forward * points[2].DistTo(points[0]));
}
IMaterial *pMat = materials->FindMaterial( "sprites/physbeam1", TEXTURE_GROUP_CLIENT_EFFECTS );
if ( pObject )
pMat = materials->FindMaterial( "sprites/physbeam", TEXTURE_GROUP_CLIENT_EFFECTS );
Vector color;
color.Init(1,1,1);
float scrollOffset = gpGlobals->curtime - (int)gpGlobals->curtime;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMat );
DrawBeamQuadratic( points[0], points[1], points[2], pObject ? 13/3.0f : 13/5.0f, color, scrollOffset );
DrawBeamQuadratic( points[0], points[1], points[2], pObject ? 13/3.0f : 13/5.0f, color, -scrollOffset );
IMaterial *pMaterial = materials->FindMaterial( "sprites/physglow", TEXTURE_GROUP_CLIENT_EFFECTS );
color32 clr={0,64,255,255};
if ( pObject )
{
clr.r = 186;
clr.g = 253;
clr.b = 247;
clr.a = 255;
}
float scale = random->RandomFloat( 3, 5 ) * ( pObject ? 3 : 2 );
// Draw the sprite
pRenderContext->Bind( pMaterial );
for ( int i = 0; i < 3; i++ )
{
DrawSprite( points[2], scale, scale, clr );
}
return 1;
}
// Only do this on the opaque pass
return BaseClass::DrawModel( flags );
}
//-----------------------------------------------------------------------------
// Purpose: Deal with input
//-----------------------------------------------------------------------------
void C_VGuiScreen::ClientThink( void )
{
int nButtonsChanged = m_nOldButtonState ^ m_nButtonState;
m_nOldButtonState = m_nButtonState;
// Debounced button codes for pressed/released
// UNDONE: Do we need auto-repeat?
m_nButtonPressed = nButtonsChanged & m_nButtonState; // The changed ones still down are "pressed"
m_nButtonReleased = nButtonsChanged & (~m_nButtonState); // The ones not down are "released"
BaseClass::ClientThink();
// FIXME: We should really be taking bob, shake, and roll into account
// but if we did, then all the inputs would be generated multiple times
// if the world was rendered multiple times (for things like water, etc.)
vgui::Panel *pPanel = m_PanelWrapper.GetPanel();
if (!pPanel)
return;
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if (!pLocalPlayer)
return;
// Generate a ray along the view direction
Vector vecEyePosition = pLocalPlayer->EyePosition();
QAngle viewAngles = pLocalPlayer->EyeAngles( );
// Compute cursor position...
Ray_t lookDir;
Vector endPos;
float u, v;
// Viewmodel attached screens that take input need to have a moving cursor
// Do a pick under the cursor as our selection
Vector viewDir;
AngleVectors( viewAngles, &viewDir );
VectorMA( vecEyePosition, 1000.0f, viewDir, endPos );
lookDir.Init( vecEyePosition, endPos );
if (!IntersectWithRay( lookDir, &u, &v, NULL ))
return;
if ( ((u < 0) || (v < 0) || (u > 1) || (v > 1)) && !m_bLoseThinkNextFrame)
return;
// This will cause our panel to grab all input!
g_pClientMode->ActivateInGameVGuiContext( pPanel );
// Convert (u,v) into (px,py)
int px = (int)(u * m_nPixelWidth + 0.5f);
int py = (int)(v * m_nPixelHeight + 0.5f);
// Generate mouse input commands
if ((px != m_nOldPx) || (py != m_nOldPy))
{
g_InputInternal->InternalCursorMoved( px, py );
m_nOldPx = px;
m_nOldPy = py;
}
if (m_nButtonPressed & IN_ATTACK)
{
g_InputInternal->SetMouseCodeState( MOUSE_LEFT, vgui::BUTTON_PRESSED );
g_InputInternal->InternalMousePressed(MOUSE_LEFT);
}
if (m_nButtonPressed & IN_ATTACK2)
{
g_InputInternal->SetMouseCodeState( MOUSE_RIGHT, vgui::BUTTON_PRESSED );
g_InputInternal->InternalMousePressed( MOUSE_RIGHT );
}
if ( (m_nButtonReleased & IN_ATTACK) || m_bLoseThinkNextFrame) // for a button release on loosing focus
{
g_InputInternal->SetMouseCodeState( MOUSE_LEFT, vgui::BUTTON_RELEASED );
g_InputInternal->InternalMouseReleased( MOUSE_LEFT );
}
if (m_nButtonReleased & IN_ATTACK2)
{
g_InputInternal->SetMouseCodeState( MOUSE_RIGHT, vgui::BUTTON_RELEASED );
g_InputInternal->InternalMouseReleased( MOUSE_RIGHT );
}
if ( m_bLoseThinkNextFrame == true )
{
m_bLoseThinkNextFrame = false;
SetNextClientThink( CLIENT_THINK_NEVER );
}
g_pClientMode->DeactivateInGameVGuiContext( );
}
//-----------------------------------------------------------------------------
// Purpose: Apply TrackIR to CUserCmd creation
// Input : frametime -
// *cmd -
//-----------------------------------------------------------------------------
void CInput::TrackIRMove( float frametime, CUserCmd *cmd )
{
#if !defined( _X360 )
if ( !IsHeadTrackingEnabled() )
return;
// complete initialization if first time in ( needed as cvars are not available at initialization time )
// verify TrackIR is available and that the user wants to use it
if (!m_fTrackIRAvailable )
{
return;
}
if (tir_start.GetFloat() == 1.0)
{
Init_TrackIR();
tir_start.SetValue(0);
}
if (tir_stop.GetFloat() == 1.0)
{
Shutdown_TrackIR();
tir_stop.SetValue(0);
}
// grab the data from the TrackIR
TRACKIRDATA tid;
NPRESULT result;
// Go get the latest data
result = NPS_GetData(&tid);
if( NP_OK == result )
{
QAngle viewangles;
QAngle engineview;
// get the current player
C_BasePlayer * pPlayer = C_BasePlayer::GetLocalPlayer();
// calculate the amount of rotation from TrackIR
viewangles[YAW] = g_angleCenter[YAW] + (tid.fNPYaw / (float) TIR_MAX_VALUE) * tir_maxyaw.GetFloat();
viewangles[PITCH] = g_angleCenter[PITCH] + (tid.fNPPitch / (float) TIR_MAX_VALUE) * tir_maxpitch.GetFloat();
viewangles[ROLL] = g_angleCenter[ROLL] + (tid.fNPRoll / (float) TIR_MAX_VALUE) * tir_maxroll.GetFloat() * -1.0;
// get the direction the player is facing
QAngle eyeAngle;
eyeAngle = pPlayer->EyeAngles();
// add in the head rotation
eyeAngle += viewangles;
// get the rotation matrix for the head
matrix3x4_t mat;
AngleMatrix( pPlayer->EyeAngles(), mat );
// create a normalized vector based on the TIR input
Vector tirForward, tirEye;
tirForward.x = (tid.fNPZ / (float) TIR_MAX_VALUE) * -1;
tirForward.y = (tid.fNPX / (float) TIR_MAX_VALUE);
tirForward.z = (tid.fNPY / (float) TIR_MAX_VALUE);
// now rotate the vector based on the eye angle
VectorRotate(tirForward, mat, tirEye);
// scale the translation vector
tirEye.x *= tir_maxz.GetFloat();
tirEye.y *= tir_maxx.GetFloat();
tirEye.z *= tir_maxy.GetFloat();
// save the values for later
pPlayer->SetEyeOffset(tirEye);
pPlayer->SetEyeAngleOffset(viewangles);
cmd->headangles = viewangles;
cmd->headoffset = tirEye;
}
#endif
}
