628 lines
23 KiB
C++
628 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#ifndef CONVAR_H
|
|
#define CONVAR_H
|
|
|
|
#if _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "../icvar.h"
|
|
#include "../tier0/dbg.h"
|
|
#include "iconvar.h"
|
|
#include "utlstring.h"
|
|
#include "utlvector.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 (*FnCommandCallbackVoid_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 CreateBase(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, FnCommandCallbackVoid_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 {
|
|
FnCommandCallbackVoid_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
|