// // Draws the ammo bar on the hud // int CHudAmmo::DrawBar(int x, int y, int width, int height, float f) { int r, g, b; if (f < 0) f = 0; if (f > 1) f = 1; if (f) { int w = f * width; // Always show at least one pixel if we have ammo. if (w <= 0) w = 1; const auto& barColor = GetHud().GetAmmoBarColor(); FillRGBA(x, y, w, height, barColor.r(), barColor.g(), barColor.b(), 255); x += w; width -= w; } GetHud().GetPrimaryColor().UnpackRGB(r, g, b); FillRGBA(x, y, width, height, r, g, b, 128); return (x + width); }
//----------------------------------------------------------------------------- // Purpose: Stop obscuring other elements in this group //----------------------------------------------------------------------------- void CHudElement::UnhideLowerPriorityHudElementsInGroup( const char *pszGroupName ) { // look up the render group int iGroupIndex = GetHud().LookupRenderGroupIndexByName( pszGroupName ); // unlock the group GetHud().UnlockRenderGroup( iGroupIndex, this ); }
/* ======================== idMenuHandler_HUD::Update ======================== */ void idMenuHandler_HUD::Update() { if( gui == NULL || !gui->IsActive() ) { return; } if( nextScreen != activeScreen ) { if( activeScreen > HUD_AREA_INVALID && activeScreen < HUD_NUM_AREAS && menuScreens[ activeScreen ] != NULL ) { menuScreens[ activeScreen ]->HideScreen( static_cast<mainMenuTransition_t>( transition ) ); } if( nextScreen > HUD_AREA_INVALID && nextScreen < HUD_NUM_AREAS && menuScreens[ nextScreen ] != NULL ) { menuScreens[ nextScreen ]->ShowScreen( static_cast<mainMenuTransition_t>( transition ) ); } transition = MENU_TRANSITION_INVALID; activeScreen = nextScreen; } idPlayer* player = gameLocal.GetLocalPlayer(); if( player != NULL ) { if( player->IsTipVisible() && autoHideTip && !hiding ) { if( gameLocal.time >= tipStartTime + TIP_DISPLAY_TIME ) { player->HideTip(); } } if( player->IsSoundChannelPlaying( SND_CHANNEL_PDA_AUDIO ) && GetHud() != NULL ) { GetHud()->UpdateAudioLog( true ); } else { GetHud()->UpdateAudioLog( false ); } if( radioMessage ) { GetHud()->UpdateCommunication( true, player ); } else { GetHud()->UpdateCommunication( false, player ); } } idMenuHandler::Update(); }
void CHudBattery::VidInit() { int HUD_suit_empty = GetHud().GetSpriteIndex( "suit_empty" ); int HUD_suit_full = GetHud().GetSpriteIndex( "suit_full" ); m_hSprite1 = m_hSprite2 = 0; // delaying get sprite handles until we know the sprites are loaded m_prc1 = &GetHud().GetSpriteRect( HUD_suit_empty ); m_prc2 = &GetHud().GetSpriteRect( HUD_suit_full ); m_iHeight = m_prc2->bottom - m_prc1->top; m_fFade = 0; }
bool CHudFlashlight::Draw(float flTime) { if ( GetHud().GetHideHudBits().Any( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ) return true; int r, g, b, x, y, a; wrect_t rc; if (!( Hud().GetWeaponBits() & (1<<(WEAPON_SUIT)) )) return true; if (m_fOn) a = 225; else a = MIN_ALPHA; if (m_flBat < 0.20) GetHud().GetEmptyItemColor().UnpackRGB(r,g,b); else GetHud().GetPrimaryColor().UnpackRGB(r,g,b); ScaleColors(r, g, b, a); y = (m_prc1->bottom - m_prc2->top)/2; x = ScreenWidth - m_iWidth - m_iWidth/2 ; // Draw the flashlight casing SPR_Set(m_hSprite1, r, g, b ); SPR_DrawAdditive( 0, x, y, m_prc1); if ( m_fOn ) { // draw the flashlight beam x = ScreenWidth - m_iWidth/2; SPR_Set( m_hBeam, r, g, b ); SPR_DrawAdditive( 0, x, y, m_prcBeam ); } // draw the flashlight energy level x = ScreenWidth - m_iWidth - m_iWidth/2 ; int iOffset = m_iWidth * (1.0 - m_flBat); if (iOffset < m_iWidth) { rc = *m_prc2; rc.left += iOffset; SPR_Set(m_hSprite2, r, g, b ); SPR_DrawAdditive( 0, x + iOffset, y, &rc); } return true; }
void CHudAmmo::VidInit() { // Load sprites for buckets (top row of weapon menu) m_HUD_bucket0 = GetHud().GetSpriteIndex( "bucket1" ); m_HUD_selection = GetHud().GetSpriteIndex( "selection" ); //TODO: get the sprite once instead of fetching it over and over - Solokiller m_hsprBuckets = GetHud().GetSprite(m_HUD_bucket0); m_iBucketWidth = GetHud().GetSpriteRect(m_HUD_bucket0).right - GetHud().GetSpriteRect(m_HUD_bucket0).left; m_iBucketHeight = GetHud().GetSpriteRect(m_HUD_bucket0).bottom - GetHud().GetSpriteRect(m_HUD_bucket0).top; gHR.iHistoryGap = max( gHR.iHistoryGap, GetHud().GetSpriteRect(m_HUD_bucket0).bottom - GetHud().GetSpriteRect(m_HUD_bucket0).top); if (ScreenWidth >= 640) { m_iABWidth = 20; m_iABHeight = 4; } else { m_iABWidth = 10; m_iABHeight = 2; } m_pWeapon = nullptr; }
//----------------------------------------------------------------------------- // Purpose: Remove this hud element from the global list in CHUD //----------------------------------------------------------------------------- CHudElement::~CHudElement() { if ( m_bNeedsRemove ) { GetHud().RemoveHudElement( this ); } }
virtual void ApplySchemeSettings( vgui::IScheme *pScheme ) { BaseClass::ApplySchemeSettings( pScheme ); GetHud().InitColors( pScheme ); SetPaintBackgroundEnabled( false ); }
void CHudFlashlight::VidInit() { int HUD_flash_empty = GetHud().GetSpriteIndex( "flash_empty" ); int HUD_flash_full = GetHud().GetSpriteIndex( "flash_full" ); int HUD_flash_beam = GetHud().GetSpriteIndex( "flash_beam" ); m_hSprite1 = GetHud().GetSprite(HUD_flash_empty); m_hSprite2 = GetHud().GetSprite(HUD_flash_full); m_hBeam = GetHud().GetSprite(HUD_flash_beam); m_prc1 = &GetHud().GetSpriteRect(HUD_flash_empty); m_prc2 = &GetHud().GetSpriteRect(HUD_flash_full); m_prcBeam = &GetHud().GetSpriteRect(HUD_flash_beam); m_iWidth = m_prc2->right - m_prc2->left; }
/* ======================== idMenuHandler_HUD::HideTip ======================== */ void idMenuHandler_HUD::HideTip() { idMenuScreen_HUD* screen = GetHud(); if( screen != NULL && !hiding ) { screen->HideTip(); } hiding = true; }
//----------------------------------------------------------------------------- // Purpose: We can register to be affected by multiple hud render groups //----------------------------------------------------------------------------- void CHudElement::RegisterForRenderGroup( const char *pszGroupName ) { int iGroupIndex = GetHud().RegisterForRenderGroup( pszGroupName ); // add group index to our list of registered groups if ( m_HudRenderGroups.Find( iGroupIndex ) == m_HudRenderGroups.InvalidIndex() ) { m_HudRenderGroups.AddToTail( iGroupIndex ); } }
//----------------------------------------------------------------------------- // Purpose: Allows HUD to modify input data //----------------------------------------------------------------------------- void CHud::ProcessInput( bool bActive ) { if ( bActive ) { m_iKeyBits = input->GetButtonBits( false ); // Weaponbits need to be sent down as a UserMsg now. GetHud().Think(); } }
/* ======================== idMenuHandler_HUD::ShowTip ======================== */ void idMenuHandler_HUD::ShowTip( const char* title, const char* tip, bool autoHide ) { autoHideTip = autoHideTip; tipStartTime = gameLocal.time; hiding = false; idMenuScreen_HUD* screen = GetHud(); if( screen != NULL ) { screen->ShowTip( title, tip ); } }
// Selects the next item in the weapon menu void CHudAmmo::UserCmd_NextWeapon(void) { if ( m_bPlayerDead || GetHud().GetHideHudBits().Any( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) return; if ( !m_pActiveSel || m_pActiveSel == ( CBasePlayerWeapon*)1 ) m_pActiveSel = m_pWeapon; int slot = 0; CBasePlayerWeapon* pWeapon = nullptr; if ( m_pActiveSel ) { slot = m_pActiveSel->GetWeaponInfo()->GetBucket(); pWeapon = m_pActiveSel->m_pNext; if( !pWeapon ) { if( slot == ( MAX_WEAPON_SLOTS - 1 ) ) slot = 0; else ++slot; } } CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer(); for ( int loop = 0; loop <= 1; loop++ ) { for ( ; slot < MAX_WEAPON_SLOTS; slot++ ) { if( !pWeapon ) pWeapon = pPlayer->m_rgpPlayerItems[ slot ]; for ( ; pWeapon; pWeapon = pWeapon->m_pNext ) { if ( pWeapon && pPlayer->HasAmmo( pWeapon ) ) { m_pActiveSel = pWeapon; return; } } pWeapon = nullptr; } slot = 0; // start looking from the first slot again } m_pActiveSel = nullptr; }
void CHudAmmo::MsgFunc_HideWeapon( const char *pszName, int iSize, void *pbuf ) { CBufferReader reader( pbuf, iSize ); GetHud().GetHideHudBits() = reader.ReadByte(); if (gEngfuncs.IsSpectateOnly()) return; if ( GetHud().GetHideHudBits().Any( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) { wrect_t nullrc = {}; m_pActiveSel = nullptr; SetCrosshair( 0, nullrc, 0, 0, 0 ); } else { if ( m_pWeapon ) { const auto& crosshair = m_pWeapon->GetWeaponInfo()->GetHUDInfo()->GetCrosshair(); SetCrosshair( crosshair.hSprite, crosshair.rect, 255, 255, 255 ); } } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CHudElement::ShouldDraw( void ) { bool bShouldDraw = m_pHud && !m_pHud->IsHidden( m_iHiddenBits ); if ( bShouldDraw ) { // for each render group int iNumGroups = m_HudRenderGroups.Count(); for ( int iGroupIndex = 0; iGroupIndex < iNumGroups; iGroupIndex++ ) { if ( GetHud().IsRenderGroupLockedFor( this, m_HudRenderGroups.Element(iGroupIndex ) ) ) return false; } } return bShouldDraw; }
void OpenVoiceMenu( int index ) { // do not show the menu if the player is dead or is an observer C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return; if ( !pPlayer->IsAlive() || pPlayer->IsObserver() ) return; CHudMenu *pMenu = (CHudMenu *) GetHud().FindElement( "CHudMenu" ); if ( !pMenu ) return; // if they hit the key again, close the menu if ( g_ActiveVoiceMenu == index ) { pMenu->HideMenu(); g_ActiveVoiceMenu = 0; return; } if ( index > 0 && index < 9 ) { KeyValues *pKV = new KeyValues( "MenuItems" ); CMultiplayRules *pRules = dynamic_cast< CMultiplayRules * >( GameRules() ); if ( pRules ) { if ( !pRules->GetVoiceMenuLabels( index-1, pKV ) ) { pKV->deleteThis(); return; } } pMenu->ShowMenu_KeyValueItems( pKV ); pKV->deleteThis(); g_ActiveVoiceMenu = index; } else { g_ActiveVoiceMenu = 0; } }
void CHudAmmo::Reset() { m_fFade = 0; GetFlags() |= HUD_ACTIVE; //!!! m_pActiveSel = nullptr; GetHud().GetHideHudBits() = 0; if( CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer() ) { pPlayer->GetWeapons().ClearAll(); } m_pWeapon = nullptr; gHR.Reset(); }
//----------------------------------------------------------------------------- // Purpose: Multiplies mouse values by sensitivity. Note that for windows mouse settings // the input x,y offsets are already scaled based on that. The custom acceleration, therefore, // is totally engine-specific and applies as a post-process to allow more user tuning. // Input : *x - // *y - //----------------------------------------------------------------------------- void CInput::ScaleMouse( int nSlot, float *x, float *y ) { float mx = *x; float my = *y; float flHudSensitivity = GetHud( nSlot ).GetSensitivity(); float mouse_senstivity = ( flHudSensitivity != 0 ) ? flHudSensitivity : sensitivity.GetFloat(); if ( m_customaccel.GetBool() ) { float raw_mouse_movement_distance = sqrt( mx * mx + my * my ); float acceleration_scale = m_customaccel_scale.GetFloat(); float accelerated_sensitivity_max = m_customaccel_max.GetFloat(); float accelerated_sensitivity_exponent = m_customaccel_exponent.GetFloat(); float accelerated_sensitivity = ( (float)pow( raw_mouse_movement_distance, accelerated_sensitivity_exponent ) * acceleration_scale + mouse_senstivity ); if ( accelerated_sensitivity_max > 0.0001f && accelerated_sensitivity > accelerated_sensitivity_max ) { accelerated_sensitivity = accelerated_sensitivity_max; } *x *= accelerated_sensitivity; *y *= accelerated_sensitivity; // Further re-scale by yaw and pitch magnitude if user requests alternate mode 2 // This means that they will need to up their value for m_customaccel_scale greatly (>40x) since m_pitch/yaw default // to 0.022 if ( m_customaccel.GetInt() == 2 ) { *x *= m_yaw.GetFloat(); *y *= m_pitch->GetFloat(); } } else { *x *= mouse_senstivity; *y *= mouse_senstivity; } }
//----------------------------------------------------------------------------- // Purpose: Static class creation factory // Searches list of registered factories for a match and then instances the // requested technology by name // Input : *name - // Output : CBaseTFTechnology //----------------------------------------------------------------------------- void CHudElementHelper::CreateAllElements( void ) { // Start of list CHudElementHelper *p = m_sHelpers; while ( p ) { // only create this element in slot 0 if ( ( p->m_iFlags & HUDELEMENT_SS_FULLSCREEN_ONLY ) && ( GET_ACTIVE_SPLITSCREEN_SLOT() != 0 ) ) { p = p->m_pNext; continue; } // Dispatch creation function directly CHudElement *( *fCreate )( void ) = p->m_pfnCreate; CHudElement *newElement = (fCreate)(); if ( newElement ) { GetHud().AddHudElement( newElement ); } p = p->GetNext(); } }
void CHudAmmo::SelectSlot( int iSlot, const bool fAdvance, int iDirection ) { if( auto pMenu = GETHUDCLASS( CHudMenu ) ) { if ( pMenu->m_fMenuDisplayed && !fAdvance && (iDirection == 1) ) { // menu is overriding slot use commands pMenu->SelectMenuItem( iSlot + 1 ); // slots are one off the key numbers return; } } if ( iSlot > MAX_WEAPON_SLOTS ) return; if ( m_bPlayerDead || GetHud().GetHideHudBits().Any( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) return; if (!( Hud().GetWeaponBits() & (1<<(WEAPON_SUIT)) )) return; if ( ! ( Hud().GetWeaponBits() & ~(1<<(WEAPON_SUIT)) )) return; CBasePlayerWeapon *p = NULL; bool fastSwitch = CVAR_GET_FLOAT( "hud_fastswitch" ) != 0; CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer(); if ( ( m_pActiveSel == NULL) || ( m_pActiveSel == ( CBasePlayerWeapon *)1) || (iSlot != m_pActiveSel->GetWeaponInfo()->GetBucket()) ) { PlaySound( "common/wpn_hudon.wav", 1 ); p = pPlayer->GetFirstPos( iSlot ); if ( p && fastSwitch ) // check for fast weapon switch mode { // if fast weapon switch is on, then weapons can be selected in a single keypress // but only if there is only one item in the bucket CBasePlayerWeapon *p2 = pPlayer->GetNextActivePos( p->GetWeaponInfo()->GetBucket(), p->GetWeaponInfo()->GetPosition() ); if ( !p2 ) { // only one active item in bucket, so change directly to weapon ServerCmd( p->GetWeaponInfo()->GetWeaponName() ); g_weaponselect = p->GetWeaponInfo()->GetID(); return; } } } else { PlaySound("common/wpn_moveselect.wav", 1); if ( m_pActiveSel ) p = pPlayer->GetNextActivePos( m_pActiveSel->GetWeaponInfo()->GetBucket(), m_pActiveSel->GetWeaponInfo()->GetPosition() ); if ( !p ) p = pPlayer->GetFirstPos( iSlot ); } if ( !p ) // no selection found { // just display the weapon list, unless fastswitch is on just ignore it if ( !fastSwitch ) m_pActiveSel = ( CBasePlayerWeapon *)1; else m_pActiveSel = nullptr; } else m_pActiveSel = p; }
// Selects the previous item in the menu void CHudAmmo::UserCmd_PrevWeapon(void) { if ( m_bPlayerDead || GetHud().GetHideHudBits().Any( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) return; if ( !m_pActiveSel || m_pActiveSel == ( CBasePlayerWeapon*)1 ) m_pActiveSel = m_pWeapon; CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer(); CBasePlayerWeapon* pWeapon = nullptr; int slot = MAX_WEAPON_SLOTS-1; if ( m_pActiveSel ) { slot = m_pActiveSel->GetWeaponInfo()->GetBucket(); for( CBasePlayerWeapon* pWpn = pPlayer->m_rgpPlayerItems[ slot ], * pPrev = nullptr; pWpn; pPrev = pWpn, pWpn = pWpn->m_pNext ) { if( pWpn == m_pActiveSel ) { pWeapon = pPrev; break; } } if( !pWeapon ) { if( slot == 0 ) slot = MAX_WEAPON_SLOTS - 1; else --slot; } } for ( int loop = 0; loop <= 1; loop++ ) { for ( ; slot >= 0; slot-- ) { //TODO: consider making the weapon list a double linked list, or turn the weapon list into a single array of pointers. - Solokiller if( !pWeapon ) { pWeapon = pPlayer->m_rgpPlayerItems[ slot ]; while( pWeapon && pWeapon->m_pNext ) pWeapon = pWeapon->m_pNext; } while( pWeapon ) { if( pPlayer->HasAmmo( pWeapon ) ) { m_pActiveSel = pWeapon; return; } auto pWpn = pPlayer->m_rgpPlayerItems[ slot ]; while( pWpn && pWpn->m_pNext && pWpn != pWeapon && pWpn->m_pNext != pWeapon ) pWpn = pWpn->m_pNext; if( pWpn != pWeapon ) pWeapon = pWpn; else pWeapon = nullptr; } } slot = MAX_WEAPON_SLOTS-1; } m_pActiveSel = nullptr; }
bool CHudAmmo::Draw(float flTime) { int a, x, y, r, g, b; int AmmoWidth; if (!( Hud().GetWeaponBits() & (1<<(WEAPON_SUIT)) )) return true; if ( GetHud().GetHideHudBits().Any( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) return true; // Draw Weapon Menu DrawWList(flTime); // Draw ammo pickup history gHR.DrawAmmoHistory( flTime ); if (!( GetFlags() & HUD_ACTIVE)) return false; if (!m_pWeapon) return false; if( m_pCrosshair->value != 0 && m_hCrosshair != INVALID_HSPRITE ) { float flScale; switch( static_cast<int>( m_pCrosshairMode->value ) ) { default: case CROSS_NATIVESCALE: flScale = 1; break; case CROSS_RESSCALE: flScale = max( ( ScreenWidth / 640.0 ) * 0.75, 1.0 ); break; case CROSS_USERSCALE: flScale = fabs( m_pCrosshairScale->value ); break; } class CCrosshairTriCallback : public ITriCoordFallback { public: void Calculate( HSPRITE hSprite, const int frame, const wrect_t& rect, const float flScale, int& x, int& y ) override { x = ( ScreenWidth - ( ( rect.right - rect.left ) ) ) / 2; y = ( ScreenHeight - ( ( rect.bottom - rect.top ) ) ) / 2; } }; CCrosshairTriCallback callback; Tri_DrawScaledSprite( m_hCrosshair, 0, m_iR, m_iG, m_iB, 255, kRenderTransTexture, flScale, callback, &m_CrosshairRC ); } CBasePlayerWeapon *pw = m_pWeapon; // shorthand // SPR_Draw Ammo if( !pw->GetWeaponInfo()->GetPrimaryAmmo() && !pw->GetWeaponInfo()->GetSecondaryAmmo() ) return false; int iFlags = DHN_DRAWZERO; // draw 0 values AmmoWidth = GetHud().GetSpriteRect( GetHud().GetHudNumber0Index() ).right - GetHud().GetSpriteRect( GetHud().GetHudNumber0Index() ).left; a = (int) max( static_cast<float>( MIN_ALPHA ), m_fFade ); if (m_fFade > 0) m_fFade -= ( Hud().GetTimeDelta() * 20 ); GetHud().GetPrimaryColor().UnpackRGB(r,g,b); ScaleColors(r, g, b, a ); // Does this weapon have a clip? y = ScreenHeight - GetHud().GetFontHeight() - GetHud().GetFontHeight() /2; CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer(); // Does weapon have any ammo at all? if ( auto pAmmo = pw->GetWeaponInfo()->GetPrimaryAmmo() ) { const auto& ammo = m_pWeapon->GetWeaponInfo()->GetHUDInfo()->GetPrimaryAmmo(); int iIconWidth = ammo.rect.right - ammo.rect.left; if (pw->m_iClientClip >= 0) { // room for the number and the '|' and the current ammo x = ScreenWidth - (8 * AmmoWidth) - iIconWidth; x = GetHud().DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pw->m_iClientClip, r, g, b); int iBarWidth = AmmoWidth/10; x += AmmoWidth/2; GetHud().GetPrimaryColor().UnpackRGB(r,g,b); // draw the | bar FillRGBA(x, y, iBarWidth, GetHud().GetFontHeight(), r, g, b, a); x += iBarWidth + AmmoWidth/2; // GL Seems to need this ScaleColors(r, g, b, a ); x = GetHud().DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b); } else { // SPR_Draw a bullets only line x = ScreenWidth - 4 * AmmoWidth - iIconWidth; x = GetHud().DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b); } // Draw the ammo Icon int iOffset = ( ammo.rect.bottom - ammo.rect.top)/8; SPR_Set( ammo.hSprite, r, g, b); SPR_DrawAdditive(0, x, y - iOffset, &ammo.rect ); } // Does weapon have seconday ammo? if ( auto pAmmo = pw->GetWeaponInfo()->GetSecondaryAmmo() ) { const auto& ammo2 = m_pWeapon->GetWeaponInfo()->GetHUDInfo()->GetSecondaryAmmo(); int iIconWidth = ammo2.rect.right - ammo2.rect.left; // Do we have secondary ammo? if ( pPlayer->CountAmmo( pAmmo->GetID() ) > 0 ) { y -= GetHud().GetFontHeight() + GetHud().GetFontHeight() /4; x = ScreenWidth - 4 * AmmoWidth - iIconWidth; x = GetHud().DrawHudNumber(x, y, iFlags|DHN_3DIGITS, pPlayer->CountAmmo( pAmmo->GetID() ), r, g, b); // Draw the ammo Icon SPR_Set( ammo2.hSprite, r, g, b); int iOffset = ( ammo2.rect.bottom - ammo2.rect.top)/8; SPR_DrawAdditive(0, x, y - iOffset, &ammo2.rect ); } } return true; }
void CHudElement::UnregisterForRenderGroup( const char *pszGroupName ) { int iGroupIndex = GetHud().RegisterForRenderGroup( pszGroupName ); m_HudRenderGroups.FindAndRemove( iGroupIndex ); }
// // Draw Weapon Menu // int CHudAmmo::DrawWList(float flTime) { int r,g,b,x,y,a,i; if ( !m_pActiveSel ) return 0; int iActiveSlot; if ( m_pActiveSel == ( CBasePlayerWeapon *)1 ) iActiveSlot = -1; // current slot has no weapons else iActiveSlot = m_pActiveSel->GetWeaponInfo()->GetBucket(); x = 10; //!!! y = 10; //!!! CBasePlayer* pPlayer = g_Prediction.GetLocalPlayer(); // Ensure that there are available choices in the active slot if ( iActiveSlot > 0 ) { if ( !pPlayer->GetFirstPos( iActiveSlot ) ) { m_pActiveSel = ( CBasePlayerWeapon *)1; iActiveSlot = -1; } } // Shepard : determine how many buckets we should draw int iBucketsToDraw = 0; for ( i = 0; i < MAX_WEAPON_SLOTS; i++ ) { for ( int j = 0; j < MAX_WEAPONS; j++ ) { CBasePlayerWeapon *pWeapon = pPlayer->GetWeapon( i, j ); if ( pWeapon && pWeapon->GetWeaponInfo() && pWeapon->GetWeaponInfo()->GetBucket() > iBucketsToDraw ) iBucketsToDraw = pWeapon->GetWeaponInfo()->GetBucket(); } } iBucketsToDraw++; // Draw top line for ( i = 0; i < iBucketsToDraw; i++ ) { int iWidth; GetHud().GetPrimaryColor().UnpackRGB(r,g,b); if ( iActiveSlot == i ) a = 255; else a = 192; ScaleColors(r, g, b, 255); SPR_Set( GetHud().GetSprite(m_HUD_bucket0 + i), r, g, b ); // make active slot wide enough to accomodate gun pictures if ( i == iActiveSlot ) { CBasePlayerWeapon *p = pPlayer->GetFirstPos(iActiveSlot); if ( p ) iWidth = p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.right - p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.left; else iWidth = m_iBucketWidth; } else iWidth = m_iBucketWidth; SPR_DrawAdditive(0, x, y, &GetHud().GetSpriteRect(m_HUD_bucket0 + i)); x += iWidth + 5; } a = 128; //!!! x = 10; // Draw all of the buckets for (i = 0; i < iBucketsToDraw; i++) { y = m_iBucketHeight + 10; // If this is the active slot, draw the bigger pictures, // otherwise just draw boxes if ( i == iActiveSlot ) { CBasePlayerWeapon *p = pPlayer->m_rgpPlayerItems[ i ]; int iWidth = m_iBucketWidth; if ( p ) iWidth = p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.right - p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.left; for( ; p; p = p->m_pNext ) { if ( !p->GetWeaponInfo() ) continue; auto pHUDInfo = p->GetWeaponInfo()->GetHUDInfo(); GetHud().GetPrimaryColor().UnpackRGB( r,g,b ); // if active, then we must have ammo. if ( m_pActiveSel == p ) { SPR_Set( pHUDInfo->GetActive().hSprite, r, g, b ); SPR_DrawAdditive(0, x, y, &pHUDInfo->GetActive().rect ); SPR_Set( GetHud().GetSprite(m_HUD_selection), r, g, b ); SPR_DrawAdditive(0, x, y, &GetHud().GetSpriteRect(m_HUD_selection)); } else { // Draw Weapon if Red if no ammo if ( pPlayer->HasAmmo(p) ) ScaleColors(r, g, b, 192); else { GetHud().GetEmptyItemColor().UnpackRGB(r,g,b); ScaleColors(r, g, b, 128); } SPR_Set( pHUDInfo->GetInactive().hSprite, r, g, b ); SPR_DrawAdditive( 0, x, y, &pHUDInfo->GetInactive().rect ); } // Draw Ammo Bar DrawAmmoBar(p, x + m_iABWidth/2, y, m_iABWidth, m_iABHeight); y += pHUDInfo->GetActive().rect.bottom - pHUDInfo->GetActive().rect.top + 5; } x += iWidth + 5; } else { // Draw Row of weapons. GetHud().GetPrimaryColor().UnpackRGB(r,g,b); for ( CBasePlayerWeapon* p = pPlayer->m_rgpPlayerItems[ i ]; p; p = p->m_pNext ) { if ( !p->GetWeaponInfo() ) continue; if ( pPlayer->HasAmmo(p) ) { GetHud().GetPrimaryColor().UnpackRGB(r,g,b); a = 128; } else { GetHud().GetEmptyItemColor().UnpackRGB(r,g,b); a = 96; } FillRGBA( x, y, m_iBucketWidth, m_iBucketHeight, r, g, b, a ); y += m_iBucketHeight + 5; } x += m_iBucketWidth + 5; } } return 1; }
bool CHudBattery::Draw(float flTime) { if ( GetHud().GetHideHudBits().Any( HIDEHUD_HEALTH ) ) return true; wrect_t rc; rc = *m_prc2; #if defined( _TFC ) float fScale = 0.0; if ( m_iBatMax > 0 ) fScale = 1.0 / (float)m_iBatMax; rc.top += m_iHeight * ((float)(m_iBatMax-(min(m_iBatMax,m_iBat))) * fScale); // battery can go from 0 to m_iBatMax so * fScale goes from 0 to 1 #else rc.top += m_iHeight * ((float)(100-(min(100,m_iBat))) * 0.01); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1 #endif if (!( Hud().GetWeaponBits() & (1<<(WEAPON_SUIT)) )) return true; int r, g, b, x, y, a = MIN_ALPHA; GetHud().GetPrimaryColor().UnpackRGB( r, g, b ); // Has health changed? Flash the health # if (m_fFade) { if (m_fFade > FADE_TIME) m_fFade = FADE_TIME; m_fFade -= ( Hud().GetTimeDelta() * 20); if (m_fFade <= 0) { m_fFade = 0; } // Fade the health number back to dim a += ( m_fFade / FADE_TIME ) * 128; } ScaleColors(r, g, b, a ); int iOffset = (m_prc1->bottom - m_prc1->top)/6; y = ScreenHeight - GetHud().GetFontHeight() - GetHud().GetFontHeight() / 2; x = ScreenWidth/5; // make sure we have the right sprite handles if ( !m_hSprite1 ) m_hSprite1 = GetHud().GetSprite( GetHud().GetSpriteIndex( "suit_empty" ) ); if ( !m_hSprite2 ) m_hSprite2 = GetHud().GetSprite( GetHud().GetSpriteIndex( "suit_full" ) ); SPR_Set(m_hSprite1, r, g, b ); SPR_DrawAdditive( 0, x, y - iOffset, m_prc1); if (rc.bottom > rc.top) { SPR_Set(m_hSprite2, r, g, b ); SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc); } x += (m_prc1->right - m_prc1->left); x = GetHud().DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b); return true; }
// This is called by cdll_client_int to setup view model origins. This has to be done before // simulation so entities can access attachment points on view models during simulation. void CViewRender::OnRenderStart() { VPROF_("CViewRender::OnRenderStart", 2, VPROF_BUDGETGROUP_OTHER_UNACCOUNTED, false, 0); IterateRemoteSplitScreenViewSlots_Push( true ); FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh ) { ACTIVE_SPLITSCREEN_PLAYER_GUARD_VGUI( hh ); // This will fill in one of the m_UserView[ hh ] slots SetUpView(); // Adjust mouse sensitivity based upon the current FOV C_BasePlayer *player = C_BasePlayer::GetLocalPlayer(); if ( player ) { default_fov.SetValue( player->m_iDefaultFOV ); //Update our FOV, including any zooms going on int iDefaultFOV = default_fov.GetInt(); int localFOV = player->GetFOV(); int min_fov = player->GetMinFOV(); // Don't let it go too low localFOV = MAX( min_fov, localFOV ); GetHud().m_flFOVSensitivityAdjust = 1.0f; #ifndef _XBOX if ( GetHud().m_flMouseSensitivityFactor ) { GetHud().m_flMouseSensitivity = sensitivity.GetFloat() * GetHud().m_flMouseSensitivityFactor; } else #endif { // No override, don't use huge sensitivity if ( localFOV == iDefaultFOV ) { #ifndef _XBOX // reset to saved sensitivity GetHud().m_flMouseSensitivity = 0; #endif } else { // Set a new sensitivity that is proportional to the change from the FOV default and scaled // by a separate compensating factor if ( iDefaultFOV == 0 ) { Assert(0); // would divide by zero, something is broken with iDefatulFOV iDefaultFOV = 1; } GetHud().m_flFOVSensitivityAdjust = ((float)localFOV / (float)iDefaultFOV) * // linear fov downscale zoom_sensitivity_ratio.GetFloat(); // sensitivity scale factor #ifndef _XBOX GetHud().m_flMouseSensitivity = GetHud().m_flFOVSensitivityAdjust * sensitivity.GetFloat(); // regular sensitivity #endif } } } } // Setup the frustum cache for this frame. m_bAllowViewAccess = true; FOR_EACH_VALID_SPLITSCREEN_PLAYER( iSlot ) { const CViewSetup &view = GetView( iSlot ); FrustumCache()->Add( &view, iSlot ); } FrustumCache()->SetUpdated(); m_bAllowViewAccess = false; IterateRemoteSplitScreenViewSlots_Pop(); }
//----------------------------------------------------------------------------- // Purpose: Draw the weapon's crosshair //----------------------------------------------------------------------------- void C_BaseCombatWeapon::DrawCrosshair() { #ifndef INFESTED_DLL C_BasePlayer *player = C_BasePlayer::GetLocalPlayer(); if ( !player ) return; Color clr = GetHud().m_clrNormal; /* // TEST: if the thing under your crosshair is on a different team, light the crosshair with a different color. Vector vShootPos, vShootAngles; GetShootPosition( vShootPos, vShootAngles ); Vector vForward; AngleVectors( vShootAngles, &vForward ); // Change the color depending on if we're looking at a friend or an enemy. CPartitionFilterListMask filter( PARTITION_ALL_CLIENT_EDICTS ); trace_t tr; traceline->TraceLine( vShootPos, vShootPos + vForward * 10000, COLLISION_GROUP_NONE, MASK_SHOT, &tr, true, ~0, &filter ); if ( tr.index != 0 && tr.index != INVALID_CLIENTENTITY_HANDLE ) { C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( tr.index ); if ( pEnt ) { if ( pEnt->GetTeamNumber() != player->GetTeamNumber() ) { g = b = 0; } } } */ CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair ); if ( !crosshair ) return; // Find out if this weapon's auto-aimed onto a target bool bOnTarget = ( m_iState == WEAPON_IS_ACTIVE ) && player->m_fOnTarget; if ( player->GetFOV() >= 90 ) { // normal crosshairs if ( bOnTarget && GetWpnData().iconAutoaim ) { clr[3] = 255; crosshair->SetCrosshair( GetWpnData().iconAutoaim, clr ); } else if ( GetWpnData().iconCrosshair ) { clr[3] = 255; crosshair->SetCrosshair( GetWpnData().iconCrosshair, clr ); } else { crosshair->ResetCrosshair(); } } else { Color white( 255, 255, 255, 255 ); // zoomed crosshairs if (bOnTarget && GetWpnData().iconZoomedAutoaim) crosshair->SetCrosshair(GetWpnData().iconZoomedAutoaim, white); else if ( GetWpnData().iconZoomedCrosshair ) crosshair->SetCrosshair( GetWpnData().iconZoomedCrosshair, white ); else crosshair->ResetCrosshair(); } #endif }