1522 lines
39 KiB
C++
1522 lines
39 KiB
C++
//===== Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ======//
|
||
//
|
||
// Purpose:
|
||
//
|
||
// $NoKeywords: $
|
||
//
|
||
//===========================================================================//
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include "basetypes.h"
|
||
#include "tier1/convar.h"
|
||
#include "tier1/strtools.h"
|
||
#include "tier1/characterset.h"
|
||
#include "tier1/utlbuffer.h"
|
||
#include "tier1/tier1.h"
|
||
#include "tier1/convar_serverbounded.h"
|
||
#include "icvar.h"
|
||
#include "tier0/dbg.h"
|
||
#if defined( _X360 )
|
||
#include "xbox/xbox_console.h"
|
||
#endif
|
||
#include "tier0/memdbgon.h"
|
||
|
||
|
||
// Comment this out when we release.
|
||
//#define ALLOW_DEVELOPMENT_CVARS
|
||
// This enables the l4d style of culling all cvars that are not marked FCVAR_RELEASE :
|
||
// #define CULL_ALL_CVARS_NOT_FCVAR_RELEASE
|
||
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Statically constructed list of ConCommandBases,
|
||
// used for registering them with the ICVar interface
|
||
//-----------------------------------------------------------------------------
|
||
ConCommandBase *ConCommandBase::s_pConCommandBases = NULL;
|
||
IConCommandBaseAccessor *ConCommandBase::s_pAccessor = NULL;
|
||
static int s_nCVarFlag = 0;
|
||
static int s_nDLLIdentifier = -1; // A unique identifier indicating which DLL this convar came from
|
||
static bool s_bRegistered = false;
|
||
|
||
class CDefaultAccessor : public IConCommandBaseAccessor
|
||
{
|
||
public:
|
||
virtual bool RegisterConCommandBase( ConCommandBase *pVar )
|
||
{
|
||
// Link to engine's list instead
|
||
g_pCVar->RegisterConCommand( pVar );
|
||
return true;
|
||
}
|
||
};
|
||
|
||
static CDefaultAccessor s_DefaultAccessor;
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Called by the framework to register ConCommandBases with the ICVar
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor )
|
||
{
|
||
if ( !g_pCVar || s_bRegistered )
|
||
return;
|
||
|
||
Assert( s_nDLLIdentifier < 0 );
|
||
s_bRegistered = true;
|
||
s_nCVarFlag = nCVarFlag;
|
||
s_nDLLIdentifier = g_pCVar->AllocateDLLIdentifier();
|
||
|
||
ConCommandBase *pCur, *pNext;
|
||
|
||
ConCommandBase::s_pAccessor = pAccessor ? pAccessor : &s_DefaultAccessor;
|
||
pCur = ConCommandBase::s_pConCommandBases;
|
||
while ( pCur )
|
||
{
|
||
pNext = pCur->m_pNext;
|
||
pCur->AddFlags( s_nCVarFlag );
|
||
pCur->Init();
|
||
pCur = pNext;
|
||
}
|
||
|
||
g_pCVar->AddSplitScreenConVars();
|
||
g_pCVar->ProcessQueuedMaterialThreadConVarSets();
|
||
|
||
ConCommandBase::s_pConCommandBases = NULL;
|
||
}
|
||
|
||
void ConVar_Unregister( )
|
||
{
|
||
if ( !g_pCVar || !s_bRegistered )
|
||
return;
|
||
|
||
Assert( s_nDLLIdentifier >= 0 );
|
||
|
||
// Do this after unregister!!!
|
||
g_pCVar->RemoveSplitScreenConVars( s_nDLLIdentifier );
|
||
g_pCVar->UnregisterConCommands( s_nDLLIdentifier );
|
||
s_nDLLIdentifier = -1;
|
||
s_bRegistered = false;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Default constructor
|
||
//-----------------------------------------------------------------------------
|
||
ConCommandBase::ConCommandBase( void )
|
||
{
|
||
m_bRegistered = false;
|
||
m_pszName = NULL;
|
||
m_pszHelpString = NULL;
|
||
|
||
m_nFlags = 0;
|
||
m_pNext = NULL;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: The base console invoked command/cvar interface
|
||
// Input : *pName - name of variable/command
|
||
// *pHelpString - help text
|
||
// flags - flags
|
||
//-----------------------------------------------------------------------------
|
||
ConCommandBase::ConCommandBase( const char *pName, const char *pHelpString /*=0*/, int flags /*= 0*/ )
|
||
{
|
||
Create( pName, pHelpString, flags );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
ConCommandBase::~ConCommandBase( void )
|
||
{
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool ConCommandBase::IsCommand( void ) const
|
||
{
|
||
// Assert( 0 ); This can't assert. . causes a recursive assert in Sys_Printf, etc.
|
||
return true;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Returns the DLL identifier
|
||
//-----------------------------------------------------------------------------
|
||
CVarDLLIdentifier_t ConCommandBase::GetDLLIdentifier() const
|
||
{
|
||
return s_nDLLIdentifier;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *pName -
|
||
// callback -
|
||
// *pHelpString -
|
||
// flags -
|
||
//-----------------------------------------------------------------------------
|
||
void ConCommandBase::Create( const char *pName, const char *pHelpString /*= 0*/, int flags /*= 0*/ )
|
||
{
|
||
static char *empty_string = "";
|
||
|
||
m_bRegistered = false;
|
||
|
||
// Name should be static data
|
||
Assert( pName );
|
||
m_pszName = pName;
|
||
m_pszHelpString = pHelpString ? pHelpString : empty_string;
|
||
|
||
m_nFlags = flags;
|
||
|
||
#ifdef ALLOW_DEVELOPMENT_CVARS
|
||
m_nFlags &= ~FCVAR_DEVELOPMENTONLY;
|
||
#endif
|
||
|
||
if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
|
||
{
|
||
m_pNext = s_pConCommandBases;
|
||
s_pConCommandBases = this;
|
||
}
|
||
else
|
||
{
|
||
// It's unregistered
|
||
m_pNext = NULL;
|
||
}
|
||
|
||
// If s_pAccessor is already set (this ConVar is not a global variable),
|
||
// register it.
|
||
if ( s_pAccessor )
|
||
{
|
||
Init();
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Used internally by OneTimeInit to initialize.
|
||
//-----------------------------------------------------------------------------
|
||
void ConCommandBase::Init()
|
||
{
|
||
if ( s_pAccessor )
|
||
{
|
||
s_pAccessor->RegisterConCommandBase( this );
|
||
}
|
||
}
|
||
|
||
void ConCommandBase::Shutdown()
|
||
{
|
||
if ( g_pCVar )
|
||
{
|
||
g_pCVar->UnregisterConCommand( this );
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Return name of the command/var
|
||
// Output : const char
|
||
//-----------------------------------------------------------------------------
|
||
const char *ConCommandBase::GetName( void ) const
|
||
{
|
||
return m_pszName;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : flag -
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool ConCommandBase::IsFlagSet( int flag ) const
|
||
{
|
||
return ( flag & m_nFlags ) ? true : false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : flags -
|
||
//-----------------------------------------------------------------------------
|
||
void ConCommandBase::AddFlags( int flags )
|
||
{
|
||
m_nFlags |= flags;
|
||
|
||
#ifdef ALLOW_DEVELOPMENT_CVARS
|
||
m_nFlags &= ~FCVAR_DEVELOPMENTONLY;
|
||
#endif
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: removes specified flags
|
||
//-----------------------------------------------------------------------------
|
||
void ConCommandBase::RemoveFlags( int flags )
|
||
{
|
||
m_nFlags &= ~flags;
|
||
}
|
||
|
||
// Returns current flags
|
||
int ConCommandBase::GetFlags() const
|
||
{
|
||
return m_nFlags;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : const ConCommandBase
|
||
//-----------------------------------------------------------------------------
|
||
const ConCommandBase *ConCommandBase::GetNext( void ) const
|
||
{
|
||
return m_pNext;
|
||
}
|
||
|
||
ConCommandBase *ConCommandBase::GetNext( void )
|
||
{
|
||
return m_pNext;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Copies string using local new/delete operators
|
||
// Input : *from -
|
||
// Output : char
|
||
//-----------------------------------------------------------------------------
|
||
char *ConCommandBase::CopyString( const char *from )
|
||
{
|
||
int len;
|
||
char *to;
|
||
|
||
len = strlen( from );
|
||
if ( len <= 0 )
|
||
{
|
||
to = new char[1];
|
||
to[0] = 0;
|
||
}
|
||
else
|
||
{
|
||
to = new char[len+1];
|
||
V_strncpy( to, from, len+1 );
|
||
}
|
||
return to;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : const char
|
||
//-----------------------------------------------------------------------------
|
||
const char *ConCommandBase::GetHelpText( void ) const
|
||
{
|
||
return m_pszHelpString;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Has this cvar been registered
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool ConCommandBase::IsRegistered( void ) const
|
||
{
|
||
return m_bRegistered;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
//
|
||
// Con Commands start here
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Global methods
|
||
//-----------------------------------------------------------------------------
|
||
static characterset_t s_BreakSet;
|
||
static bool s_bBuiltBreakSet = false;
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Tokenizer class
|
||
//-----------------------------------------------------------------------------
|
||
CCommand::CCommand()
|
||
{
|
||
if ( !s_bBuiltBreakSet )
|
||
{
|
||
s_bBuiltBreakSet = true;
|
||
CharacterSetBuild( &s_BreakSet, "{}()':" );
|
||
}
|
||
|
||
Reset();
|
||
}
|
||
|
||
CCommand::CCommand( int nArgC, const char **ppArgV )
|
||
{
|
||
Assert( nArgC > 0 );
|
||
|
||
if ( !s_bBuiltBreakSet )
|
||
{
|
||
s_bBuiltBreakSet = true;
|
||
CharacterSetBuild( &s_BreakSet, "{}()':" );
|
||
}
|
||
|
||
Reset();
|
||
|
||
char *pBuf = m_pArgvBuffer;
|
||
char *pSBuf = m_pArgSBuffer;
|
||
m_nArgc = nArgC;
|
||
for ( int i = 0; i < nArgC; ++i )
|
||
{
|
||
m_ppArgv[i] = pBuf;
|
||
int nLen = V_strlen( ppArgV[i] );
|
||
memcpy( pBuf, ppArgV[i], nLen+1 );
|
||
if ( i == 0 )
|
||
{
|
||
m_nArgv0Size = nLen;
|
||
}
|
||
pBuf += nLen+1;
|
||
|
||
bool bContainsSpace = strchr( ppArgV[i], ' ' ) != NULL;
|
||
if ( bContainsSpace )
|
||
{
|
||
*pSBuf++ = '\"';
|
||
}
|
||
memcpy( pSBuf, ppArgV[i], nLen );
|
||
pSBuf += nLen;
|
||
if ( bContainsSpace )
|
||
{
|
||
*pSBuf++ = '\"';
|
||
}
|
||
|
||
if ( i != nArgC - 1 )
|
||
{
|
||
*pSBuf++ = ' ';
|
||
}
|
||
}
|
||
}
|
||
|
||
void CCommand::Reset()
|
||
{
|
||
m_nArgc = 0;
|
||
m_nArgv0Size = 0;
|
||
m_pArgSBuffer[0] = 0;
|
||
}
|
||
|
||
characterset_t* CCommand::DefaultBreakSet()
|
||
{
|
||
return &s_BreakSet;
|
||
}
|
||
|
||
bool CCommand::Tokenize( const char *pCommand, characterset_t *pBreakSet )
|
||
{
|
||
Reset();
|
||
if ( !pCommand )
|
||
return false;
|
||
|
||
// Use default break set
|
||
if ( !pBreakSet )
|
||
{
|
||
pBreakSet = &s_BreakSet;
|
||
}
|
||
|
||
// Copy the current command into a temp buffer
|
||
// NOTE: This is here to avoid the pointers returned by DequeueNextCommand
|
||
// to become invalid by calling AddText. Is there a way we can avoid the memcpy?
|
||
int nLen = V_strlen( pCommand );
|
||
if ( nLen >= COMMAND_MAX_LENGTH - 1 )
|
||
{
|
||
Warning( "CCommand::Tokenize: Encountered command which overflows the tokenizer buffer.. Skipping!\n" );
|
||
return false;
|
||
}
|
||
|
||
memcpy( m_pArgSBuffer, pCommand, nLen + 1 );
|
||
|
||
// Parse the current command into the current command buffer
|
||
CUtlBuffer bufParse( m_pArgSBuffer, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
|
||
int nArgvBufferSize = 0;
|
||
while ( bufParse.IsValid() && ( m_nArgc < COMMAND_MAX_ARGC ) )
|
||
{
|
||
char *pArgvBuf = &m_pArgvBuffer[nArgvBufferSize];
|
||
int nMaxLen = COMMAND_MAX_LENGTH - nArgvBufferSize;
|
||
int nStartGet = bufParse.TellGet();
|
||
int nSize = bufParse.ParseToken( pBreakSet, pArgvBuf, nMaxLen );
|
||
if ( nSize < 0 )
|
||
break;
|
||
|
||
// Check for overflow condition
|
||
if ( nMaxLen == nSize )
|
||
{
|
||
Reset();
|
||
return false;
|
||
}
|
||
|
||
if ( m_nArgc == 1 )
|
||
{
|
||
// Deal with the case where the arguments were quoted
|
||
m_nArgv0Size = bufParse.TellGet();
|
||
bool bFoundEndQuote = m_pArgSBuffer[m_nArgv0Size-1] == '\"';
|
||
if ( bFoundEndQuote )
|
||
{
|
||
--m_nArgv0Size;
|
||
}
|
||
m_nArgv0Size -= nSize;
|
||
Assert( m_nArgv0Size != 0 );
|
||
|
||
// The StartGet check is to handle this case: "foo"bar
|
||
// which will parse into 2 different args. ArgS should point to bar.
|
||
bool bFoundStartQuote = ( m_nArgv0Size > nStartGet ) && ( m_pArgSBuffer[m_nArgv0Size-1] == '\"' );
|
||
Assert( bFoundEndQuote == bFoundStartQuote );
|
||
if ( bFoundStartQuote )
|
||
{
|
||
--m_nArgv0Size;
|
||
}
|
||
}
|
||
|
||
m_ppArgv[ m_nArgc++ ] = pArgvBuf;
|
||
if( m_nArgc >= COMMAND_MAX_ARGC )
|
||
{
|
||
Warning( "CCommand::Tokenize: Encountered command which overflows the argument buffer.. Clamped!\n" );
|
||
}
|
||
|
||
nArgvBufferSize += nSize + 1;
|
||
Assert( nArgvBufferSize <= COMMAND_MAX_LENGTH );
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Helper function to parse arguments to commands.
|
||
//-----------------------------------------------------------------------------
|
||
const char* CCommand::FindArg( const char *pName ) const
|
||
{
|
||
int nArgC = ArgC();
|
||
for ( int i = 1; i < nArgC; i++ )
|
||
{
|
||
if ( !V_stricmp( Arg(i), pName ) )
|
||
return (i+1) < nArgC ? Arg( i+1 ) : "";
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int CCommand::FindArgInt( const char *pName, int nDefaultVal ) const
|
||
{
|
||
const char *pVal = FindArg( pName );
|
||
if ( pVal )
|
||
return atoi( pVal );
|
||
else
|
||
return nDefaultVal;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Default console command autocompletion function
|
||
//-----------------------------------------------------------------------------
|
||
int DefaultCompletionFunc( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Constructs a console command
|
||
//-----------------------------------------------------------------------------
|
||
//ConCommand::ConCommand()
|
||
//{
|
||
// m_bIsNewConCommand = true;
|
||
//}
|
||
|
||
ConCommand::ConCommand( const char *pName, FnCommandCallbackV1_t callback, const char *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
|
||
{
|
||
// Set the callback
|
||
m_fnCommandCallbackV1 = callback;
|
||
m_bUsingNewCommandCallback = false;
|
||
m_bUsingCommandCallbackInterface = false;
|
||
m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
|
||
m_bHasCompletionCallback = completionFunc != 0 ? true : false;
|
||
|
||
// Setup the rest
|
||
BaseClass::Create( pName, pHelpString, flags );
|
||
}
|
||
|
||
ConCommand::ConCommand( const char *pName, FnCommandCallback_t callback, const char *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
|
||
{
|
||
// Set the callback
|
||
m_fnCommandCallback = callback;
|
||
m_bUsingNewCommandCallback = true;
|
||
m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
|
||
m_bHasCompletionCallback = completionFunc != 0 ? true : false;
|
||
m_bUsingCommandCallbackInterface = false;
|
||
|
||
// Setup the rest
|
||
BaseClass::Create( pName, pHelpString, flags );
|
||
}
|
||
|
||
ConCommand::ConCommand( const char *pName, ICommandCallback *pCallback, const char *pHelpString /*= 0*/, int flags /*= 0*/, ICommandCompletionCallback *pCompletionCallback /*= 0*/ )
|
||
{
|
||
// Set the callback
|
||
m_pCommandCallback = pCallback;
|
||
m_bUsingNewCommandCallback = false;
|
||
m_pCommandCompletionCallback = pCompletionCallback;
|
||
m_bHasCompletionCallback = ( pCompletionCallback != 0 );
|
||
m_bUsingCommandCallbackInterface = true;
|
||
|
||
// Setup the rest
|
||
BaseClass::Create( pName, pHelpString, flags );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Destructor
|
||
//-----------------------------------------------------------------------------
|
||
ConCommand::~ConCommand( void )
|
||
{
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Returns true if this is a command
|
||
//-----------------------------------------------------------------------------
|
||
bool ConCommand::IsCommand( void ) const
|
||
{
|
||
return true;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Invoke the function if there is one
|
||
//-----------------------------------------------------------------------------
|
||
void ConCommand::Dispatch( const CCommand &command )
|
||
{
|
||
if ( m_bUsingNewCommandCallback )
|
||
{
|
||
if ( m_fnCommandCallback )
|
||
{
|
||
( *m_fnCommandCallback )( command );
|
||
return;
|
||
}
|
||
}
|
||
else if ( m_bUsingCommandCallbackInterface )
|
||
{
|
||
if ( m_pCommandCallback )
|
||
{
|
||
m_pCommandCallback->CommandCallback( command );
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ( m_fnCommandCallbackV1 )
|
||
{
|
||
( *m_fnCommandCallbackV1 )();
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Command without callback!!!
|
||
AssertMsg1( 0, "Encountered ConCommand '%s' without a callback!\n", GetName() );
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Calls the autocompletion method to get autocompletion suggestions
|
||
//-----------------------------------------------------------------------------
|
||
int ConCommand::AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands )
|
||
{
|
||
if ( m_bUsingCommandCallbackInterface )
|
||
{
|
||
if ( !m_pCommandCompletionCallback )
|
||
return 0;
|
||
return m_pCommandCompletionCallback->CommandCompletionCallback( partial, commands );
|
||
}
|
||
|
||
Assert( m_fnCompletionCallback );
|
||
if ( !m_fnCompletionCallback )
|
||
return 0;
|
||
|
||
char rgpchCommands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ];
|
||
int iret = ( m_fnCompletionCallback )( partial, rgpchCommands );
|
||
for ( int i = 0 ; i < iret; ++i )
|
||
{
|
||
CUtlString str = rgpchCommands[ i ];
|
||
commands.AddToTail( str );
|
||
}
|
||
return iret;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Returns true if the console command can autocomplete
|
||
//-----------------------------------------------------------------------------
|
||
bool ConCommand::CanAutoComplete( void )
|
||
{
|
||
return m_bHasCompletionCallback;
|
||
}
|
||
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
//
|
||
// Console Variables
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Various constructors
|
||
//-----------------------------------------------------------------------------
|
||
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags /* = 0 */ )
|
||
{
|
||
Create( pName, pDefaultValue, flags );
|
||
}
|
||
|
||
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags, const char *pHelpString )
|
||
{
|
||
Create( pName, pDefaultValue, flags, pHelpString );
|
||
}
|
||
|
||
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags, const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
|
||
{
|
||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
|
||
}
|
||
|
||
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags, const char *pHelpString, FnChangeCallback_t callback )
|
||
{
|
||
Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
|
||
}
|
||
|
||
ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags, const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback_t callback )
|
||
{
|
||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Destructor
|
||
//-----------------------------------------------------------------------------
|
||
ConVar::~ConVar( void )
|
||
{
|
||
if ( m_Value.m_pszString )
|
||
{
|
||
delete[] m_Value.m_pszString;
|
||
m_Value.m_pszString = NULL;
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Install a change callback (there shouldn't already be one....)
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::InstallChangeCallback( FnChangeCallback_t callback, bool bInvoke /*=true*/ )
|
||
{
|
||
if ( !callback )
|
||
{
|
||
Warning( "InstallChangeCallback called with NULL callback, ignoring!!!\n" );
|
||
return;
|
||
}
|
||
|
||
if ( m_pParent->m_fnChangeCallbacks.Find( callback ) != m_pParent->m_fnChangeCallbacks.InvalidIndex() )
|
||
{
|
||
// Same ptr added twice, sigh...
|
||
Warning( "InstallChangeCallback ignoring duplicate change callback!!!\n" );
|
||
return;
|
||
}
|
||
|
||
m_pParent->m_fnChangeCallbacks.AddToTail( callback );
|
||
|
||
// Call it immediately to set the initial value...
|
||
if ( bInvoke )
|
||
{
|
||
callback( this, m_Value.m_pszString, m_Value.m_fValue );
|
||
}
|
||
}
|
||
|
||
void ConVar::RemoveChangeCallback( FnChangeCallback_t callback )
|
||
{
|
||
m_pParent->m_fnChangeCallbacks.FindAndRemove( callback );
|
||
}
|
||
|
||
bool ConVar::IsFlagSet( int flag ) const
|
||
{
|
||
return ( flag & m_pParent->m_nFlags ) ? true : false;
|
||
}
|
||
|
||
int ConVar::GetFlags() const
|
||
{
|
||
return m_pParent->m_nFlags;
|
||
}
|
||
|
||
const char *ConVar::GetHelpText( void ) const
|
||
{
|
||
return m_pParent->m_pszHelpString;
|
||
}
|
||
|
||
void ConVar::AddFlags( int flags )
|
||
{
|
||
m_pParent->m_nFlags |= flags;
|
||
|
||
#ifdef ALLOW_DEVELOPMENT_CVARS
|
||
m_pParent->m_nFlags &= ~FCVAR_DEVELOPMENTONLY;
|
||
#endif
|
||
}
|
||
|
||
bool ConVar::IsRegistered( void ) const
|
||
{
|
||
return m_pParent->m_bRegistered;
|
||
}
|
||
|
||
const char *ConVar::GetName( void ) const
|
||
{
|
||
return m_pParent->m_pszName;
|
||
}
|
||
|
||
const char *ConVar::GetBaseName( void ) const
|
||
{
|
||
return m_pParent->m_pszName;
|
||
}
|
||
|
||
int ConVar::GetSplitScreenPlayerSlot( void ) const
|
||
{
|
||
// Default implementation (certain FCVAR_USERINFO derive a new type of convar and set this)
|
||
return 0;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool ConVar::IsCommand( void ) const
|
||
{
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input :
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::Init()
|
||
{
|
||
BaseClass::Init();
|
||
}
|
||
|
||
bool ConVar::InternalSetColorFromString( const char *value )
|
||
{
|
||
bool bColor = false;
|
||
|
||
// Try pulling RGBA color values out of the string
|
||
int nRGBA[4];
|
||
int nParamsRead = sscanf( value, "%i %i %i %i", &(nRGBA[0]), &(nRGBA[1]), &(nRGBA[2]), &(nRGBA[3]) );
|
||
|
||
if ( nParamsRead >= 3 )
|
||
{
|
||
// This is probably a color!
|
||
if ( nParamsRead == 3 )
|
||
{
|
||
// Assume they wanted full alpha
|
||
nRGBA[3] = 255;
|
||
}
|
||
|
||
if ( nRGBA[0] >= 0 && nRGBA[0] <= 255 &&
|
||
nRGBA[1] >= 0 && nRGBA[1] <= 255 &&
|
||
nRGBA[2] >= 0 && nRGBA[2] <= 255 &&
|
||
nRGBA[3] >= 0 && nRGBA[3] <= 255 )
|
||
{
|
||
// This is definitely a color!
|
||
bColor = true;
|
||
|
||
// Stuff all the values into each byte of our int
|
||
unsigned char *pColorElement = ((unsigned char*)&m_Value.m_nValue);
|
||
pColorElement[0] = nRGBA[0];
|
||
pColorElement[1] = nRGBA[1];
|
||
pColorElement[2] = nRGBA[2];
|
||
pColorElement[3] = nRGBA[3];
|
||
|
||
// Copy that value into a float (even though this has little meaning)
|
||
m_Value.m_fValue = ( float )( m_Value.m_nValue );
|
||
}
|
||
}
|
||
|
||
return bColor;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::InternalSetValue( const char *value )
|
||
{
|
||
if ( IsFlagSet( FCVAR_MATERIAL_THREAD_MASK ) )
|
||
{
|
||
if ( g_pCVar && !g_pCVar->IsMaterialThreadSetAllowed() )
|
||
{
|
||
g_pCVar->QueueMaterialThreadSetValue( this, value );
|
||
return;
|
||
}
|
||
}
|
||
|
||
char tempVal[ 32 ];
|
||
char *val;
|
||
|
||
Assert(m_pParent == this); // Only valid for root convars.
|
||
|
||
float flOldValue = m_Value.m_fValue;
|
||
val = (char *)value;
|
||
if ( !val )
|
||
val = "";
|
||
|
||
if ( !InternalSetColorFromString( value ) )
|
||
{
|
||
// Not a color, do the standard thing
|
||
float fNewValue = ( float )atof( value );
|
||
if ( !IsFinite( fNewValue ) )
|
||
{
|
||
Warning( "Warning: %s = '%s' is infinite, clamping value.\n", GetName(), value );
|
||
fNewValue = FLT_MAX;
|
||
}
|
||
|
||
if ( ClampValue( fNewValue ) )
|
||
{
|
||
V_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
|
||
val = tempVal;
|
||
}
|
||
|
||
// Redetermine value
|
||
m_Value.m_fValue = fNewValue;
|
||
m_Value.m_nValue = ( int )( m_Value.m_fValue );
|
||
}
|
||
|
||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||
{
|
||
ChangeStringValue( val, flOldValue );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *tempVal -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::ChangeStringValue( const char *tempVal, float flOldValue )
|
||
{
|
||
Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
|
||
|
||
char* pszOldValue = (char*)stackalloc( m_Value.m_StringLength );
|
||
memcpy( pszOldValue, m_Value.m_pszString, m_Value.m_StringLength );
|
||
|
||
int len = V_strlen(tempVal) + 1;
|
||
|
||
if ( len > m_Value.m_StringLength)
|
||
{
|
||
if (m_Value.m_pszString)
|
||
{
|
||
delete[] m_Value.m_pszString;
|
||
}
|
||
|
||
m_Value.m_pszString = new char[len];
|
||
m_Value.m_StringLength = len;
|
||
}
|
||
|
||
memcpy( m_Value.m_pszString, tempVal, len );
|
||
|
||
// Invoke any necessary callback function
|
||
for ( int i = 0; i < m_fnChangeCallbacks.Count(); ++i )
|
||
{
|
||
m_fnChangeCallbacks[ i ]( this, pszOldValue, flOldValue );
|
||
}
|
||
|
||
if ( g_pCVar )
|
||
{
|
||
g_pCVar->CallGlobalChangeCallbacks( this, pszOldValue, flOldValue );
|
||
}
|
||
|
||
stackfree( pszOldValue );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Check whether to clamp and then perform clamp
|
||
// Input : value -
|
||
// Output : Returns true if value changed
|
||
//-----------------------------------------------------------------------------
|
||
bool ConVar::ClampValue( float& value )
|
||
{
|
||
if ( m_bHasMin && ( value < m_fMinVal ) )
|
||
{
|
||
value = m_fMinVal;
|
||
return true;
|
||
}
|
||
|
||
if ( m_bHasMax && ( value > m_fMaxVal ) )
|
||
{
|
||
value = m_fMaxVal;
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::InternalSetFloatValue( float fNewValue )
|
||
{
|
||
if ( fNewValue == m_Value.m_fValue )
|
||
return;
|
||
|
||
if ( IsFlagSet( FCVAR_MATERIAL_THREAD_MASK ) )
|
||
{
|
||
if ( g_pCVar && !g_pCVar->IsMaterialThreadSetAllowed() )
|
||
{
|
||
g_pCVar->QueueMaterialThreadSetValue( this, fNewValue );
|
||
return;
|
||
}
|
||
}
|
||
|
||
Assert( m_pParent == this ); // Only valid for root convars.
|
||
|
||
// Check bounds
|
||
ClampValue( fNewValue );
|
||
|
||
// Redetermine value
|
||
float flOldValue = m_Value.m_fValue;
|
||
m_Value.m_fValue = fNewValue;
|
||
m_Value.m_nValue = ( int )m_Value.m_fValue;
|
||
|
||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||
{
|
||
char tempVal[ 32 ];
|
||
V_snprintf( tempVal, sizeof( tempVal), "%f", m_Value.m_fValue );
|
||
ChangeStringValue( tempVal, flOldValue );
|
||
}
|
||
else
|
||
{
|
||
Assert( m_fnChangeCallbacks.Count() == 0 );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::InternalSetIntValue( int nValue )
|
||
{
|
||
if ( nValue == m_Value.m_nValue )
|
||
return;
|
||
|
||
if ( IsFlagSet( FCVAR_MATERIAL_THREAD_MASK ) )
|
||
{
|
||
if ( g_pCVar && !g_pCVar->IsMaterialThreadSetAllowed() )
|
||
{
|
||
g_pCVar->QueueMaterialThreadSetValue( this, nValue );
|
||
return;
|
||
}
|
||
}
|
||
|
||
Assert( m_pParent == this ); // Only valid for root convars.
|
||
|
||
float fValue = (float)nValue;
|
||
if ( ClampValue( fValue ) )
|
||
{
|
||
nValue = ( int )( fValue );
|
||
}
|
||
|
||
// Redetermine value
|
||
float flOldValue = m_Value.m_fValue;
|
||
m_Value.m_fValue = fValue;
|
||
m_Value.m_nValue = nValue;
|
||
|
||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||
{
|
||
char tempVal[ 32 ];
|
||
V_snprintf( tempVal, sizeof( tempVal ), "%d", m_Value.m_nValue );
|
||
ChangeStringValue( tempVal, flOldValue );
|
||
}
|
||
else
|
||
{
|
||
Assert( m_fnChangeCallbacks.Count() == 0 );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::InternalSetColorValue( Color value )
|
||
{
|
||
// Stuff color values into an int
|
||
int nValue;
|
||
|
||
unsigned char *pColorElement = ((unsigned char*)&nValue);
|
||
pColorElement[0] = value[0];
|
||
pColorElement[1] = value[1];
|
||
pColorElement[2] = value[2];
|
||
pColorElement[3] = value[3];
|
||
|
||
// Call the int internal set
|
||
InternalSetIntValue( nValue );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Private creation
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::Create( const char *pName, const char *pDefaultValue, int flags /*= 0*/,
|
||
const char *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
|
||
bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback_t callback /*= NULL*/ )
|
||
{
|
||
static char *empty_string = "";
|
||
|
||
m_pParent = this;
|
||
|
||
// Name should be static data
|
||
m_pszDefaultValue = pDefaultValue ? pDefaultValue : empty_string;
|
||
Assert( m_pszDefaultValue );
|
||
|
||
m_bHasMin = bMin;
|
||
m_fMinVal = fMin;
|
||
m_bHasMax = bMax;
|
||
m_fMaxVal = fMax;
|
||
|
||
if ( callback )
|
||
{
|
||
m_fnChangeCallbacks.AddToTail( callback );
|
||
}
|
||
|
||
m_Value.m_StringLength = strlen( m_pszDefaultValue ) + 1;
|
||
m_Value.m_pszString = new char[m_Value.m_StringLength];
|
||
memcpy( m_Value.m_pszString, m_pszDefaultValue, m_Value.m_StringLength );
|
||
|
||
if ( !InternalSetColorFromString( m_Value.m_pszString ) )
|
||
{
|
||
m_Value.m_fValue = ( float )atof( m_Value.m_pszString );
|
||
if ( !IsFinite( m_Value.m_fValue ) )
|
||
{
|
||
Warning( "ConVar(%s) defined with infinite float value (%s)\n", pName, m_Value.m_pszString );
|
||
m_Value.m_fValue = FLT_MAX;
|
||
Assert( 0 );
|
||
}
|
||
|
||
// Bounds Check, should never happen, if it does, no big deal
|
||
if ( m_bHasMin && ( m_Value.m_fValue < m_fMinVal ) )
|
||
{
|
||
Assert( 0 );
|
||
}
|
||
|
||
if ( m_bHasMax && ( m_Value.m_fValue > m_fMaxVal ) )
|
||
{
|
||
Assert( 0 );
|
||
}
|
||
|
||
m_Value.m_nValue = ( int )m_Value.m_fValue;
|
||
}
|
||
|
||
//If we're not tagged as cheat, archive or release then hide us.
|
||
#if CULL_ALL_CVARS_NOT_FCVAR_RELEASE
|
||
// FIXMEL4DTOMAINMERGE: will need to assess if this hides too many convars for TF and other projects in main
|
||
if ( !( flags & ( FCVAR_CHEAT | FCVAR_ARCHIVE | FCVAR_RELEASE | FCVAR_USERINFO ) ) )
|
||
{
|
||
flags |= FCVAR_DEVELOPMENTONLY;
|
||
}
|
||
#else
|
||
|
||
#endif
|
||
|
||
|
||
BaseClass::Create( pName, pHelpString, flags );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::SetValue(const char *value)
|
||
{
|
||
ConVar *var = ( ConVar * )m_pParent;
|
||
var->InternalSetValue( value );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::SetValue( float value )
|
||
{
|
||
ConVar *var = ( ConVar * )m_pParent;
|
||
var->InternalSetFloatValue( value );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::SetValue( int value )
|
||
{
|
||
ConVar *var = ( ConVar * )m_pParent;
|
||
var->InternalSetIntValue( value );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : value -
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::SetValue( Color value )
|
||
{
|
||
ConVar *var = ( ConVar * )m_pParent;
|
||
var->InternalSetColorValue( value );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Reset to default value
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar::Revert( void )
|
||
{
|
||
// Force default value again
|
||
ConVar *var = ( ConVar * )m_pParent;
|
||
var->SetValue( var->m_pszDefaultValue );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : minVal -
|
||
// Output : true if there is a min set
|
||
//-----------------------------------------------------------------------------
|
||
bool ConVar::GetMin( float& minVal ) const
|
||
{
|
||
minVal = m_pParent->m_fMinVal;
|
||
return m_pParent->m_bHasMin;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : maxVal -
|
||
//-----------------------------------------------------------------------------
|
||
bool ConVar::GetMax( float& maxVal ) const
|
||
{
|
||
maxVal = m_pParent->m_fMaxVal;
|
||
return m_pParent->m_bHasMax;
|
||
}
|
||
|
||
float ConVar::GetMinValue() const
|
||
{
|
||
return m_pParent->m_fMinVal;
|
||
}
|
||
|
||
float ConVar::GetMaxValue() const
|
||
{
|
||
return m_pParent->m_fMaxVal;;
|
||
}
|
||
|
||
bool ConVar::HasMin() const
|
||
{
|
||
return m_pParent->m_bHasMin;
|
||
}
|
||
|
||
bool ConVar::HasMax() const
|
||
{
|
||
return m_pParent->m_bHasMax;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : const char
|
||
//-----------------------------------------------------------------------------
|
||
const char *ConVar::GetDefault( void ) const
|
||
{
|
||
return m_pParent->m_pszDefaultValue;
|
||
}
|
||
|
||
void ConVar::SetDefault( const char *pszDefault )
|
||
{
|
||
static char *empty_string = "";
|
||
m_pszDefaultValue = pszDefault ? pszDefault : empty_string;
|
||
Assert( m_pszDefaultValue );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// This version is simply used to make reading convars simpler.
|
||
// Writing convars isn't allowed in this mode
|
||
//-----------------------------------------------------------------------------
|
||
class CEmptyConVar : public ConVar
|
||
{
|
||
public:
|
||
CEmptyConVar() : ConVar( "", "0" ) {}
|
||
// Used for optimal read access
|
||
virtual void SetValue( const char *pValue ) {}
|
||
virtual void SetValue( float flValue ) {}
|
||
virtual void SetValue( int nValue ) {}
|
||
virtual const char *GetName( void ) const { return ""; }
|
||
virtual bool IsFlagSet( int nFlags ) const { return false; }
|
||
};
|
||
|
||
static CEmptyConVar s_EmptyConVar;
|
||
|
||
ConVarRef::ConVarRef( const char *pName )
|
||
{
|
||
Init( pName, false );
|
||
}
|
||
|
||
ConVarRef::ConVarRef( const char *pName, bool bIgnoreMissing )
|
||
{
|
||
Init( pName, bIgnoreMissing );
|
||
}
|
||
|
||
void ConVarRef::Init( const char *pName, bool bIgnoreMissing )
|
||
{
|
||
m_pConVar = g_pCVar ? g_pCVar->FindVar( pName ) : &s_EmptyConVar;
|
||
if ( !m_pConVar )
|
||
{
|
||
m_pConVar = &s_EmptyConVar;
|
||
}
|
||
m_pConVarState = static_cast< ConVar * >( m_pConVar );
|
||
if( !IsValid() )
|
||
{
|
||
static bool bFirst = true;
|
||
if ( g_pCVar || bFirst )
|
||
{
|
||
if ( !bIgnoreMissing )
|
||
{
|
||
Warning( "ConVarRef %s doesn't point to an existing ConVar\n", pName );
|
||
}
|
||
bFirst = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
ConVarRef::ConVarRef( IConVar *pConVar )
|
||
{
|
||
m_pConVar = pConVar ? pConVar : &s_EmptyConVar;
|
||
m_pConVarState = static_cast< ConVar * >( m_pConVar );
|
||
}
|
||
|
||
bool ConVarRef::IsValid() const
|
||
{
|
||
return m_pConVar != &s_EmptyConVar;
|
||
}
|
||
|
||
// Helper for splitscreen ConVars
|
||
SplitScreenConVarRef::SplitScreenConVarRef( const char *pName )
|
||
{
|
||
Init( pName, false );
|
||
}
|
||
|
||
SplitScreenConVarRef::SplitScreenConVarRef( const char *pName, bool bIgnoreMissing )
|
||
{
|
||
Init( pName, bIgnoreMissing );
|
||
}
|
||
|
||
void SplitScreenConVarRef::Init( const char *pName, bool bIgnoreMissing )
|
||
{
|
||
for ( int i = 0; i < MAX_SPLITSCREEN_CLIENTS; ++i )
|
||
{
|
||
cv_t &info = m_Info[ i ];
|
||
char pchName[ 256 ];
|
||
if ( i != 0 )
|
||
{
|
||
V_snprintf( pchName, sizeof( pchName ), "%s%d", pName, i + 1 );
|
||
}
|
||
else
|
||
{
|
||
V_strncpy( pchName, pName, sizeof( pchName ) );
|
||
}
|
||
|
||
info.m_pConVar = g_pCVar ? g_pCVar->FindVar( pchName ) : &s_EmptyConVar;
|
||
if ( !info.m_pConVar )
|
||
{
|
||
info.m_pConVar = &s_EmptyConVar;
|
||
if ( i > 0 )
|
||
{
|
||
// Point at slot zero instead, in case we got in here with a non FCVAR_SS var...
|
||
info.m_pConVar = m_Info[ 0 ].m_pConVar;
|
||
}
|
||
}
|
||
info.m_pConVarState = static_cast< ConVar * >( info.m_pConVar );
|
||
}
|
||
|
||
if ( !IsValid() )
|
||
{
|
||
static bool bFirst = true;
|
||
if ( g_pCVar || bFirst )
|
||
{
|
||
if ( !bIgnoreMissing )
|
||
{
|
||
Warning( "ConVarRef %s doesn't point to an existing ConVar\n", pName );
|
||
}
|
||
bFirst = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
SplitScreenConVarRef::SplitScreenConVarRef( IConVar *pConVar )
|
||
{
|
||
cv_t &info = m_Info[ 0 ];
|
||
info.m_pConVar = pConVar ? pConVar : &s_EmptyConVar;
|
||
info.m_pConVarState = static_cast< ConVar * >( info.m_pConVar );
|
||
|
||
for ( int i = 1; i < MAX_SPLITSCREEN_CLIENTS; ++i )
|
||
{
|
||
info = m_Info[ i ];
|
||
char pchName[ 256 ];
|
||
V_snprintf( pchName, sizeof( pchName ), "%s%d", pConVar->GetName(), i + 1 );
|
||
|
||
info.m_pConVar = g_pCVar ? g_pCVar->FindVar( pchName ) : &s_EmptyConVar;
|
||
if ( !info.m_pConVar )
|
||
{
|
||
info.m_pConVar = &s_EmptyConVar;
|
||
if ( i > 0 )
|
||
{
|
||
// Point at slot zero instead, in case we got in here with a non FCVAR_SS var...
|
||
info.m_pConVar = m_Info[ 0 ].m_pConVar;
|
||
}
|
||
}
|
||
info.m_pConVarState = static_cast< ConVar * >( info.m_pConVar );
|
||
}
|
||
}
|
||
|
||
bool SplitScreenConVarRef::IsValid() const
|
||
{
|
||
return m_Info[ 0 ].m_pConVar != &s_EmptyConVar;
|
||
}
|
||
|
||
struct PrintConVarFlags_t
|
||
{
|
||
int flag;
|
||
const char *desc;
|
||
};
|
||
|
||
static PrintConVarFlags_t g_PrintConVarFlags[] =
|
||
{
|
||
{ FCVAR_GAMEDLL, "game" },
|
||
{ FCVAR_CLIENTDLL, "client" },
|
||
{ FCVAR_ARCHIVE, "archive" },
|
||
{ FCVAR_NOTIFY, "notify" },
|
||
{ FCVAR_SPONLY, "singleplayer" },
|
||
{ FCVAR_NOT_CONNECTED, "notconnected" },
|
||
{ FCVAR_CHEAT, "cheat" },
|
||
{ FCVAR_REPLICATED, "replicated" },
|
||
{ FCVAR_SERVER_CAN_EXECUTE, "server_can_execute" },
|
||
{ FCVAR_CLIENTCMD_CAN_EXECUTE, "clientcmd_can_execute" },
|
||
{ FCVAR_USERINFO, "user" },
|
||
{ FCVAR_SS, "ss" },
|
||
{ FCVAR_SS_ADDED, "ss_added" },
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar_AppendFlags( const ConCommandBase *var, char *buf, size_t bufsize )
|
||
{
|
||
for ( int i = 0; i < ARRAYSIZE( g_PrintConVarFlags ) ; ++i )
|
||
{
|
||
const PrintConVarFlags_t &info = g_PrintConVarFlags[ i ];
|
||
if ( var->IsFlagSet( info.flag ) )
|
||
{
|
||
char append[ 128 ];
|
||
V_snprintf( append, sizeof( append ), " %s", info.desc );
|
||
V_strncat( buf, append, bufsize, COPY_ALL_CHARACTERS );
|
||
}
|
||
}
|
||
}
|
||
|
||
static void AppendPrintf( char *buf, size_t bufsize, char const *fmt, ... )
|
||
{
|
||
char scratch[ 1024 ];
|
||
va_list argptr;
|
||
va_start( argptr, fmt );
|
||
_vsnprintf( scratch, sizeof( scratch ) - 1, fmt, argptr );
|
||
va_end( argptr );
|
||
scratch[ sizeof( scratch ) - 1 ] = 0;
|
||
|
||
V_strncat( buf, scratch, bufsize, COPY_ALL_CHARACTERS );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void ConVar_PrintDescription( const ConCommandBase *pVar )
|
||
{
|
||
bool bMin, bMax;
|
||
float fMin, fMax;
|
||
const char *pStr;
|
||
|
||
Assert( pVar );
|
||
|
||
Color clr;
|
||
clr.SetColor( 255, 100, 100, 255 );
|
||
|
||
char outstr[ 4096 ];
|
||
outstr[ 0 ] = 0;
|
||
|
||
if ( !pVar->IsCommand() )
|
||
{
|
||
ConVar *var = ( ConVar * )pVar;
|
||
const ConVar_ServerBounded *pBounded = dynamic_cast<const ConVar_ServerBounded*>( var );
|
||
|
||
bMin = var->GetMin( fMin );
|
||
bMax = var->GetMax( fMax );
|
||
|
||
const char *value = NULL;
|
||
char tempVal[ 32 ];
|
||
|
||
if ( pBounded || var->IsFlagSet( FCVAR_NEVER_AS_STRING ) )
|
||
{
|
||
value = tempVal;
|
||
|
||
int intVal = pBounded ? pBounded->GetInt() : var->GetInt();
|
||
float floatVal = pBounded ? pBounded->GetFloat() : var->GetFloat();
|
||
|
||
if ( fabs( (float)intVal - floatVal ) < 0.000001 )
|
||
{
|
||
V_snprintf( tempVal, sizeof( tempVal ), "%d", intVal );
|
||
}
|
||
else
|
||
{
|
||
V_snprintf( tempVal, sizeof( tempVal ), "%f", floatVal );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
value = var->GetString();
|
||
}
|
||
|
||
if ( value )
|
||
{
|
||
AppendPrintf( outstr, sizeof( outstr ), "\"%s\" = \"%s\"", var->GetName(), value );
|
||
|
||
if ( V_stricmp( value, var->GetDefault() ) )
|
||
{
|
||
AppendPrintf( outstr, sizeof( outstr ), " ( def. \"%s\" )", var->GetDefault() );
|
||
}
|
||
}
|
||
|
||
if ( bMin )
|
||
{
|
||
AppendPrintf( outstr, sizeof( outstr ), " min. %f", fMin );
|
||
}
|
||
if ( bMax )
|
||
{
|
||
AppendPrintf( outstr, sizeof( outstr ), " max. %f", fMax );
|
||
}
|
||
|
||
// Handle virtualized cvars.
|
||
if ( pBounded && fabs( pBounded->GetFloat() - var->GetFloat() ) > 0.0001f )
|
||
{
|
||
AppendPrintf( outstr, sizeof( outstr ), " [%.3f server clamped to %.3f]",
|
||
var->GetFloat(), pBounded->GetFloat() );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ConCommand *var = ( ConCommand * )pVar;
|
||
|
||
AppendPrintf( outstr, sizeof( outstr ), "\"%s\" ", var->GetName() );
|
||
}
|
||
|
||
ConVar_AppendFlags( pVar, outstr, sizeof( outstr ) );
|
||
|
||
pStr = pVar->GetHelpText();
|
||
if ( pStr && *pStr )
|
||
{
|
||
ConMsg( "%-80s - %.80s\n", outstr, pStr );
|
||
}
|
||
else
|
||
{
|
||
ConMsg( "%-80s\n", outstr );
|
||
}
|
||
}
|