//====== Copyright © 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose: Implmentation of IEngineTool callback interface
//  Tool .dlls can call back through this interface to talk to the engine
//
//=============================================================================

#include "ienginetoolinternal.h"
#include "EngineSoundInternal.h"
#include "vengineserver_impl.h"
#include "cdll_engine_int.h"
#include "toolframework/ienginetool.h"
#include "client.h"
#include "server.h"
#include "con_nprint.h"
#include "toolframework/itoolframework.h"
#include "sound.h"
#include "screen.h"
#include "render.h"
#include "gl_matsysiface.h"
#include "cl_main.h"
#include "sys_dll.h"
#include "ivideomode.h"
#include "voice.h"
#include "filesystem_engine.h"
#include "enginetrace.h"
#include "Overlay.h"
#include "r_efx.h"
#include "r_local.h"
#include "lightcache.h"
#include "ispatialpartitioninternal.h"
#include "networkstringtableserver.h"
#include "networkstringtable.h"
#include "igame.h"
#include "gl_rmain.h"

#ifndef DEDICATED
#include "vgui_baseui_interface.h"
#endif

// NOTE: This has to be the last file included!
#include "tier0/memdbgon.h"


// External variables and APIs needed
extern CSysModule *g_GameDLL;
extern ConVar host_timescale;
extern	CGlobalVars g_ServerGlobalVariables;
void SV_ForceSend();
CreateInterfaceFn ClientDLL_GetFactory( void );
extern CNetworkStringTableContainer *networkStringTableContainerServer;

IOverlayMgr *OverlayMgr();

void SV_ForceSend();

extern ConVar host_framerate;

void CL_StartMovie( const char *filename, int flags, int nWidth, int nHeight, float flFrameRate, int jpeg_quality );
void CL_EndMovie();
bool CL_IsRecordingMovie();
void VGui_SetGameDLLPanelsVisible( bool show );
float AudioSource_GetSoundDuration( char const *pName );

//-----------------------------------------------------------------------------
// Purpose: Singleton implementation of external tools callback interface
//-----------------------------------------------------------------------------
class CEngineTool : public IEngineToolInternal
{
public:
	CEngineTool();

	// Methods of IEngineToolFramework
	// Take over input
	virtual void		ShowCursor( bool show );
	virtual bool		IsCursorVisible() const;

	// Helpers for implementing a tool switching UI
	virtual int			GetToolCount() const;
	virtual const char	*GetToolName( int index ) const;
	virtual void		SwitchToTool( int index );

	virtual bool		IsTopmostTool( const IToolSystem *sys ) const;
 	virtual const IToolSystem *GetToolSystem( int index ) const;
	virtual IToolSystem *GetTopmostTool();

	// If module not already loaded, loads it and optionally switches to first tool in module.  Returns false if load failed or tool already loaded
	virtual bool		LoadToolModule( char const *pToolModule, bool bSwitchToFirst );

public:
	// Retrieve factories from server.dll and client.dll to get at specific interfaces defined within
	virtual void		GetServerFactory( CreateInterfaceFn& factory );
	virtual void		GetClientFactory( CreateInterfaceFn& factory );

	// Issue a console command
	virtual void		Command( const char *cmd );
	// Flush console command buffer right away
	virtual void		Execute();

	// If in a level, get name of current level
	virtual const char	*GetCurrentMap();
	virtual void		ChangeToMap( const char *mapname );
	virtual bool		IsMapValid( const char *mapname );

	// Method for causing engine to call client to render scene with no view model or overlays
	virtual void		RenderView( CViewSetup &view, int nFlags, int nWhatToRender );

	// Returns true if the player is fully connected and active in game (i.e, not still loading)
	virtual bool		IsInGame();
	// Returns true if the player is connected, but not necessarily active in game (could still be loading)
	virtual bool		IsConnected();

	virtual int			GetMaxClients(); // Tools might want to ensure single player, e.g.
	
	virtual bool		IsGamePaused();
	virtual void		SetGamePaused( bool paused );

	virtual float		GetTimescale(); // host_timescale ConVar multiplied by the game timescale
	virtual void		SetTimescale( float scale );

	// Real time is unscaled, but is updated once per frame
	virtual float		GetRealTime();
	virtual float		GetRealFrameTime(); // unscaled

	virtual float		Time(); // Get high precision timer (for profiling?)

	// Host time is scaled
	virtual float		HostFrameTime(); // host_frametime
	virtual float		HostTime(); // host_time
	virtual int			HostTick(); // host_tickcount
	virtual int			HostFrameCount(); // total famecount

