tf2/tf2_src/game/client/dod/dod_hud_objectiveicons.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"
#include "hudelement.h"
#include <vgui_controls/Panel.h>
#include <vgui_controls/Label.h>
#include <vgui/ISurface.h>
#include "c_baseplayer.h"
#include <vgui_controls/Panel.h>
#include "dod_gamerules.h"
#include "iclientmode.h"
#include "c_dod_objective_resource.h"
#include "c_dod_playerresource.h"
#include "c_dod_player.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "hud_macros.h"
#include <baseviewport.h>	//for IViewPortPanel
#include "spectatorgui.h"
#include "dod_round_timer.h"
#include "vgui_controls/AnimationController.h"
#include "dod_hud_freezepanel.h"

class CHudObjectiveIcons : public CHudElement, public vgui::Panel
{
public:
	DECLARE_CLASS_SIMPLE( CHudObjectiveIcons, vgui::Panel );

	CHudObjectiveIcons( const char *pName );
	
	virtual void ApplySchemeSettings( IScheme *scheme );
	virtual void Paint();
	virtual void Init();
	virtual void VidInit();
	virtual void Reset();

	virtual void FireGameEvent( IGameEvent *event );

	void DrawBackgroundBox( int xpos, int ypos, int nBoxWidth, int nBoxHeight, bool bCutCorner );

	virtual bool IsVisible( void );

private:

	vgui::Label	*m_pTimer;
	vgui::Label *m_pTimeAdded;

	CHudTexture *m_pIconDefended;

	int m_iCPTextures[8];
	int m_iCPCappingTextures[8];

	int m_iBackgroundTexture;
	Color m_clrBackground;
	Color m_clrBorder;

	int m_iLastCP;	// the index of the area we were last in

	CHudTexture *m_pC4Icon;
	CHudTexture *m_pExplodedIcon;
	CHudTexture *m_pC4PlantedBG;

	int m_iSecondsAdded;		// how many seconds were added in the last time_added event
	bool bInTimerWarningAnim;
	float m_flDrawTimeAddedUntil;

	CPanelAnimationVar( vgui::HFont, m_hTimerFont, "TimerFont", "Default" );
	CPanelAnimationVar( vgui::HFont, m_hTimerFontSmall, "TimerFontSmall", "DefaultSmall" );

	CPanelAnimationVar( vgui::HFont, m_hTextFont, "ChatFont", "Default" );

	CPanelAnimationVarAliasType( int, m_nIconSize, "iconsize", "24", "proportional_int" );
	CPanelAnimationVarAliasType( int, m_nSeparatorWidth, "separator_width", "7", "proportional_int" );
	CPanelAnimationVarAliasType( int, m_nCornerCutSize, "CornerCutSize", "5", "proportional_int" );
	CPanelAnimationVarAliasType( int, m_nBackgroundOverlap, "BackgroundOverlap", "5", "proportional_int" );

	CPanelAnimationVarAliasType( int, m_iIconStartX, "icon_start_x", "10", "proportional_int" );
	CPanelAnimationVarAliasType( int, m_iIconStartY, "icon_start_y", "10", "proportional_int" );
	CPanelAnimationVarAliasType( float, m_flIconExpand, "icon_expand", "0", "proportional_float" );

	CPanelAnimationVar( Color, m_clrTimer, "TimerBG", "255 0 0 128" );

	CPanelAnimationVarAliasType( int, m_nTimeAddedHeight, "time_added_height", "12", "proportional_int" );
	CPanelAnimationVar( float, m_flTimeAddedExpandPercent, "time_added_height_anim", "0.0" );
	CPanelAnimationVar( float, m_flTimeAddedAlpha, "time_added_alpha", "0" );

	CPanelAnimationVar( float, m_flTimeAddedDuration, "time_added_duration", "3.5" );
};

