FF Diff Viewer

cl_dll/hl2_hud/hud_damageindicator.cpp

456789
//
//=============================================================================//

#include "cbase.h"
#include "hud.h"
#include "text_message.h"
4567891011
//
//=============================================================================//

// Mirv (2006/03/11) A lot of this has been rewritten for support of 4 prongs

#include "cbase.h"
#include "hud.h"
#include "text_message.h"

32333435363738394041424344454647
//-----------------------------------------------------------------------------
class CHudDamageIndicator : public CHudElement, public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CHudDamageIndicator, vgui::Panel );

public:
	CHudDamageIndicator( const char *pElementName );
	void Init( void );
	void Reset( void );
	virtual bool ShouldDraw( void );

	// Handler for our message
	void MsgFunc_Damage( bf_read &msg );

private:
	virtual void Paint();
34353637383940414243444546474849
//-----------------------------------------------------------------------------
class CHudDamageIndicator : public CHudElement, public vgui::Panel
{
	DECLARE_CLASS_SIMPLE(CHudDamageIndicator, vgui::Panel);

public:
	CHudDamageIndicator(const char *pElementName);
	void Init();
	void Reset();
	virtual bool ShouldDraw();

	// Handler for our message
	void MsgFunc_Damage(bf_read &msg);

private:
	virtual void Paint();

4849505152535455565758596061626364656667686970717273747576777879808182
	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);

private:
	CPanelAnimationVarAliasType( float, m_flDmgX, "dmg_xpos", "10", "proportional_float" );
	CPanelAnimationVarAliasType( float, m_flDmgY, "dmg_ypos", "80", "proportional_float" );
	CPanelAnimationVarAliasType( float, m_flDmgWide, "dmg_wide", "30", "proportional_float" );
	CPanelAnimationVarAliasType( float, m_flDmgTall1, "dmg_tall1", "300", "proportional_float" );
	CPanelAnimationVarAliasType( float, m_flDmgTall2, "dmg_tall2", "240", "proportional_float" );

	CPanelAnimationVar( Color, m_DmgColorLeft, "DmgColorLeft", "255 0 0 0" );
	CPanelAnimationVar( Color, m_DmgColorRight, "DmgColorRight", "255 0 0 0" );

	CPanelAnimationVar( Color, m_DmgHighColorLeft, "DmgHighColorLeft", "255 0 0 0" );
	CPanelAnimationVar( Color, m_DmgHighColorRight, "DmgHighColorRight", "255 0 0 0" );

	CPanelAnimationVar( Color, m_DmgFullscreenColor, "DmgFullscreenColor", "255 0 0 0" );

	void DrawDamageIndicator(int side);
	void DrawFullscreenDamageIndicator();
	void GetDamagePosition( const Vector &vecDelta, float *flRotation );

	CMaterialReference m_WhiteAdditiveMaterial;
};

DECLARE_HUDELEMENT( CHudDamageIndicator );
DECLARE_HUD_MESSAGE( CHudDamageIndicator, Damage );

enum
{
	DAMAGE_ANY,
	DAMAGE_LOW,
	DAMAGE_HIGH,
};

#define ANGLE_ANY	0.0f
505152535455565758596061626364656667686970717273747576777879808182838485
	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);

private:
	CPanelAnimationVarAliasType(float, m_flDmgX, "dmg_xpos", "30", "proportional_float");
	CPanelAnimationVarAliasType(float, m_flDmgY, "dmg_ypos", "100", "proportional_float");

	CPanelAnimationVarAliasType(float, m_flDmgX2, "dmg_xpos2", "30", "proportional_float");
	CPanelAnimationVarAliasType(float, m_flDmgY2, "dmg_ypos2", "220", "proportional_float");

	CPanelAnimationVarAliasType(float, m_flDmgWide, "dmg_wide", "30", "proportional_float");
	CPanelAnimationVarAliasType(float, m_flDmgTall1, "dmg_tall1", "300", "proportional_float");
	CPanelAnimationVarAliasType(float, m_flDmgTall2, "dmg_tall2", "240", "proportional_float");

	CPanelAnimationVar(Color, m_DmgColorLeft, "DmgColorLeft", "255 0 0 0");
	CPanelAnimationVar(Color, m_DmgColorRight, "DmgColorRight", "255 0 0 0");
	CPanelAnimationVar(Color, m_DmgColorFront, "DmgColorFront", "255 0 0 0");
	CPanelAnimationVar(Color, m_DmgColorBehind, "DmgColorBehind", "255 0 0 0");

	void DrawDamageIndicator(int side);
	void DrawFullscreenDamageIndicator();
	void GetDamagePosition(const Vector &vecDelta, float *flRotation);

	CMaterialReference m_WhiteAdditiveMaterial;
};