	virtual float		ServerTime(); // gpGlobals->curtime on server
	virtual float		ServerFrameTime(); // gpGlobals->frametime on server
	virtual int			ServerTick(); // gpGlobals->tickcount on server
	virtual float		ServerTickInterval(); // tick interval on server

	virtual float		ClientTime(); // gpGlobals->curtime on client
	virtual float		ClientFrameTime(); // gpGlobals->frametime on client
	virtual int			ClientTick(); // gpGlobals->tickcount on client

	virtual void		SetClientFrameTime( float frametime ); // gpGlobals->frametime on client

	// Currently the engine doesn't like to do networking when it's paused, but if a tool changes entity state, it can be useful to force 
	//  a network update to get that state over to the client
	virtual void		ForceUpdateDuringPause();

	// Maybe through modelcache???
	virtual model_t		*GetModel( HTOOLHANDLE hEntity );
	// Get the .mdl file used by entity (if it's a cbaseanimating)
	virtual studiohdr_t *GetStudioModel( HTOOLHANDLE hEntity );

	// SINGLE PLAYER/LISTEN SERVER ONLY (just matching the client .dll api for this)
	// Prints the formatted string to the notification area of the screen ( down the right hand edge
	//  numbered lines starting at position 0
	virtual void		Con_NPrintf( int pos, const char *fmt, ... );
	// SINGLE PLAYER/LISTEN SERVER ONLY(just matching the client .dll api for this)
	// Similar to Con_NPrintf, but allows specifying custom text color and duration information
	virtual void		Con_NXPrintf( const struct con_nprint_s *info, const char *fmt, ... );

	// Get the current game directory (hl2, tf2, hl1, cstrike, etc.)
	virtual void        GetGameDir( char *szGetGameDir, int maxlength );

// Do we need separate rects for the 3d "viewport" vs. the tools surface??? and can we control viewports from
	virtual void		GetScreenSize( int& width, int &height );

	virtual int			StartSound( 
		int iUserData,
		bool staticsound,
		int iEntIndex, 
		int iChannel, 
		const char *pSample, 
		float flVolume, 
		soundlevel_t iSoundlevel, 
		const Vector& origin,
		const Vector& direction,
		int iFlags = 0, 
		int iPitch = PITCH_NORM, 
		bool bUpdatePositions = true, 
		float delay = 0.0f, 
		int speakerentity = -1 );

	virtual void	StopSoundByGuid( int guid );
	virtual void	SetVolumeByGuid( int guid, float flVolume );
	virtual bool	IsSoundStillPlaying( int guid );
	virtual bool	GetSoundChannelVolume( const char* sound, float &flVolumeLeft, float &flVolumeRight ) { return false; }
	virtual float	GetSoundDuration( int guid );
	virtual void	ReloadSound( const char *pSample );
	virtual void	StopAllSounds( );
	virtual void	SetAudioState( const AudioState_t &audioState );
	virtual void	SetMainView( const Vector &vecOrigin, const QAngle &angles );
	virtual bool	GetPlayerView( CViewSetup &playerView, int x, int y, int w, int h );
	virtual void	CreatePickingRay( const CViewSetup &viewSetup, int x, int y, Vector& org, Vector& forward );
	virtual bool	IsLoopingSound( int guid );

	virtual void	InstallQuitHandler( void *pvUserData, FnQuitHandler func );
	virtual void	TakeTGAScreenShot( const char *filename, int width, int height );
	// Even if game is paused, force networking to update to get new server state down to client
	virtual void	ForceSend();

	virtual bool	IsRecordingMovie();

	// NOTE: Params can contain file name, frame rate, output avi, output raw, and duration
	virtual void	StartMovieRecording( KeyValues *pMovieParams );
	virtual void	EndMovieRecording();
	virtual void	CancelMovieRecording();
	virtual AVIHandle_t GetRecordingAVIHandle();

	virtual void	StartRecordingVoiceToFile( const char *filename, const char *pPathID = 0 );
	virtual void	StopRecordingVoiceToFile();
	virtual bool	IsVoiceRecording();

	virtual void	TraceRay( const Ray_t &ray, unsigned int fMask, ITraceFilter *pTraceFilter, CBaseTrace *pTrace );
	virtual void	TraceRayServer( const Ray_t &ray, unsigned int fMask, ITraceFilter *pTraceFilter, CBaseTrace *pTrace );

