int CHudBackground::Draw(float flTime) { int r = 0, g = 0, b = 0, x = 0, y = 0; int x_length = 0, y_length = 0; // positions of the spots y_length = gHUD.GetSpriteRect(m_HUD_back).bottom - gHUD.GetSpriteRect(m_HUD_back).top; x_length = gHUD.GetSpriteRect(m_HUD_back).right - gHUD.GetSpriteRect(m_HUD_back).left; UnpackRGB(r, g, b, RGB_WHITEISH); ScaleColors(r, g, b, 255); // position the sprite in the upper right corner of display... x = XRES(0); y = (YRES(480) - y_length); if (g_iWaterLevel != 3) { y_length = gHUD.GetSpriteRect(m_HUD_back).bottom - gHUD.GetSpriteRect(m_HUD_back).top; x_length = gHUD.GetSpriteRect(m_HUD_back).right - gHUD.GetSpriteRect(m_HUD_back).left; SPR_Set(m_hSprite, r, g, b); SPR_DrawHoles(0, x, y, m_SpriteArea); return 1; } else { y_length = gHUD.GetSpriteRect(m_HUD_water).bottom - gHUD.GetSpriteRect(m_HUD_water).top; x_length = gHUD.GetSpriteRect(m_HUD_water).right - gHUD.GetSpriteRect(m_HUD_water).left; SPR_Set(gHUD.GetSprite(m_HUD_water), r, g, b); SPR_DrawHoles((((int)(flTime*14))%24), x, y, m_SpriteArea); return 0; } }
int CHudHealth::DrawDamage(float flTime) { int r, g, b, a; DAMAGE_IMAGE *pdmg; if (!m_bitsDamage) return 1; UnpackRGB(r,g,b, RGB_YELLOWISH); a = (int)( fabs(sin(flTime*2)) * 256.0); ScaleColors(r, g, b, a); // Draw all the items int i; for (i = 0; i < NUM_DMG_TYPES; i++) { if (m_bitsDamage & giDmgFlags[i]) { pdmg = &m_dmg[i]; SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b ); SPR_DrawAdditive(0, pdmg->x, pdmg->y, &gHUD.GetSpriteRect(m_HUD_dmg_bio + i)); } } // check for bits that should be expired for ( i = 0; i < NUM_DMG_TYPES; i++ ) { DAMAGE_IMAGE *pdmg = &m_dmg[i]; if ( m_bitsDamage & giDmgFlags[i] ) { pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire ); if ( pdmg->fExpire <= flTime // when the time has expired && a < 40 ) // and the flash is at the low point of the cycle { pdmg->fExpire = 0; int y = pdmg->y; pdmg->x = pdmg->y = 0; // move everyone above down for (int j = 0; j < NUM_DMG_TYPES; j++) { pdmg = &m_dmg[j]; if ((pdmg->y) && (pdmg->y < y)) pdmg->y += giDmgHeight; } m_bitsDamage &= ~giDmgFlags[i]; // clear the bits } } } return 1; }
int CHudHealth::Draw(float flTime) { int r, g, b; int a = 0, x, y; int HealthWidth; if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) || gEngfuncs.IsSpectateOnly() ) return 1; if ( !m_HSPRITE ) m_HSPRITE = LoadSprite(PAIN_NAME); // Has health changed? Flash the health # if (m_fFade) { m_fFade -= (gHUD.m_flTimeDelta * 20); if (m_fFade <= 0) { a = MIN_ALPHA; m_fFade = 0; } // Fade the health number back to dim a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128; } else a = MIN_ALPHA; // If health is getting low, make it bright red if (m_iHealth <= 15) a = 255; GetPainColor( r, g, b ); ScaleColors(r, g, b, a ); // Only draw health if we have the suit. if (gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))) { HealthWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left; int CrossWidth = gHUD.GetSpriteRect(m_HUD_cross).right - gHUD.GetSpriteRect(m_HUD_cross).left; y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = CrossWidth /2; SPR_Set(gHUD.GetSprite(m_HUD_cross), r, g, b); SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_cross)); x = CrossWidth + HealthWidth / 2; //x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b); gHUD.DrawHudNumber2( x, y, false, 3, m_iHealth, r, g, b); } DrawDamage(flTime); return DrawPain(flTime); }
int CHudAmmoSecondary::Draw( float flTime ) { if( ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) ) return 1; // draw secondary ammo icons above normal ammo readout int a, x, y, r, g, b, AmmoWidth; UnpackRGB( r, g, b, RGB_YELLOWISH ); a = (int)max( MIN_ALPHA, m_fFade ); if( m_fFade > 0 ) m_fFade -= ( gHUD.m_flTimeDelta * 20 ); // slowly lower alpha to fade out icons ScaleColors( r, g, b, a ); AmmoWidth = gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).right - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).left; y = ScreenHeight - ( gHUD.m_iFontHeight * 4 ); // this is one font height higher than the weapon ammo values x = ScreenWidth - AmmoWidth; if( m_HUD_ammoicon ) { // Draw the ammo icon x -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).right - gHUD.GetSpriteRect( m_HUD_ammoicon ).left ); y -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).top - gHUD.GetSpriteRect( m_HUD_ammoicon ).bottom ); SPR_Set( gHUD.GetSprite( m_HUD_ammoicon ), r, g, b ); SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect( m_HUD_ammoicon ) ); } else { // move the cursor by the '0' char instead, since we don't have an icon to work with x -= AmmoWidth; y -= ( gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).top - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).bottom ); } // draw the ammo counts, in reverse order, from right to left for( int i = MAX_SEC_AMMO_VALUES-1; i >= 0; i-- ) { if( m_iAmmoAmounts[i] < 0 ) continue; // negative ammo amounts imply that they shouldn't be drawn // half a char gap between the ammo number and the previous pic x -= ( AmmoWidth / 2 ); // draw the number, right-aligned x -= ( gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth ); gHUD.DrawHudNumber( x, y, DHN_DRAWZERO, m_iAmmoAmounts[i], r, g, b ); if( i != 0 ) { // draw the divider bar x -= ( AmmoWidth / 2 ); FillRGBA( x, y, ( AmmoWidth/10 ), gHUD.m_iFontHeight, r, g, b, a ); } } return 1; }
int CHudFlashlight::Draw(float flTime) { if ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ) return 1; int r, g, b, x, y, a; wrect_t rc; if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1; if (m_fOn) a = 225; else a = MIN_ALPHA; if (m_flBat < 0.20) UnpackRGB(r,g,b, RGB_REDISH); else { gHUD.GetPrimaryHudColor(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 1; }
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; }
int CHudAmmo::Draw(float flTime) { int a, x, y, r, g, b; int AmmoWidth; int iCrossX; int iCrossY; int iCrossLength; char *chCrossHair = "+"; // Heh /*if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1;*/ if((gHUD.m_iHideHUDDisplay & (HIDEHUD_WEAPONS | HIDEHUD_ALL))) return 1; // Draw Weapon Menu DrawWList(flTime); // Draw ammo pickup history gHR.DrawAmmoHistory(flTime); if(!(m_iFlags & HUD_ACTIVE)) return 0; if(!m_pWeapon) return 0; WEAPON *pw = m_pWeapon; // shorthand // SPR_Draw Ammo if((pw->iAmmoType < 0) && (pw->iAmmo2Type < 0)) return 0; int iFlags = DHN_DRAWZERO; // draw 0 values AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left; a = (int)max(MIN_ALPHA, m_fFade); if(m_fFade > 0) m_fFade -= (gHUD.m_flTimeDelta * 20); UnpackRGB(r, g, b, RGB_YELLOWISH); ScaleColors(r, g, b, a); // Does this weapon have a clip? y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; /******************* DRAW CROSSHAIR *********************/ iCrossLength = gHUD.m_scrinfo.charWidths[*chCrossHair]; iCrossY = ScreenHeight / 2 - gHUD.m_scrinfo.iCharHeight / 2; iCrossX = ScreenWidth / 2 - iCrossLength / 2; gHUD.DrawHudString(iCrossX, iCrossY, iCrossX + 50, chCrossHair, 170, 170, 170); /******************* DRAW CROSSHAIR *********************/ // Does weapon have any ammo at all? if(m_pWeapon->iAmmoType > 0) { int iIconWidth = m_pWeapon->rcAmmo.right - m_pWeapon->rcAmmo.left; if(pw->iClip >= 0) { x = ScreenWidth - (8 * AmmoWidth) - iIconWidth; UnpackRGB(r, g, b, RGB_YELLOWISH); // GL Seems to need this ScaleColors(r, g, b, a); m_iNumberXPosition = x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b); } // Draw the ammo Icon int iOffset = (m_pWeapon->rcAmmo.bottom - m_pWeapon->rcAmmo.top) / 8; SPR_Set(m_pWeapon->hAmmo, r, g, b); SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo); m_iXPosition = x; } return 1; }
int CHudStatusBar::Draw(float fTime) { int r, g, b, a, name_r, name_g, name_b; if(m_bReparseString) { for(int i = 0; i < MAX_STATUSBAR_LINES; i++) ParseStatusString(i); m_bReparseString = FALSE; } //Not Watching anyone if(m_iStatusValues[1] == 0) { m_iFlags &= ~HUD_ACTIVE; return 1; } // Draw the status bar lines for(int i = 0; i < MAX_STATUSBAR_LINES; i++) { int TextHeight = 0; int TotalTextWidth = 0; //Ugly way to get if(m_iTeamMate[i]) { TotalTextWidth += gHUD.ReturnStringPixelLength(m_szName[i]); TotalTextWidth += gHUD.ReturnStringPixelLength(m_szHealth[i]); TotalTextWidth += gHUD.ReturnStringPixelLength(m_szArmor[i]); TotalTextWidth += 48; TextHeight = gHUD.m_scrinfo.iCharHeight; } else TotalTextWidth += gHUD.ReturnStringPixelLength(m_szName[i]); TextHeight = gHUD.m_scrinfo.iCharHeight; if(g_iNameColors == 1) { name_r = 255; name_g = 50; name_b = 50; } else if(g_iNameColors == 2) { name_r = 50; name_g = 50; name_b = 255; } else name_r = name_g = name_b = 255; int Y_START; if(ScreenHeight >= 480) Y_START = ScreenHeight - 55; else Y_START = ScreenHeight - 45; int x = gHUD.m_Ammo.m_iNumberXPosition; int y = Y_START; // = ( ScreenHeight / 2 ) + ( TextHeight * 3 ); int x_offset; a = 200; UnpackRGB(r, g, b, RGB_NORMAL); ScaleColors(r, g, b, a); ScaleColors(name_r, name_g, name_b, 125); //Draw the name First gHUD.DrawHudString(x, y, 1024, m_szName[i], name_r, name_g, name_b); if(!m_iTeamMate[i]) continue; //Get the length in pixels for the name x_offset = gHUD.ReturnStringPixelLength(m_szName[i]); //Add the offset x += (x_offset + 8); //Now draw the Sprite for the health SPR_Set(m_hHealth, r, g, b); SPR_DrawHoles(0, x, y, &gHUD.GetSpriteRect(m_iHealthSpriteIndex)); //Add the sprite width size x += 16; //Draw the health value ( x + offset for the name lenght + width of the sprite ) gHUD.DrawHudString(x, y, 1024, m_szHealth[i], name_r, name_g, name_b); //Get the length in pixels for the health x_offset = gHUD.ReturnStringPixelLength(m_szHealth[i]); //Add the offset x += (x_offset + 8); //Now draw the Sprite for the Armor SPR_Set(m_hArmor, r, g, b); SPR_DrawHoles(0, x, y, &gHUD.GetSpriteRect(m_iArmorSpriteIndex)); x += 16; //Draw the armor value ( x + offset for the name lenght + width of the sprite ) gHUD.DrawHudString(x, y, 1024, m_szArmor[i], name_r, name_g, name_b); } return 1; }
int CHudScores::Draw(float time) { if (cl_scores->value < 1.0f) return 0; const size_t rows_to_draw = static_cast<size_t>(cl_scores->value); const uint8_t alpha = static_cast<uint8_t>(std::min(255.0f, std::max(0.0f, cl_scores_alpha->value))); int x, y; if (sscanf(cl_scores_pos->string, "%d %d", &x, &y) != 2) { x = 0; y = 0; } std::array<ScoreRow, NUM_ROWS> rows; size_t row_count = 0; const auto scoreboard = gViewPort->GetScoreBoard(); if (!gHUD.m_Teamplay) { gViewPort->GetAllPlayersInfo(); for (int row = 0; row < scoreboard->m_iRows; ++row) { if (scoreboard->m_iIsATeam[row]) continue; const auto sorted = scoreboard->m_iSortedRows[row]; if (g_IsSpectator[sorted]) continue; const int score = g_PlayerExtraInfo[sorted].frags; const uint8_t color = g_PlayerExtraInfo[sorted].teamnumber % iNumberOfTeamColors; char* name = nullptr; if (steam_id::is_showing_real_names()) name = const_cast<char*>(steam_id::get_real_name(sorted - 1).c_str()); if (!name || name[0] == '\0') name = g_PlayerInfoList[sorted].name; if (!name || name[0] == '\0') continue; rows[row_count].score = score; rows[row_count].name = name; rows[row_count].color = color; if (++row_count >= rows_to_draw) break; } } else { for (int row = 0; row < scoreboard->m_iRows; ++row) { if (scoreboard->m_iIsATeam[row] != TEAM_YES) continue; const auto sorted = scoreboard->m_iSortedRows[row]; const int score = g_TeamInfo[sorted].frags; const uint8_t color = g_TeamInfo[sorted].teamnumber % iNumberOfTeamColors; char* name = g_TeamInfo[sorted].name; rows[row_count].score = score; rows[row_count].name = name; rows[row_count].color = color; if (++row_count >= rows_to_draw) break; } } const auto last_row = rows.cbegin() + row_count; // Figure out the scoreboard dimensions. int score_width = 0, name_width = 0; for (auto row = rows.cbegin(); row != last_row; ++row) { char buf[16]; std::snprintf(buf, ARRAYSIZE(buf), "%d", row->score); score_width = std::max(score_width, gHUD.GetHudStringWidth(buf)); name_width = std::max(name_width, gHUD.GetHudStringWidthWithColorTags(row->name)); } // Draw the scoreboard. for (auto row = rows.cbegin(); row != last_row; ++row) { int r = iTeamColors[row->color][0], g = iTeamColors[row->color][1], b = iTeamColors[row->color][2]; FillRGBA(x, y, PADDING + score_width + GAP + name_width + PADDING, gHUD.m_scrinfo.iCharHeight, r, g, b, alpha); ScaleColors(r, g, b, 135); char buf[16]; std::snprintf(buf, ARRAYSIZE(buf), "%d", row->score); gHUD.DrawHudStringRightAligned(x + PADDING + score_width, y, buf, r, g, b); gHUD.DrawHudStringWithColorTags(x + PADDING + score_width + GAP, y, row->name, r, g, b); y += gHUD.m_scrinfo.iCharHeight; } return 0; }
int CHudHealth::DrawPain(float flTime) { if(!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight)) return 1; int r, g, b; int x, y, a, shade; // TODO: get the shift value of the health a = 255; // max brightness until then float fFade = gHUD.m_flTimeDelta * 2; // SPR_Draw top if(m_fAttackFront > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackFront, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 0) / 2; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 0) * 3; SPR_DrawAdditive(0, x, y, NULL); m_fAttackFront = max(0, m_fAttackFront - fFade); } else m_fAttackFront = 0; if(m_fAttackRight > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackRight, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 + SPR_Width(m_hSprite, 1) * 2; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 1) / 2; SPR_DrawAdditive(1, x, y, NULL); m_fAttackRight = max(0, m_fAttackRight - fFade); } else m_fAttackRight = 0; if(m_fAttackRear > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackRear, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 2) / 2; y = ScreenHeight / 2 + SPR_Height(m_hSprite, 2) * 2; SPR_DrawAdditive(2, x, y, NULL); m_fAttackRear = max(0, m_fAttackRear - fFade); } else m_fAttackRear = 0; if(m_fAttackLeft > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackLeft, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 3) * 3; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 3) / 2; SPR_DrawAdditive(3, x, y, NULL); m_fAttackLeft = max(0, m_fAttackLeft - fFade); } else m_fAttackLeft = 0; return 1; }
int CHudFlashlight::Draw( float flTime ) { static bool show = ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ); if( show != !( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ) ) { show = !( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ); if( gMobileEngfuncs ) { gMobileEngfuncs->pfnTouchHideButtons( "flashlight", !show ); } } if( !show ) return 1; int r, g, b, x, y, a; wrect_t rc; if( gEngfuncs.IsSpectateOnly() ) return 1; if( !( gHUD.m_iWeaponBits & ( 1 << ( WEAPON_SUIT ) ) ) ) return 1; if( m_fOn ) a = 225; else a = MIN_ALPHA; if( m_flBat < 0.20 ) UnpackRGB( r,g,b, RGB_REDISH ); else UnpackRGB( r,g,b, RGB_YELLOWISH ); 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 1; }
int CHudHealth::Draw(float flTime) { int r, g, b; int a = 0, x, y; int HealthWidth; // if (m_iHealth <= 0) // return 1; if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH ) return 1; if ( !m_hSprite ) m_hSprite = LoadSprite(PAIN_NAME); // Has health changed? Flash the health # if (m_fFade) { m_fFade -= (gHUD.m_flTimeDelta * 20); if (m_fFade <= 0) { a = MIN_ALPHA; m_fFade = 0; } // Fade the health number back to dim a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128; } else a = MIN_ALPHA; // If health is getting low, make it bright red if (m_iHealth <= 15) a = 255; GetPainColor( r, g, b ); ScaleColors(r, g, b, a ); // Only draw health if we have the suit. { HealthWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left; int CrossWidth = gHUD.GetSpriteRect(m_HUD_cross).right - gHUD.GetSpriteRect(m_HUD_cross).left; y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = CrossWidth /2; SPR_Set(gHUD.GetSprite(m_HUD_cross), r, g, b); SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_cross)); x = CrossWidth + HealthWidth / 2; x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b); x += HealthWidth/2; int iHeight = gHUD.m_iFontHeight; int iWidth = HealthWidth/10; FillRGBA(x, y, iWidth, iHeight, 255, 160, 0, a); } DrawDamage(flTime); return DrawPain(flTime); }
// // Draw Ammo pickup history // int HistoryResource::DrawAmmoHistory(float flTime) { for(int i = 0; i < MAX_HISTORY; i++) { if(rgAmmoHistory[i].type) { rgAmmoHistory[i].DisplayTime = min(rgAmmoHistory[i].DisplayTime, gHUD.m_flTime + HISTORY_DRAW_TIME); if(rgAmmoHistory[i].DisplayTime <= flTime) { // pic drawing time has expired memset(&rgAmmoHistory[i], 0, sizeof(HIST_ITEM)); CheckClearHistory(); } else if(rgAmmoHistory[i].type == HISTSLOT_AMMO) { wrect_t rcPic; HSPRITE *spr = gWR.GetAmmoPicFromWeapon(rgAmmoHistory[i].iId, rcPic); int r, g, b; UnpackRGB(r, g, b, RGB_YELLOWISH); float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80; ScaleColors(r, g, b, min(scale, 255)); // Draw the pic int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i)); int xpos = ScreenWidth - 24; if(spr && *spr) // weapon isn't loaded yet so just don't draw the pic { // the dll has to make sure it has sent info the weapons you need SPR_Set(*spr, r, g, b); SPR_DrawAdditive(0, xpos, ypos, &rcPic); } // Draw the number gHUD.DrawHudNumberString(xpos - 10, ypos, xpos - 100, rgAmmoHistory[i].iCount, r, g, b); } else if(rgAmmoHistory[i].type == HISTSLOT_WEAP) { WEAPON *weap = gWR.GetWeapon(rgAmmoHistory[i].iId); if(!weap) return 1; // we don't know about the weapon yet, so don't draw anything int r, g, b; UnpackRGB(r, g, b, RGB_YELLOWISH); if(!gWR.HasAmmo(weap)) UnpackRGB(r, g, b, RGB_REDISH); // if the weapon doesn't have ammo, display it as red float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80; ScaleColors(r, g, b, min(scale, 255)); int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i)); int xpos = ScreenWidth - (weap->rcInactive.right - weap->rcInactive.left); SPR_Set(weap->hInactive, r, g, b); SPR_DrawAdditive(0, xpos, ypos, &weap->rcInactive); } else if(rgAmmoHistory[i].type == HISTSLOT_ITEM) { int r, g, b; if(!rgAmmoHistory[i].iId) continue; // sprite not loaded wrect_t rect = gHUD.GetSpriteRect(rgAmmoHistory[i].iId); UnpackRGB(r, g, b, RGB_YELLOWISH); float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80; ScaleColors(r, g, b, min(scale, 255)); int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i)); int xpos = ScreenWidth - (rect.right - rect.left) - 10; SPR_Set(gHUD.GetSprite(rgAmmoHistory[i].iId), r, g, b); SPR_DrawAdditive(0, xpos, ypos, &rect); } } } return 1; }
int CHudHealth::DrawDamage(float flTime) { int r, g, b, a; DAMAGE_IMAGE *pdmg; if (!m_bitsDamage) return 1; UnpackRGB(r,g,b, RGB_YELLOWISH); a = (int)( fabs(sin(flTime*2)) * 256.0); ScaleColors(r, g, b, a); // Draw all the items for (int i = 0; i < NUM_DMG_TYPES; i++) { if (m_bitsDamage & giDmgFlags[i]) { pdmg = &m_dmg[i]; SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b ); // Discwar: Hack. Freeze is the only icon we use. Just place it directly above the disc ammo int iX = (ScreenWidth - DISC_ICON_WIDTH) / 2; int iXPos = iX - DISC_ICON_SPACER; SPR_DrawAdditive(0, iXPos + (DISC_ICON_SPACER), ScreenHeight - YRES(92), &gHUD.GetSpriteRect(m_HUD_dmg_bio + i)); } } /* // check for bits that should be expired for ( i = 0; i < NUM_DMG_TYPES; i++ ) { DAMAGE_IMAGE *pdmg = &m_dmg[i]; if ( m_bitsDamage & giDmgFlags[i] ) { pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire ); if ( pdmg->fExpire <= flTime // when the time has expired && a < 40 ) // and the flash is at the low point of the cycle { pdmg->fExpire = 0; int y = pdmg->y; pdmg->x = pdmg->y = 0; // move everyone above down for (int j = 0; j < NUM_DMG_TYPES; j++) { pdmg = &m_dmg[j]; if ((pdmg->y) && (pdmg->y < y)) pdmg->y += giDmgHeight; } m_bitsDamage &= ~giDmgFlags[i]; // clear the bits } } } */ return 1; }
int CHudBattery::Draw(float flTime) { if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH ) return 1; int r, g, b, x, y, a; wrect_t rc; rc = *m_prc2; int theMaxArmor = gHUD.GetHUDMaxArmor(); float theScalar = 1.0f/theMaxArmor; rc.top += m_iHeight * ((float)(theMaxArmor-(min(theMaxArmor, m_iBat))) * theScalar); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1 gHUD.GetPrimaryHudColor(r, g, b); if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1; // Has health changed? Flash the health # if (m_fFade) { if (m_fFade > FADE_TIME) m_fFade = FADE_TIME; m_fFade -= (gHUD.m_flTimeDelta * 20); if (m_fFade <= 0) { a = 128; m_fFade = 0; } // Fade the health number back to dim a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128; } else a = MIN_ALPHA; ScaleColors(r, g, b, a ); int iOffset = (m_prc1->bottom - m_prc1->top)/6; int theInset = 0; if(gHUD.GetIsAlien()) { theInset = ScreenWidth()*kResourceEnergyBarWidth; } int theViewport[4]; gHUD.GetViewport(theViewport); y = theViewport[1] + theViewport[3] - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = theViewport[0] + theInset + kArmorLeftInset*ScreenWidth(); // make sure we have the right sprite handles if ( !m_hSprite1 ) m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) ); if ( !m_hSprite2 ) m_hSprite2 = gHUD.GetSprite( gHUD.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 = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b); return 1; }
// // Draw Weapon Menu // int CHudAmmo::DrawWList(float flTime) { int r, g, b, x, y, a, i; if(!gpActiveSel) return 0; int iActiveSlot; if(gpActiveSel == (WEAPON *)1) iActiveSlot = -1; // current slot has no weapons else iActiveSlot = gpActiveSel->iSlot; x = 10; //!!! y = 10; //!!! // Ensure that there are available choices in the active slot if(iActiveSlot > 0) { if(!gWR.GetFirstPos(iActiveSlot)) { gpActiveSel = (WEAPON *)1; iActiveSlot = -1; } } // Draw top line for(i = 0; i < MAX_WEAPON_SLOTS; i++) { int iWidth; UnpackRGB(r, g, b, RGB_YELLOWISH); if(iActiveSlot == i) a = 255; else a = 192; ScaleColors(r, g, b, 255); SPR_Set(gHUD.GetSprite(m_HUD_bucket0 + i), r, g, b); // make active slot wide enough to accomodate gun pictures if(i == iActiveSlot) { WEAPON *p = gWR.GetFirstPos(iActiveSlot); if(p) iWidth = p->rcActive.right - p->rcActive.left; } else iWidth = giBucketWidth; if(i == iActiveSlot) SPR_DrawAdditive(0, x + 104, y, &gHUD.GetSpriteRect(m_HUD_bucket0 + i)); else SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_bucket0 + i)); x += iWidth + 5; } a = 128; //!!! x = 10; // Draw all of the buckets for(i = 1; i < MAX_WEAPON_SLOTS + 1; i++) { y = giBucketHeight + 10; // If this is the active slot, draw the bigger pictures, // otherwise just draw boxes if(i == iActiveSlot) { WEAPON *p = gWR.GetFirstPos(i); int iWidth = giBucketWidth; if(p) iWidth = p->rcActive.right - p->rcActive.left; for(int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++) { p = gWR.GetWeaponSlot(i, iPos); if(!p || !p->iId) continue; UnpackRGB(r, g, b, RGB_YELLOWISH); // if active, then we must have ammo. if(gpActiveSel == p) { if(gWR.HasAmmo(p)) ScaleColors(r, g, b, 192); else { UnpackRGB(r, g, b, RGB_REDISH); ScaleColors(r, g, b, 128); } SPR_Set(p->hActive, r, g, b); SPR_DrawAdditive(0, x, y, &p->rcActive); } else { // Draw Weapon if Red if no ammo if(gWR.HasAmmo(p)) ScaleColors(r, g, b, 192); else { UnpackRGB(r, g, b, RGB_REDISH); ScaleColors(r, g, b, 128); } SPR_Set(p->hInactive, r, g, b); SPR_DrawAdditive(0, x, y, &p->rcInactive); } // Draw Ammo Bar DrawAmmoBar(p, x + giABWidth / 2, y, giABWidth, giABHeight); y += p->rcActive.bottom - p->rcActive.top + 5; } x += iWidth + 5; } else { // Draw Row of weapons. UnpackRGB(r, g, b, RGB_YELLOWISH); for(int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++) { WEAPON *p = gWR.GetWeaponSlot(i, iPos); if(!p || !p->iId) continue; if(gWR.HasAmmo(p)) { UnpackRGB(r, g, b, RGB_YELLOWISH); a = 128; } else { UnpackRGB(r, g, b, RGB_REDISH); a = 96; } FillRGBA(x, y, giBucketWidth, giBucketHeight, r, g, b, a); y += giBucketHeight + 5; } x += giBucketWidth + 5; } } return 1; }
bool CHudBattery::Draw(float flTime) { if ( gHUD.m_iHideHUDDisplay & 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 (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return true; int r, g, b, x, y, a = MIN_ALPHA; gHUD.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 -= (gHUD.m_flTimeDelta * 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 - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = ScreenWidth/5; // make sure we have the right sprite handles if ( !m_hSprite1 ) m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) ); if ( !m_hSprite2 ) m_hSprite2 = gHUD.GetSprite( gHUD.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 = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b); return true; }
int CHudAmmo::Draw(float flTime) { int a, x, y, r, g, b; int AmmoWidth; if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1; if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) ) return 1; // Draw Weapon Menu DrawWList(flTime); // Draw ammo pickup history gHR.DrawAmmoHistory( flTime ); if (!(m_iFlags & HUD_ACTIVE)) return 0; if (!m_pWeapon) return 0; // Fograin92: We're rendering ammo counters using new HUD, begone with this thing! return 0; WEAPON *pw = m_pWeapon; // shorthand // SPR_Draw Ammo if ((pw->iAmmoType < 0) && (pw->iAmmo2Type < 0)) return 0; int iFlags = DHN_DRAWZERO; // draw 0 values AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left; a = (int) max( MIN_ALPHA, m_fFade ); if (m_fFade > 0) m_fFade -= (gHUD.m_flTimeDelta * 20); // Fograin92: A little changes //UnpackRGB(r,g,b, RGB_YELLOWISH); r = SM_HUDcolor(1); g = SM_HUDcolor(2); b = SM_HUDcolor(3); ScaleColors(r, g, b, a ); // Does this weapon have a clip? y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight/2; // Does weapon have any ammo at all? if (m_pWeapon->iAmmoType > 0) { int iIconWidth = m_pWeapon->rcAmmo.right - m_pWeapon->rcAmmo.left; if (pw->iClip >= 0) { // room for the number and the '|' and the current ammo x = ScreenWidth - (8 * AmmoWidth) - iIconWidth; x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pw->iClip, r, g, b); wrect_t rc; rc.top = 0; rc.left = 0; rc.right = AmmoWidth; rc.bottom = 100; int iBarWidth = AmmoWidth/10; x += AmmoWidth/2; // Fograin92: A little changes //UnpackRGB(r,g,b, RGB_YELLOWISH); r = SM_HUDcolor(1); g = SM_HUDcolor(2); b = SM_HUDcolor(3); // draw the | bar FillRGBA(x, y, iBarWidth, gHUD.m_iFontHeight, r, g, b, a); x += iBarWidth + AmmoWidth/2;; // GL Seems to need this ScaleColors(r, g, b, a ); x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b); } else { // SPR_Draw a bullets only line x = ScreenWidth - 4 * AmmoWidth - iIconWidth; x = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, gWR.CountAmmo(pw->iAmmoType), r, g, b); } // Draw the ammo Icon int iOffset = (m_pWeapon->rcAmmo.bottom - m_pWeapon->rcAmmo.top)/8; SPR_Set(m_pWeapon->hAmmo, r, g, b); SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo); } // Does weapon have seconday ammo? if (pw->iAmmo2Type > 0) { int iIconWidth = m_pWeapon->rcAmmo2.right - m_pWeapon->rcAmmo2.left; // Do we have secondary ammo? if ((pw->iAmmo2Type != 0) && (gWR.CountAmmo(pw->iAmmo2Type) > 0)) { y -= gHUD.m_iFontHeight + gHUD.m_iFontHeight/4; x = ScreenWidth - 4 * AmmoWidth - iIconWidth; x = gHUD.DrawHudNumber(x, y, iFlags|DHN_3DIGITS, gWR.CountAmmo(pw->iAmmo2Type), r, g, b); // Draw the ammo Icon SPR_Set(m_pWeapon->hAmmo2, r, g, b); int iOffset = (m_pWeapon->rcAmmo2.bottom - m_pWeapon->rcAmmo2.top)/8; SPR_DrawAdditive(0, x, y - iOffset, &m_pWeapon->rcAmmo2); } } return 1; }
int CHudBattery::Draw(float flTime) { if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH ) return 1; // modif de jUlien if ( !(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))) ) return 1; /* int r, g, b, x, y, a; wrect_t rc; rc = *m_prc2; 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 UnpackRGB(r,g,b, RGB_YELLOWISH); if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1; // Has health changed? Flash the health # if (m_fFade) { if (m_fFade > FADE_TIME) m_fFade = FADE_TIME; m_fFade -= (gHUD.m_flTimeDelta * 20); if (m_fFade <= 0) { a = 128; m_fFade = 0; } // Fade the health number back to dim a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128; } else a = MIN_ALPHA; ScaleColors(r, g, b, a ); int iOffset = (m_prc1->bottom - m_prc1->top)/6; y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = ScreenWidth/5; // make sure we have the right sprite handles if ( !m_hSprite1 ) m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) ); if ( !m_hSprite2 ) m_hSprite2 = gHUD.GetSprite( gHUD.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 = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b); */ // modif de Julien // affichage du nouveau hud for ( int i = 0; i < 7; i++ ) { // couleurs précalculées int r = m_flArmor[i][0], g = m_flArmor[i][1], b = m_flArmor[i][2]; // brillance pour les dommages if ( m_flPain[i] > 0 ) { // blanc r = r + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - r ); g = g + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - g ); b = b + ( m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - b ); m_flPain[i] = max ( 0, m_flPain[i] - gHUD.m_flTimeDelta ); } if ( m_flPain[i] < 0 ) { // rouge r = r + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 255 - r ); g = g + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 0 - g ); b = b + ( -m_flPain[i] / ARMOR_PAIN_TIME ) * ( 0 - b ); m_flPain[i] = min ( 0, m_flPain[i] + gHUD.m_flTimeDelta ); } ScaleColors ( r,g,b, 200 ); SPR_Set( m_sprCorps, r, g, b ); SPR_DrawAdditive(i, 0, 0, &m_wrcCorps); } //----------------------- return 1; }
bool CHudAmmo::Draw(float flTime) { int a, x, y, r, g, b; int AmmoWidth; if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return true; if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) ) return true; // Draw Weapon Menu DrawWList(flTime); // Draw ammo pickup history gHR.DrawAmmoHistory( flTime ); if (!(m_iFlags & 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 = abs( 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 = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left; a = (int) max( static_cast<float>( MIN_ALPHA ), m_fFade ); if (m_fFade > 0) m_fFade -= (gHUD.m_flTimeDelta * 20); gHUD.GetPrimaryColor().UnpackRGB(r,g,b); ScaleColors(r, g, b, a ); // Does this weapon have a clip? y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight/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 = gHUD.DrawHudNumber(x, y, iFlags | DHN_3DIGITS, pw->m_iClientClip, r, g, b); wrect_t rc; rc.top = 0; rc.left = 0; rc.right = AmmoWidth; rc.bottom = 100; int iBarWidth = AmmoWidth/10; x += AmmoWidth/2; gHUD.GetPrimaryColor().UnpackRGB(r,g,b); // draw the | bar FillRGBA(x, y, iBarWidth, gHUD.m_iFontHeight, r, g, b, a); x += iBarWidth + AmmoWidth/2;; // GL Seems to need this ScaleColors(r, g, b, a ); x = gHUD.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 = gHUD.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 -= gHUD.m_iFontHeight + gHUD.m_iFontHeight/4; x = ScreenWidth - 4 * AmmoWidth - iIconWidth; x = gHUD.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; }
int CHudBattery::Draw( float flTime ) { if( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH ) return 1; if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) )) return 1; int r, g, b, x, y, a; wrect_t rc; rc = *m_prc2; // battery can go from 0 to 100 so * 0.01 goes from 0 to 1 rc.top += m_iHeight * ((float)( 100 - ( min( 100, m_iBat ))) * 0.01f ); UnpackRGB( r, g, b, RGB_YELLOWISH ); // Has health changed? Flash the health # if( m_fFade ) { if( m_fFade > FADE_TIME ) m_fFade = FADE_TIME; m_fFade -= (gHUD.m_flTimeDelta * 20); if( m_fFade <= 0 ) { a = 128; m_fFade = 0; } // Fade the health number back to dim a = MIN_ALPHA + (m_fFade / FADE_TIME) * 128; } else { a = MIN_ALPHA; } ScaleColors( r, g, b, a ); int iOffset = (m_prc1->bottom - m_prc1->top) / 6; y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2; x = ScreenWidth / 5; // make sure we have the right sprite handles if( !m_hSprite1 ) m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" )); if( !m_hSprite2 ) m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" )); if( !m_hSprite1Helmet ) m_hSprite1Helmet = gHUD.GetSprite( gHUD.GetSpriteIndex( "suithelmet_empty" )); if( !m_hSprite2Helmet ) m_hSprite2Helmet = gHUD.GetSprite( gHUD.GetSpriteIndex( "suithelmet_full" )); if( m_enArmorType == Vest ) SPR_Set( m_hSprite1, r, g, b ); else SPR_Set( m_hSprite1Helmet, r, g, b ); SPR_DrawAdditive( 0, x, y - iOffset, m_prc1 ); if( rc.bottom > rc.top ) { if( m_enArmorType == Vest ) SPR_Set( m_hSprite2, r, g, b ); else SPR_Set( m_hSprite2Helmet, r, g, b ); SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc ); } x += (m_prc1->right - m_prc1->left); x = gHUD.DrawHudNumber( x, y, DHN_3DIGITS|DHN_DRAWZERO, m_iBat, r, g, b ); return 1; }
// // 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; gHUD.GetPrimaryColor().UnpackRGB(r,g,b); if ( iActiveSlot == i ) a = 255; else a = 192; ScaleColors(r, g, b, 255); SPR_Set(gHUD.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, &gHUD.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->GetFirstPos( i ); int iWidth = m_iBucketWidth; if ( p ) iWidth = p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.right - p->GetWeaponInfo()->GetHUDInfo()->GetActive().rect.left; for ( int iPos = 0; iPos < MAX_WEAPONS; iPos++ ) { p = pPlayer->GetWeapon( i, iPos ); if ( !p || !p->GetWeaponInfo() ) continue; auto pHUDInfo = p->GetWeaponInfo()->GetHUDInfo(); gHUD.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(gHUD.GetSprite(m_HUD_selection), r, g, b ); SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_selection)); } else { // Draw Weapon if Red if no ammo if ( pPlayer->HasAmmo(p) ) ScaleColors(r, g, b, 192); else { gHUD.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. gHUD.GetPrimaryColor().UnpackRGB(r,g,b); for ( int iPos = 0; iPos < MAX_WEAPONS; iPos++ ) { CBasePlayerWeapon *p = pPlayer->GetWeapon( i, iPos ); if ( !p || !p->GetWeaponInfo() ) continue; if ( pPlayer->HasAmmo(p) ) { gHUD.GetPrimaryColor().UnpackRGB(r,g,b); a = 128; } else { gHUD.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; }