DECLARE_HUDELEMENT(CHudDamageIndicator);
DECLARE_HUD_MESSAGE(CHudDamageIndicator, Damage);

enum
{
	DAMAGE_ANY, 
	DAMAGE_LOW, 
	DAMAGE_HIGH, 
};

#define ANGLE_ANY	0.0f

96979899100101102103104105106107108109110111112113114115116117118
//-----------------------------------------------------------------------------
static DamageAnimation_t g_DamageAnimations[] =
{
	{ "HudTakeDamageDrown",		DMG_DROWN,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },
	{ "HudTakeDamagePoison",	DMG_POISON,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },
	{ "HudTakeDamageBurn",		DMG_BURN,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },
	{ "HudTakeDamageRadiation",	DMG_RADIATION,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },
	{ "HudTakeDamageRadiation",	DMG_ACID,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },

	{ "HudTakeDamageHighLeft",	DMG_ANY,	45.0f,		135.0f,		DAMAGE_HIGH },
	{ "HudTakeDamageHighRight",	DMG_ANY,	225.0f,		315.0f,		DAMAGE_HIGH },
	{ "HudTakeDamageHigh",		DMG_ANY,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_HIGH },
	
	{ "HudTakeDamageLeft",		DMG_ANY,	45.0f,		135.0f,		DAMAGE_ANY },
	{ "HudTakeDamageRight",		DMG_ANY,	225.0f,		315.0f,		DAMAGE_ANY },
	{ "HudTakeDamageBehind",	DMG_ANY,	135.0f,		225.0f,		DAMAGE_ANY },

	// fall through to front damage
	{ "HudTakeDamageFront",		DMG_ANY,	ANGLE_ANY,	ANGLE_ANY,	DAMAGE_ANY },
	{ NULL },
};