	bool			CanQuit();
	void			UpdateScreenshot();

	bool			ShouldSuppressDeInit() const;

	virtual bool		IsConsoleVisible();
	virtual int			GetPointContents( const Vector &vecPosition );
	virtual int			GetActiveDLights( dlight_t *pList[MAX_DLIGHTS] );
	virtual int			GetLightingConditions( const Vector &vecPosition, Vector *pColors, int nMaxLocalLights, LightDesc_t *pLocalLights );

	// precache methods
	virtual bool		PrecacheSound( const char *pName, bool bPreload = false );
	virtual bool		PrecacheModel( const char *pName, bool bPreload = false );

	virtual float		GetMono16Samples( const char *pszName, CUtlVector< short >& sampleList );

	virtual void		GetWorldToScreenMatrixForView( const CViewSetup &view, VMatrix *pVMatrix );
	virtual SpatialPartitionHandle_t CreatePartitionHandle( IHandleEntity *pEntity, SpatialPartitionListMask_t listMask, const Vector& mins, const Vector& maxs );
	virtual void DestroyPartitionHandle( SpatialPartitionHandle_t hPartition );
	virtual void InstallPartitionQueryCallback( IPartitionQueryCallback *pQuery );
	virtual void RemovePartitionQueryCallback( IPartitionQueryCallback *pQuery );
	virtual void ElementMoved( SpatialPartitionHandle_t handle, const Vector& mins, const Vector& maxs );

	virtual float		GetSoundDuration( const char *pszName );

	virtual void		ValidateSoundCache( char const *pchSoundName );
	virtual void		PrefetchSound( char const *pchSoundName );

	virtual void* GetEngineHwnd();
	virtual void		OnModeChanged( bool bGameMode );
public:
	// Methods of IEngineToolInternal
	virtual void	SetIsInGame( bool bIsInGame );

	virtual float	GetSoundElapsedTime( int guid );
	virtual bool	GetPreventSound( void );

private:
	bool m_bIsInGame;

	struct QuitHandler_t
	{
		void			*userdata;
		FnQuitHandler	func;
	};

	CUtlVector< QuitHandler_t >	m_QuitHandlers;

	char				m_szScreenshotFile[ MAX_OSPATH ];
	int					m_nScreenshotWidth;
	int					m_nScreenshotHeight;

	bool				m_bRecordingMovie;
	bool				m_bSuppressDeInit;
	char				m_szVoiceoverFile[ MAX_OSPATH ];
};


//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
static CEngineTool g_EngineTool;
IEngineToolInternal *g_pEngineToolInternal = &g_EngineTool;

