clientmode_commander.cpp

hl2 source code. Do not use it illegal.

//======== (C) Copyright 1999, 2000 Valve, L.L.C. All rights reserved. ========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose: 
//
// $Workfile:     $
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "hud_chat.h"
#include "clientmode_commander.h"
#include "vgui_int.h"
#include "ivmodemanager.h"
#include "iinput.h"
#include "kbutton.h"
#include "usercmd.h"
#include "c_basetfplayer.h"
#include "view_shared.h"
#include "in_main.h"
#include "commanderoverlaypanel.h"
#include "IViewRender.h"
#include "keydefs.h"
#include <vgui/IInput.h>
#include <vgui/IPanel.h>


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

enum
{
	VISIBLE_STATIC_PROP_HEIGHT = 7500
};

extern Vector g_vecRenderOrigin;
extern QAngle g_vecRenderAngles;

static ConVar Commander_SlueSpeed( "commander_speed", "800.0", 0 );
static ConVar Commander_MouseSpeed( "commander_mousespeed", "200.0", 0 );
static ConVar Commander_RightMoveSpeedScale( "commander_rightmovespeedscale", "2.0", 0 );
static ConVar Commander_InvertMouse( "commander_invertmouse", "1.0", 0 );

// Public version of the commander mode;
IClientMode *ClientModeCommander()
{
	// TF2 Commander View Mode
	static CClientModeCommander g_ClientModeCommander;
	return &g_ClientModeCommander;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *commander - 
//-----------------------------------------------------------------------------
void CCommanderViewportPanel::SetCommanderView( CClientModeCommander *commander )
{
	m_pCommanderView = commander;

	if ( m_pOverlayPanel )
	{
		m_pOverlayPanel->SetCommanderView( m_pCommanderView );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CCommanderOverlayPanel
//-----------------------------------------------------------------------------
CCommanderOverlayPanel *CCommanderViewportPanel::GetCommanderOverlayPanel( void )
{
	return m_pOverlayPanel;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CCommanderViewportPanel::CCommanderViewportPanel( void ) :
	vgui::Panel( NULL, "CommanderViewportPanel" ),
	m_CursorCommander( vgui::dc_arrow ),
	m_CursorRightMouseMove(vgui::dc_hand)
{
	m_pOverlayPanel = new CCommanderOverlayPanel();
	m_pOverlayPanel->SetParent( this );

	SetPaintEnabled( false );
	SetPaintBorderEnabled( false );
	SetPaintBackgroundEnabled( false );

	SetCursor( m_CursorCommander );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CCommanderViewportPanel::~CCommanderViewportPanel( void )
{
}

//-----------------------------------------------------------------------------
// call these when commander view is enabled/disabled
//-----------------------------------------------------------------------------


void CCommanderViewportPanel::Enable()
{
	vgui::VPANEL pRoot = VGui_GetClientDLLRootPanel();

	SetCursor(m_CursorCommander);
	vgui::surface()->SetCursor( m_CursorCommander );

	// Make the viewport fill the root panel.
	if ( pRoot)
	{
		int wide, tall;
		vgui::ipanel()->GetSize(pRoot, wide, tall);
		SetBounds(0, 0, wide, tall);
	}

	C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );

	if ( m_pOverlayPanel && ent )
	{
		m_pOverlayPanel->Enable();
	}

	SetVisible( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CCommanderViewportPanel::Disable()
{
	if ( m_pOverlayPanel )
	{
		m_pOverlayPanel->Disable();
	}

	SetVisible( false );
}

void CCommanderViewportPanel::MinimapClicked( const Vector& clickWorldPos )
{
	// Don't use Z... our current z is what we want
	Vector actualOrigin, offset;
	VectorCopy( clickWorldPos, actualOrigin );
	actualOrigin.z = m_pOverlayPanel->TacticalOrigin().z;

	m_pOverlayPanel->ActualToVisibleOffset( offset );
	VectorSubtract( actualOrigin, offset, actualOrigin );
	m_pOverlayPanel->BoundOrigin( actualOrigin );
	m_pOverlayPanel->TacticalOrigin() = actualOrigin;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CClientModeCommander::CClientModeCommander()
{
	m_pClear = NULL;
	m_pSkyBox = NULL;
	m_ScaledSlueSpeed = 10;
	m_Log_BaseEto2 = 1.4427f;	// factor to convert from a logarithm of base E to base 2.

	m_pViewport = new CCommanderViewportPanel;
	m_pViewport->SetCommanderView( this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CClientModeCommander::~CClientModeCommander()
{
	// NOTE: map must be deleted first
	delete m_pViewport;
}


//-----------------------------------------------------------------------------
// Purpose: Called once at dll load time
//-----------------------------------------------------------------------------
void CClientModeCommander::Init( void )
{
	BaseClass::Init();
	m_pViewport->RequestFocus();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : vgui::Panel
//-----------------------------------------------------------------------------
vgui::Panel *CClientModeCommander::GetMinimapParent( void )
{
	return GetCommanderOverlayPanel();
}

//-----------------------------------------------------------------------------
// Inherited from IMinimapClient
//-----------------------------------------------------------------------------
void CClientModeCommander::MinimapClicked( const Vector& clickWorldPos )
{
	if ( m_pViewport )
	{
		m_pViewport->MinimapClicked( clickWorldPos );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CCommanderOverlayPanel	*CClientModeCommander::GetCommanderOverlayPanel( void )
{
	if ( m_pViewport )
	{
		return m_pViewport->GetCommanderOverlayPanel();
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------

void CClientModeCommander::Enable()
{
	vgui::VPANEL pRoot;

	// Add our viewport to the root panel.
	if(pRoot = VGui_GetClientDLLRootPanel() )
	{
		m_pViewport->SetParent( pRoot );
	}

	m_pViewport->Enable();

	// HACK: Find a better place for these
	m_pClear = (ConVar *)cvar->FindVar( "gl_clear" );
	m_pSkyBox = (ConVar *)cvar->FindVar( "r_drawskybox" );

	m_pViewport->RequestFocus();

	HudCommanderOverlayMgr()->Enable( true );

	BaseClass::Enable();

	Layout();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClientModeCommander::Disable()
{
	BaseClass::Disable();

	vgui::VPANEL pRoot;

	m_pViewport->Disable();

	// Remove our viewport from the root panel.
	if(pRoot = VGui_GetClientDLLRootPanel() )
	{
		m_pViewport->SetParent( (vgui::VPANEL)NULL );
	}

	input->ResetMouse();
	HudCommanderOverlayMgr()->Enable( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------

void CClientModeCommander::Update()
{
	if ( !engine->IsInGame() )
	{
		// Disable commander view
		modemanager->SwitchMode( false, false );
		return;
	}

	ClientModeTFBase::Update();

	Vector mins, maxs;
	m_pViewport->GetCommanderOverlayPanel()->GetVisibleArea( mins, maxs );
	MapData().SetVisibleArea( mins, maxs );

	HudCommanderOverlayMgr()->Tick( );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClientModeCommander::Layout()
{
	BaseClass::Layout();

	// Force it to recompute it's boundaries
	m_pViewport->GetCommanderOverlayPanel()->Disable();
	m_pViewport->GetCommanderOverlayPanel()->Enable();
}

//-----------------------------------------------------------------------------
// Purpose: The mode can choose to not draw fog
//-----------------------------------------------------------------------------
bool CClientModeCommander::ShouldDrawFog( void )
{
	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Checks map bounds and determines ideal height for tactical view
// Input  : fov - 
//			zoom - 
// Output : float
//-----------------------------------------------------------------------------
float CClientModeCommander::GetHeightForMap( float zoom )
{
	Vector mins, maxs;
	MapData().GetMapBounds( mins, maxs );
	return maxs.z + TACTICAL_ZOFFSET; 
}


bool CClientModeCommander::GetOrthoParameters(CViewSetup *pSetup)
{
	Vector vCenter;
	float xSize, ySize;
	m_pViewport->GetCommanderOverlayPanel()->GetOrthoRenderBox(vCenter, xSize, ySize);

	pSetup->m_bOrtho = true;
	pSetup->m_OrthoLeft   = -xSize;
	pSetup->m_OrthoTop    = -ySize;
	pSetup->m_OrthoRight  = xSize;
	pSetup->m_OrthoBottom = ySize;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *angles - 
//-----------------------------------------------------------------------------
void CClientModeCommander::OverrideView( CViewSetup *pSetup )
{
	// Turn off vis when in commander mode
	view->DisableVis();
	VectorCopy( m_pViewport->GetCommanderOverlayPanel()->TacticalAngles(), pSetup->angles );
	VectorCopy( m_pViewport->GetCommanderOverlayPanel()->TacticalOrigin(), pSetup->origin );
}

//-----------------------------------------------------------------------------
// Purpose: Scale commander slue speed based on viewport zoom factor
// Output : float
//-----------------------------------------------------------------------------
float CClientModeCommander::GetScaledSlueSpeed( void )
{
	return m_ScaledSlueSpeed;
}

//-----------------------------------------------------------------------------
// Purpose: Convert move to scaled move
// Input  : in - 
// Output : float
//-----------------------------------------------------------------------------
float CClientModeCommander::Commander_ResampleMove( float in )
{
	float sign;
	float move;