void UIDrawVariableBarSpriteHoles(int inSprite, int inX, int inY, float inPercentage)
{
// Assumes that frame 0 is the empty sprite, frame 1 is full sprite
const int kEmptyFrame = 0;
const int kFullFrame = 1;
int theSpriteWidth = SPR_Width(inSprite, kFullFrame);
int theSpriteHeight = SPR_Height(inSprite, kFullFrame);
int theColorComponent = 255;
// Draw empty sprite
SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent);
SPR_DrawHoles(kEmptyFrame, inX, inY, NULL);
// Draw secondary level if specified, at half brightness
int theFilledHeight = theSpriteHeight*inPercentage;
theFilledHeight = theSpriteHeight*inPercentage;
// Draw partially full sprite. Enable scissor so it's not all drawn.
SPR_EnableScissor(inX, inY + (theSpriteHeight - theFilledHeight), theSpriteWidth, theFilledHeight);
SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent);
SPR_DrawHoles(kFullFrame, inX, inY, NULL);
SPR_DisableScissor();
}
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;
}
}
void FadingImageLabel::DoPaint()
{
//const float thePercentToChopOffXEdge = .1f;
//const float thePercentToChopOffYEdge = 0.0f;
int theX, theY;
this->getPos(theX, theY);
//if(!IEngineStudio.IsHardware())
//{
// theX += ScreenWidth/2;
// theY += ScreenHeight/2;
//}
int theWidth, theHeight;
this->getSize(theWidth, theHeight);
//ASSERT(this->mVisibleWidth <= theWidth);
//ASSERT(this->mVisibleHeight <= theHeight);
if((this->mVisibleWidth <= theWidth) && (this->mVisibleHeight <= theHeight))
{
int r, g, b, a;
this->getBgColor(r, g, b, a);
float theGammaSlope = gHUD.GetGammaSlope();
r = r/theGammaSlope;
g = g/theGammaSlope;
b = b/theGammaSlope;
// Don't take gamma slope into account for alpha
a = 255 - a;
////int theXBorder = thePercentToChopOffXEdge*ScreenWidth;
////int theYBorder = thePercentToChopOffYEdge*ScreenHeight;
int theXBorder = (theWidth - this->mVisibleWidth)/2;
int theYBorder = (theHeight - this->mVisibleHeight)/2;
//vguiSimpleBox(theXBorder, theYBorder, theWidth - theXBorder*2 + theXBorder, theHeight - theYBorder*2 + theYBorder, r, g, b, a);
if(!this->mImageMode)
{
//FillRGBA(theXBorder, theYBorder, theWidth - theXBorder*2, theHeight - theYBorder*2, r, g, b, a);
//int theSprite = Safe_SPR_Load("sprites/marinenode.spr");
//DrawScaledHUDSprite(theSprite, kRenderTransAdd, 1, theX, theY, theWidth, theHeight, 0);
gEngfuncs.pTriAPI->RenderMode(kRenderTransAlpha);
gEngfuncs.pTriAPI->CullFace(TRI_NONE);
//gEngfuncs.pTriAPI->Brightness(1);
theX = theXBorder;
theY = theYBorder;
theWidth = theWidth - theXBorder*2;
theHeight = theHeight - theYBorder*2;
// 0 = selectable, valid
// 1 = selectable, valid, current
// 2 = selectable, invalid
// 3 = selectable, invalid, current
int theFrame = 0;
if(this->GetEnabled() && this->GetDrawHighlighted())
{
theFrame = 1;
}
else if(!this->GetEnabled())
{
theFrame = this->GetFadeState() ? 3 : 2;
}
//char theFrameNumber[64];
//sprintf(theFrameNumber, "Frame %d", theFrame);
//this->mTextImage.setText(theFrameNumber);
if(!this->mSprite)
{
this->mSprite = Safe_SPR_Load(this->mImageName.c_str());
this->mSpriteWidth = SPR_Width(this->mSprite, this->mSpriteFrame);
this->mSpriteHeight = SPR_Height(this->mSprite, this->mSpriteFrame);
ASSERT(this->mSprite > 0);
}
if(this->mSprite && gEngfuncs.pTriAPI->SpriteTexture((struct model_s*)gEngfuncs.GetSpritePointer(this->mSprite), theFrame))
{
gEngfuncs.pTriAPI->Begin(TRI_TRIANGLE_STRIP);
vec3_t theVertex;
gEngfuncs.pTriAPI->TexCoord2f(0, 1);
theVertex.x = theX;
theVertex.y = theY + theHeight;
theVertex.z = 0;
//gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a);
gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex);
gEngfuncs.pTriAPI->TexCoord2f(0, 0);
theVertex.x = theX;
theVertex.y = theY;
//gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a);
gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex);
gEngfuncs.pTriAPI->TexCoord2f(1, 1);
theVertex.x = theX + theWidth;
theVertex.y = theY + theHeight;
//gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a);
gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex);
gEngfuncs.pTriAPI->TexCoord2f(1, 0);
theVertex.x = theX + theWidth;
theVertex.y = theY;
//gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a);
gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex);
gEngfuncs.pTriAPI->End();
}
gEngfuncs.pTriAPI->RenderMode(kRenderNormal);
}
else
{
SPR_Set(this->mSprite, a, a, a);
int theSpriteWidth = SPR_Width(this->mSprite, this->mSpriteFrame);
int theSpriteHeight = SPR_Height(this->mSprite, this->mSpriteFrame);
//SPR_DrawAdditive(theFrame, (theWidth - theSpriteWidth)/2, (theHeight - theSpriteHeight)/2, NULL);
SPR_DrawHoles(this->mSpriteFrame, (theWidth - theSpriteWidth)/2, (theHeight - theSpriteHeight)/2, NULL);
}
}
}
// Draw node lines
void PieNode::paintBackground()
{
// For each child
for(int i = 0; i < kNumNodes; i++)
{
PieNode* theCurrentPieNode = this->mArray[i];
if(theCurrentPieNode)
{
// Draw line from us to them indicating pie node in that direction
if(theCurrentPieNode->GetValveAlpha() < 255)
{
// If node above us isn't highlighted, don't draw line to us
//if(theCurrentPieNode->HasSelectedNodeAbove() || theCurrentPieNode->HasSelectedNodeBelow())
// All those lines are getting confusing. Only draw the lines around this pie node that
// connect to a selected parent or selected child
if(theCurrentPieNode->HasSelectedNodeBelow() || this->GetDrawSelected())
{
// Find correct line to draw from center of edge of source pie node to center
// of edge of dest pie node
int theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1;
if(this->ComputeRelativeConnectorCoordinates(theCurrentPieNode, theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1))
{
// What color to draw the line in?
//vgui::Color theCurrentColor = this->GetColor();
vgui::Color theCurrentColor;
//theCurrentPieNode->getBgColor(theCurrentColor);
if(this->mEnabled)
{
theCurrentPieNode->getFgColor(theCurrentColor);
}
else
{
theCurrentPieNode->getBgColor(theCurrentColor);
}
int r, g, b, a;
theCurrentColor.getColor(r, g, b, a);
// Take gamma into account
//r *= this->mColorBias;
//g *= this->mColorBias;
//b *= this->mColorBias;
a = this->GetValveAlpha();
// //if(theCurrentPieNode->GetEnabled())
// //{
// g = (theCurrentPieNode->HasSelectedNodeBelow() ? 255 : kDarkGreenColor);
// //g = (theCurrentPieNode->HasSelectedNodeAbove() ? 255 : kDarkGreenColor);
// //}
// // ...else this will draw lines in disabled color too, using current fade alpha
// Stupid Valve-alpha, vguiSimpleLine wants normal alpha of course
a = 255 - a;
a *= this->mColorBias;
// Only draw if child isn't invisible. Draw line
// relative from current node.
if(this->mConnectorSprite == 0 && (this->mConnectorSpriteName != ""))
{
this->mConnectorSprite = Safe_SPR_Load(this->mConnectorSpriteName.c_str());
}
if(this->mConnectorSprite > 0)
{
// Approximate alpha
float theAlpha = a/255.0f;
int theSpriteRed = theAlpha*r;
int theSpriteGreen = theAlpha*g;
int theSpriteBlue = theAlpha*b;
SPR_Set(this->mConnectorSprite, theSpriteRed, theSpriteGreen, theSpriteBlue);
int theLineWidth = abs(theRelativeLineX1 - theRelativeLineX0);
int theLineHeight = abs(theRelativeLineY1 - theRelativeLineY0);
// Use second frame if vertical
int theConnectorFrame = 0;
if(theLineHeight > 0)
{
theConnectorFrame = 1;
}
int theConnectorSpriteWidth = SPR_Width(this->mConnectorSprite, theConnectorFrame);
int theConnectorSpriteHeight = SPR_Height(this->mConnectorSprite, theConnectorFrame);
int thePieNodeWidth, thePieNodeHeight;
this->getContentSize(thePieNodeWidth, thePieNodeHeight);
int thePieNodeX, thePieNodeY;
this->getPos(thePieNodeX, thePieNodeY);
int theStartX = 0;
int theStartY = 0;
if(theConnectorFrame == 0)
{
int theXOffset = (theLineWidth - theConnectorSpriteWidth)/2;
//if(theXOffset < 0)
// theXOffset = 0;
theStartX = min(theRelativeLineX0, theRelativeLineX1) + theXOffset;
theStartY = min(theRelativeLineY0, theRelativeLineY1) - theConnectorSpriteHeight/2;
// int theScissorStartX = thePieNodeX + min(theRelativeLineX0, theRelativeLineX1) + thePieNodeWidth/2;
// int theScissorStartY = thePieNodeY + theStartY;
// int theScissorEndX = theScissorStartX + theLineWidth - thePieNodeWidth/2;
// int theScissorEndY = theScissorStartY + theConnectorSpriteHeight;
//vguiSimpleBox(theScissorStartX - thePieNodeX, theScissorStartY - thePieNodeY, theScissorEndX - thePieNodeX, theScissorEndY - thePieNodeY, 255, 255, 0, 128);
// SPR_EnableScissor(theScissorStartX, theScissorStartY, theLineWidth, theConnectorSpriteHeight);
}
else
{
int theYOffset = (theLineHeight - theConnectorSpriteHeight)/2;
//if(theYOffset < 0)
// theYOffset = 0;
theStartX = min(theRelativeLineX0, theRelativeLineX1) - theConnectorSpriteWidth/2;
theStartY = min(theRelativeLineY0, theRelativeLineY1) + theYOffset;
// int theScissorStartX = thePieNodeX + theStartX;
// int theScissorStartY = thePieNodeY + min(theRelativeLineY0, theRelativeLineY1);
// int theScissorEndX = theScissorStartX + theConnectorSpriteWidth;
// int theScissorEndY = theScissorStartY + theLineHeight - thePieNodeHeight;
//vguiSimpleBox(theScissorStartX - thePieNodeX, theScissorStartY - thePieNodeY, theScissorEndX - thePieNodeX, theScissorEndY - thePieNodeY, 255, 255, 0, 128);
// SPR_EnableScissor(theScissorStartX, theScissorStartY, theConnectorSpriteWidth, theLineHeight);
}
// Take into account our position, including our parent(s), when drawing
// Panel* theParent = this->getParent();
// while(theParent)
// {
// int theX, theY;
// theParent->getPos(theX, theY);
// theStartX += theX;
// theStartY += theY;
// theParent = theParent->getParent();
// }
// Draw it
//SPR_DrawAdditive(theConnectorFrame, theStartX, theStartY, NULL);
SPR_DrawHoles(theConnectorFrame, theStartX, theStartY, NULL);
// gEngfuncs.pfnSPR_DisableScissor();
}
else
{
vguiSimpleLine(theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1, r, g, b, a);
}
vguiSimpleBox(theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1, 255, 255, 0, 128);
}
}
}
}
}
}
int CHudRadar::Draw(float flTime)
{ if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) || gEngfuncs.IsSpectateOnly() || !(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))))
{ return 1;
}
cl_entity_t *pLocal = gEngfuncs.GetLocalPlayer();
if(!pLocal)
{ return 1;
}
float flPlayerAngles, flLength, flAngle, flRadians, pos_x, pos_y;
vec3_t vecViewAngles, v_right, vecPlayerOrigin, vecOtherOrigin, vecDifference, vecAngles;
/*
* Draw Background radar
*/
// Get origin for radar
int x = ScreenWidth;
int y = 0;
int iRadarWidth = gHUD.GetSpriteRect(m_HUD_radar).right - gHUD.GetSpriteRect(m_HUD_radar).left;
int iRadarHeight = gHUD.GetSpriteRect(m_HUD_radar).bottom - gHUD.GetSpriteRect(m_HUD_radar).top;
int infox = ScreenWidth - INFO_WIDTH;
int infoy = iRadarHeight;
int infoheight = gHUD.GetSpriteRect(m_HUD_radar_info).bottom - gHUD.GetSpriteRect(m_HUD_radar_info).top;
x -= iRadarWidth;
// Slide radar + info bar in/out when we enable/disable
if(m_blPrevRadar != m_blRadar && !m_blSliding)
{ m_blSliding = true;
m_flSlideTime = flTime;
}
// We switched the radar on/off while in the middle of sliding
else if(m_blPrevRadar == m_blRadar && m_blSliding)
{ m_blPrevRadar = !m_blPrevRadar;
// Invert time
float flSlideTime = flTime - m_flSlideTime;
flSlideTime = SLIDETIME - flSlideTime;
m_flSlideTime = flTime - flSlideTime;
}
if(m_blSliding)
{ // Sliding is done, disable
if((m_flSlideTime + SLIDETIME) < flTime)
{ m_blSliding = false;
m_flSlideTime = 0;
m_blPrevRadar = m_blRadar;
// Done sliding and radar is off, disable
if(!m_blRadar)
{ return 1;
}
}
// we're still sliding
else
{ float flPercent;
if(m_blRadar)
flPercent = (SLIDETIME-(flTime - m_flSlideTime))/SLIDETIME;
else
flPercent = (flTime - m_flSlideTime)/SLIDETIME;
// Slide Radar
y = -iRadarHeight * flPercent;
// Slide Infobox
infox += INFO_WIDTH * flPercent;
}
}
// Done sliding and radar is off, disable
if(!m_blRadar && !m_blSliding)
{ return 1;
}
// Draw Radar
SPR_Set(gHUD.GetSprite(m_HUD_radar), 255, 255, 255);
SPR_DrawHoles(0, x,y, &gHUD.GetSpriteRect(m_HUD_radar));
// Draw info box
SPR_Set(gHUD.GetSprite(m_HUD_radar_info), 255,255,255);
SPR_DrawHoles(0, infox,infoy, &gHUD.GetSpriteRect(m_HUD_radar_info));
if(m_blSliding)
m_iyBottomRadar = y + iRadarHeight;
else
m_iyBottomRadar = infoy + infoheight;
// Sliding or radar is just off, dont display information
if(m_blSliding || !m_blRadar)
{ return 1;
}
/*
* Get Player Angles
*/
// Setting player angles
gEngfuncs.GetViewAngles((float *)vecViewAngles);
AngleVectors(vecViewAngles, NULL, v_right, NULL );
// Inverse vector
VectorInverse(v_right);
v_right.z = 0;
// Get angles
VectorAngles(v_right,vecAngles);
flPlayerAngles = vecAngles.y;
// strictly 0 to 360
if(flPlayerAngles < 0)
flPlayerAngles += 360;
// Move x and y to the middle of the radar
x += OFFSET_RAD_WIDTH;
y += OFFSET_RAD_HEIGHT;
/*
* Loop and draw dots
*/
for(int i=0; i<MAX_PLAYERS; i++)
{ int r=255,g=255,b=255;
bool blDrawInfo = false;
cl_entity_t *pPlayer = gEngfuncs.GetEntityByIndex(i);
// Invalid
if(!pPlayer)
{ continue;
}
// Not player
if(!pPlayer->player)
{ continue;
}
// Render check, make sure player is being rendered
if(!g_RenderCheck[i].blRendered)
{ continue;
}
// Draw yourself as a orange dot
if(pPlayer == pLocal)
{ r=255;
g=255;
b=0;
}
// Get Origins
vecPlayerOrigin = pLocal->origin;
vecOtherOrigin = pPlayer->origin;
vecPlayerOrigin.z = 0;
vecOtherOrigin.z = 0;
vecDifference = vecPlayerOrigin - vecOtherOrigin;
flLength = vecDifference.Length();
// Player is too far away, dont draw
if(flLength > MAX_RADAR_DIST)
continue;
vecDifference = vecDifference.Normalize();
// Set 0 to 360
VectorAngles(vecDifference, vecAngles);
flAngle = vecAngles.y;
if(flAngle < 0)
flAngle += 360;
// Subtract Angles
flAngle = flPlayerAngles - flAngle;
// Set length according to the size of the radar
flLength = (flLength/(float)MAX_RADAR_DIST) * RAD_DIAM;
// Angles to radians
flRadians = flAngle * PI_180;
pos_x = int(cos(flRadians)*flLength);
pos_y = int(sin(flRadians)*flLength);
// Set positions + draw radar
pos_x += x;
pos_y += y;
// Shift dot over so it's drawn in the correct position
int iDotWidth = (gHUD.GetSpriteRect(m_HUD_radardot).right - gHUD.GetSpriteRect(m_HUD_radardot).left)/2;
int iDotHeight = (gHUD.GetSpriteRect(m_HUD_radardot).bottom - gHUD.GetSpriteRect(m_HUD_radardot).top)/2;
pos_x -= iDotWidth;
pos_y -= iDotHeight;
// Person is targeted by our missles, color them red
if( gHUD.m_Lockon.FindLock( pPlayer->index ) != -1 )
{ r=255;
g=0;
b=0;
}
// Yellow if our crosshair is/was over the player
if( gHUD.m_Crosshair.m_iMouseOverEnt == pPlayer->index && ((flTime - gHUD.m_Crosshair.m_flMouseOverTime) < 3) )
{ UnpackRGB(r,g,b, RGB_YELLOWISH);
blDrawInfo = true;
}
// Draw
SPR_Set(gHUD.GetSprite(m_HUD_radardot), r,g,b);
SPR_DrawAdditive(0, pos_x,pos_y, &gHUD.GetSpriteRect(m_HUD_radardot));
// Draw information if specified
if(blDrawInfo)
{ int line_height=0,line_width=0;
pos_x = ScreenWidth - INFO_WIDTH + INFO_OFFSET_WIDTH;
pos_y = iRadarHeight + INFO_OFFSET_HEIGHT;
hud_player_info_t *pl_info = &g_PlayerInfoList[i];
char szName[128];
// Get colors
float flTeamR,flTeamG,flTeamB;
if((g_PlayerExtraInfo[i].teamnumber == g_PlayerExtraInfo[pLocal->index].teamnumber) && gHUD.m_Teamplay)
{ flTeamR=0;
flTeamG=0.9;
flTeamB=0;
}
else
{ flTeamR=1.0;
flTeamG=0.2;
flTeamB=0.2;
}
// Draw player name
strcpy(szName,"Name: ");
int iNameX = DrawConsoleString( pos_x, pos_y, szName );
// Draw name in color, depending if player is on your team
strcpy(szName, pl_info->name);
// Set color
gEngfuncs.pfnDrawSetTextColor(flTeamR,flTeamG,flTeamB);
// Draw
DrawConsoleString( iNameX, pos_y, szName );
// Adjust offset
GetConsoleStringSize( szName, &line_width, &line_height );
pos_y += line_height + INFO_OFFSET_LINE;
// Draw Label
strcpy(szName,"Mech: ");
iNameX = DrawConsoleString( pos_x, pos_y, szName );
// Get Mech Name
int iClass = g_PlayerExtraInfo[i].playerclass;
if(iClass < 0)
iClass = 0;
else if(iClass >= PC_LASTCLASS)
iClass = PC_LASTCLASS-1;
strcpy(szName, szClassNames[iClass] );
// Set Color
gEngfuncs.pfnDrawSetTextColor(flTeamR,flTeamG,flTeamB);
// Draw Mech Name
DrawConsoleString( iNameX, pos_y, szName );
}
}
return 1;
}
int CHudHealth::Draw(float flTime)
{
int r = 0, g = 0, b = 0;
int x = 0, y = 0;
int iDraw = 0;
if ( gHUD.m_iHideHUDDisplay & (HIDEHUD_ALL) )
return 1;
if(g_iTeamNumber == UNDEFINED || g_iTeamNumber == SPECS )
{
gHUD.m_iHideHUDDisplay |= HIDEHUD_HEALTH;
return 1;
}
if(g_iUser1 != 0)
return 1;
m_flHealth = g_flHealth;
if ( !m_hSprite )
m_hSprite = LoadSprite(PAIN_NAME);
//hocked on here as this is a good palce as they are related.
if(IEngineStudio.IsHardware())
iDraw = gBackground.Draw(flTime);
if(iDraw == 0)
{
gHUD.m_iHideHUDDisplay |= HIDEHUD_HEALTH;
return 1;
}
else
{
gHUD.m_iHideHUDDisplay &= ~HIDEHUD_HEALTH;
}
gStamina.Draw(flTime);
if(ScreenWidth >= 640)
gMiddle.Draw(flTime);
gHintBox.Draw(flTime);
UnpackRGB(r, g, b, RGB_WHITEISH);
HSPRITE m_hSprite = gHUD.GetSprite( m_HUD_health );
wrect_t *m_SpriteArea = &gHUD.GetSpriteRect( m_HUD_health );
int x_length, y_length; // positions of the spots
y_length = gHUD.GetSpriteRect(m_HUD_health).bottom - gHUD.GetSpriteRect(m_HUD_health).top;
x_length = gHUD.GetSpriteRect(m_HUD_health).right - gHUD.GetSpriteRect(m_HUD_health).left;
if(ScreenWidth >= 640)
x = 5;
else
x = 2;
y = (YRES(480) - (y_length + ((ScreenWidth >= 640) ? 5 : 3)));
if(!IEngineStudio.IsHardware())
{
UnpackRGB(r, g, b, RGB_WHITEISH);
gStamina.Draw(flTime);
if(ScreenWidth >= 640)
x = 5;
else
x = 2;
y = (YRES(480) - (20 + ((ScreenWidth >= 640) ? 5 : 3)));
gHUD.DrawHudNumber(x, y, DHN_2DIGITS | DHN_DRAWZERO, m_flHealth, r, g, b);
return 1;
}
SPR_Set(m_hSprite, r, g, b);
int iClipLevel = (y_length - ((m_flHealth * y_length) / MAX_HEALTH));
//clipper starts at the clipping level. its height is the full amount of health take away the mamount clipped
SPR_EnableScissor(x, y+iClipLevel, 24 , y_length-iClipLevel);
SPR_DrawHoles(0, x, y, m_SpriteArea);
SPR_DisableScissor();
DrawDamage(flTime);
return DrawPain(flTime);
}
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 CHudRadar::Draw(float flTime)
{
if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) ||
gEngfuncs.IsSpectateOnly() ||
!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT))) ||
gHUD.m_fPlayerDead )
return 1;
int iTeamNumber = g_PlayerExtraInfo[ gHUD.m_Scoreboard.m_iPlayerNum ].teamnumber;
int r, g, b;
if( cl_radartype->value )
{
SPR_Set(m_hRadarOpaque.spr, 200, 200, 200);
SPR_DrawHoles(0, 0, 0, &m_hRadarOpaque.rect);
}
else
{
SPR_Set( m_hRadar.spr, 25, 75, 25 );
SPR_DrawAdditive( 0, 0, 0, &m_hRadarOpaque.rect );
}
if( bUseRenderAPI )
{
gEngfuncs.pTriAPI->RenderMode( kRenderTransAdd );
gEngfuncs.pTriAPI->CullFace( TRI_NONE );
gEngfuncs.pTriAPI->Brightness( 1 );
gRenderAPI.GL_SelectTexture( 0 );
}
for(int i = 0; i < 33; i++)
{
// skip local player and dead players
if( i == gHUD.m_Scoreboard.m_iPlayerNum || g_PlayerExtraInfo[i].dead )
continue;
// skip non-teammates
if( g_PlayerExtraInfo[i].teamnumber != iTeamNumber )
continue;
// decide should player draw at this time. For flashing.
// Always true for non-flashing players
if( !FlashTime( flTime, &g_PlayerExtraInfo[i]) )
continue;
// player with C4 must be red
if( g_PlayerExtraInfo[i].has_c4 )
{
DrawUtils::UnpackRGB( r, g, b, RGB_REDISH );
}
else
{
// white
DrawUtils::UnpackRGB( r, g, b, RGB_WHITE );
}
// calc radar position
Vector pos = WorldToRadar(gHUD.m_vecOrigin, g_PlayerExtraInfo[i].origin, gHUD.m_vecAngles);
DrawZAxis( pos, r, g, b, 255 );
}
// Terrorist specific code( C4 Bomb )
if( g_PlayerExtraInfo[gHUD.m_Scoreboard.m_iPlayerNum].teamnumber == TEAM_TERRORIST )
{
if ( !g_PlayerExtraInfo[33].dead &&
g_PlayerExtraInfo[33].radarflashes &&
FlashTime( flTime, &g_PlayerExtraInfo[33] ))
{
Vector pos = WorldToRadar(gHUD.m_vecOrigin, g_PlayerExtraInfo[33].origin, gHUD.m_vecAngles);
if( g_PlayerExtraInfo[33].playerclass ) // bomb planted
{
DrawCross( pos.x, pos.y, 255, 0, 0, 255 );
}
else
{
DrawZAxis( pos, 255, 0, 0, 255 );
}
}
}
// Counter-Terrorist specific code( hostages )
else if( g_PlayerExtraInfo[gHUD.m_Scoreboard.m_iPlayerNum].teamnumber == TEAM_CT )
{
// draw hostages for CT
for( int i = 0; i < MAX_HOSTAGES; i++ )
{
if( !HostageFlashTime( flTime, g_HostageInfo + i ) )
{
continue;
}
Vector pos = WorldToRadar(gHUD.m_vecOrigin, g_HostageInfo[i].origin, gHUD.m_vecAngles);
if( g_HostageInfo[i].dead )
{
DrawZAxis( pos, 255, 0, 0, 255 );
}
else
{
DrawZAxis( pos, 4, 25, 110, 255 );
}
}
}
return 0;
}
//
// Draw Weapon Menu
//
int CHudAmmo::DrawWList(float flTime)
{
// int r,g,b,x,y,a,i;
int baseX, baseY, x,y;
bool blFakeActive = false;
// Check if sliding is finished
if(m_blSliding)
{ if(m_flSlideTime + SLIDETIME < gHUD.m_flTime)
{ m_blSliding = false;
m_blSlideIn = false;
m_flSlideTime = 0;
}
}
// "Fake" active weapon so we can slide the weapon bar out with the correct information
if ( !gpActiveSel )
{ // start sliding
if(m_blPrevStatus)
{ m_blPrevStatus = false;
SlideIn();
blFakeActive = true;
gpActiveSel = gpLastSel;
if(!gpActiveSel)
return 0;
}
else if(m_blSliding)
{ blFakeActive = true;
gpActiveSel = gpLastSel;
if(!gpActiveSel)
return 0;
}
else
{ m_blPrevStatus = false;
return 0;
}
}
else
{ if(!m_blPrevStatus)
{ SlideOut();
}
m_blPrevStatus = true;
}
int iActiveSlot;
if ( gpActiveSel == (WEAPON *)1 )
iActiveSlot = -1; // current slot has no weapons
else
iActiveSlot = gpActiveSel->iSlot;
baseX=x=0;
baseY=y=GetYBase(m_iweapcenterHeight);
// Ensure that there are available choices in the active slot
if ( iActiveSlot > 0 )
{
if ( !gWR.GetFirstPos( iActiveSlot ) )
{
gpActiveSel = (WEAPON *)1;
iActiveSlot = -1;
}
}
// Draw left bar edge
SPR_Set(gHUD.GetSprite(m_HUD_wpleft), 255, 255, 255 );
SPR_DrawHoles(0,x,y, &gHUD.GetSpriteRect(m_HUD_wpleft));
// Move over drawing position to the end of the left bar
x+=m_iweapedgeWidth;
// Draw all of the buckets
for (int i = 0; i < MAX_WEAPON_SLOTS; i++)
{
// Set bucket rect
wrect_t bucketrect;
bucketrect.top = 0;
bucketrect.left = 0;
bucketrect.bottom = BUCKET_HEIGHT;
bucketrect.right = BUCKET_WIDTH;
// If this is the active slot, draw the bigger pictures,
WEAPON *p = gWR.GetFirstPos( i );
/* int iWidth = BUCKET_WIDTH;
int iHeight = BUCKET_HEIGHT;*/
if ( p )
{/* iWidth = p->rcActive.right - p->rcActive.left;
iHeight = p->rcActive.bottom - p->rcActive.top;*/
}
for ( int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++ )
{
p = gWR.GetWeaponSlot( i, iPos );
if ( !p || !p->iId )
continue;
// Draw bucket
SPR_Set(gHUD.GetSprite(m_HUD_wpcenter), 255, 255, 255 );
SPR_DrawHoles(0, x, y, &gHUD.GetSpriteRect(m_HUD_wpcenter));
// Active weapon
if ( gpActiveSel == p )
{ SPR_Set(p->hActive, 255, 255, 255 );
SPR_Draw(0, x+OFFSETBUCKET_X, y+OFFSETBUCKET_Y, &bucketrect);
}
// Unactive weapon
else
{ SPR_Set(p->hInactive, 255, 255, 255 );
SPR_Draw(0, x+OFFSETBUCKET_X, y+OFFSETBUCKET_Y, &bucketrect);
}
x+=m_iweapcenterWidth;
}
}
// Draw right bar edge
SPR_Set(gHUD.GetSprite(m_HUD_wpright), 255, 255, 255 );
SPR_DrawHoles(0,x,y, &gHUD.GetSpriteRect(m_HUD_wpright));
// Set active back to NULL
if(blFakeActive)
{ gpActiveSel = NULL;
}
// Redone by Pcjoe
/*
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;
}
else
iWidth = giBucketWidth;
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 < MAX_WEAPON_SLOTS; 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 )
{
SPR_Set(p->hActive, r, g, b );
SPR_DrawAdditive(0, x, y, &p->rcActive);
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 ( 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;
}
