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; }