void CDAViewRender::PerformSlowMoEffect( const CViewSetup &view )
{
C_SDKPlayer *pPlayer = C_SDKPlayer::GetLocalOrSpectatedPlayer();
if ( !pPlayer )
return;
if (!da_postprocess_shaders.GetBool())
return;
if (!pPlayer->IsAlive())
m_flStyleLerp = 0;
ConVarRef da_postprocess_slowmo("da_postprocess_slowmo");
ConVarRef da_postprocess_deathcam("da_postprocess_deathcam");
ConVarRef da_postprocess_skill("da_postprocess_skill");
ConVarRef da_postprocess_vr("da_postprocess_vr");
da_postprocess_vr.SetValue(UseVR());
if (pPlayer->IsStyleSkillActive())
m_flStyleLerp = Approach(1, m_flStyleLerp, gpGlobals->frametime*2);
else
m_flStyleLerp = Approach(0, m_flStyleLerp, gpGlobals->frametime);
bool bShowPostProcess = false;
if (pPlayer->GetSlowMoMultiplier() < 1)
bShowPostProcess = true;
else if (m_flStyleLerp)
bShowPostProcess = true;
else if (!pPlayer->IsAlive() && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM)
bShowPostProcess = true;
else if (da_postprocess_compare.GetInt() || da_postprocess_slowmo.GetInt())
bShowPostProcess = true;
if ( bShowPostProcess )
{
IMaterial *pMaterial = materials->FindMaterial( "shaders/slowmo", TEXTURE_GROUP_CLIENT_EFFECTS, true );
if ( !IsErrorMaterial(pMaterial) )
{
if (pPlayer->IsAlive())
da_postprocess_deathcam.SetValue(false);
else
da_postprocess_deathcam.SetValue(true);
da_postprocess_skill.SetValue(m_flStyleLerp);
if (da_postprocess_compare.GetInt() == 1)
DrawScreenEffectMaterial( pMaterial, view.x, view.y, view.width/2, view.height );
else
DrawScreenEffectMaterial( pMaterial, view.x, view.y, view.width, view.height );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Same as ScreenTransform, but transforms to HUD space.
// These are totally different things in VR mode!
//-----------------------------------------------------------------------------
int HudTransform( const Vector& point, Vector& screen )
{
if ( UseVR() )
{
return FrustumTransform ( g_ClientVirtualReality.GetHudProjectionFromWorld(), point, screen );
}
else
{
return FrustumTransform ( engine->WorldToScreenMatrix(), point, screen );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eyeOrigin -
// eyeAngles -
// zNear -
// zFar -
// fov -
//-----------------------------------------------------------------------------
void CBasePlayer::CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov )
{
#if defined( CLIENT_DLL )
if( UseVR() )
g_ClientVirtualReality.CancelTorsoTransformOverride();
#endif
if ( IsObserver() )
{
CalcObserverView( eyeOrigin, eyeAngles, fov );
}
else
{
CalcPlayerView( eyeOrigin, eyeAngles, fov );
}
// NVNT update fov on the haptics dll for input scaling.
#if defined( CLIENT_DLL )
if(IsLocalPlayer() && haptics)
haptics->UpdatePlayerFOV(fov);
#endif
}
void CSDKModeManager::LevelInit( const char *newmap )
{
g_pClientMode->LevelInit( newmap );
ConVarRef cl_detail_max_sway("cl_detail_max_sway");
ConVarRef cl_detail_avoid_radius("cl_detail_avoid_radius");
ConVarRef cl_detail_avoid_force("cl_detail_avoid_force");
ConVarRef cl_detail_avoid_recover_speed("cl_detail_avoid_recover_speed");
// HACK: the detail sway convars are archive, and default to 0. Existing CS:S players thus have no detail
// prop sway. We'll force them to DoD's default values for now.
if ( !cl_detail_max_sway.GetFloat() &&
!cl_detail_avoid_radius.GetFloat() &&
!cl_detail_avoid_force.GetFloat() &&
!cl_detail_avoid_recover_speed.GetFloat() )
{
cl_detail_max_sway.SetValue( "5" );
cl_detail_avoid_radius.SetValue( "64" );
cl_detail_avoid_force.SetValue( "0.4" );
cl_detail_avoid_recover_speed.SetValue( "0.25" );
}
if (UseVR())
{
#ifdef _DEBUG
ConVarRef("vr_force_windowed").SetValue(true);
#endif
ConVarRef("vr_first_person_uses_world_model").SetValue(false);
ConVarRef("vr_moveaim_reticle_yaw_limit").SetValue(15);
ConVarRef("vr_moveaim_reticle_yaw_limit_zoom").SetValue(15);
ConVarRef("vr_viewmodel_offset_forward").SetValue(5);
ConVarRef("vr_zoom_multiplier").SetValue(1.4f);
}
AB_Input_LevelInit();
}
//-----------------------------------------------------------------------------
// 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 SoftwareCursorChangedCB( IConVar *pVar, const char *pOldValue, float fOldValue )
{
ConVar *pConVar = (ConVar *)pVar;
vgui::surface()->SetSoftwareCursor( pConVar->GetBool() || UseVR() );
}
//-----------------------------------------------------------------------------
// Purpose: Render current view into specified rectangle
// Input : *rect - is computed by CVideoMode_Common::GetClientViewRect()
//-----------------------------------------------------------------------------
void CViewRender::Render( vrect_t *rect )
{
Assert(s_DbgSetupOrigin == m_View.origin);
Assert(s_DbgSetupAngles == m_View.angles);
VPROF_BUDGET( "CViewRender::Render", "CViewRender::Render" );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
vrect_t vr = *rect;
// Stub out the material system if necessary.
CMatStubHandler matStub;
engine->EngineStats_BeginFrame();
// Assume normal vis
m_bForceNoVis = false;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
// Set for console commands, etc.
render->SetMainView ( m_View.origin, m_View.angles );
for( StereoEye_t eEye = GetFirstEye(); eEye <= GetLastEye(); eEye = (StereoEye_t)(eEye+1) )
{
CViewSetup &view = GetView( eEye );
#if 0 && defined( CSTRIKE_DLL )
const bool bPlayingBackReplay = g_pEngineClientReplay && g_pEngineClientReplay->IsPlayingReplayDemo();
if ( pPlayer && !bPlayingBackReplay )
{
C_BasePlayer *pViewTarget = pPlayer;
if ( pPlayer->IsObserver() && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
pViewTarget = dynamic_cast<C_BasePlayer*>( pPlayer->GetObserverTarget() );
}
if ( pViewTarget )
{
float targetFOV = (float)pViewTarget->m_iFOV;
if ( targetFOV == 0 )
{
// FOV of 0 means use the default FOV
targetFOV = g_pGameRules->DefaultFOV();
}
float deltaFOV = view.fov - m_flLastFOV;
float FOVDirection = targetFOV - pViewTarget->m_iFOVStart;
// Clamp FOV changes to stop FOV oscillation
if ( ( deltaFOV < 0.0f && FOVDirection > 0.0f ) ||
( deltaFOV > 0.0f && FOVDirection < 0.0f ) )
{
view.fov = m_flLastFOV;
}
// Catch case where FOV overshoots its target FOV
if ( ( view.fov < targetFOV && FOVDirection <= 0.0f ) ||
( view.fov > targetFOV && FOVDirection >= 0.0f ) )
{
view.fov = targetFOV;
}
m_flLastFOV = view.fov;
}
}
#endif
static ConVarRef sv_restrict_aspect_ratio_fov( "sv_restrict_aspect_ratio_fov" );
float aspectRatio = engine->GetScreenAspectRatio() * 0.75f; // / (4/3)
float limitedAspectRatio = aspectRatio;
if ( ( sv_restrict_aspect_ratio_fov.GetInt() > 0 && engine->IsWindowedMode() && gpGlobals->maxClients > 1 ) ||
sv_restrict_aspect_ratio_fov.GetInt() == 2 )
{
limitedAspectRatio = MIN( aspectRatio, 1.85f * 0.75f ); // cap out the FOV advantage at a 1.85:1 ratio (about the widest any legit user should be)
}
view.fov = ScaleFOVByWidthRatio( view.fov, limitedAspectRatio );
view.fovViewmodel = ScaleFOVByWidthRatio( view.fovViewmodel, aspectRatio );
// Let the client mode hook stuff.
g_pClientMode->PreRender(&view);
g_pClientMode->AdjustEngineViewport( vr.x, vr.y, vr.width, vr.height );
ToolFramework_AdjustEngineViewport( vr.x, vr.y, vr.width, vr.height );
float flViewportScale = mat_viewportscale.GetFloat();
view.m_nUnscaledX = vr.x;
view.m_nUnscaledY = vr.y;
view.m_nUnscaledWidth = vr.width;
view.m_nUnscaledHeight = vr.height;
switch( eEye )
{
case STEREO_EYE_MONO:
{
#if 0
// Good test mode for debugging viewports that are not full-size.
view.width = vr.width * flViewportScale * 0.75f;
view.height = vr.height * flViewportScale * 0.75f;
view.x = vr.x + view.width * 0.10f;
view.y = vr.y + view.height * 0.20f;
#else
view.x = vr.x * flViewportScale;
view.y = vr.y * flViewportScale;
view.width = vr.width * flViewportScale;
view.height = vr.height * flViewportScale;
#endif
float engineAspectRatio = engine->GetScreenAspectRatio();
view.m_flAspectRatio = ( engineAspectRatio > 0.0f ) ? engineAspectRatio : ( (float)view.width / (float)view.height );
}
break;
case STEREO_EYE_RIGHT:
case STEREO_EYE_LEFT:
{
g_pSourceVR->GetViewportBounds( (ISourceVirtualReality::VREye)(eEye - 1 ), &view.x, &view.y, &view.width, &view.height );
view.m_nUnscaledWidth = view.width;
view.m_nUnscaledHeight = view.height;
view.m_nUnscaledX = view.x;
view.m_nUnscaledY = view.y;
}
break;
default:
Assert ( false );
break;
}
// if we still don't have an aspect ratio, compute it from the view size
if( view.m_flAspectRatio <= 0.f )
view.m_flAspectRatio = (float)view.width / (float)view.height;
int nClearFlags = VIEW_CLEAR_DEPTH | VIEW_CLEAR_STENCIL;
if( gl_clear_randomcolor.GetBool() )
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->ClearColor3ub( rand()%256, rand()%256, rand()%256 );
pRenderContext->ClearBuffers( true, false, false );
pRenderContext->Release();
}
else if ( gl_clear.GetBool() )
{
nClearFlags |= VIEW_CLEAR_COLOR;
}
else if ( IsPosix() )
{
MaterialAdapterInfo_t adapterInfo;
materials->GetDisplayAdapterInfo( materials->GetCurrentAdapter(), adapterInfo );
// On Posix, on ATI, we always clear color if we're antialiasing
if ( adapterInfo.m_VendorID == 0x1002 )
{
if ( g_pMaterialSystem->GetCurrentConfigForVideoCard().m_nAASamples > 0 )
{
nClearFlags |= VIEW_CLEAR_COLOR;
}
}
}
// Determine if we should draw view model ( client mode override )
bool drawViewModel = g_pClientMode->ShouldDrawViewModel();
if ( cl_leveloverview.GetFloat() > 0 )
{
SetUpOverView();
nClearFlags |= VIEW_CLEAR_COLOR;
drawViewModel = false;
}
// Apply any player specific overrides
if ( pPlayer )
{
// Override view model if necessary
if ( !pPlayer->m_Local.m_bDrawViewmodel )
{
drawViewModel = false;
}
}
int flags = 0;
if( eEye == STEREO_EYE_MONO || eEye == STEREO_EYE_LEFT || ( g_ClientVirtualReality.ShouldRenderHUDInWorld() ) )
{
flags = RENDERVIEW_DRAWHUD;
}
if ( drawViewModel )
{
flags |= RENDERVIEW_DRAWVIEWMODEL;
}
if( eEye == STEREO_EYE_RIGHT )
{
// we should use the monitor view from the left eye for both eyes
flags |= RENDERVIEW_SUPPRESSMONITORRENDERING;
}
RenderView( view, nClearFlags, flags );
if ( UseVR() )
{
bool bDoUndistort = ! engine->IsTakingScreenshot();
if ( bDoUndistort )
{
g_ClientVirtualReality.PostProcessFrame( eEye );
}
// logic here all cloned from code in viewrender.cpp around RenderHUDQuad:
// figure out if we really want to draw the HUD based on freeze cam
bool bInFreezeCam = ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM );
// draw the HUD after the view model so its "I'm closer" depth queues work right.
if( !bInFreezeCam && g_ClientVirtualReality.ShouldRenderHUDInWorld() )
{
// TODO - a bit of a shonky test - basically trying to catch the main menu, the briefing screen, the loadout screen, etc.
bool bTranslucent = !g_pMatSystemSurface->IsCursorVisible();
g_ClientVirtualReality.OverlayHUDQuadWithUndistort( view, bDoUndistort, g_pClientMode->ShouldBlackoutAroundHUD(), bTranslucent );
}
}
}
// TODO: should these be inside or outside the stereo eye stuff?
g_pClientMode->PostRender();
engine->EngineStats_EndFrame();
#if !defined( _X360 )
// Stop stubbing the material system so we can see the budget panel
matStub.End();
#endif
// Draw all of the UI stuff "fullscreen"
// (this is not health, ammo, etc. Nor is it pre-game briefing interface stuff - this is the stuff that appears when you hit Esc in-game)
// In stereo mode this is rendered inside of RenderView so it goes into the render target
if( !g_ClientVirtualReality.ShouldRenderHUDInWorld() )
{
CViewSetup view2d;
view2d.x = rect->x;
view2d.y = rect->y;
view2d.width = rect->width;
view2d.height = rect->height;
render->Push2DView( view2d, 0, NULL, GetFrustum() );
render->VGui_Paint( PAINT_UIPANELS | PAINT_CURSOR );
render->PopView( GetFrustum() );
}
}
void CInput::CreateMove ( int sequence_number, float input_sample_frametime, bool active )
{
CUserCmd *cmd = &m_pCommands[ sequence_number % MULTIPLAYER_BACKUP ];
CVerifiedUserCmd *pVerified = &m_pVerifiedCommands[ sequence_number % MULTIPLAYER_BACKUP ];
cmd->Reset();
cmd->command_number = sequence_number;
cmd->tick_count = gpGlobals->tickcount;
QAngle viewangles;
engine->GetViewAngles( viewangles );
QAngle originalViewangles = viewangles;
if ( active || sv_noclipduringpause.GetInt() )
{
// Determine view angles
AdjustAngles ( input_sample_frametime );
// Determine sideways movement
ComputeSideMove( cmd );
// Determine vertical movement
ComputeUpwardMove( cmd );
// Determine forward movement
ComputeForwardMove( cmd );
// Scale based on holding speed key or having too fast of a velocity based on client maximum
// speed.
ScaleMovements( cmd );
// Allow mice and other controllers to add their inputs
ControllerMove( input_sample_frametime, cmd );
#ifdef SIXENSE
g_pSixenseInput->SixenseFrame( input_sample_frametime, cmd );
if( g_pSixenseInput->IsEnabled() )
{
g_pSixenseInput->SetView( input_sample_frametime, cmd );
}
#endif
}
else
{
// need to run and reset mouse input so that there is no view pop when unpausing
if ( !m_fCameraInterceptingMouse && m_fMouseActive )
{
float mx, my;
GetAccumulatedMouseDeltasAndResetAccumulators( &mx, &my );
ResetMouse();
}
}
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
engine->GetViewAngles( viewangles );
// Latch and clear impulse
cmd->impulse = in_impulse;
in_impulse = 0;
// Latch and clear weapon selection
if ( m_hSelectedWeapon != NULL )
{
C_BaseCombatWeapon *weapon = m_hSelectedWeapon;
cmd->weaponselect = weapon->entindex();
cmd->weaponsubtype = weapon->GetSubType();
// Always clear weapon selection
m_hSelectedWeapon = NULL;
}
// Set button and flag bits
#ifdef SIXENSE
if( g_pSixenseInput->IsEnabled() )
{
// Some buttons were set in SixenseUpdateKeys, so or in any real keypresses
cmd->buttons |= GetButtonBits( 1 );
}
else
{
cmd->buttons = GetButtonBits( 1 );
}
#else
// Set button and flag bits
cmd->buttons = GetButtonBits( 1 );
#endif
// Using joystick?
#ifdef SIXENSE
if ( in_joystick.GetInt() || g_pSixenseInput->IsEnabled() )
#else
if ( in_joystick.GetInt() )
#endif
{
if ( cmd->forwardmove > 0 )
{
cmd->buttons |= IN_FORWARD;
}
else if ( cmd->forwardmove < 0 )
{
cmd->buttons |= IN_BACK;
}
}
// Use new view angles if alive, otherwise user last angles we stored off.
if ( g_iAlive )
{
VectorCopy( viewangles, cmd->viewangles );
VectorCopy( viewangles, m_angPreviousViewAngles );
}
else
{
VectorCopy( m_angPreviousViewAngles, cmd->viewangles );
}
// Let the move manager override anything it wants to.
if ( g_pClientMode->CreateMove( input_sample_frametime, cmd ) )
{
// Get current view angles after the client mode tweaks with it
#ifdef SIXENSE
// Only set the engine angles if sixense is not enabled. It is done in SixenseInput::SetView otherwise.
if( !g_pSixenseInput->IsEnabled() )
{
engine->SetViewAngles( cmd->viewangles );
}
#else
engine->SetViewAngles( cmd->viewangles );
#endif
if ( UseVR() )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if( pPlayer && !pPlayer->GetVehicle() )
{
QAngle curViewangles, newViewangles;
Vector curMotion, newMotion;
engine->GetViewAngles( curViewangles );
curMotion.Init (
cmd->forwardmove,
cmd->sidemove,
cmd->upmove );
g_ClientVirtualReality.OverridePlayerMotion ( input_sample_frametime, originalViewangles, curViewangles, curMotion, &newViewangles, &newMotion );
engine->SetViewAngles( newViewangles );
cmd->forwardmove = newMotion[0];
cmd->sidemove = newMotion[1];
cmd->upmove = newMotion[2];
cmd->viewangles = newViewangles;
}
else
{
Vector vPos;
g_ClientVirtualReality.GetTorsoRelativeAim( &vPos, &cmd->viewangles );
engine->SetViewAngles( cmd->viewangles );
}
}
}
m_flLastForwardMove = cmd->forwardmove;
cmd->random_seed = MD5_PseudoRandom( sequence_number ) & 0x7fffffff;
HLTVCamera()->CreateMove( cmd );
#if defined( REPLAY_ENABLED )
ReplayCamera()->CreateMove( cmd );
#endif
#if defined( HL2_CLIENT_DLL )
// copy backchannel data
int i;
for (i = 0; i < m_EntityGroundContact.Count(); i++)
{
cmd->entitygroundcontact.AddToTail( m_EntityGroundContact[i] );
}
m_EntityGroundContact.RemoveAll();
#endif
pVerified->m_cmd = *cmd;
pVerified->m_crc = cmd->GetChecksum();
}
void CInput::ExtraMouseSample( float frametime, bool active )
{
CUserCmd dummy;
CUserCmd *cmd = &dummy;
cmd->Reset();
QAngle viewangles;
engine->GetViewAngles( viewangles );
QAngle originalViewangles = viewangles;
if ( active )
{
// Determine view angles
AdjustAngles ( frametime );
// Determine sideways movement
ComputeSideMove( cmd );
// Determine vertical movement
ComputeUpwardMove( cmd );
// Determine forward movement
ComputeForwardMove( cmd );
// Scale based on holding speed key or having too fast of a velocity based on client maximum
// speed.
ScaleMovements( cmd );
// Allow mice and other controllers to add their inputs
ControllerMove( frametime, cmd );
#ifdef SIXENSE
g_pSixenseInput->SixenseFrame( frametime, cmd );
if( g_pSixenseInput->IsEnabled() )
{
g_pSixenseInput->SetView( frametime, cmd );
}
#endif
}
// Retreive view angles from engine ( could have been set in IN_AdjustAngles above )
engine->GetViewAngles( viewangles );
// Set button and flag bits, don't blow away state
#ifdef SIXENSE
if( g_pSixenseInput->IsEnabled() )
{
// Some buttons were set in SixenseUpdateKeys, so or in any real keypresses
cmd->buttons |= GetButtonBits( 0 );
}
else
{
cmd->buttons = GetButtonBits( 0 );
}
#else
cmd->buttons = GetButtonBits( 0 );
#endif
// Use new view angles if alive, otherwise user last angles we stored off.
if ( g_iAlive )
{
VectorCopy( viewangles, cmd->viewangles );
VectorCopy( viewangles, m_angPreviousViewAngles );
}
else
{
VectorCopy( m_angPreviousViewAngles, cmd->viewangles );
}
// Let the move manager override anything it wants to.
if ( g_pClientMode->CreateMove( frametime, cmd ) )
{
// Get current view angles after the client mode tweaks with it
engine->SetViewAngles( cmd->viewangles );
prediction->SetLocalViewAngles( cmd->viewangles );
}
// Let the headtracker override the view at the very end of the process so
// that vehicles and other stuff in g_pClientMode->CreateMove can override
// first
if ( active && UseVR() )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if( pPlayer && !pPlayer->GetVehicle() )
{
QAngle curViewangles, newViewangles;
Vector curMotion, newMotion;
engine->GetViewAngles( curViewangles );
curMotion.Init (
cmd->forwardmove,
cmd->sidemove,
cmd->upmove );
g_ClientVirtualReality.OverridePlayerMotion ( frametime, originalViewangles, curViewangles, curMotion, &newViewangles, &newMotion );
engine->SetViewAngles( newViewangles );
cmd->forwardmove = newMotion[0];
cmd->sidemove = newMotion[1];
cmd->upmove = newMotion[2];
cmd->viewangles = newViewangles;
prediction->SetLocalViewAngles( cmd->viewangles );
}
}
}
void CBaseViewModel::CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles )
{
// UNDONE: Calc this on the server? Disabled for now as it seems unnecessary to have this info on the server
#if defined( CLIENT_DLL )
QAngle vmangoriginal = eyeAngles;
QAngle vmangles = eyeAngles;
Vector vmorigin = eyePosition;
CBaseCombatWeapon *pWeapon = m_hWeapon.Get();
//Allow weapon lagging
if ( pWeapon != NULL )
{
#if defined( CLIENT_DLL )
if ( !prediction->InPrediction() )
#endif
{
// add weapon-specific bob
pWeapon->AddViewmodelBob( this, vmorigin, vmangles );
#if defined ( CSTRIKE_DLL )
CalcViewModelLag( vmorigin, vmangles, vmangoriginal );
#endif
}
}
// Add model-specific bob even if no weapon associated (for head bob for off hand models)
AddViewModelBob( owner, vmorigin, vmangles );
#if !defined ( CSTRIKE_DLL )
// This was causing weapon jitter when rotating in updated CS:S; original Source had this in above InPrediction block 07/14/10
// Add lag
CalcViewModelLag( vmorigin, vmangles, vmangoriginal );
#endif
#if defined( CLIENT_DLL )
if ( !prediction->InPrediction() )
{
// Let the viewmodel shake at about 10% of the amplitude of the player's view
vieweffects->ApplyShake( vmorigin, vmangles, 0.1 );
}
#endif
if( UseVR() )
{
g_ClientVirtualReality.OverrideViewModelTransform( vmorigin, vmangles, pWeapon && pWeapon->ShouldUseLargeViewModelVROverride() );
}
SetLocalOrigin( vmorigin );
SetLocalAngles( vmangles );
#ifdef SIXENSE
if( g_pSixenseInput->IsEnabled() && (owner->GetObserverMode()==OBS_MODE_NONE) && !UseVR() )
{
const float max_gun_pitch = 20.0f;
float viewmodel_fov_ratio = g_pClientMode->GetViewModelFOV()/owner->GetFOV();
QAngle gun_angles = g_pSixenseInput->GetViewAngleOffset() * -viewmodel_fov_ratio;
// Clamp pitch a bit to minimize seeing back of viewmodel
if( gun_angles[PITCH] < -max_gun_pitch )
{
gun_angles[PITCH] = -max_gun_pitch;
}
#ifdef WIN32 // ShouldFlipViewModel comes up unresolved on osx? Mabye because it's defined inline? fixme
if( ShouldFlipViewModel() )
{
gun_angles[YAW] *= -1.0f;
}
#endif
vmangles = EyeAngles() + gun_angles;
SetLocalAngles( vmangles );
}
#endif
#endif
}
void C_PropVehicleDriveable::DrawHudElements( )
{
CHudTexture *pIcon;
int iIconX, iIconY;
if (m_bHasGun)
{
// draw crosshairs for vehicle gun
pIcon = gHUD.GetIcon( "gunhair" );
if ( pIcon != NULL )
{
float x, y;
if( UseVR() )
{
C_BasePlayer *pPlayer = (C_BasePlayer *)GetPassenger( VEHICLE_ROLE_DRIVER );
Vector vecStart, vecDirection;
pPlayer->EyePositionAndVectors( &vecStart, &vecDirection, NULL, NULL );
Vector vecEnd = vecStart + vecDirection * MAX_TRACE_LENGTH;
trace_t tr;
UTIL_TraceLine( vecStart, vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
Vector screen;
screen.Init();
ScreenTransform(tr.endpos, screen);
int vx, vy, vw, vh;
vgui::surface()->GetFullscreenViewport( vx, vy, vw, vh );
float screenWidth = vw;
float screenHeight = vh;
x = 0.5f * ( 1.0f + screen[0] ) * screenWidth + 0.5f;
y = 0.5f * ( 1.0f - screen[1] ) * screenHeight + 0.5f;
}
else
{
Vector screen;
x = ScreenWidth()/2;
y = ScreenHeight()/2;
#if TRIANGULATED_CROSSHAIR
ScreenTransform( m_vecGunCrosshair, screen );
x += 0.5 * screen[0] * ScreenWidth() + 0.5;
y -= 0.5 * screen[1] * ScreenHeight() + 0.5;
#endif
}
x -= pIcon->Width() / 2;
y -= pIcon->Height() / 2;
Color clr = ( m_bUnableToFire ) ? gHUD.m_clrCaution : gHUD.m_clrNormal;
pIcon->DrawSelf( x, y, clr );
}
if ( m_nScannerDisabledWeapons )
{
// Draw icons for scanners "weps disabled"
pIcon = gHUD.GetIcon( "dmg_bio" );
if ( pIcon )
{
iIconY = 467 - pIcon->Height() / 2;
iIconX = 385;
if ( !m_bScannerWepIcon )
{
pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, 255, 255 ) );
m_bScannerWepIcon = true;
m_iScannerWepFlashTimer = 0;
m_bScannerWepDim = true;
}
else
{
pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, GetFlashColorIntensity(55, 255, m_bScannerWepDim, 10, m_iScannerWepFlashTimer), 255 ) );
m_iScannerWepFlashTimer++;
m_iScannerWepFlashTimer %= 20;
if(!m_iScannerWepFlashTimer)
m_bScannerWepDim ^= 1;
}
}
}
}
if ( m_nScannerDisabledVehicle )
{
// Draw icons for scanners "vehicle disabled"
pIcon = gHUD.GetIcon( "dmg_bio" );
if ( pIcon )
{
iIconY = 467 - pIcon->Height() / 2;
iIconX = 410;
if ( !m_bScannerVehicleIcon )
{
pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, 255, 255 ) );
m_bScannerVehicleIcon = true;
m_iScannerVehicleFlashTimer = 0;
m_bScannerVehicleDim = true;
}
else
{
pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, GetFlashColorIntensity(55, 255, m_bScannerVehicleDim, 10, m_iScannerVehicleFlashTimer), 255 ) );
m_iScannerVehicleFlashTimer++;
m_iScannerVehicleFlashTimer %= 20;
if(!m_iScannerVehicleFlashTimer)
m_bScannerVehicleDim ^= 1;
}
}
}
}
int CEstrangedSystemCaps::GetCaps( void )
{
int systemCaps = ( CAPS_MATERIAL_POSTPROCESS | CAPS_SHADER_POSTPROCESS | CAPS_ESTRANGED_DEPTHPASS | CAPS_SHADOW_DEPTHPASS );
// If we're in the middle of building cubemaps
ConVarRef building_cubemaps("building_cubemaps");
if ( building_cubemaps.GetBool() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
systemCaps &= ~CAPS_MATERIAL_POSTPROCESS;
}
// Check for null-ness...
if ( g_pMaterialSystemHardwareConfig )
{
// If we don't support shader model 3.0
if ( !g_pMaterialSystemHardwareConfig->SupportsShaderModel_3_0() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we support fetch4 (ATI)
if ( g_pMaterialSystemHardwareConfig->SupportsFetch4() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we use ATI depth formats
int shadowFilterMode = g_pMaterialSystemHardwareConfig->GetShadowFilterMode();
if ( shadowFilterMode != NVIDIA_PCF_POISSON && ( shadowFilterMode == ATI_NO_PCF_FETCH4 || shadowFilterMode == ATI_NOPCF ) )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// If we're not running with DirectX 9
if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 )
{
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADOW_DEPTHPASS;
}
// If we're not running with DirectX 8
if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 80 )
{
systemCaps &= ~CAPS_MATERIAL_POSTPROCESS;
}
}
// If we're not Windows
if ( !IsWindows() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
}
// ae - temporary bugfix: disable shader
// post processing on mac
if ( IsOSX() )
{
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
}
// If we're in VR mode
if ( UseVR() )
{
systemCaps &= ~CAPS_ESTRANGED_DEPTHPASS;
systemCaps &= ~CAPS_SHADER_POSTPROCESS;
}
// Check null
if ( materials )
{
// If we don't support shadow depth textures
if ( !materials->SupportsShadowDepthTextures() )
{
systemCaps &= ~CAPS_SHADOW_DEPTHPASS;
}
}
return systemCaps;
}