99100101102103104105106107108109110111112113114115116117118119120121
//-----------------------------------------------------------------------------
static DamageAnimation_t g_DamageAnimations[] =
{
	{ "HudTakeDamageDrown", 		DMG_DROWN, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 
	{ "HudTakeDamagePoison", 		DMG_POISON, ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 
//	{ "HudTakeDamageBurn", 			DMG_BURN, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 
	{ "HudTakeDamageRadiation", 	DMG_RADIATION, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 
	{ "HudTakeDamageRadiation", 	DMG_ACID, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 

	{ "HudTakeDamageHighLeft", 		DMG_ANY, 	45.0f, 		135.0f, 		DAMAGE_HIGH }, 
	{ "HudTakeDamageHighRight", 	DMG_ANY, 	225.0f, 		315.0f, 		DAMAGE_HIGH }, 
	{ "HudTakeDamageHigh", 			DMG_ANY, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_HIGH }, 
	
	{ "HudTakeDamageLeft", 			DMG_ANY, 	45.0f, 		135.0f, 		DAMAGE_ANY }, 
	{ "HudTakeDamageRight", 		DMG_ANY, 	225.0f, 		315.0f, 		DAMAGE_ANY }, 
	{ "HudTakeDamageBehind", 		DMG_ANY, 	135.0f, 		225.0f, 		DAMAGE_ANY }, 

	// fall through to front damage
	{ "HudTakeDamageFront", 		DMG_ANY, 	ANGLE_ANY, 	ANGLE_ANY, 	DAMAGE_ANY }, 
	{ NULL }, 
};

119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CHudDamageIndicator::CHudDamageIndicator( const char *pElementName ) : CHudElement( pElementName ), BaseClass(NULL, "HudDamageIndicator")
{
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );

	m_WhiteAdditiveMaterial.Init( "vgui/white_additive", TEXTURE_GROUP_VGUI ); 
	
	SetHiddenBits( HIDEHUD_HEALTH );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudDamageIndicator::Reset( void )
{
	m_DmgColorLeft[3] = 0;
	m_DmgColorRight[3] = 0;
	m_DmgHighColorLeft[3] = 0;
	m_DmgHighColorRight[3] = 0;
	m_DmgFullscreenColor[3] = 0;
}

void CHudDamageIndicator::Init( void )
{
	HOOK_HUD_MESSAGE( CHudDamageIndicator, Damage );
}

//-----------------------------------------------------------------------------
122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CHudDamageIndicator::CHudDamageIndicator(const char *pElementName) : CHudElement(pElementName), BaseClass(NULL, "HudDamageIndicator")
{
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent(pParent);

	m_WhiteAdditiveMaterial.Init("vgui/white_additive", TEXTURE_GROUP_VGUI); 
	
	SetHiddenBits(HIDEHUD_HEALTH);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudDamageIndicator::Reset()
{
	m_DmgColorLeft[3] = 0;
	m_DmgColorRight[3] = 0;
	m_DmgColorFront[3] = 0;
	m_DmgColorBehind[3] = 0;
}

void CHudDamageIndicator::Init()
{
	HOOK_HUD_MESSAGE(CHudDamageIndicator, Damage);
}

//-----------------------------------------------------------------------------

151152153154155156157158159160161162163164165
// costly traversal.  Called per frame, return true if thinking and 
// painting need to occur.
//-----------------------------------------------------------------------------
bool CHudDamageIndicator::ShouldDraw( void )
{
	bool bNeedsDraw = m_DmgColorLeft[3] || 
						m_DmgColorRight[3] || 
						m_DmgHighColorLeft[3] || 
						m_DmgHighColorRight[3] ||
						m_DmgFullscreenColor[3];

	return ( bNeedsDraw && CHudElement::ShouldDraw() );
}

//-----------------------------------------------------------------------------
153154155156157158159160161162163164165166167
// costly traversal.  Called per frame, return true if thinking and 
// painting need to occur.
//-----------------------------------------------------------------------------
bool CHudDamageIndicator::ShouldDraw()
{
	if (!CHudElement::ShouldDraw())
		return false;

	if (!m_DmgColorLeft[3] && !m_DmgColorRight[3] && !m_DmgColorFront[3] && !m_DmgColorBehind[3])
		return false;

	return true;
}

//-----------------------------------------------------------------------------

167168169170171172173174175176
//-----------------------------------------------------------------------------
void CHudDamageIndicator::DrawDamageIndicator(int side)
{
	IMesh *pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_WhiteAdditiveMaterial );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

	int insetY = (m_flDmgTall1 - m_flDmgTall2) / 2;

169170171172173174175176177178
//-----------------------------------------------------------------------------
void CHudDamageIndicator::DrawDamageIndicator(int side)
{
	IMesh *pMesh = materials->GetDynamicMesh(true, NULL, NULL, m_WhiteAdditiveMaterial);

	CMeshBuilder meshBuilder;
	meshBuilder.Begin(pMesh, MATERIAL_QUADS, 1);

	int insetY = (m_flDmgTall1 - m_flDmgTall2) / 2;

179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307
	int y[4] = { m_flDmgY, m_flDmgY + insetY, m_flDmgY + m_flDmgTall1 - insetY, m_flDmgY + m_flDmgTall1 };
	int alpha[4] = { 0.0f, 1.0f, 1.0f, 0.0f };

	// see if we're high damage
	bool bHighDamage = false;
	if ( m_DmgHighColorRight[3] > m_DmgColorRight[3] || m_DmgHighColorLeft[3] > m_DmgColorLeft[3] )
	{
		// make more of the screen be covered by damage
		x1 = GetWide() * 0.0f;
		x2 = GetWide() * 0.5f;
		y[0] = 0.0f;
		y[1] = 0.0f;
		y[2] = GetTall();
		y[3] = GetTall();
		alpha[0] = 1.0f;
		alpha[1] = 0.0f;
		alpha[2] = 0.0f;
		alpha[3] = 1.0f;
		bHighDamage = true;
	}

	int r, g, b, a;
	if (side == 1)
	{
		if ( bHighDamage )
		{
			r = m_DmgHighColorRight[0], g = m_DmgHighColorRight[1], b = m_DmgHighColorRight[2], a = m_DmgHighColorRight[3];
		}
		else
		{
			r = m_DmgColorRight[0], g = m_DmgColorRight[1], b = m_DmgColorRight[2], a = m_DmgColorRight[3];
		}

		// realign x coords
		x1 = GetWide() - x1;
		x2 = GetWide() - x2;

		meshBuilder.Color4ub( r, g, b, a * alpha[0]);
		meshBuilder.TexCoord2f( 0,0,0 );
		meshBuilder.Position3f( x1, y[0], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[3] );
		meshBuilder.TexCoord2f( 0,0,1 );
		meshBuilder.Position3f( x1, y[3], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[2] );
		meshBuilder.TexCoord2f( 0,1,1 );
		meshBuilder.Position3f( x2, y[2], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[1] );
		meshBuilder.TexCoord2f( 0,1,0 );
		meshBuilder.Position3f( x2, y[1], 0 );
		meshBuilder.AdvanceVertex();
	}
	else
	{
		if ( bHighDamage )
		{
			r = m_DmgHighColorLeft[0], g = m_DmgHighColorLeft[1], b = m_DmgHighColorLeft[2], a = m_DmgHighColorLeft[3];
		}
		else
		{
			r = m_DmgColorLeft[0], g = m_DmgColorLeft[1], b = m_DmgColorLeft[2], a = m_DmgColorLeft[3];
		}

		meshBuilder.Color4ub( r, g, b, a * alpha[0] );
		meshBuilder.TexCoord2f( 0,0,0 );
		meshBuilder.Position3f( x1, y[0], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[1] );
		meshBuilder.TexCoord2f( 0,1,0 );
		meshBuilder.Position3f( x2, y[1], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[2] );
		meshBuilder.TexCoord2f( 0,1,1 );
		meshBuilder.Position3f( x2, y[2], 0 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub( r, g, b, a * alpha[3] );
		meshBuilder.TexCoord2f( 0,0,1 );
		meshBuilder.Position3f( x1, y[3], 0 );
		meshBuilder.AdvanceVertex();
	}

	meshBuilder.End();
	pMesh->Draw();
}

//-----------------------------------------------------------------------------
// Purpose: Draws full screen damage fade
//-----------------------------------------------------------------------------
void CHudDamageIndicator::DrawFullscreenDamageIndicator()
{
	IMesh *pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_WhiteAdditiveMaterial );

	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
	int r = m_DmgFullscreenColor[0], g = m_DmgFullscreenColor[1], b = m_DmgFullscreenColor[2], a = m_DmgFullscreenColor[3];

	float wide = GetWide(), tall = GetTall();

	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.TexCoord2f( 0,0,0 );
	meshBuilder.Position3f( 0.0f, 0.0f, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.TexCoord2f( 0,1,0 );
	meshBuilder.Position3f( wide, 0.0f, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.TexCoord2f( 0,1,1 );
	meshBuilder.Position3f( wide, tall, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.Color4ub( r, g, b, a );
	meshBuilder.TexCoord2f( 0,0,1 );
	meshBuilder.Position3f( 0.0f, tall, 0 );
	meshBuilder.AdvanceVertex();

	meshBuilder.End();
	pMesh->Draw();
}
181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
	int y[4] = { m_flDmgY, m_flDmgY + insetY, m_flDmgY + m_flDmgTall1 - insetY, m_flDmgY + m_flDmgTall1 };
	int alpha[4] = { 0.0f, 1.0f, 1.0f, 0.0f };

	int r, g, b, a;

	if (side == 0)
	{
		r = m_DmgColorLeft[0], g = m_DmgColorLeft[1], b = m_DmgColorLeft[2], a = m_DmgColorLeft[3];

		meshBuilder.Color4ub(r, g, b, a * alpha[0]);
		meshBuilder.TexCoord2f(0, 0, 0);
		meshBuilder.Position3f(x1, y[0], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[1]);
		meshBuilder.TexCoord2f(0, 1, 0);
		meshBuilder.Position3f(x2, y[1], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[2]);
		meshBuilder.TexCoord2f(0, 1, 1);
		meshBuilder.Position3f(x2, y[2], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[3]);
		meshBuilder.TexCoord2f(0, 0, 1);
		meshBuilder.Position3f(x1, y[3], 0);
		meshBuilder.AdvanceVertex();
	}
	else if (side == 1)
	{
		r = m_DmgColorRight[0], g = m_DmgColorRight[1], b = m_DmgColorRight[2], a = m_DmgColorRight[3];

		// realign x coords
		x1 = GetWide() - x1;
		x2 = GetWide() - x2;

		meshBuilder.Color4ub(r, g, b, a * alpha[0]);
		meshBuilder.TexCoord2f(0, 0, 0);
		meshBuilder.Position3f(x1, y[0], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[3]);
		meshBuilder.TexCoord2f(0, 0, 1);
		meshBuilder.Position3f(x1, y[3], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[2]);
		meshBuilder.TexCoord2f(0, 1, 1);
		meshBuilder.Position3f(x2, y[2], 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[1]);
		meshBuilder.TexCoord2f(0, 1, 0);
		meshBuilder.Position3f(x2, y[1], 0);
		meshBuilder.AdvanceVertex();

	}
	else if (side == 2)
	{
		r = m_DmgColorFront[0], g = m_DmgColorFront[1], b = m_DmgColorFront[2], a = m_DmgColorFront[3];

		int insetY = (m_flDmgTall1 - m_flDmgTall2) / 2;

		int y1 = m_flDmgX2;
		int y2 = m_flDmgX2 + m_flDmgWide;
		int x[4] = { m_flDmgY2, m_flDmgY2 + insetY, m_flDmgY2 + m_flDmgTall1 - insetY, m_flDmgY2 + m_flDmgTall1 };
		int alpha[4] = { 0.0f, 1.0f, 1.0f, 0.0f };

		meshBuilder.Color4ub(r, g, b, a * alpha[0]);
		meshBuilder.TexCoord2f(0, 0, 0);
		meshBuilder.Position3f(x[0], y1, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[3]);
		meshBuilder.TexCoord2f(0, 1, 0);
		meshBuilder.Position3f(x[3], y1, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[2]);
		meshBuilder.TexCoord2f(0, 1, 1);
		meshBuilder.Position3f(x[2], y2, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[1]);
		meshBuilder.TexCoord2f(0, 0, 1);
		meshBuilder.Position3f(x[1], y2, 0);
		meshBuilder.AdvanceVertex();
	}
	else if (side == 3)
	{
		r = m_DmgColorBehind[0], g = m_DmgColorBehind[1], b = m_DmgColorBehind[2], a = m_DmgColorBehind[3];

		int insetY = (m_flDmgTall1 - m_flDmgTall2) / 2;

		int y1 = m_flDmgX2;
		int y2 = m_flDmgX2 + m_flDmgWide;
		int x[4] = { m_flDmgY2, m_flDmgY2 + insetY, m_flDmgY2 + m_flDmgTall1 - insetY, m_flDmgY2 + m_flDmgTall1 };
		int alpha[4] = { 0.0f, 1.0f, 1.0f, 0.0f };

		// realign x coords
		y1 = GetTall() - y1;
		y2 = GetTall() - y2;

		meshBuilder.Color4ub(r, g, b, a * alpha[0]);
		meshBuilder.TexCoord2f(0, 0, 0);
		meshBuilder.Position3f(x[0], y1, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[1]);
		meshBuilder.TexCoord2f(0, 1, 0);
		meshBuilder.Position3f(x[1], y2, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[2]);
		meshBuilder.TexCoord2f(0, 1, 1);
		meshBuilder.Position3f(x[2], y2, 0);
		meshBuilder.AdvanceVertex();

		meshBuilder.Color4ub(r, g, b, a * alpha[3]);
		meshBuilder.TexCoord2f(0, 0, 1);
		meshBuilder.Position3f(x[3], y1, 0);
		meshBuilder.AdvanceVertex();
	}

	meshBuilder.End();
	pMesh->Draw();
}

311312313314315316317318319320321322323324325326327328
//-----------------------------------------------------------------------------
void CHudDamageIndicator::Paint()
{
	// draw fullscreen damage indicators
	DrawFullscreenDamageIndicator();

	// draw side damage indicators
	DrawDamageIndicator(0);
	DrawDamageIndicator(1);
}

//-----------------------------------------------------------------------------
// Purpose: Message handler for Damage message
//-----------------------------------------------------------------------------
void CHudDamageIndicator::MsgFunc_Damage( bf_read &msg )
{
	int armor = msg.ReadByte();	// armor
	int damageTaken = msg.ReadByte();	// health
312313314315316317318319320321322323324325326327328
//-----------------------------------------------------------------------------
void CHudDamageIndicator::Paint()
{
	// draw side damage indicators
	DrawDamageIndicator(0);
	DrawDamageIndicator(1);
	DrawDamageIndicator(2);
	DrawDamageIndicator(3);
}

//-----------------------------------------------------------------------------
// Purpose: Message handler for Damage message
//-----------------------------------------------------------------------------
void CHudDamageIndicator::MsgFunc_Damage(bf_read &msg)
{
	int armor = msg.ReadByte();	// armor
	int damageTaken = msg.ReadByte();	// health

335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391
	vecFrom.z = msg.ReadFloat();

	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
	if ( !pPlayer )
		return;

	// player has just died, just run the dead damage animation
	if ( pPlayer->GetHealth() <= 0 )
	{
		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HudPlayerDeath" );
		return;
	}

	// ignore damage without direction
	// this should never happen, unless it's drowning damage, 
	// or the player is forcibly killed, handled above
	if ( vecFrom == vec3_origin && !(bitsDamage & DMG_DROWN))
		return;

	Vector vecDelta = (vecFrom - MainViewOrigin());
	VectorNormalize( vecDelta );

	int highDamage = DAMAGE_LOW;
	if ( damageTaken > 25 )
	{
		highDamage = DAMAGE_HIGH;
	}

	// if we have no suit, all damage is high
	if ( !pPlayer->IsSuitEquipped() )
	{
		highDamage = DAMAGE_HIGH;
	}

	if ( damageTaken > 0 || armor > 0 )
	{
		// see which quandrant the effect is in
		float angle;
		GetDamagePosition( vecDelta, &angle );

		// see which effect to play
		DamageAnimation_t *dmgAnim = g_DamageAnimations;
		for ( ; dmgAnim->name != NULL; ++dmgAnim )
		{
			if ( dmgAnim->bitsDamage && !(bitsDamage & dmgAnim->bitsDamage) )
				continue;

			if ( dmgAnim->angleMinimum && angle < dmgAnim->angleMinimum )
				continue;

			if ( dmgAnim->angleMaximum && angle > dmgAnim->angleMaximum )
				continue;

			if ( dmgAnim->damage && dmgAnim->damage != highDamage )
				continue;

			// we have a match, break
335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
	vecFrom.z = msg.ReadFloat();

	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
	if (!pPlayer)
		return;

	// player has just died, just run the dead damage animation
	if (pPlayer->GetHealth() <= 0)
	{
		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HudPlayerDeath");
		return;
	}

	// UNDONE: ignore damage without direction
	// this should never happen, unless it's drowning damage, 
	// or the player is forcibly killed, handled above
	if (vecFrom == vec3_origin && ! (bitsDamage & DMG_DROWN))
	{
		if (damageTaken > 0)
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HudTakeDamageAll");
		}
		
		return;
	}

	Vector vecDelta = (vecFrom - MainViewOrigin());
	VectorNormalize(vecDelta);

	int highDamage = DAMAGE_LOW;
/*	if (damageTaken > 25)
	{
		highDamage = DAMAGE_HIGH;
	}

	// if we have no suit, all damage is high
	if (!pPlayer->IsSuitEquipped())
	{
		highDamage = DAMAGE_HIGH;
	}*/

	if (damageTaken > 0 || armor > 0)
	{
		// see which quandrant the effect is in
		float angle;
		GetDamagePosition(vecDelta, &angle);

		// see which effect to play
		DamageAnimation_t *dmgAnim = g_DamageAnimations;
		for (; dmgAnim->name != NULL; ++dmgAnim)
		{
			if (dmgAnim->bitsDamage && ! (bitsDamage & dmgAnim->bitsDamage))
				continue;

			if (dmgAnim->angleMinimum && angle < dmgAnim->angleMinimum)
				continue;

			if (dmgAnim->angleMaximum && angle > dmgAnim->angleMaximum)
				continue;

			if (dmgAnim->damage && dmgAnim->damage != highDamage)
				continue;

			// we have a match, break

392393394395396397398399400
			break;
		}

		if ( dmgAnim->name )
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( dmgAnim->name );
		}
	}
}
399400401402403404405406407
			break;
		}

		if (dmgAnim->name)
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(dmgAnim->name);
		}
	}
}

402403404405406407408
//-----------------------------------------------------------------------------
// Purpose: Convert a damage position in world units to the screen's units
//-----------------------------------------------------------------------------
void CHudDamageIndicator::GetDamagePosition( const Vector &vecDelta, float *flRotation )
{
	float flRadius = 360.0f;

409410411412413414415
//-----------------------------------------------------------------------------
// Purpose: Convert a damage position in world units to the screen's units
//-----------------------------------------------------------------------------
void CHudDamageIndicator::GetDamagePosition(const Vector &vecDelta, float *flRotation)
{
	float flRadius = 360.0f;

410411412413414415416417418419420421422423424425426427428429430431432433434435436
	Vector playerPosition = MainViewOrigin();
	QAngle playerAngles = MainViewAngles();

	Vector forward, right, up(0,0,1);
	AngleVectors (playerAngles, &forward, NULL, NULL );
	forward.z = 0;
	VectorNormalize(forward);
	CrossProduct( up, forward, right );
	float front = DotProduct(vecDelta, forward);
	float side = DotProduct(vecDelta, right);
	float xpos = flRadius * -side;
	float ypos = flRadius * -front;

	// Get the rotation (yaw)
	*flRotation = atan2(xpos, ypos) + M_PI;
	*flRotation *= 180 / M_PI;

	float yawRadians = -(*flRotation) * M_PI / 180.0f;
	float ca = cos( yawRadians );
	float sa = sin( yawRadians );
				 
	// Rotate it around the circle
	xpos = (int)((ScreenWidth() / 2) + (flRadius * sa));
	ypos = (int)((ScreenHeight() / 2) - (flRadius * ca));
}

//-----------------------------------------------------------------------------
417418419420421422423424425426427428429430431432433434435436437438439440441442443
	Vector playerPosition = MainViewOrigin();
	QAngle playerAngles = MainViewAngles();

	Vector forward, right, up(0, 0, 1);
	AngleVectors(playerAngles, &forward, NULL, NULL);
	forward.z = 0;
	VectorNormalize(forward);
	CrossProduct(up, forward, right);
	float front = DotProduct(vecDelta, forward);
	float side = DotProduct(vecDelta, right);
	float xpos = flRadius * -side;
	float ypos = flRadius * -front;

	// Get the rotation(yaw)
	*flRotation = atan2(xpos, ypos) + M_PI;
	*flRotation *= 180 / M_PI;

	float yawRadians = - (*flRotation) * M_PI / 180.0f;
	float ca = cos(yawRadians);
	float sa = sin(yawRadians);
				 
	// Rotate it around the circle
	xpos = (int) ((ScreenWidth() / 2) + (flRadius * sa));
	ypos = (int) ((ScreenHeight() / 2) - (flRadius * ca));
}

//-----------------------------------------------------------------------------