DECLARE_HUDELEMENT( CHudObjectiveIcons );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CHudObjectiveIcons::CHudObjectiveIcons( const char *pName ) : vgui::Panel( NULL, "HudObjectiveIcons" ), CHudElement( pName )
{
	SetParent( g_pClientMode->GetViewport() );
	SetHiddenBits( 0 );

	m_pTimer = new vgui::Label( this, "HudObjectivesRoundTimer", " " );
	if ( m_pTimer )
	{
		m_pTimer->SetContentAlignment( Label::a_center );
	}

	m_pTimeAdded = new vgui::Label( this, "HudObjectivesTimeAdded", " " );
	if ( m_pTimeAdded )
	{
		m_pTimeAdded->SetContentAlignment( Label::a_center );
	}

	m_iBackgroundTexture = vgui::surface()->DrawGetTextureId( "vgui/white" );
	if ( m_iBackgroundTexture == -1 )
	{
		m_iBackgroundTexture = vgui::surface()->CreateNewTextureID();
	}
	vgui::surface()->DrawSetTextureFile( m_iBackgroundTexture, "vgui/white", true, true );

	m_iLastCP = -1;

	m_iSecondsAdded = 0;
	bInTimerWarningAnim = false;

	m_flDrawTimeAddedUntil = -1;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::Init( void )
{
	for( int i = 0 ; i < 8 ; i++ )
	{
		m_iCPTextures[i] = vgui::surface()->CreateNewTextureID();
		m_iCPCappingTextures[i] = vgui::surface()->CreateNewTextureID();
	}

	ListenForGameEvent( "dod_timer_time_added" );
	ListenForGameEvent( "dod_timer_flash" );
}

void CHudObjectiveIcons::VidInit( void )
{
	m_flTimeAddedExpandPercent = 0.0;
	m_flTimeAddedAlpha = 0.0;
	m_flDrawTimeAddedUntil = -1;

	CHudElement::VidInit();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::Reset( void )
{
	m_iLastCP = -1;
	m_flIconExpand = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CHudObjectiveIcons::IsVisible( void )
{
	if ( IsTakingAFreezecamScreenshot() )
		return false;

	return BaseClass::IsVisible();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::FireGameEvent( IGameEvent *event )
{
	const char *eventname = event->GetName();

	if ( FStrEq( "dod_timer_time_added", eventname ) )
	{
		// show time added under the timer, flash
		m_iSecondsAdded = event->GetInt( "seconds_added" );

		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "TimerFlash" ); 

		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ShowTimeAdded" ); 

		if ( !m_pTimeAdded->IsVisible() )
		{
			m_pTimeAdded->SetVisible( true );
		}

		wchar_t wText[12];

		int iSecondsToDraw = abs(m_iSecondsAdded);
		bool bNegative = ( m_iSecondsAdded < 0 );

#ifdef WIN32
		_snwprintf( wText, sizeof(wText)/sizeof(wchar_t), L"%s %d:%02d", bNegative ? L"-" : L"+", iSecondsToDraw / 60, iSecondsToDraw % 60 );
#else
		_snwprintf( wText, sizeof(wText)/sizeof(wchar_t), L"%S %d:%02d", bNegative ? L"-" : L"+", iSecondsToDraw / 60, iSecondsToDraw % 60 );
#endif

		m_pTimeAdded->SetText( wText );

		m_flDrawTimeAddedUntil = gpGlobals->curtime + m_flTimeAddedDuration;

	}
	else if ( FStrEq( "dod_timer_flash", eventname ) )
	{
		// generic flash, used for 5, 2, 1 minute warnings
		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "TimerFlash" ); 
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	m_hTextFont = pScheme->GetFont( "ChatFont" );
	m_hTimerFontSmall = pScheme->GetFont( "TimerFontSmall" );

	m_clrBackground = pScheme->GetColor( "HudPanelBackground", GetFgColor() );
	m_clrBorder = pScheme->GetColor( "HudPanelBorder", GetBgColor() );

	m_pC4Icon = gHUD.GetIcon( "icon_c4" );
	m_pExplodedIcon = gHUD.GetIcon( "icon_c4_exploded" );
	m_pC4PlantedBG = gHUD.GetIcon( "icon_c4_planted_bg" );
	m_pIconDefended = gHUD.GetIcon( "icon_defended" );

	m_pTimer->SetFont( m_hTimerFont );
	m_pTimeAdded->SetFont( m_hTimerFontSmall );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::DrawBackgroundBox( int xpos, int ypos, int nBoxWidth, int nBoxHeight, bool bCutCorner )
{
	int nCornerCutSize = bCutCorner ? m_nCornerCutSize : 0;
	vgui::Vertex_t verts[5];

	verts[0].Init( Vector2D( xpos, ypos ) );
	verts[1].Init( Vector2D( xpos + nBoxWidth, ypos ) );
	verts[2].Init( Vector2D( xpos + nBoxWidth + 1, ypos + nBoxHeight - nCornerCutSize + 1 ) );
	verts[3].Init( Vector2D( xpos + nBoxWidth - nCornerCutSize + 1, ypos + nBoxHeight + 1 ) );
	verts[4].Init( Vector2D( xpos, ypos + nBoxHeight ) );

	vgui::surface()->DrawSetTexture( m_iBackgroundTexture );
	vgui::surface()->DrawSetColor( Color( m_clrBackground ) );
	vgui::surface()->DrawTexturedPolygon( 5, verts );

	vgui::Vertex_t borderverts[5];

	borderverts[0].Init( Vector2D( xpos, ypos ) );
	borderverts[1].Init( Vector2D( xpos + nBoxWidth, ypos ) );
	borderverts[2].Init( Vector2D( xpos + nBoxWidth, ypos + nBoxHeight - nCornerCutSize ) );
	borderverts[3].Init( Vector2D( xpos + nBoxWidth - nCornerCutSize, ypos + nBoxHeight ) );
	borderverts[4].Init( Vector2D( xpos, ypos + nBoxHeight ) );

	vgui::surface()->DrawSetColor( Color( m_clrBorder ) );
	vgui::surface()->DrawTexturedPolyLine( borderverts, 5 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudObjectiveIcons::Paint()
{
	int ypos = m_iIconStartY;
	int xpos = m_iIconStartX;
	static Color clrIcon( 255, 255, 255, 255 );

	if( !g_pObjectiveResource )	// MATTTODO: hasn't been transmited yet .. fix ?
	{
		return;
	}

	// Hide the time added if it is time to do so
	if ( m_flDrawTimeAddedUntil > 0 && m_flDrawTimeAddedUntil < gpGlobals->curtime )
	{
		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HideTimeAdded" ); 

		m_flDrawTimeAddedUntil = -1;
	}

	vgui::surface()->DrawSetTextFont( m_hTextFont );
	vgui::surface()->DrawSetColor( clrIcon );
	
	if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
	{
		ypos += g_pSpectatorGUI->GetTopBarHeight();
	}

	int num = g_pObjectiveResource->GetNumControlPoints();
	bool bShowTimer = ( g_DODRoundTimer != NULL );

	if ( num <= 0 && !bShowTimer )
	{
		if ( m_pTimer && m_pTimer->IsVisible() )
		{
			m_pTimer->SetVisible( false );
		}

		if ( m_pTimeAdded && m_pTimeAdded->IsVisible() )
		{
			m_pTimeAdded->SetVisible( false );
		}

		return; // nothing to draw yet
	}

	int iLastVisible = 0;

	int k;

	// let's count how many visible capture points we have (for cutting the corner of the last visible one)
	for( k = 0 ; k < num ; k++ )
	{
		if( g_pObjectiveResource->IsCPVisible( k ) )
		{
			iLastVisible = k;
		}
	}

	// do we have a round timer?
	if( bShowTimer )
	{
		if ( m_pTimer )
		{
			if ( !m_pTimer->IsVisible() )
			{
				m_pTimer->SetVisible( true );
			}

			m_pTimer->SetBounds( xpos, ypos, 2 * m_nIconSize, m_nIconSize );
			m_pTimer->SetBgColor( m_clrTimer );

			m_pTimeAdded->SetBounds( xpos, ypos + m_nIconSize, 2 * m_nIconSize, m_nTimeAddedHeight + m_nBackgroundOverlap );
			m_pTimeAdded->SetBgColor( Color(0,0,0,0) );

			int iRoundTime = (int)g_DODRoundTimer->GetTimeRemaining();

			int minutes = iRoundTime / 60;
			int seconds = iRoundTime % 60;

			if( minutes < 0 ) minutes = 0;
			if( minutes > 99 ) minutes = 99;
			if( seconds < 0 ) seconds = 0;

			// cut the corner if this is all we're drawing

			// figure out the height. will change if we're drawing the +1:00 below it
			int boxHeight = 2*m_nBackgroundOverlap + m_nIconSize + (int)( (float)m_nTimeAddedHeight * m_flTimeAddedExpandPercent );

			DrawBackgroundBox( xpos - m_nBackgroundOverlap, ypos - m_nBackgroundOverlap, m_pTimer->GetWide() + 2 * m_nBackgroundOverlap, boxHeight, ( num <= 0 ) ? true : false );

			// set the time
			char szTime[16];
			Q_snprintf( szTime, sizeof( szTime ), "%02d:%02d", minutes, seconds );
			m_pTimer->SetText( szTime );

			m_pTimeAdded->SetAlpha( (int)m_flTimeAddedAlpha );

			xpos += ( m_pTimer->GetWide() + m_nSeparatorWidth + m_nBackgroundOverlap * 2 );
		}
	}
	else
	{
		if ( m_pTimer && m_pTimer->IsVisible() )
		{
			m_pTimer->SetVisible( false );
		}
	}

	C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
	int iCurrentCapAreaIndex = pPlayer->GetCPIndex();

	if ( pPlayer->IsAlive() == false )
	{
		m_iLastCP = -1;
	}

	int index;

	for( index = 0 ; index < num ; index++ )
	{
		if( g_pObjectiveResource->IsCPVisible( index ) )
		{
			int iOwnerIcon = g_pObjectiveResource->GetCPCurrentOwnerIcon( index );

			float uv1 = 0.0f;
			float uv2 = 1.0f;

			float flXPos = (float)xpos;
			float flYPos = (float)ypos;
			float flIconSize = (float)m_nIconSize;

			if ( index == iCurrentCapAreaIndex )
			{
				// animate the current cp
				flXPos -= m_flIconExpand;
				flYPos -= m_flIconExpand;
				flIconSize += m_flIconExpand*2;

				m_iLastCP = iCurrentCapAreaIndex;
			}
			else if ( m_iLastCP == index )
			{
				// as a backup, animate out of the one we just left
				flXPos -= m_flIconExpand;
				flYPos -= m_flIconExpand;
				flIconSize += m_flIconExpand*2;
			}


			int iBombsRequired = g_pObjectiveResource->GetBombsRequired( index );

			if ( iBombsRequired > 0 )
			{
				DrawBackgroundBox( flXPos - m_nBackgroundOverlap, flYPos - m_nBackgroundOverlap, flIconSize + 2 * m_nBackgroundOverlap, flIconSize + 2 * m_nBackgroundOverlap + m_nTimeAddedHeight, ( index != iLastVisible ) ? false : true );
			}
			else
			{
				DrawBackgroundBox( flXPos - m_nBackgroundOverlap, flYPos - m_nBackgroundOverlap, flIconSize + 2 * m_nBackgroundOverlap, flIconSize + 2 * m_nBackgroundOverlap, ( index != iLastVisible ) ? false : true );
			}

			// Draw the background for the icon

			// allow for error
			if ( g_pObjectiveResource->IsBombSetAtPoint( index ) )
			{
				// if bomb timer is > 0, draw swipe
				float flBombTime = g_pObjectiveResource->GetBombTimeForPoint( index );	// round up

				// draw the 'white' version underneath
				int iBlankIcon = g_pObjectiveResource->GetCPTimerCapIcon( index );

				if ( iBlankIcon == 0 )
				{	
					iBlankIcon = g_pObjectiveResource->GetIconForTeam( index, TEAM_UNASSIGNED );
				}

				const char *szMatName = GetMaterialNameFromIndex( iBlankIcon );

				vgui::surface()->DrawSetTextureFile( m_iCPTextures[index], szMatName, true, false );

				Vector2D uv11( uv1, uv1 );
				Vector2D uv21( uv2, uv1 );
				Vector2D uv22( uv2, uv2 );
				Vector2D uv12( uv1, uv2 );

				vgui::Vertex_t vert[4];	
				vert[0].Init( Vector2D( flXPos,					flYPos               ), uv11 );
				vert[1].Init( Vector2D( flXPos + flIconSize,	flYPos               ), uv21 );
				vert[2].Init( Vector2D( flXPos + flIconSize,	flYPos + flIconSize ), uv22 );				
				vert[3].Init( Vector2D( flXPos,					flYPos + flIconSize ), uv12 );

				vgui::surface()->DrawSetColor( Color(255,255,255,255) );	
				vgui::surface()->DrawTexturedPolygon( 4, vert );
			
				// draw the real version in a circular swipe
				float flPercentRemaining = ( flBombTime / DOD_BOMB_TIMER_LENGTH );

				float flHalfWide = (float)flIconSize / 2.0f;
				float flHalfTall = (float)flIconSize / 2.0f;

				const float flCompleteCircle = ( 2.0f * M_PI );
				const float fl90degrees = flCompleteCircle * 0.25f;
				const float fl45degrees = fl90degrees * 0.5f;

				float flEndAngle = flCompleteCircle * flPercentRemaining; // clockwise

				typedef struct 
				{
					Vector2D vecTrailing;
					Vector2D vecLeading;
				} icon_quadrant_t;

				/*
				Quadrants are numbered 0 - 7 counter-clockwise
				_________________
				|	  0	| 7		|
				|		|		|
				|  1	|    6  |
				-----------------
				|  2	|	 5  |
				|		|		|
				|	  3	| 4		|
				-----------------
				*/

				// Encode the leading and trailing edge of each quadrant 
				// in the range 0.0 -> 1.0

				icon_quadrant_t quadrants[8];
				quadrants[0].vecTrailing.Init( 0.5, 0.0 );
				quadrants[0].vecLeading.Init( 0.0, 0.0 );

				quadrants[1].vecTrailing.Init( 0.0, 0.0 );
				quadrants[1].vecLeading.Init( 0.0, 0.5 );

				quadrants[2].vecTrailing.Init( 0.0, 0.5 );
				quadrants[2].vecLeading.Init( 0.0, 1.0 );

				quadrants[3].vecTrailing.Init( 0.0, 1.0 );
				quadrants[3].vecLeading.Init( 0.5, 1.0 );

				quadrants[4].vecTrailing.Init( 0.5, 1.0 );
				quadrants[4].vecLeading.Init( 1.0, 1.0 );

				quadrants[5].vecTrailing.Init( 1.0, 1.0 );
				quadrants[5].vecLeading.Init( 1.0, 0.5 );

				quadrants[6].vecTrailing.Init( 1.0, 0.5 );
				quadrants[6].vecLeading.Init( 1.0, 0.0 );

				quadrants[7].vecTrailing.Init( 1.0, 0.0 );
				quadrants[7].vecLeading.Init( 0.5, 0.0 );

				szMatName = GetMaterialNameFromIndex( iOwnerIcon );

				vgui::surface()->DrawSetTextureFile( m_iCPTextures[index], szMatName, true, false );
				vgui::surface()->DrawSetColor( Color(255,255,255,255) );	

				Vector2D uvMid( 0.5, 0.5 );
				Vector2D vecMid( flXPos + flHalfWide, flYPos + flHalfTall );

				int j;
				for ( j=0;j<=7;j++ )
				{
					float flMinAngle = j * fl45degrees;	

					float flAngle = clamp( flEndAngle - flMinAngle, 0, fl45degrees );

					if ( flAngle <= 0 )
					{
						// past our quadrant, draw nothing
						continue;
					}
					else
					{
						// draw our segment
						vgui::Vertex_t vert[3];	

						// vert 0 is mid ( 0.5, 0.5 )
						vert[0].Init( vecMid, uvMid );

						int xdir = 0, ydir = 0;

						switch( j )
						{
						case 0:  
						case 7:
							//right
							xdir = 1;
							ydir = 0;
							break;

						case 1: 
						case 2:
							//up
							xdir = 0;
							ydir = -1;
							break;

						case 3:
						case 4:
							//left
							xdir = -1;
							ydir = 0;
							break;

						case 5:
						case 6:
							//down
							xdir = 0;
							ydir = 1;
							break;
						}

						Vector2D vec1;
						Vector2D uv1;

						// vert 1 is the variable vert based on leading edge
						vec1.x = flXPos + quadrants[j].vecTrailing.x * flIconSize - xdir * tan(flAngle) * flHalfWide;
						vec1.y = flYPos + quadrants[j].vecTrailing.y * flIconSize - ydir * tan(flAngle) * flHalfTall;

						uv1.x = quadrants[j].vecTrailing.x - xdir * abs( quadrants[j].vecLeading.x - quadrants[j].vecTrailing.x ) * tan(flAngle);
						uv1.y = quadrants[j].vecTrailing.y - ydir * abs( quadrants[j].vecLeading.y - quadrants[j].vecTrailing.y ) * tan(flAngle);

						vert[1].Init( vec1, uv1 );

						// vert 2 is our trailing edge
						vert[2].Init( Vector2D( flXPos + quadrants[j].vecTrailing.x * flIconSize,
							flYPos + quadrants[j].vecTrailing.y * flIconSize ),
							quadrants[j].vecTrailing );

						vgui::surface()->DrawTexturedPolygon( 3, vert );					
					}	
				}

				if ( g_pObjectiveResource->IsBombBeingDefused( index ) )
				{
					float flSize = 0.75;
					int iconX = (int)( flXPos + flIconSize * ( ( 1.0 - flSize ) / 2 ) );
					int iconY = (int)( flYPos + flIconSize * ( ( 1.0 - flSize ) / 2 ) );
					int iconW = (int)( flIconSize * flSize );					

					Color c(255,255,255,255);
					m_pIconDefended->DrawSelf( iconX, iconY, iconW, iconW, c );
				}
			}
			else
			{
				// Draw the owner's icon
				if( iOwnerIcon != 0 )
				{
					const char *szMatName = GetMaterialNameFromIndex( iOwnerIcon );

					vgui::surface()->DrawSetTextureFile( m_iCPTextures[index], szMatName, true, false );
					
					/*
					// re-enable if we want to have animating cp icons
					// todo: framerate
					IVguiMatInfo *pMat = vgui::surface()->DrawGetTextureMatInfoFactory( m_iCPTextures[index] );

					if ( !pMat )
						return;

					int iNumFrames = pMat->GetNumAnimationFrames();

					IVguiMatInfoVar *m_pFrameVar;

					bool bFound = false;
					m_pFrameVar = pMat->FindVarFactory( "$frame", &bFound );

					static int frame = 0;

					if ( bFound )
					{
						frame++;
						m_pFrameVar->SetIntValue( frame % iNumFrames );
					}
					*/

					Vector2D uv11( uv1, uv1 );
					Vector2D uv21( uv2, uv1 );
					Vector2D uv22( uv2, uv2 );
					Vector2D uv12( uv1, uv2 );

					vgui::Vertex_t vert[4];	
					vert[0].Init( Vector2D( flXPos,					flYPos              ), uv11 );
					vert[1].Init( Vector2D( flXPos + flIconSize,	flYPos              ), uv21 );
					vert[2].Init( Vector2D( flXPos + flIconSize,	flYPos + flIconSize ), uv22 );				
					vert[3].Init( Vector2D( flXPos,					flYPos + flIconSize ), uv12 );

					vgui::surface()->DrawSetColor( Color(255,255,255,255) );	
					vgui::surface()->DrawTexturedPolygon( 4, vert );
				}		
			}
			
			// see if there are players in the area
			int iNumAllies = g_pObjectiveResource->GetNumPlayersInArea( index, TEAM_ALLIES );
			int iNumAxis = g_pObjectiveResource->GetNumPlayersInArea( index, TEAM_AXIS );

			int iCappingTeam = g_pObjectiveResource->GetCappingTeam( index );

			// Draw bomb icons under cap points
			if ( iBombsRequired > 0 )
			{
				int iBombsRemaining = g_pObjectiveResource->GetBombsRemaining( index );

				bool bBombPlanted = g_pObjectiveResource->IsBombSetAtPoint( index );

				int yIcon = ypos + flIconSize + YRES(2);

				int iIconHalfWidth = XRES(5);
				int iIconWidth = iIconHalfWidth * 2;

				Color c(255,255,255,255);

				switch( iBombsRequired )
				{
				case 1:
					{
						int xMid = xpos + ( flIconSize * 0.50f );

						switch( iBombsRemaining )
						{
						case 0:
							m_pExplodedIcon->DrawSelf( xMid - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							break;
						case 1:
							if ( bBombPlanted )
							{
								// draw the background behind 1
								int alpha = (float)( abs( sin(2*gpGlobals->curtime) ) * 205.0 + 50.0 );
								m_pC4PlantedBG->DrawSelf( xMid - iIconWidth, yIcon - iIconHalfWidth, iIconWidth*2, iIconWidth*2, Color( 255,255,255,alpha) );
							}
							m_pC4Icon->DrawSelf( xMid - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							break;
						}
					}
					break;
				case 2:
					{
						int xMid1 = xpos + ( flIconSize * 0.25f );
						int xMid2 = xpos + ( flIconSize * 0.75f );

						switch( iBombsRemaining )
						{
						case 0:
							m_pExplodedIcon->DrawSelf( xMid1 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							m_pExplodedIcon->DrawSelf( xMid2 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							break;
						case 1:
							if ( bBombPlanted )
							{
								// draw the background behind 1
								int alpha = (float)( abs( sin(2*gpGlobals->curtime) ) * 205.0 + 50.0 );
								m_pC4PlantedBG->DrawSelf( xMid1 - iIconWidth, yIcon - iIconHalfWidth, iIconWidth*2, iIconWidth*2, Color( 255,255,255,alpha) );
							}
							m_pC4Icon->DrawSelf( xMid1 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							m_pExplodedIcon->DrawSelf( xMid2 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							break;
						case 2:
							if ( bBombPlanted )
							{
								// draw the background behind 2
								int alpha = (float)( abs( sin(2*gpGlobals->curtime) ) * 205.0 + 50.0 );
								m_pC4PlantedBG->DrawSelf( xMid2 - iIconWidth, yIcon - iIconHalfWidth, iIconWidth*2, iIconWidth*2, Color( 255,255,255,alpha) );
							}
							m_pC4Icon->DrawSelf( xMid1 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							m_pC4Icon->DrawSelf( xMid2 - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
							break;
						}
					}
					break;
				default:
					{
						// general solution for > 2 bombs

						if ( iBombsRemaining > 0 )
						{
							// draw a bomb icon, then a 'x 3' for how many there are remaining

							if ( bBombPlanted )
							{
								// draw the background behind 2
								int alpha = (float)( abs( sin( 2*gpGlobals->curtime) ) * 205.0 + 50.0 );
								m_pC4PlantedBG->DrawSelf( xpos - iIconHalfWidth, yIcon - iIconHalfWidth, iIconWidth*2, iIconWidth*2, Color( 255,255,255,alpha) );
							}

							m_pC4Icon->DrawSelf( xpos, yIcon, iIconWidth, iIconWidth, c );

							// draw text saying how many bombs there are
							{
								wchar_t wText[6];
								_snwprintf( wText, sizeof(wText)/sizeof(wchar_t), L"x %d", iBombsRemaining );

								vgui::surface()->DrawSetTextColor( g_PR->GetTeamColor( TEAM_SPECTATOR ) );

								// set pos centered under icon
								vgui::surface()->DrawSetTextPos( xpos + ( flIconSize * 0.50f ), yIcon + YRES(2) );

								for ( wchar_t *wch = wText ; *wch != 0 ; wch++ )
								{
									vgui::surface()->DrawUnicodeChar( *wch );
								}
							}

						}
						else
						{
							int xMid = xpos + ( flIconSize * 0.50f );
							m_pExplodedIcon->DrawSelf( xMid - iIconHalfWidth, yIcon, iIconWidth, iIconWidth, c );
						}
					}
					break;
				}
			}

			// see if one team is partially capping,
			// should show a 1/2 under the cap icon
			if ( iCappingTeam == TEAM_UNASSIGNED )
			{
				if ( iNumAllies > 0 && iNumAxis == 0 )
				{
					iCappingTeam = TEAM_ALLIES;
				}
				else if ( iNumAxis > 0 && iNumAllies == 0 )
				{
					iCappingTeam = TEAM_AXIS;
				}

				if ( iCappingTeam == TEAM_UNASSIGNED || iCappingTeam == g_pObjectiveResource->GetOwningTeam( index ) )
				{
					// no team is capping, even partially
					// or the person in the area already owns it
					xpos += ( m_nIconSize + m_nSeparatorWidth + m_nBackgroundOverlap * 2 );
					continue;
				}
			}

			// Draw the number of cappers below the icon
			int numPlayers = g_pObjectiveResource->GetNumPlayersInArea( index, iCappingTeam );
			int requiredPlayers = g_pObjectiveResource->GetRequiredCappers( index, iCappingTeam );

			if ( requiredPlayers > 1 )
			{
				numPlayers = MIN( numPlayers, requiredPlayers );

				wchar_t wText[6];
				_snwprintf( wText, sizeof(wText)/sizeof(wchar_t), L"%d/%d", numPlayers, requiredPlayers );

				vgui::surface()->DrawSetTextColor( g_PR->GetTeamColor( iCappingTeam ) );

				// get string length
				int len = g_pMatSystemSurface->DrawTextLen( m_hTextFont, "2/2" );

				// set pos centered under icon
				vgui::surface()->DrawSetTextPos( xpos + ( m_nIconSize / 2.0f ) - ( len / 2 ), ypos + flIconSize + m_nBackgroundOverlap + YRES( 2 ) ); // + 2 to account for the outlined box

				for ( wchar_t *wch = wText ; *wch != 0 ; wch++ )
				{
					vgui::surface()->DrawUnicodeChar( *wch );
				}
			}

			if ( g_pObjectiveResource->GetCappingTeam( index ) != TEAM_UNASSIGNED )
			{
				int iCapperIcon = g_pObjectiveResource->GetCPCappingIcon( index );

				// Draw the capper's icon
				if( iOwnerIcon != iCapperIcon && iCapperIcon != 0 )
				{
					// axis caps swipe from right to left...allied from left to right
					bool bAxis = ( g_pObjectiveResource->GetCappingTeam(index) == TEAM_AXIS ) ? true : false;

					//swipe!
					float flCapPercentage = g_pObjectiveResource->GetCPCapPercentage(index);
					
					// reversing the direction of the swipe effect
					if ( bAxis )
					{
						flCapPercentage = 1.0f - g_pObjectiveResource->GetCPCapPercentage(index);
					}

					float width = ( flIconSize * flCapPercentage );
					const char *szCappingMatName = GetMaterialNameFromIndex( iCapperIcon );
					
					vgui::surface()->DrawSetTextureFile( m_iCPCappingTextures[index], szCappingMatName, true, false );

					vgui::Vertex_t vert[4];	

					Vector2D uv11( uv1, uv1 );
					Vector2D uv21( flCapPercentage, uv1 );
					Vector2D uv22( flCapPercentage, uv2 );
					Vector2D uv12( uv1, uv2 );

					// reversing the direction of the swipe effect
					if ( bAxis )
					{
						uv11.x = flCapPercentage;
						uv21.x = uv2;
						uv22.x = uv2;
						uv12.x = flCapPercentage;
					}

					Vector2D upperLeft ( flXPos,         flYPos );
					Vector2D upperRight( flXPos + width, flYPos );
					Vector2D lowerRight( flXPos + width, flYPos + flIconSize );
					Vector2D lowerLeft ( flXPos,		 flYPos + flIconSize );

					/// reversing the direction of the swipe effect
					if ( bAxis )
					{
						upperLeft.x  = flXPos + width;
						upperRight.x = flXPos + flIconSize;
						lowerRight.x = flXPos + flIconSize;
						lowerLeft.x  = flXPos + width;
					}
					
					vert[0].Init( upperLeft, uv11 );
					vert[1].Init( upperRight, uv21 );
					vert[2].Init( lowerRight, uv22 );				
					vert[3].Init( lowerLeft, uv12 );
							
					vgui::surface()->DrawSetColor( Color(255,255,255,255) );
					vgui::surface()->DrawTexturedPolygon( 4, vert );
				}
			}
			
			xpos += ( m_nIconSize + m_nSeparatorWidth + m_nBackgroundOverlap * 2 );
		}
	}
}