//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======//

 //

 // Purpose: 

 //

 // $Workfile:     $

 // $Date:         $

 //

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

 // $NoKeywords: $

 //===========================================================================//

 #ifndef CONVAR_H

 #define CONVAR_H

 #if _WIN32

 #pragma once

 #endif

 #include "tier0/dbg.h"

 #include "tier1/iconvar.h"

 #include "tier1/utlvector.h"

 #include "tier1/utlstring.h"

 #include "Color.h"

 #include "icvar.h"

 #ifdef _WIN32

 #define FORCEINLINE_CVAR FORCEINLINE

 #elif POSIX

 #define FORCEINLINE_CVAR inline

 #else

 #error "implement me"

 #endif

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

 // Uncomment me to test for threading issues for material system convars

 // NOTE: You want to disable all threading when you do this

 // +host_thread_mode 0 +r_threaded_particles 0 +sv_parallel_packentities 0 +sv_disable_querycache 0

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

 //#define CONVAR_TEST_MATERIAL_THREAD_CONVARS 1

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

 // Forward declarations

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

 class ConVar;

 class CCommand;

 class ConCommand;

 class ConCommandBase;

 struct characterset_t;

 struct CCommandContext

 {

 	CCommandContext( int index )

 	{

 		_index = index;

 	}

 	int Get() const

 	{

 		return _index;

 	}

 private:

 	int _index;

 };

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

 // Any executable that wants to use ConVars need to implement one of

 // these to hook up access to console variables.

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

 class IConCommandBaseAccessor

 {

 public:

 	// Flags is a combination of FCVAR flags in cvar.h.

 	// hOut is filled in with a handle to the variable.

 	virtual bool RegisterConCommandBase( ConCommandBase *pVar ) = 0;

 };

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

 // Helper method for console development

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

 #if defined( _X360 )

 void ConVar_PublishToVXConsole();

 #endif

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

 // Called when a ConCommand needs to execute

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

 typedef void ( *FnCommandCallbackV1_t )( void );

 typedef void ( *FnCommandCallback_t )( const CCommandContext &context, const CCommand &command );

 #define COMMAND_COMPLETION_MAXITEMS		64

 #define COMMAND_COMPLETION_ITEM_LENGTH	64

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

 // Returns 0 to COMMAND_COMPLETION_MAXITEMS worth of completion strings

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

 typedef int  ( *FnCommandCompletionCallback )( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] );

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

 // Interface version

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

 class ICommandCallback

 {

 public:

 	virtual void CommandCallback( const CCommand &command ) = 0;

 };

 class ICommandCallback2

 {

 public:

 	virtual void CommandCallback( const CCommandContext &context, const CCommand &command ) = 0;

 };

 class ICommandCompletionCallback

 {

 public:

 	virtual int  CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) = 0;

 };

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

 // Purpose: The base console invoked command/cvar interface

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

 class ConCommandBase

 {

 	friend class CCvar;

 	friend class ConVar;

 	friend class ConCommand;

 	friend void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor );

 	friend void ConVar_PublishToVXConsole();

 	// FIXME: Remove when ConVar changes are done

 	friend class CDefaultCvar;

 public:

 								ConCommandBase( void );

 								ConCommandBase( const char *pName, const char *pHelpString = 0, 

 									int flags = 0 );

 	virtual						~ConCommandBase( void );

 	virtual	bool				IsCommand( void ) const;

 	// Check flag

 	virtual bool				IsFlagSet( int flag ) const;

 	// Set flag

 	virtual void				AddFlags( int flags );

 	// Clear flag

 	virtual void				RemoveFlags( int flags );

 	virtual int					GetFlags() const;

 	// Return name of cvar

 	virtual const char			*GetName( void ) const;

 	// Return help text for cvar

 	virtual const char			*GetHelpText( void ) const;

 	// Deal with next pointer

 	const ConCommandBase		*GetNext( void ) const;

 	ConCommandBase				*GetNext( void );

 	virtual bool				IsRegistered( void ) const;

 	// Returns the DLL identifier

 	virtual CVarDLLIdentifier_t	GetDLLIdentifier() const;

 protected:

 	virtual void				Create( const char *pName, const char *pHelpString = 0, 

 									int flags = 0 );

 	// Used internally by OneTimeInit to initialize/shutdown

 	virtual void				Init();

 	void						Shutdown();

 	// Internal copy routine ( uses new operator from correct module )

 	char						*CopyString( const char *from );

 private:

 	// Next ConVar in chain

 	// Prior to register, it points to the next convar in the DLL.

 	// Once registered, though, m_pNext is reset to point to the next

 	// convar in the global list

 	ConCommandBase				*m_pNext;

 	// Has the cvar been added to the global list?

 	bool						m_bRegistered;

 	// Static data

 	const char 					*m_pszName;

 	const char 					*m_pszHelpString;

 	// ConVar flags

 	int							m_nFlags;

 protected:

 	// ConVars add themselves to this list for the executable. 

 	// Then ConVar_Register runs through  all the console variables 

 	// and registers them into a global list stored in vstdlib.dll

 	static ConCommandBase		*s_pConCommandBases;

 	// ConVars in this executable use this 'global' to access values.

 	static IConCommandBaseAccessor	*s_pAccessor;

 public:

 	inline void SetFlags(int flags)	

 	{ 

 		m_nFlags = flags; 

 	}

 };

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

 // Command tokenizer

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

 class CCommand

 {

 public:

 	CCommand();

 	CCommand( int nArgC, const char **ppArgV );

 	bool Tokenize( const char *pCommand, characterset_t *pBreakSet = NULL );

 	void Reset();

 	int ArgC() const;

 	const char **ArgV() const;

 	const char *ArgS() const;					// All args that occur after the 0th arg, in string form

 	const char *GetCommandString() const;		// The entire command in string form, including the 0th arg

 	const char *operator[]( int nIndex ) const;	// Gets at arguments

 	const char *Arg( int nIndex ) const;		// Gets at arguments

 	// Helper functions to parse arguments to commands.

 	const char* FindArg( const char *pName ) const;

 	int FindArgInt( const char *pName, int nDefaultVal ) const;

 	static int MaxCommandLength();

 	static characterset_t* DefaultBreakSet();

 private:

 	enum

 	{

 		COMMAND_MAX_ARGC = 64,

 		COMMAND_MAX_LENGTH = 512,

 	};

 	int		m_nArgc;

 	int		m_nArgv0Size;

 	char	m_pArgSBuffer[ COMMAND_MAX_LENGTH ];

 	char	m_pArgvBuffer[ COMMAND_MAX_LENGTH ];

 	const char*	m_ppArgv[ COMMAND_MAX_ARGC ];

 };

 inline int CCommand::MaxCommandLength()

 {

 	return COMMAND_MAX_LENGTH - 1;

 }

 inline int CCommand::ArgC() const

 {

 	return m_nArgc;

 }

 inline const char **CCommand::ArgV() const

 {

 	return m_nArgc ? (const char**)m_ppArgv : NULL;

 }

 inline const char *CCommand::ArgS() const

 {

 	return m_nArgv0Size ? &m_pArgSBuffer[m_nArgv0Size] : "";

 }

 inline const char *CCommand::GetCommandString() const

 {

 	return m_nArgc ? m_pArgSBuffer : "";

 }

 inline const char *CCommand::Arg( int nIndex ) const

 {

 	// FIXME: Many command handlers appear to not be particularly careful

 	// about checking for valid argc range. For now, we're going to

 	// do the extra check and return an empty string if it's out of range

 	if ( nIndex < 0 || nIndex >= m_nArgc )

 		return "";

 	return m_ppArgv[nIndex];

 }

 inline const char *CCommand::operator[]( int nIndex ) const

 {

 	return Arg( nIndex );

 }

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

 // Purpose: The console invoked command

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

 class ConCommand : public ConCommandBase

 {

 friend class CCvar;

 public:

 	typedef ConCommandBase BaseClass;

 	ConCommand( const char *pName, FnCommandCallbackV1_t callback, 

 		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

 	ConCommand( const char *pName, FnCommandCallback_t callback, 

 		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

 	ConCommand( const char *pName, ICommandCallback *pCallback, 

 		const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );

 	ConCommand( const char *pName, ICommandCallback2 *pCallback, 

 		const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );

 	virtual ~ConCommand( void );

 	virtual	bool IsCommand( void ) const;

 	virtual int AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands );

 	virtual bool CanAutoComplete( void );

 	// Invoke the function

 	virtual void Dispatch( const CCommandContext &context, const CCommand &command );

 private:

 	// NOTE: To maintain backward compat, we have to be very careful:

 	// All public virtual methods must appear in the same order always

 	// since engine code will be calling into this code, which *does not match*

 	// in the mod code; it's using slightly different, but compatible versions

 	// of this class. Also: Be very careful about adding new fields to this class.

 	// Those fields will not exist in the version of this class that is instanced

 	// in mod code.

 	// Call this function when executing the command

 	union

 	{

 		FnCommandCallbackV1_t m_fnCommandCallbackV1;

 		FnCommandCallback_t m_fnCommandCallback;

 		ICommandCallback *m_pCommandCallback; 

 		ICommandCallback2 *m_pCommandCallback2; 

 	};

 	union

 	{

 		FnCommandCompletionCallback	m_fnCompletionCallback;

 		ICommandCompletionCallback *m_pCommandCompletionCallback;

 	};

 	bool m_bHasCompletionCallback : 1;

 	bool m_bUsingNewCommandCallback : 1;

 	bool m_bUsingCommandCallbackInterface : 1;

 	bool m_bUsingCommandCallbackInterface2 : 1;

 public:

 	inline FnCommandCallback_t GetCallback() const

 	{ 

 		return m_fnCommandCallback; 

 	}

 };

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

 // Purpose: A console variable

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

 class ConVar : public ConCommandBase, public IConVar

 {

 friend class CCvar;

 friend class ConVarRef;

 friend class SplitScreenConVarRef;

 public:

 	typedef ConCommandBase BaseClass;

 								ConVar( const char *pName, const char *pDefaultValue, int flags = 0);

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, FnChangeCallback_t callback );

 								ConVar( const char *pName, const char *pDefaultValue, int flags, 

 									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax,

 									FnChangeCallback_t callback );

 	virtual						~ConVar( void );

 	virtual bool				IsFlagSet( int flag ) const;

 	virtual const char*			GetHelpText( void ) const;

 	virtual bool				IsRegistered( void ) const;

 	virtual const char			*GetName( void ) const;

 	// Return name of command (usually == GetName(), except in case of FCVAR_SS_ADDED vars

 	virtual const char			*GetBaseName( void ) const;

 	virtual int					GetSplitScreenPlayerSlot() const;

 	virtual void				AddFlags( int flags );

 	virtual int					GetFlags() const;

 	virtual	bool				IsCommand( void ) const;

 	// Install a change callback (there shouldn't already be one....)

 	void InstallChangeCallback( FnChangeCallback_t callback, bool bInvoke = true );

 	void RemoveChangeCallback( FnChangeCallback_t callbackToRemove );

 	int GetChangeCallbackCount() const { return m_pParent->m_fnChangeCallbacks.Count(); }

 	FnChangeCallback_t GetChangeCallback( int slot ) const { return m_pParent->m_fnChangeCallbacks[ slot ]; }

 	// Retrieve value

 	FORCEINLINE_CVAR float			GetFloat( void ) const;

 	FORCEINLINE_CVAR int			GetInt( void ) const;

 	FORCEINLINE_CVAR Color			GetColor( void ) const;

 	FORCEINLINE_CVAR bool			GetBool() const {  return !!GetInt(); }

 	FORCEINLINE_CVAR char const	   *GetString( void ) const;

 	// Compiler driven selection for template use

 	template <typename T> T Get( void ) const;

 	template <typename T> T Get( T * ) const;

 	// Any function that allocates/frees memory needs to be virtual or else you'll have crashes

 	//  from alloc/free across dll/exe boundaries.

 	// These just call into the IConCommandBaseAccessor to check flags and set the var (which ends up calling InternalSetValue).

 	virtual void				SetValue( const char *value );

 	virtual void				SetValue( float value );

 	virtual void				SetValue( int value );

 	virtual void				SetValue( Color value );

 	// Reset to default value

 	void						Revert( void );

 	// True if it has a min/max setting

 	bool						HasMin() const;

 	bool						HasMax() const;

 	bool						GetMin( float& minVal ) const;

 	bool						GetMax( float& maxVal ) const;

 	float						GetMinValue() const;

 	float						GetMaxValue() const;

 	const char					*GetDefault( void ) const;

 	// Value

 	struct CVValue_t

 	{

 		char						*m_pszString;

 		int							m_StringLength;

 		// Values

 		float						m_fValue;

 		int							m_nValue;

 	};

 	FORCEINLINE_CVAR CVValue_t &GetRawValue()

 	{

 		return m_Value;

 	}

 	FORCEINLINE_CVAR const CVValue_t &GetRawValue() const

 	{

 		return m_Value;

 	}

 private:

 	bool						InternalSetColorFromString( const char *value );

 	// Called by CCvar when the value of a var is changing.

 	virtual void				InternalSetValue(const char *value);

 	// For CVARs marked FCVAR_NEVER_AS_STRING

 	virtual void				InternalSetFloatValue( float fNewValue );

 	virtual void				InternalSetIntValue( int nValue );

 	virtual void				InternalSetColorValue( Color value );

 	virtual bool				ClampValue( float& value );

 	virtual void				ChangeStringValue( const char *tempVal, float flOldValue );

 	virtual void				Create( const char *pName, const char *pDefaultValue, int flags = 0,

 									const char *pHelpString = 0, bool bMin = false, float fMin = 0.0,

 									bool bMax = false, float fMax = false, FnChangeCallback_t callback = 0 );

 	// Used internally by OneTimeInit to initialize.

 	virtual void				Init();

 protected:

 	// This either points to "this" or it points to the original declaration of a ConVar.

 	// This allows ConVars to exist in separate modules, and they all use the first one to be declared.

 	// m_pParent->m_pParent must equal m_pParent (ie: m_pParent must be the root, or original, ConVar).

 	ConVar						*m_pParent;

 	// Static data

 	const char					*m_pszDefaultValue;

 	CVValue_t					m_Value;

 	// Min/Max values

 	bool						m_bHasMin;

 	float						m_fMinVal;

 	bool						m_bHasMax;

 	float						m_fMaxVal;

 	// Call this function when ConVar changes

 	CUtlVector< FnChangeCallback_t > m_fnChangeCallbacks;

 public:

 	inline void SetMin(bool set, float min=0.0)

 	{ 

 		m_bHasMin = set; 

 		m_fMinVal = min; 

 	}

 	inline void SetMax(bool set, float max=0.0)

 	{

 		m_bHasMax = set;

 		m_fMaxVal = max; 

 	}

 };

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

 // Purpose: Return ConVar value as a float

 // Output : float

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

 FORCEINLINE_CVAR float ConVar::GetFloat( void ) const

 {

 #ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

 	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

 #endif

 	return m_pParent->m_Value.m_fValue;

 }

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

 // Purpose: Return ConVar value as an int

 // Output : int

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

 FORCEINLINE_CVAR int ConVar::GetInt( void ) const 

 {

 #ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

 	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

 #endif

 	return m_pParent->m_Value.m_nValue;

 }

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

 // Purpose: Return ConVar value as a color

 // Output : Color

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

 FORCEINLINE_CVAR Color ConVar::GetColor( void ) const 

 {

 #ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

 	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

 #endif

 	unsigned char *pColorElement = ((unsigned char *)&m_pParent->m_Value.m_nValue);

 	return Color( pColorElement[0], pColorElement[1], pColorElement[2], pColorElement[3] );

 }

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

 template <> FORCEINLINE_CVAR float			ConVar::Get<float>( void ) const		{ return GetFloat(); }

 template <> FORCEINLINE_CVAR int			ConVar::Get<int>( void ) const			{ return GetInt(); }

 template <> FORCEINLINE_CVAR bool			ConVar::Get<bool>( void ) const			{ return GetBool(); }

 template <> FORCEINLINE_CVAR const char *	ConVar::Get<const char *>( void ) const	{ return GetString(); }

 template <> FORCEINLINE_CVAR float			ConVar::Get<float>( float *p ) const				{ return ( *p = GetFloat() ); }

 template <> FORCEINLINE_CVAR int			ConVar::Get<int>( int *p ) const					{ return ( *p = GetInt() ); }

 template <> FORCEINLINE_CVAR bool			ConVar::Get<bool>( bool *p ) const					{ return ( *p = GetBool() ); }

 template <> FORCEINLINE_CVAR const char *	ConVar::Get<const char *>( char const **p ) const	{ return ( *p = GetString() ); }

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

 // Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.

 // Output : const char *

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

 FORCEINLINE_CVAR const char *ConVar::GetString( void ) const 

 {

 #ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

 	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

 #endif

 	if ( m_nFlags & FCVAR_NEVER_AS_STRING )

 		return "FCVAR_NEVER_AS_STRING";

 	char const *str = m_pParent->m_Value.m_pszString;

 	return str ? str : "";

 }

 class CSplitScreenAddedConVar : public ConVar

 {

 	typedef ConVar BaseClass;

 public:

 	CSplitScreenAddedConVar( int nSplitScreenSlot, const char *pName, const ConVar *pBaseVar ) :

 		BaseClass

 		( 

 			pName, 

 			pBaseVar->GetDefault(), 

 			// Keep basevar flags, except remove _SS and add _SS_ADDED instead

 			( pBaseVar->GetFlags() & ~FCVAR_SS ) | FCVAR_SS_ADDED, 

 			pBaseVar->GetHelpText(), 

 			pBaseVar->HasMin(),

 			pBaseVar->GetMinValue(),

 			pBaseVar->HasMax(),

 			pBaseVar->GetMaxValue()

 		),

 		m_pBaseVar( pBaseVar ),

 		m_nSplitScreenSlot( nSplitScreenSlot )

 	{

 		for ( int i = 0; i < pBaseVar->GetChangeCallbackCount(); ++i )

 		{

 			InstallChangeCallback( pBaseVar->GetChangeCallback( i ), false );

 		}

 		Assert( nSplitScreenSlot >= 1 );

 		Assert( nSplitScreenSlot < MAX_SPLITSCREEN_CLIENTS );

 		Assert( m_pBaseVar );

 		Assert( IsFlagSet( FCVAR_SS_ADDED ) );

 		Assert( !IsFlagSet( FCVAR_SS ) );

 	}

 	const ConVar *GetBaseVar() const;

 	virtual const char *GetBaseName() const;

 	void SetSplitScreenPlayerSlot( int nSlot );

 	virtual int GetSplitScreenPlayerSlot() const;

 protected:

 	const ConVar	*m_pBaseVar;

 	int		m_nSplitScreenSlot;

 };

 FORCEINLINE_CVAR const ConVar *CSplitScreenAddedConVar::GetBaseVar() const 

 { 

 	Assert( m_pBaseVar );

 	return m_pBaseVar; 

 }

 FORCEINLINE_CVAR const char *CSplitScreenAddedConVar::GetBaseName() const 

 { 

 	Assert( m_pBaseVar );

 	return m_pBaseVar->GetName(); 

 }

 FORCEINLINE_CVAR void CSplitScreenAddedConVar::SetSplitScreenPlayerSlot( int nSlot ) 

 { 

 	m_nSplitScreenSlot = nSlot; 

 }

 FORCEINLINE_CVAR int CSplitScreenAddedConVar::GetSplitScreenPlayerSlot() const 

 { 

 	return m_nSplitScreenSlot; 

 }

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

 // Used to read/write convars that already exist (replaces the FindVar method)

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

 class ConVarRef

 {

 public:

 	ConVarRef( const char *pName );

 	ConVarRef( const char *pName, bool bIgnoreMissing );

 	ConVarRef( IConVar *pConVar );

 	void Init( const char *pName, bool bIgnoreMissing );

 	bool IsValid() const;

 	bool IsFlagSet( int nFlags ) const;

 	IConVar *GetLinkedConVar();

 	// Get/Set value

 	float GetFloat( void ) const;

 	int GetInt( void ) const;

 	Color GetColor( void ) const;

 	bool GetBool() const { return !!GetInt(); }

 	const char *GetString( void ) const;

 	void SetValue( const char *pValue );

 	void SetValue( float flValue );

 	void SetValue( int nValue );

 	void SetValue( Color value );

 	void SetValue( bool bValue );

 	const char *GetName() const;

 	const char *GetDefault() const;

 	const char *GetBaseName() const;

 	int	GetSplitScreenPlayerSlot() const;

 private:

 	// High-speed method to read convar data

 	IConVar *m_pConVar;

 	ConVar *m_pConVarState;

 };

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

 // Did we find an existing convar of that name?

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

 FORCEINLINE_CVAR bool ConVarRef::IsFlagSet( int nFlags ) const

 {

 	return ( m_pConVar->IsFlagSet( nFlags ) != 0 );

 }

 FORCEINLINE_CVAR IConVar *ConVarRef::GetLinkedConVar()

 {

 	return m_pConVar;

 }

 FORCEINLINE_CVAR const char *ConVarRef::GetName() const

 {

 	return m_pConVar->GetName();

 }

 FORCEINLINE_CVAR const char *ConVarRef::GetBaseName() const

 {

 	return m_pConVar->GetBaseName();

 }

 FORCEINLINE_CVAR int ConVarRef::GetSplitScreenPlayerSlot() const

 {

 	return m_pConVar->GetSplitScreenPlayerSlot();

 }

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

 // Purpose: Return ConVar value as a float

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

 FORCEINLINE_CVAR float ConVarRef::GetFloat( void ) const

 {

 	return m_pConVarState->m_Value.m_fValue;

 }

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

 // Purpose: Return ConVar value as an int

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

 FORCEINLINE_CVAR int ConVarRef::GetInt( void ) const 

 {

 	return m_pConVarState->m_Value.m_nValue;

 }

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

 // Purpose: Return ConVar value as a color

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

 FORCEINLINE_CVAR Color ConVarRef::GetColor( void ) const 

 {

 	return m_pConVarState->GetColor();

 }

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

 // Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.

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

 FORCEINLINE_CVAR const char *ConVarRef::GetString( void ) const 

 {

 	Assert( !IsFlagSet( FCVAR_NEVER_AS_STRING ) );

 	return m_pConVarState->m_Value.m_pszString;

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( const char *pValue )

 {

 	m_pConVar->SetValue( pValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( float flValue )

 {

 	m_pConVar->SetValue( flValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( int nValue )

 {

 	m_pConVar->SetValue( nValue );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( Color value )

 {

 	m_pConVar->SetValue( value );

 }

 FORCEINLINE_CVAR void ConVarRef::SetValue( bool bValue )

 {

 	m_pConVar->SetValue( bValue ? 1 : 0 );

 }

 FORCEINLINE_CVAR const char *ConVarRef::GetDefault() const

 {

 	return m_pConVarState->m_pszDefaultValue;

 }

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

 // Helper for referencing splitscreen convars (i.e., "name" and "name2")

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

 class SplitScreenConVarRef

 {

 public:

 	SplitScreenConVarRef( const char *pName );

 	SplitScreenConVarRef( const char *pName, bool bIgnoreMissing );

 	SplitScreenConVarRef( IConVar *pConVar );

 	void Init( const char *pName, bool bIgnoreMissing );

 	bool IsValid() const;

 	bool IsFlagSet( int nFlags ) const;

 	// Get/Set value

 	float GetFloat( int nSlot ) const;

 	int GetInt( int nSlot ) const;

 	Color GetColor( int nSlot ) const;

 	bool GetBool( int nSlot ) const { return !!GetInt( nSlot ); }

 	const char *GetString( int nSlot  ) const;

 	void SetValue( int nSlot, const char *pValue );

 	void SetValue( int nSlot, float flValue );

 	void SetValue( int nSlot, int nValue );

 	void SetValue( int nSlot, Color value );

 	void SetValue( int nSlot, bool bValue );

 	const char *GetName( int nSlot ) const;

 	const char *GetDefault() const;

 	const char *GetBaseName() const;

 private:

 	struct cv_t

 	{

 		IConVar *m_pConVar;

 		ConVar *m_pConVarState;

 	};

 	cv_t	m_Info[ MAX_SPLITSCREEN_CLIENTS ];

 };

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

 // Did we find an existing convar of that name?

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

 FORCEINLINE_CVAR bool SplitScreenConVarRef::IsFlagSet( int nFlags ) const

 {

 	return ( m_Info[ 0 ].m_pConVar->IsFlagSet( nFlags ) != 0 );

 }

 FORCEINLINE_CVAR const char *SplitScreenConVarRef::GetName( int nSlot ) const

 {

 	return m_Info[ nSlot ].m_pConVar->GetName();

 }

 FORCEINLINE_CVAR const char *SplitScreenConVarRef::GetBaseName() const

 {

 	return m_Info[ 0 ].m_pConVar->GetBaseName();

 }

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

 // Purpose: Return ConVar value as a float

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

 FORCEINLINE_CVAR float SplitScreenConVarRef::GetFloat( int nSlot ) const

 {

 	return m_Info[ nSlot ].m_pConVarState->m_Value.m_fValue;

 }

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

 // Purpose: Return ConVar value as an int

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

 FORCEINLINE_CVAR int SplitScreenConVarRef::GetInt( int nSlot ) const 

 {

 	return m_Info[ nSlot ].m_pConVarState->m_Value.m_nValue;

 }

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

 // Purpose: Return ConVar value as an int

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

 FORCEINLINE_CVAR Color SplitScreenConVarRef::GetColor( int nSlot ) const 

 {

 	return m_Info[ nSlot ].m_pConVarState->GetColor();

 }

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

 // Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.

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

 FORCEINLINE_CVAR const char *SplitScreenConVarRef::GetString( int nSlot ) const 

 {

 	Assert( !IsFlagSet( FCVAR_NEVER_AS_STRING ) );

 	return m_Info[ nSlot ].m_pConVarState->m_Value.m_pszString;

 }

 FORCEINLINE_CVAR void SplitScreenConVarRef::SetValue( int nSlot, const char *pValue )

 {

 	m_Info[ nSlot ].m_pConVar->SetValue( pValue );

 }

 FORCEINLINE_CVAR void SplitScreenConVarRef::SetValue( int nSlot, float flValue )

 {

 	m_Info[ nSlot ].m_pConVar->SetValue( flValue );

 }

 FORCEINLINE_CVAR void SplitScreenConVarRef::SetValue( int nSlot, int nValue )

 {

 	m_Info[ nSlot ].m_pConVar->SetValue( nValue );