//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"
#include "hud.h"
#include "hudelement.h"
#include "iclientmode.h"
#include "c_basehlplayer.h"
#include "view_scene.h"
#include "engine/IEngineSound.h"
#include "vgui_controls/AnimationController.h"
#include "vgui_controls/Controls.h"
#include "vgui_controls/Panel.h"
#include "vgui/ISurface.h"
#include "iviewrender.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

ConVar hud_draw_active_reticle("hud_draw_active_reticle", "0" );
ConVar hud_draw_fixed_reticle("hud_draw_fixed_reticle", "0", FCVAR_ARCHIVE );
ConVar hud_autoaim_scale_icon( "hud_autoaim_scale_icon", "0" );
ConVar hud_autoaim_method( "hud_autoaim_method", "1" );

ConVar hud_reticle_scale("hud_reticle_scale", "1.0" );
ConVar hud_reticle_minalpha( "hud_reticle_minalpha", "125" );
ConVar hud_reticle_maxalpha( "hud_reticle_maxalpha", "255" );
ConVar hud_alpha_speed("hud_reticle_alpha_speed", "700" );
ConVar hud_magnetism("hud_magnetism", "0.3" );

enum 
{
	AUTOAIM_METHOD_RETICLE = 1,
	AUTOAIM_METHOD_DRIFT,
};

using namespace vgui;

class CHUDAutoAim : public CHudElement, public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CHUDAutoAim, vgui::Panel );
public:
	CHUDAutoAim( const char *pElementName );
	void ApplySchemeSettings( IScheme *scheme );
	void Init( void );
	void VidInit( void );
	bool ShouldDraw( void );
	virtual void OnThink();
	virtual void Paint();

private:
	void ResetAlpha() { m_alpha = 0; }
	void ResetScale() { m_scale = 1.0f; }
	
	void ResetPosition()
	{
		m_vecPos.x = ScreenWidth() / 2;
		m_vecPos.y = ScreenHeight() / 2;
		m_vecPos.z = 0;
	}

	Vector	m_vecPos;
	float	m_alpha;
	float	m_scale;

	float	m_alphaFixed; // alpha value for the fixed element.

	int		m_textureID_ActiveReticle;
	int		m_textureID_FixedReticle;
};

DECLARE_HUDELEMENT( CHUDAutoAim );

CHUDAutoAim::CHUDAutoAim( const char *pElementName ) :
	CHudElement( pElementName ), BaseClass( NULL, "HUDAutoAim" )
{
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );
	SetHiddenBits( HIDEHUD_CROSSHAIR );
}

void CHUDAutoAim::ApplySchemeSettings( IScheme *scheme )
{
	BaseClass::ApplySchemeSettings( scheme );

	SetPaintBackgroundEnabled( false );
}

void CHUDAutoAim::Init( void )
{
	ResetPosition();
	ResetAlpha();
	ResetScale();
}

void CHUDAutoAim::VidInit( void )
{
	SetAlpha( 255 );
	Init();

	m_textureID_ActiveReticle = vgui::surface()->CreateNewTextureID();
	vgui::surface()->DrawSetTextureFile( m_textureID_ActiveReticle, "vgui/hud/autoaim", true, false );

	m_textureID_FixedReticle = vgui::surface()->CreateNewTextureID();
	vgui::surface()->DrawSetTextureFile( m_textureID_FixedReticle, "vgui/hud/xbox_reticle", true, false );
}

//-----------------------------------------------------------------------------
// Purpose: Save CPU cycles by letting the HUD system early cull
// costly traversal.  Called per frame, return true if thinking and 
// painting need to occur.
//-----------------------------------------------------------------------------
bool CHUDAutoAim::ShouldDraw( void )
{	
	C_BaseHLPlayer *pLocalPlayer = (C_BaseHLPlayer *)C_BasePlayer::GetLocalPlayer();
	if ( pLocalPlayer )
	{
		if( !pLocalPlayer->m_HL2Local.m_bDisplayReticle )
		{
			return false;
		}
	}

	return ( (hud_draw_fixed_reticle.GetBool() || hud_draw_active_reticle.GetBool()) && CHudElement::ShouldDraw() && !engine->IsDrawingLoadingImage() );
}

