diff options
Diffstat (limited to 'mp/src/public/tier1/convar.h')
| -rw-r--r-- | mp/src/public/tier1/convar.h | 672 |
1 files changed, 672 insertions, 0 deletions
diff --git a/mp/src/public/tier1/convar.h b/mp/src/public/tier1/convar.h new file mode 100644 index 00000000..7cf21f53 --- /dev/null +++ b/mp/src/public/tier1/convar.h @@ -0,0 +1,672 @@ +//========= Copyright 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 "icvar.h"
+
+#ifdef _WIN32
+#define FORCEINLINE_CVAR FORCEINLINE
+#elif POSIX
+#define FORCEINLINE_CVAR inline
+#else
+#error "implement me"
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+class ConVar;
+class CCommand;
+class ConCommand;
+class ConCommandBase;
+struct characterset_t;
+
+
+
+//-----------------------------------------------------------------------------
+// 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 ) && !defined( _RETAIL )
+void ConVar_PublishToVXConsole();
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Called when a ConCommand needs to execute
+//-----------------------------------------------------------------------------
+typedef void ( *FnCommandCallbackV1_t )( void );
+typedef void ( *FnCommandCallback_t )( 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 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 );
+
+ // 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;
+};
+
+
+//-----------------------------------------------------------------------------
+// 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 );
+
+ 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 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;
+ };
+
+ union
+ {
+ FnCommandCompletionCallback m_fnCompletionCallback;
+ ICommandCompletionCallback *m_pCommandCompletionCallback;
+ };
+
+ bool m_bHasCompletionCallback : 1;
+ bool m_bUsingNewCommandCallback : 1;
+ bool m_bUsingCommandCallbackInterface : 1;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A console variable
+//-----------------------------------------------------------------------------
+class ConVar : public ConCommandBase, public IConVar
+{
+friend class CCvar;
+friend class ConVarRef;
+
+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;
+ virtual void AddFlags( int flags );
+ virtual bool IsCommand( void ) const;
+
+ // Install a change callback (there shouldn't already be one....)
+ void InstallChangeCallback( FnChangeCallback_t callback );
+
+ // Retrieve value
+ FORCEINLINE_CVAR float GetFloat( void ) const;
+ FORCEINLINE_CVAR int GetInt( void ) const;
+ FORCEINLINE_CVAR bool GetBool() const { return !!GetInt(); }
+ FORCEINLINE_CVAR char const *GetString( void ) 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 );
+
+ // Reset to default value
+ void Revert( void );
+
+ // True if it has a min/max setting
+ bool GetMin( float& minVal ) const;
+ bool GetMax( float& maxVal ) const;
+ const char *GetDefault( void ) const;
+ void SetDefault( const char *pszDefault );
+
+private:
+ // 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 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();
+ int GetFlags() { return m_pParent->m_nFlags; }
+private:
+
+ // 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;
+
+ // Value
+ // Dynamically allocated
+ char *m_pszString;
+ int m_StringLength;
+
+ // Values
+ float m_fValue;
+ int m_nValue;
+
+ // Min/Max values
+ bool m_bHasMin;
+ float m_fMinVal;
+ bool m_bHasMax;
+ float m_fMaxVal;
+
+ // Call this function when ConVar changes
+ FnChangeCallback_t m_fnChangeCallback;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return ConVar value as a float
+// Output : float
+//-----------------------------------------------------------------------------
+FORCEINLINE_CVAR float ConVar::GetFloat( void ) const
+{
+ return m_pParent->m_fValue;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return ConVar value as an int
+// Output : int
+//-----------------------------------------------------------------------------
+FORCEINLINE_CVAR int ConVar::GetInt( void ) const
+{
+ return m_pParent->m_nValue;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.
+// Output : const char *
+//-----------------------------------------------------------------------------
+FORCEINLINE_CVAR const char *ConVar::GetString( void ) const
+{
+ if ( m_nFlags & FCVAR_NEVER_AS_STRING )
+ return "FCVAR_NEVER_AS_STRING";
+
+ return ( m_pParent->m_pszString ) ? m_pParent->m_pszString : "";
+}
+
+
+//-----------------------------------------------------------------------------
+// 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;
+ 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( bool bValue );
+
+ const char *GetName() const;
+
+ const char *GetDefault() 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();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return ConVar value as a float
+//-----------------------------------------------------------------------------
+FORCEINLINE_CVAR float ConVarRef::GetFloat( void ) const
+{
+ return m_pConVarState->m_fValue;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return ConVar value as an int
+//-----------------------------------------------------------------------------
+FORCEINLINE_CVAR int ConVarRef::GetInt( void ) const
+{
+ return m_pConVarState->m_nValue;
+}
+
+//-----------------------------------------------------------------------------
+// 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_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( bool bValue )
+{
+ m_pConVar->SetValue( bValue ? 1 : 0 );
+}
+
+FORCEINLINE_CVAR const char *ConVarRef::GetDefault() const
+{
+ return m_pConVarState->m_pszDefaultValue;
+}
+
+
+//-----------------------------------------------------------------------------
+// Called by the framework to register ConCommands with the ICVar
+//-----------------------------------------------------------------------------
+void ConVar_Register( int nCVarFlag = 0, IConCommandBaseAccessor *pAccessor = NULL );
+void ConVar_Unregister( );
+
+
+//-----------------------------------------------------------------------------
+// Utility methods
+//-----------------------------------------------------------------------------
+void ConVar_PrintFlags( const ConCommandBase *var );
+void ConVar_PrintDescription( const ConCommandBase *pVar );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Utility class to quickly allow ConCommands to call member methods
+//-----------------------------------------------------------------------------
+#pragma warning (disable : 4355 )
+
+template< class T >
+class CConCommandMemberAccessor : public ConCommand, public ICommandCallback, public ICommandCompletionCallback
+{
+ typedef ConCommand BaseClass;
+ typedef void ( T::*FnMemberCommandCallback_t )( const CCommand &command );
+ typedef int ( T::*FnMemberCommandCompletionCallback_t )( const char *pPartial, CUtlVector< CUtlString > &commands );
+
+public:
+ CConCommandMemberAccessor( T* pOwner, const char *pName, FnMemberCommandCallback_t callback, const char *pHelpString = 0,
+ int flags = 0, FnMemberCommandCompletionCallback_t completionFunc = 0 ) :
+ BaseClass( pName, this, pHelpString, flags, ( completionFunc != 0 ) ? this : NULL )
+ {
+ m_pOwner = pOwner;
+ m_Func = callback;
+ m_CompletionFunc = completionFunc;
+ }
+
+ ~CConCommandMemberAccessor()
+ {
+ Shutdown();
+ }
+
+ void SetOwner( T* pOwner )
+ {
+ m_pOwner = pOwner;
+ }
+
+ virtual void CommandCallback( const CCommand &command )
+ {
+ Assert( m_pOwner && m_Func );
+ (m_pOwner->*m_Func)( command );
+ }
+
+ virtual int CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands )
+ {
+ Assert( m_pOwner && m_CompletionFunc );
+ return (m_pOwner->*m_CompletionFunc)( pPartial, commands );
+ }
+
+private:
+ T* m_pOwner;
+ FnMemberCommandCallback_t m_Func;
+ FnMemberCommandCompletionCallback_t m_CompletionFunc;
+};
+
+#pragma warning ( default : 4355 )
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Utility macros to quicky generate a simple console command
+//-----------------------------------------------------------------------------
+#define CON_COMMAND( name, description ) \
+ static void name( const CCommand &args ); \
+ static ConCommand name##_command( #name, name, description ); \
+ static void name( const CCommand &args )
+
+#define CON_COMMAND_F( name, description, flags ) \
+ static void name( const CCommand &args ); \
+ static ConCommand name##_command( #name, name, description, flags ); \
+ static void name( const CCommand &args )
+
+#define CON_COMMAND_F_COMPLETION( name, description, flags, completion ) \
+ static void name( const CCommand &args ); \
+ static ConCommand name##_command( #name, name, description, flags, completion ); \
+ static void name( const CCommand &args )
+
+#define CON_COMMAND_EXTERN( name, _funcname, description ) \
+ void _funcname( const CCommand &args ); \
+ static ConCommand name##_command( #name, _funcname, description ); \
+ void _funcname( const CCommand &args )
+
+#define CON_COMMAND_EXTERN_F( name, _funcname, description, flags ) \
+ void _funcname( const CCommand &args ); \
+ static ConCommand name##_command( #name, _funcname, description, flags ); \
+ void _funcname( const CCommand &args )
+
+#define CON_COMMAND_MEMBER_F( _thisclass, name, _funcname, description, flags ) \
+ void _funcname( const CCommand &args ); \
+ friend class CCommandMemberInitializer_##_funcname; \
+ class CCommandMemberInitializer_##_funcname \
+ { \
+ public: \
+ CCommandMemberInitializer_##_funcname() : m_ConCommandAccessor( NULL, name, &_thisclass::_funcname, description, flags ) \
+ { \
+ m_ConCommandAccessor.SetOwner( GET_OUTER( _thisclass, m_##_funcname##_register ) ); \
+ } \
+ private: \
+ CConCommandMemberAccessor< _thisclass > m_ConCommandAccessor; \
+ }; \
+ \
+ CCommandMemberInitializer_##_funcname m_##_funcname##_register; \
+
+
+#endif // CONVAR_H
|