void EngineTool_InstallQuitHandler( void *pvUserData, FnQuitHandler func )
{
	g_EngineTool.InstallQuitHandler( pvUserData, func );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool EngineTool_CheckQuitHandlers()
{
	return g_EngineTool.CanQuit();
}

void EngineTool_UpdateScreenshot()
{
	g_EngineTool.UpdateScreenshot();
}

//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CEngineTool::CEngineTool()
{
	m_bIsInGame = false;
	m_szScreenshotFile[ 0 ] = 0;
	m_nScreenshotWidth = 180;
	m_nScreenshotHeight = 100;

	m_bRecordingMovie = false;
	m_bSuppressDeInit = false;
	m_szVoiceoverFile[ 0 ] = 0;
}


//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
void CEngineTool::ShowCursor( bool show )
{
	Assert( 0 );
}

bool CEngineTool::IsCursorVisible() const
{
	Assert( 0 );
	return true;
}

int CEngineTool::GetPointContents( const Vector &vecPosition )
{
	return g_pEngineTraceClient->GetPointContents( vecPosition, NULL );
}

int CEngineTool::GetActiveDLights( dlight_t *pList[MAX_DLIGHTS] )
{
	return g_pEfx->CL_GetActiveDLights( pList );
}

bool WorldLightToMaterialLight( dworldlight_t* pWorldLight, LightDesc_t& light );

int CEngineTool::GetLightingConditions( const Vector &vecLightingOrigin, Vector *pColors, int nMaxLocalLights, LightDesc_t *pLocalLights )
{
	LightcacheGetDynamic_Stats stats;
	LightingState_t state;
	LightcacheGetDynamic( vecLightingOrigin, state, stats, NULL );
	Assert( state.numlights >= 0 && state.numlights < MAXLOCALLIGHTS );
	memcpy( pColors, state.r_boxcolor, sizeof(state.r_boxcolor) );

	int nLightCount = 0;
	for ( int i = 0; i < state.numlights; ++i )
	{
		LightDesc_t *pLightDesc = &pLocalLights[nLightCount];
		if (!WorldLightToMaterialLight( state.locallight[i], *pLightDesc ))
			continue;

		// Apply lightstyle
		float bias = LightStyleValue( state.locallight[i]->style );

		// Deal with overbrighting + bias
		pLightDesc->m_Color[0] *= bias;
		pLightDesc->m_Color[1] *= bias;
		pLightDesc->m_Color[2] *= bias;

		if ( ++nLightCount >= nMaxLocalLights )
			break;
	}
	return nLightCount;
}

void CEngineTool::GetServerFactory( CreateInterfaceFn& factory )
{
	factory = Sys_GetFactory( g_GameDLL );
}

void CEngineTool::GetClientFactory( CreateInterfaceFn& factory )
{
	factory = ClientDLL_GetFactory();
}

void CEngineTool::Command( const char *cmd )
{
	Cbuf_AddText( Cbuf_GetCurrentPlayer(), cmd );
}

void CEngineTool::Execute()
{
	Cbuf_Execute();
}

const char *CEngineTool::GetCurrentMap()
{
	if ( sv.IsDedicated() )
		return "Dedicated Server";

	if ( !GetBaseLocalClient().IsConnected() )
	{
		if ( sv.IsLoading() )
			return sv.GetMapName();

		return "";
	}

	return GetBaseLocalClient().m_szLevelName;
}

void CEngineTool::ChangeToMap( const char *mapname )
{
	if ( modelloader->Map_IsValid( mapname ) )
	{
		Cbuf_AddText( Cbuf_GetCurrentPlayer(), va( "map \"%s\"\n", mapname ) );
	}
}

bool CEngineTool::IsMapValid( const char *mapname )
{
	return modelloader->Map_IsValid( mapname );
}

// Allows tools to kick off rendering by having the engine call the client
void CEngineTool::RenderView( CViewSetup &view, int nFlags, int whatToRender )
{
	// Call client
	ACTIVE_SPLITSCREEN_PLAYER_GUARD( 0 );
	g_ClientDLL->RenderView( view, nFlags, whatToRender );
}

void CEngineTool::SetIsInGame( bool bIsInGame )
{
	m_bIsInGame = bIsInGame;
}

bool CEngineTool::IsInGame()
{
	return m_bIsInGame && GetBaseLocalClient().IsConnected();
}

bool CEngineTool::IsConnected()
{
	return GetBaseLocalClient().IsConnected();
}

int	 CEngineTool::GetMaxClients()
{
	return GetBaseLocalClient().m_nMaxClients;
}

bool CEngineTool::IsGamePaused()
{
	return GetBaseLocalClient().IsPaused();
}

bool CEngineTool::IsConsoleVisible()
{
#ifdef DEDICATED
	return false;
#else
	return EngineVGui()->IsConsoleVisible();
#endif
}

void CEngineTool::SetGamePaused( bool paused )
{
	sv.SetPaused( paused );
}

float CEngineTool::GetTimescale()
{
	return host_timescale.GetFloat() * sv.GetTimescale();
}

void CEngineTool::SetTimescale( float scale )
{
	host_timescale.SetValue( scale );
}

float CEngineTool::Time()
{
	return Plat_FloatTime();
}

// Real time is unscaled, but is updated once per frame
float CEngineTool::GetRealTime()
{
	return realtime;
}

float CEngineTool::GetRealFrameTime()
{
	return host_frametime_unscaled;
}

float CEngineTool::HostFrameTime()
{
	return host_frametime;
}

float CEngineTool::HostTime()
{
	return host_time;
}

int CEngineTool::HostTick()
{
	return host_tickcount;
}

int CEngineTool::HostFrameCount()
{
	return host_framecount;
}

float CEngineTool::ServerTime()
{
	return g_ServerGlobalVariables.curtime;
}

float CEngineTool::ServerFrameTime()
{
	return g_ServerGlobalVariables.frametime;
}
int CEngineTool::ServerTick()
{
	return g_ServerGlobalVariables.tickcount;
}

float CEngineTool::ServerTickInterval()
{
	return g_ServerGlobalVariables.interval_per_tick;
}

float CEngineTool::ClientTime()
{
	return g_ClientGlobalVariables.curtime;
}

float CEngineTool::ClientFrameTime()
{
	return g_ClientGlobalVariables.frametime;
}

int CEngineTool::ClientTick()
{
	return g_ClientGlobalVariables.tickcount;
}

void CEngineTool::SetClientFrameTime( float frametime )
{
	g_ClientGlobalVariables.frametime = frametime;
}

void CEngineTool::ForceUpdateDuringPause()
{
	SV_ForceSend();
}

model_t *CEngineTool::GetModel( HTOOLHANDLE hEntity )
{
	Assert( 0 );
	return NULL;
}

studiohdr_t *CEngineTool::GetStudioModel( HTOOLHANDLE hEntity )
{
	Assert( 0 );
	return NULL;
}

void CEngineTool::Con_NPrintf( int pos, const char *fmt, ... )
{
	char buf[ 1024 ];
	va_list argptr;
	va_start( argptr, fmt );
	_vsnprintf( buf, sizeof( buf ) - 1, fmt, argptr );
	va_end( argptr );

	return ::Con_NPrintf( pos, "%s", buf );
}

void CEngineTool::Con_NXPrintf( const struct con_nprint_s *info, const char *fmt, ... )
{
	char buf[ 1024 ];
	va_list argptr;
	va_start( argptr, fmt );
	_vsnprintf( buf, sizeof( buf ) - 1, fmt, argptr );
	va_end( argptr );

	::Con_NXPrintf( info, "%s", buf );
}

void CEngineTool::GetGameDir( char *szGetGameDir, int maxlength )
{
	Q_strncpy( szGetGameDir, com_gamedir, maxlength );
}

void CEngineTool::GetScreenSize( int& width, int &height )
{
	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->GetWindowSize( width, height );
}

//-----------------------------------------------------------------------------
// Purpose: Helpers for implementing a tool switching UI
// Input  :  - 
// Output : int
//-----------------------------------------------------------------------------
int CEngineTool::GetToolCount() const
{
	return toolframework->GetToolCount();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : index - 
// Output : char
//-----------------------------------------------------------------------------
const char	*CEngineTool::GetToolName( int index ) const
{
	return toolframework->GetToolName( index );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : index - 
//-----------------------------------------------------------------------------
void CEngineTool::SwitchToTool( int index )
{
	toolframework->SwitchToTool( index );
}

bool CEngineTool::IsTopmostTool( const IToolSystem *sys ) const
{
	return toolframework->IsTopmostTool( sys );
}

IToolSystem *CEngineTool::GetTopmostTool()
{
	return toolframework->GetTopmostTool();
}

const IToolSystem *CEngineTool::GetToolSystem( int index ) const
{
	return toolframework->GetToolSystem( index );
}

// If module not already loaded, loads it and optionally switches to first tool in module.  Returns false if load failed or tool already loaded
bool CEngineTool::LoadToolModule( char const *pToolModule, bool bSwitchToFirst )
{
	return toolframework->LoadToolModule( pToolModule, bSwitchToFirst );
}

void CEngineTool::ValidateSoundCache( char const *pchSoundName )
{
	S_ValidateSoundCache( pchSoundName );
}

void CEngineTool::PrefetchSound( char const *pchSoundName )
{
	S_PrefetchSound( pchSoundName, false );
}

int CEngineTool::StartSound( 
	int iUserData,
	bool staticsound,
	int iEntIndex, 
	int iChannel, 
	const char *pSample, 
	float flVolume, 
	soundlevel_t iSoundlevel, 
	const Vector& origin,
	const Vector& direction,
	int iFlags /*= 0*/, 
	int iPitch /*= PITCH_NORM*/, 
	bool bUpdatePositions /*= true*/, 
	float delay /*= 0.0f*/, 
	int speakerentity /*= -1*/ )
{
	StartSoundParams_t params;
	params.userdata = iUserData;
	params.staticsound = staticsound;
	params.soundsource = iEntIndex;
	params.entchannel = iChannel;
	params.pSfx = S_PrecacheSound( pSample );
	params.origin = origin; 
	params.direction = direction; 
	params.bUpdatePositions = bUpdatePositions;
	params.fvol = flVolume;
	params.soundlevel = iSoundlevel;
	params.flags = iFlags;
	params.pitch = iPitch; 
	params.fromserver = false;
	params.delay = delay;
	params.speakerentity = speakerentity;
	params.bToolSound = true;

	int guid = S_StartSound( params );

	return guid;
}

void CEngineTool::StopSoundByGuid( int guid )
{
	S_StopSoundByGuid( guid );
}

void CEngineTool::SetVolumeByGuid( int guid, float flVolume )
{
	S_SetVolumeByGuid( guid, flVolume );
}

bool CEngineTool::IsSoundStillPlaying( int guid )
{
	return S_IsSoundStillPlaying( guid );
}

float CEngineTool::GetSoundDuration( int guid )
{
	return S_SoundDurationByGuid( guid );
}
float CEngineTool::GetSoundElapsedTime( int guid )
{
	return S_GetElapsedTimeByGuid( guid );
}

void* CEngineTool::GetEngineHwnd()
{
	return game->GetMainWindow();
}

float CEngineTool::GetSoundDuration( const char *pszName )
{
	return AudioSource_GetSoundDuration( pszName );
}

void CEngineTool::ReloadSound( const char *pSample )
{
	S_ReloadSound( pSample );
}

void CEngineTool::StopAllSounds( )
{
	S_StopAllSounds( true );
}
bool CEngineTool::GetPreventSound( )
{
	return S_GetPreventSound( );
}

// Returns if the sound is looping
bool CEngineTool::IsLoopingSound( int guid )
{
	return S_IsLoopingSoundByGuid( guid );
}

void CEngineTool::TraceRay( const Ray_t &ray, unsigned int fMask, ITraceFilter *pTraceFilter, CBaseTrace *pTrace )
{
	trace_t tempTrace;

	g_pEngineTraceClient->TraceRay( ray, fMask, pTraceFilter, &tempTrace );

	memcpy( pTrace, &tempTrace, sizeof ( CBaseTrace ) );
}


void CEngineTool::TraceRayServer( const Ray_t &ray, unsigned int fMask, ITraceFilter *pTraceFilter, CBaseTrace *pTrace )
{
	trace_t tempTrace;

	g_pEngineTraceServer->TraceRay( ray, fMask, pTraceFilter, &tempTrace );

	memcpy( pTrace, &tempTrace, sizeof ( CBaseTrace ) );
}


void CEngineTool::SetAudioState( const AudioState_t &audioState )
{
	Host_SetAudioState( audioState );
}


// Sets the location of the main view
void CEngineTool::SetMainView( const Vector &vecOrigin, const QAngle &angles )
{
	g_EngineRenderer->SetMainView( vecOrigin, angles );
}

static float ScaleFOVByWidthRatio( float fovDegrees, float ratio )
{
	float halfAngleRadians = fovDegrees * ( 0.5f * M_PI / 180.0f );
	float t = tan( halfAngleRadians );
	t *= ratio;
	float retDegrees = ( 180.0f / M_PI ) * atan( t );
	return retDegrees * 2.0f;
}

// Gets the player view
bool CEngineTool::GetPlayerView( CViewSetup &viewSetup, int x, int y, int w, int h )
{
	if ( g_ClientDLL )
	{
		if ( !g_ClientDLL->GetPlayerView( viewSetup ) )
			return false;

		// Initialize view setup given the desired rectangle
		viewSetup.x = x;
		viewSetup.y = y;
		viewSetup.width = w;
		viewSetup.height = h;
		viewSetup.m_flAspectRatio = (viewSetup.height != 0) ? (float)viewSetup.width / (float)viewSetup.height : 4.0f / 3.0f;
		viewSetup.m_bRenderToSubrectOfLargerScreen = true;
		viewSetup.fov = ScaleFOVByWidthRatio( viewSetup.fov, viewSetup.m_flAspectRatio / ( 4.0f / 3.0f ) );
		viewSetup.fovViewmodel = ScaleFOVByWidthRatio( viewSetup.fovViewmodel, viewSetup.m_flAspectRatio / ( 4.0f / 3.0f ) );
		return true;
	}
	return false;
}


//-----------------------------------------------------------------------------
// From a location on the screen, figure out the vector into the world
//-----------------------------------------------------------------------------

void CEngineTool::CreatePickingRay( const CViewSetup &viewSetup, int x, int y, Vector& org, Vector& forward )
{
	// Remap x and y into -1 to 1 normalized space
	float xf, yf;
	xf = ( 2.0f * (float)x / (float)viewSetup.width ) - 1.0f;
	yf = ( 2.0f * (float)y / (float)viewSetup.height ) - 1.0f;

	// Flip y axis
	yf = -yf;

	VMatrix worldToScreen;
	GetWorldToScreenMatrixForView( viewSetup, &worldToScreen );
	VMatrix screenToWorld;
	MatrixInverseGeneral( worldToScreen, screenToWorld );

	// Create two points at the normalized mouse x, y pos and at the near and far z planes (0 and 1 depth)
	Vector v1, v2;
	v1.Init( xf, yf, 0.0f );
	v2.Init( xf, yf, 1.0f );
    
	Vector o2;
	// Transform the two points by the screen to world matrix
	screenToWorld.V3Mul( v1, org ); // ray start origin
	screenToWorld.V3Mul( v2, o2 );  // ray end origin
	VectorSubtract( o2, org, forward );
	forward.NormalizeInPlace();
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if all handlers say we can quit the engine
//-----------------------------------------------------------------------------
bool CEngineTool::CanQuit()
{
	int c = m_QuitHandlers.Count();
	for ( int i = 0; i < c; ++i )
	{
		QuitHandler_t& qh = m_QuitHandlers[ i ];
		FnQuitHandler func = qh.func;
		if ( func )
		{
			if ( !func( qh.userdata ) )
			{
				return false;
			}
		}
	}

	return true;
}

void CEngineTool::InstallQuitHandler( void *pvUserData, FnQuitHandler func )
{
	QuitHandler_t qh;
	qh.userdata = pvUserData;
	qh.func = func;

	m_QuitHandlers.AddToTail( qh );
}

// precache methods
bool CEngineTool::PrecacheSound( const char *pName, bool bPreload )
{
	if ( pName && TestSoundChar( pName, CHAR_SENTENCE ) )
		return true;

	bool bState = networkStringTableContainerServer->Lock( false );
	int flags = bPreload ? RES_PRELOAD : 0;
	int i = sv.PrecacheSound( pName, flags );
	networkStringTableContainerServer->Lock( bState );
	return i >= 0;
}

bool CEngineTool::PrecacheModel( const char *pName, bool bPreload )
{
	int flags = bPreload ? RES_PRELOAD : 0;
	bool bState = networkStringTableContainerServer->Lock( false );
	int i = sv.PrecacheModel( pName, flags );
	networkStringTableContainerServer->Lock( bState );
	return i >= 0;
}

void CEngineTool::TakeTGAScreenShot( const char *filename, int width, int height )
{
	Q_strncpy( m_szScreenshotFile, filename, sizeof( m_szScreenshotFile ) );

	m_nScreenshotWidth = width;
	m_nScreenshotHeight = height;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEngineTool::UpdateScreenshot()
{
	if ( g_LostVideoMemory )
		return;

	if ( m_szScreenshotFile[0] )
	{
		g_ClientDLL->WriteSaveGameScreenshotOfSize( m_szScreenshotFile, m_nScreenshotWidth, m_nScreenshotHeight );
		m_szScreenshotFile[0] = 0;
	}
}

// Even if game is paused, force networking to update to get new server state down to client
void CEngineTool::ForceSend()
{
	SV_ForceSend();
}

bool CEngineTool::IsRecordingMovie()
{
	if ( m_bRecordingMovie )
	{
		Assert( CL_IsRecordingMovie() );
		return true;
	}
	return false;
}

// NOTE: Params can contain file name, frame rate, output avi, output raw, and duration
void CEngineTool::StartMovieRecording( KeyValues *pMovieParams )
{
	if ( CL_IsRecordingMovie() )
	{
		Warning( "Can't record movie, already recording!!!\n" );
		return;
	}

	if ( m_bRecordingMovie )
		return;

	int jpeg_quality = DEFAULT_JPEG_QUALITY;

	int flags = 0;
	if ( pMovieParams->GetInt( "outputavi", 0 ) )
	{
		if ( pMovieParams->GetInt( "avisoundonly", 0 ) )
		{
			flags |= MovieInfo_t::FMOVIE_AVISOUND;
		}
		else
		{
			flags |= MovieInfo_t::FMOVIE_AVI | MovieInfo_t::FMOVIE_AVISOUND;
		}
	}
	if  ( pMovieParams->GetInt( "outputtga", 0 ) )
	{
		flags |= MovieInfo_t::FMOVIE_TGA;
	}
	if  ( pMovieParams->GetInt( "outputjpg", 0 ) )
	{
		flags |= MovieInfo_t::FMOVIE_JPG;
		jpeg_quality = pMovieParams->GetInt( "jpeg_quality" );
	}
	if  ( pMovieParams->GetInt( "outputwav", 0 ) )
	{
		flags |= MovieInfo_t::FMOVIE_WAV;
	}

	const char *pFileName = pMovieParams->GetString( "filename", NULL );
	if ( !pFileName )
	{
		Warning( "Output filename not specified!\n" );
		return;
	}

	int nWidth = pMovieParams->GetInt( "width", videomode->GetModeWidth() );
	int nHeight = pMovieParams->GetInt( "height", videomode->GetModeHeight() );
    float flFrameRate = pMovieParams->GetFloat( "framerate", 30.0f );

	m_bRecordingMovie = true;
	CL_StartMovie( pFileName, flags, nWidth, nHeight, flFrameRate, jpeg_quality );
}

void CEngineTool::EndMovieRecording()
{
	if ( !m_bRecordingMovie )
		return;

	CL_EndMovie();
	m_bRecordingMovie = false;
}

void CEngineTool::CancelMovieRecording()
{
	EndMovieRecording();
}

AVIHandle_t CEngineTool::GetRecordingAVIHandle()
{
	if ( !CL_IsRecordingMovie() )
		return AVIHANDLE_INVALID;
	return g_hCurrentAVI;
}

bool CEngineTool::ShouldSuppressDeInit() const
{
	return m_bSuppressDeInit;
}

void CEngineTool::StartRecordingVoiceToFile( const char *filename, const char *pPathID /*= 0*/ )
{	
	FileHandle_t fh = g_pFileSystem->Open( filename, "wb", pPathID );
	if ( fh != FILESYSTEM_INVALID_HANDLE )
	{
		byte foo = 'b';

		g_pFileSystem->Write( &foo, 1, fh );
		g_pFileSystem->Close( fh );
	}

	g_pFileSystem->RelativePathToFullPath( filename, pPathID, m_szVoiceoverFile, sizeof( m_szVoiceoverFile ) );

	g_pFileSystem->RemoveFile( filename, pPathID );

#if !defined( NO_VOICE )
	if ( IsVoiceRecording() )
	{
		Voice_RecordStop();
	}
	m_bSuppressDeInit = true;

	Voice_ForceInit();
	Voice_RecordStart( m_szVoiceoverFile, NULL, NULL);
#endif
}

void CEngineTool::StopRecordingVoiceToFile()
{
#if !defined( NO_VOICE )
	Voice_RecordStop();
	m_bSuppressDeInit = false;
#endif
}

float CEngineTool::GetMono16Samples( const char *pszName, CUtlVector< short >& sampleList )
{
	return S_GetMono16Samples( pszName, sampleList );
}

void CEngineTool::GetWorldToScreenMatrixForView( const CViewSetup &view, VMatrix *pVMatrix )
{
	VMatrix worldToView, viewToProjection;
	view.ComputeViewMatrices( &worldToView, &viewToProjection, pVMatrix );
}

SpatialPartitionHandle_t CEngineTool::CreatePartitionHandle( IHandleEntity *pEntity,
	SpatialPartitionListMask_t listMask, const Vector& mins, const Vector& maxs )
{
	return SpatialPartition()->CreateHandle( pEntity, listMask, mins, maxs );
}

void CEngineTool::DestroyPartitionHandle( SpatialPartitionHandle_t hPartition )
{
	SpatialPartition()->DestroyHandle( hPartition );
}

void CEngineTool::InstallPartitionQueryCallback( IPartitionQueryCallback *pQuery )
{
	SpatialPartition()->InstallQueryCallback( pQuery );
}

void CEngineTool::RemovePartitionQueryCallback( IPartitionQueryCallback *pQuery )
{
	SpatialPartition()->RemoveQueryCallback( pQuery );
}

void CEngineTool::ElementMoved( SpatialPartitionHandle_t handle, const Vector& mins, const Vector& maxs )
{
	SpatialPartition()->ElementMoved( handle, mins, maxs );
}

bool CEngineTool::IsVoiceRecording()
{
#if !defined( NO_VOICE )
	return Voice_IsRecording();
#else
	return false;
#endif
}

void CEngineTool::OnModeChanged( bool bGameMode )
{
	EngineVGui()->OnToolModeChanged( bGameMode );
}

bool EngineTool_SuppressDeInit()
{
	return g_EngineTool.ShouldSuppressDeInit();
}

void EngineTool_OverrideSampleRate( int& rate )
{
	if ( EngineTool_SuppressDeInit() )
	{
		rate = 11025;
	}
}

// Expose complex interface
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineTool, IEngineTool, VENGINETOOL_INTERFACE_VERSION, g_EngineTool );
// Expose simple interface
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineTool, IEngineToolFramework, VENGINETOOLFRAMEWORK_INTERFACE_VERSION, g_EngineTool );