#define AUTOAIM_ALPHA_UP_SPEED		1000
#define AUTOAIM_ALPHA_DOWN_SPEED	300
#define AUTOAIM_MAX_ALPHA			120
#define AUTOAIM_MAX_SCALE			1.0f
#define AUTOAIM_MIN_SCALE			0.5f
#define AUTOAIM_SCALE_SPEED			10.0f		
#define AUTOAIM_ONTARGET_CROSSHAIR_SPEED		(ScreenWidth() / 3) // Can cross the whole screen in 3 seconds.
#define AUTOAIM_OFFTARGET_CROSSHAIR_SPEED		(ScreenWidth() / 4)

void CHUDAutoAim::OnThink()
{
	int wide, tall;
	GetSize( wide, tall );

	BaseClass::OnThink();

	// Get the HL2 player
	C_BaseHLPlayer *pLocalPlayer = (C_BaseHLPlayer *)C_BasePlayer::GetLocalPlayer();
	if ( pLocalPlayer == NULL )
	{
		// Just turn the autoaim crosshair off.
		ResetPosition();
		ResetAlpha();
		ResetScale();

		m_alphaFixed = 0.0f;
		return;
	}

	// Get the autoaim target.
	CBaseEntity *pTarget = pLocalPlayer->m_HL2Local.m_hAutoAimTarget.Get();

	// Fixed element stuff
	float flFixedAlphaGoal;

	if( pTarget )
	{
		flFixedAlphaGoal = hud_reticle_maxalpha.GetFloat();
	}
	else
	{
		flFixedAlphaGoal = hud_reticle_minalpha.GetFloat();
	}

	if( pLocalPlayer->m_HL2Local.m_bZooming || pLocalPlayer->m_HL2Local.m_bWeaponLowered )
	{
		flFixedAlphaGoal = 0.0f;
	}

	m_alphaFixed = Approach( flFixedAlphaGoal, m_alphaFixed, (hud_alpha_speed.GetFloat() * gpGlobals->frametime) );
	

	switch( hud_autoaim_method.GetInt() )
	{
	case AUTOAIM_METHOD_RETICLE:
		{
			if( pLocalPlayer->m_HL2Local.m_hAutoAimTarget.Get() && pLocalPlayer->m_HL2Local.m_bStickyAutoAim )
			{
				if( !pLocalPlayer->IsInAVehicle() )
				{
					Vector vecLook;
					pLocalPlayer->EyeVectors( &vecLook, NULL, NULL );

					Vector vecMove = pLocalPlayer->GetAbsVelocity();
					float flSpeed = VectorNormalize( vecMove );
					float flDot = DotProduct( vecLook, vecMove );

					if( flSpeed >= 100 && fabs(flDot) <= 0.707f )
					{
						QAngle viewangles;
						QAngle targetangles;
						QAngle delta;

						engine->GetViewAngles( viewangles );

						Vector vecDir = pLocalPlayer->m_HL2Local.m_vecAutoAimPoint - pLocalPlayer->EyePosition();
						VectorNormalize(vecDir);
						VectorAngles( vecDir, targetangles );

						float magnetism = hud_magnetism.GetFloat();

						delta[0] = ApproachAngle( targetangles[0], viewangles[0], magnetism );
						delta[1] = ApproachAngle( targetangles[1], viewangles[1], magnetism );
						delta[2] = targetangles[2];

						//viewangles[PITCH] = clamp( viewangles[ PITCH ], -cl_pitchup.GetFloat(), cl_pitchdown.GetFloat() );
						engine->SetViewAngles( delta );
					}
				}
			}

#if 0
			bool doScaling = hud_autoaim_scale_icon.GetBool();

			// These are the X & Y coords of where the crosshair should be. Default to 
			// returning to the center of the screen if there is no target.
			int goalx = ScreenWidth() / 2;
			int goaly = ScreenHeight() / 2;
			int goalalpha = 0;
			float goalscale = AUTOAIM_MIN_SCALE;
			float speed = AUTOAIM_OFFTARGET_CROSSHAIR_SPEED;

			if( pTarget )
			{
				// Get the autoaim crosshair onto the target.
				Vector screen;

				// Center the crosshair on the entity.
				if( doScaling )
				{
					// Put the crosshair over the center of the target.
					ScreenTransform( pTarget->WorldSpaceCenter(), screen );
				}
				else
				{
					// Put the crosshair exactly where the player is aiming.
					ScreenTransform( pLocalPlayer->m_HL2Local.m_vecAutoAimPoint, screen );
				}

				// Set Goal Position and speed.
				goalx += 0.5f * screen[0] * ScreenWidth() + 0.5f;
				goaly -= 0.5f * screen[1] * ScreenHeight() + 0.5f;
				speed = AUTOAIM_ONTARGET_CROSSHAIR_SPEED;

				goalalpha = AUTOAIM_MAX_ALPHA;

				if( doScaling )
				{
					// Scale the crosshair to envelope the entity's bounds on screen.
					Vector vecMins, vecMaxs;
					Vector vecScreenMins, vecScreenMaxs;

					// Get mins and maxs in world space
					vecMins = pTarget->GetAbsOrigin() + pTarget->WorldAlignMins();
					vecMaxs = pTarget->GetAbsOrigin() + pTarget->WorldAlignMaxs();

					// Project them to screen
					ScreenTransform( vecMins, vecScreenMins );
					ScreenTransform( vecMaxs, vecScreenMaxs );

					vecScreenMins.y = (ScreenWidth()/2) - 0.5f * vecScreenMins.y * ScreenWidth() + 0.5f;
					vecScreenMaxs.y = (ScreenWidth()/2) - 0.5f * vecScreenMaxs.y * ScreenWidth() + 0.5f;

					float screenSize = vecScreenMins.y - vecScreenMaxs.y;

					// Set goal scale
					goalscale = screenSize / 64.0f; // 64 is the width of the crosshair art.
				}
				else
				{
					goalscale = 1.0f;
				}
			}

			// Now approach the goal, alpha, and scale
			Vector vecGoal( goalx, goaly, 0 );
			Vector vecDir = vecGoal - m_vecPos;
			float flDistRemaining = VectorNormalize( vecDir );
			m_vecPos += vecDir * min(flDistRemaining, (speed * gpGlobals->frametime) );

			// Lerp and Clamp scale
			float scaleDelta = fabs( goalscale - m_scale );
			float scaleMove = min( AUTOAIM_SCALE_SPEED * gpGlobals->frametime, scaleDelta );
			if( m_scale < goalscale )
			{
				m_scale += scaleMove;
			}
			else if( m_scale > goalscale )
			{
				m_scale -= scaleMove;
			}
			if( m_scale > AUTOAIM_MAX_SCALE )
			{
				m_scale = AUTOAIM_MAX_SCALE;
			}
			else if( m_scale < AUTOAIM_MIN_SCALE )
			{
				m_scale = AUTOAIM_MIN_SCALE;
			}

			if( goalalpha > m_alpha )
			{
				m_alpha += AUTOAIM_ALPHA_UP_SPEED * gpGlobals->frametime;
			}
			else if( goalalpha < m_alpha )
			{
				m_alpha -= AUTOAIM_ALPHA_DOWN_SPEED * gpGlobals->frametime;
			}

			// Clamp alpha
			if( m_alpha < 0 )
			{
				m_alpha = 0;
			}
			else if( m_alpha > AUTOAIM_MAX_ALPHA )
			{
				m_alpha = AUTOAIM_MAX_ALPHA;
			}
#endif
		}
		break;

	case AUTOAIM_METHOD_DRIFT:
		{
			if( pLocalPlayer->m_HL2Local.m_hAutoAimTarget.Get() )
			{
				QAngle viewangles;

				engine->GetViewAngles( viewangles );
				
				Vector vecDir = pLocalPlayer->m_HL2Local.m_vecAutoAimPoint - pLocalPlayer->EyePosition();
				VectorNormalize(vecDir);

				VectorAngles( vecDir, viewangles );

				//viewangles[PITCH] = clamp( viewangles[ PITCH ], -cl_pitchup.GetFloat(), cl_pitchdown.GetFloat() );
				engine->SetViewAngles( viewangles );
			}
		}
		break;
	}
}

void CHUDAutoAim::Paint()
{
	if( hud_draw_active_reticle.GetBool() )
	{
		int xCenter = m_vecPos.x;
		int yCenter = m_vecPos.y;

		int width, height;
		float xMod, yMod;

		vgui::surface()->DrawSetTexture( m_textureID_ActiveReticle );
		vgui::surface()->DrawSetColor( 255, 255, 255, m_alpha );
		vgui::surface()->DrawGetTextureSize( m_textureID_ActiveReticle, width, height );

		float uv1 = 0.5f / width, uv2 = 1.0f - uv1;

		vgui::Vertex_t vert[4];	

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

		xMod = width;
		yMod = height;

		xMod *= m_scale;
		yMod *= m_scale;

		xMod /= 2;
		yMod /= 2;

		vert[0].Init( Vector2D( xCenter + xMod, yCenter + yMod ), uv21 );
		vert[1].Init( Vector2D( xCenter - xMod, yCenter + yMod ), uv11 );
		vert[2].Init( Vector2D( xCenter - xMod, yCenter - yMod ), uv12 );
		vert[3].Init( Vector2D( xCenter + xMod, yCenter - yMod ), uv22 );
		vgui::surface()->DrawTexturedPolygon( 4, vert );
	}

	if( hud_draw_fixed_reticle.GetBool() )
	{
		int width, height;
		float xMod, yMod;

		vgui::surface()->DrawSetTexture( m_textureID_FixedReticle );
		vgui::surface()->DrawGetTextureSize( m_textureID_FixedReticle, width, height );

		int xCenter = ScreenWidth() / 2;
		int yCenter = ScreenHeight() / 2;

		vgui::Vertex_t vert[4];	

		Vector2D uv11( 0, 0 );
		Vector2D uv12( 0, 1 );
		Vector2D uv21( 1, 0 );
		Vector2D uv22( 1, 1 );

		xMod = width;
		yMod = height;

		xMod /= 2;
		yMod /= 2;

		vert[0].Init( Vector2D( xCenter + xMod, yCenter + yMod ), uv21 );
		vert[1].Init( Vector2D( xCenter - xMod, yCenter + yMod ), uv11 );
		vert[2].Init( Vector2D( xCenter - xMod, yCenter - yMod ), uv12 );
		vert[3].Init( Vector2D( xCenter + xMod, yCenter - yMod ), uv22 );

		Color	clr;
		clr = gHUD.m_clrNormal;
		int r,g,b,a;
		clr.GetColor( r,g,b,a );

		C_BaseHLPlayer *pLocalPlayer = (C_BaseHLPlayer *)C_BasePlayer::GetLocalPlayer();
		if( pLocalPlayer && pLocalPlayer->m_HL2Local.m_hAutoAimTarget.Get() )
		{
			r = 250; 
			g = 138;
			b = 4;
		}

		clr.SetColor( r,g,b,m_alphaFixed);

		vgui::surface()->DrawSetColor( clr );
		vgui::surface()->DrawTexturedPolygon( 4, vert );
	}
}