mirror of
https://github.com/alliedmodders/metamod-source.git
synced 2024-11-29 11:24:19 +01:00
Oh forgot to delete these due to new makefiles :o
--HG-- extra : convert_revision : svn%3Ac2935e3e-5518-0410-8daf-afa5dab7d4e3/trunk%40270
This commit is contained in:
Scott Ehlert
parent
3d7ae5c6ed
commit
7c00ee3424
1029
sourcemm/convar.cpp
1029
sourcemm/convar.cpp
@ -1,1029 +0,0 @@
|
||||
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//
|
||||
//=============================================================================//
|
||||
|
||||
#ifdef _XBOX
|
||||
#include "xbox/xbox_platform.h"
|
||||
#include "xbox/xbox_win32stubs.h"
|
||||
#include "xbox/xbox_core.h"
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "basetypes.h"
|
||||
#include "convar.h"
|
||||
#include "vstdlib/strtools.h"
|
||||
#include "icvar.h"
|
||||
#include "tier0/dbg.h"
|
||||
#ifdef _XBOX
|
||||
#include "vstdlib/ICommandLine.h"
|
||||
#endif
|
||||
#include "tier0/memdbgon.h"
|
||||
|
||||
ConCommandBase *ConCommandBase::s_pConCommandBases = NULL;
|
||||
IConCommandBaseAccessor *ConCommandBase::s_pAccessor = NULL;
|
||||
|
||||
#ifdef _XBOX
|
||||
static char const* GetCommandLineValue( char const *pVariableName )
|
||||
{
|
||||
int nLen = Q_strlen(pVariableName);
|
||||
char *pSearch = (char*)stackalloc(nLen + 2);
|
||||
pSearch[0] = '+';
|
||||
memcpy(&pSearch[1], pVariableName, nLen + 1);
|
||||
return CommandLine()->ParmValue(pSearch);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined( _XBOX ) && !defined( _RETAIL )
|
||||
void ConCommandBaseMgr::PublishCommands( bool bForce )
|
||||
{
|
||||
ConCommandBase *pCur;
|
||||
const char *commands[2048];
|
||||
const char *helptext[2048];
|
||||
int numCommands = 0;
|
||||
|
||||
if ( bForce )
|
||||
{
|
||||
for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
|
||||
{
|
||||
pCur->m_bRegistered = false;
|
||||
}
|
||||
}
|
||||
|
||||
// iterate and publish commands to the remote console
|
||||
for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
|
||||
{
|
||||
if ( !pCur->m_bRegistered )
|
||||
{
|
||||
// add unregistered commands to list
|
||||
if ( numCommands < sizeof(commands)/sizeof(commands[0]) )
|
||||
{
|
||||
commands[numCommands] = pCur->m_pszName;
|
||||
helptext[numCommands] = pCur->m_pszHelpString;
|
||||
numCommands++;
|
||||
}
|
||||
|
||||
// mark as registered
|
||||
pCur->m_bRegistered = true;
|
||||
}
|
||||
}
|
||||
if ( numCommands )
|
||||
{
|
||||
XBX_rAddCommands( numCommands, commands, helptext );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef _XBOX
|
||||
bool ConCommandBaseMgr::Fixup(ConCommandBase* pConCommand)
|
||||
{
|
||||
ConCommandBase *pCur;
|
||||
ConCommandBase *pPrev2;
|
||||
ConCommandBase *pCur2;
|
||||
ConCommandBase *pNext2;
|
||||
const char *name;
|
||||
static int initCount = 0;
|
||||
|
||||
// xboxissue - cvars and its class hierarchy could not be made to instance per subsystem
|
||||
// without massive mangling and re-arranging, instead...
|
||||
// there is only a single chain and therefore single /init/fixup
|
||||
// missing: need to identify which subsystem
|
||||
// could pass as part of declaration in constructor, but how to hide parameter for pc
|
||||
// the accessors (aka callbacks to subsystems) to register with engine
|
||||
// cannot be invoked as their unlink logic expect private lists
|
||||
// so this just mimics the expected end result
|
||||
// must handle early and late constructors
|
||||
// late constructors are usually function scoped static
|
||||
if (!pConCommand)
|
||||
{
|
||||
// the caller is one-time-init
|
||||
if (++initCount > 1)
|
||||
{
|
||||
// the list has already been fixed
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// the caller is a console command constructor
|
||||
if (!initCount)
|
||||
{
|
||||
// the list has not been fixed yet
|
||||
// no special behavior
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
// the list has already been fixed
|
||||
// the console command is a late constructor
|
||||
// add in to fixed list
|
||||
bool hasParent = false;
|
||||
if (!pConCommand->IsCommand())
|
||||
{
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while (pCur)
|
||||
{
|
||||
if (pCur->IsCommand() && !stricmp(pCur->m_pszName, pConCommand->m_pszName))
|
||||
{
|
||||
// set its parent
|
||||
((ConVar*)pConCommand)->m_pParent = ((ConVar*)pCur)->m_pParent;
|
||||
hasParent = true;
|
||||
break;
|
||||
}
|
||||
pCur = pCur->m_pNext;
|
||||
}
|
||||
}
|
||||
if (!hasParent)
|
||||
{
|
||||
// add to head of list
|
||||
pConCommand->m_pNext = ConCommandBase::s_pConCommandBases;
|
||||
ConCommandBase::s_pConCommandBases = pConCommand;
|
||||
}
|
||||
else
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (initCount == 1)
|
||||
{
|
||||
// iterate the cvars and set their possible proxy parents
|
||||
// skip over registered (fixed) entries
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while (pCur)
|
||||
{
|
||||
if (!pCur->IsCommand() && !pCur->m_bRegistered)
|
||||
{
|
||||
// iterate from the next node until end of list
|
||||
name = pCur->m_pszName;
|
||||
pPrev2 = pCur;
|
||||
pCur2 = pCur->m_pNext;
|
||||
while (pCur2)
|
||||
{
|
||||
pNext2 = pCur2->m_pNext;
|
||||
if (!pCur2->IsCommand() && !stricmp(pCur2->m_pszName, name))
|
||||
{
|
||||
// found duplicate
|
||||
// unlink and fixup
|
||||
pCur2->m_pNext = NULL;
|
||||
pPrev2->m_pNext = pNext2;
|
||||
|
||||
// set its parent
|
||||
((ConVar*)pCur2)->m_pParent = ((ConVar*)pCur)->m_pParent;
|
||||
}
|
||||
else
|
||||
{
|
||||
// no unlink, advance to next node
|
||||
pPrev2 = pCur2;
|
||||
}
|
||||
|
||||
pCur2 = pNext2;
|
||||
}
|
||||
|
||||
char const *pValue = GetCommandLineValue(name);
|
||||
if (pValue)
|
||||
((ConVar*)pCur)->SetValue(pValue);
|
||||
}
|
||||
pCur = pCur->m_pNext;
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined( _RETAIL )
|
||||
XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Start" );
|
||||
|
||||
PublishCommands( false );
|
||||
|
||||
XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Done" );
|
||||
#endif
|
||||
|
||||
// fixup has been performed
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConCommandBaseMgr.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
|
||||
{
|
||||
#ifdef _XBOX
|
||||
// fixup the list
|
||||
ConCommandBaseMgr::Fixup(NULL);
|
||||
#else
|
||||
ConCommandBase *pCur, *pNext;
|
||||
|
||||
ConCommandBase::s_pAccessor = pAccessor;
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while ( pCur )
|
||||
{
|
||||
pNext = pCur->m_pNext;
|
||||
pCur->Init();
|
||||
pCur = pNext;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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( char const *pName, char const *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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *pName -
|
||||
// callback -
|
||||
// *pHelpString -
|
||||
// flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::Create( char const *pName, char const *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 _XBOX
|
||||
if (ConCommandBaseMgr::Fixup(this))
|
||||
return;
|
||||
#endif
|
||||
|
||||
if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
|
||||
{
|
||||
#ifndef _XBOX
|
||||
m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = this;
|
||||
#else
|
||||
// xboxissue - engine cvars should be at head of list to
|
||||
// ensure they are set as the cvar master/parent during fixup
|
||||
if (!s_pConCommandBases || !(flags & FCVAR_NON_ENGINE))
|
||||
{
|
||||
// engine cvars, place at head of list
|
||||
m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = this;
|
||||
}
|
||||
else
|
||||
{
|
||||
// non-engine cvars, place at end of list
|
||||
ConCommandBase *cur = s_pConCommandBases;
|
||||
while (1)
|
||||
{
|
||||
if (!cur->m_pNext)
|
||||
{
|
||||
cur->m_pNext = this;
|
||||
m_pNext = NULL;
|
||||
break;
|
||||
}
|
||||
cur = cur->m_pNext;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
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 )
|
||||
return;
|
||||
|
||||
if ( m_bRegistered )
|
||||
return;
|
||||
|
||||
s_pAccessor->RegisterConCommandBase( this );
|
||||
|
||||
m_bRegistered = true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *name -
|
||||
// Output : ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommandBase const *ConCommandBase::FindCommand( char const *name )
|
||||
{
|
||||
ConCommandBase const *cmd = GetCommands();
|
||||
for ( ; cmd; cmd = cmd->GetNext() )
|
||||
{
|
||||
if ( !stricmp( name, cmd->GetName() ) )
|
||||
return cmd;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
const ConCommandBase *ConCommandBase::GetCommands( void )
|
||||
{
|
||||
return s_pConCommandBases;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *var -
|
||||
// Output : static
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::AddToList( ConCommandBase *var )
|
||||
{
|
||||
// This routine is only valid on root ConCommandBases
|
||||
var->m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = var;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Return name of the command/var
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *ConCommandBase::GetName( void ) const
|
||||
{
|
||||
return m_pszName;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flag -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::RemoveFlaggedCommands( int flag )
|
||||
{
|
||||
ConCommandBase *pNewList;
|
||||
ConCommandBase *pCommand, *pNext;
|
||||
|
||||
pNewList = NULL;
|
||||
|
||||
pCommand = s_pConCommandBases;
|
||||
while ( pCommand )
|
||||
{
|
||||
pNext = pCommand->m_pNext;
|
||||
if ( !( pCommand->m_nFlags & flag ) )
|
||||
{
|
||||
pCommand->m_pNext = pNewList;
|
||||
pNewList = pCommand;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unlink
|
||||
pCommand->m_pNext = NULL;
|
||||
}
|
||||
|
||||
pCommand = pNext;
|
||||
}
|
||||
|
||||
s_pConCommandBases = pNewList;
|
||||
}
|
||||
|
||||
void ConCommandBase::RevertFlaggedCvars( int flag )
|
||||
{
|
||||
for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
|
||||
{
|
||||
if ( var->IsCommand() )
|
||||
continue;
|
||||
|
||||
ConVar *cvar = ( ConVar * )var;
|
||||
|
||||
if ( !cvar->IsBitSet( flag ) )
|
||||
continue;
|
||||
|
||||
// It's == to the default value, don't count
|
||||
if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
|
||||
continue;
|
||||
|
||||
cvar->Revert();
|
||||
|
||||
// DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flag -
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommandBase::IsBitSet( int flag ) const
|
||||
{
|
||||
return ( flag & m_nFlags ) ? true : false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::AddFlags( int flags )
|
||||
{
|
||||
m_nFlags |= flags;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : const ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
const ConCommandBase *ConCommandBase::GetNext( void ) const
|
||||
{
|
||||
return m_pNext;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *next -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::SetNext( ConCommandBase *next )
|
||||
{
|
||||
m_pNext = next;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Copies string using local new/delete operators
|
||||
// Input : *from -
|
||||
// Output : char
|
||||
//-----------------------------------------------------------------------------
|
||||
char *ConCommandBase::CopyString( char const *from )
|
||||
{
|
||||
int len;
|
||||
char *to;
|
||||
|
||||
len = strlen( from );
|
||||
if ( len <= 0 )
|
||||
{
|
||||
to = new char[1];
|
||||
to[0] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
to = new char[len+1];
|
||||
Q_strncpy( to, from, len+1 );
|
||||
}
|
||||
return to;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Constructs a console command
|
||||
// Input : *pName - name of command
|
||||
// callback - function to call upon execution
|
||||
// *pHelpString - help text for command
|
||||
// flags - command flags, if any
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
|
||||
{
|
||||
Create( pName, callback, pHelpString, flags, completionFunc );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommand::~ConCommand( void )
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommand::IsCommand( void ) const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Invoke the function if there is one
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommand::Dispatch( void )
|
||||
{
|
||||
if ( m_fnCommandCallback )
|
||||
{
|
||||
( *m_fnCommandCallback )();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Command without callback!!!
|
||||
Assert( 0 );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *partial -
|
||||
// context -
|
||||
// longest -
|
||||
// maxcommands -
|
||||
// **commands -
|
||||
// Output : int
|
||||
//-----------------------------------------------------------------------------
|
||||
int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Create the named command
|
||||
// Input : *pName -
|
||||
// callback -
|
||||
// *pHelpString -
|
||||
// flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
|
||||
{
|
||||
// Set the callback
|
||||
m_fnCommandCallback = callback;
|
||||
|
||||
m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
|
||||
m_bHasCompletionCallback = completionFunc != 0 ? true : false;
|
||||
|
||||
// Setup the rest
|
||||
BaseClass::Create( pName, pHelpString, flags );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *partial -
|
||||
// context -
|
||||
// longest -
|
||||
// maxcommands -
|
||||
// **commands -
|
||||
//-----------------------------------------------------------------------------
|
||||
int ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
|
||||
{
|
||||
Assert( m_fnCompletionCallback );
|
||||
if ( !m_fnCompletionCallback )
|
||||
return 0;
|
||||
|
||||
return ( m_fnCompletionCallback )( partial, commands );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommand::CanAutoComplete( void )
|
||||
{
|
||||
return m_bHasCompletionCallback;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Free dynamic memory
|
||||
//-----------------------------------------------------------------------------
|
||||
ConVar::~ConVar( void )
|
||||
{
|
||||
if ( m_pszString )
|
||||
{
|
||||
delete[] m_pszString;
|
||||
m_pszString = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Install a change callback (there shouldn't already be one....)
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void ConVar::InstallChangeCallback( FnChangeCallback callback )
|
||||
{
|
||||
Assert( !m_fnChangeCallback || !callback );
|
||||
m_fnChangeCallback = callback;
|
||||
|
||||
if (m_fnChangeCallback)
|
||||
{
|
||||
// Call it immediately to set the initial value...
|
||||
m_fnChangeCallback( this, m_pszString );
|
||||
}
|
||||
}
|
||||
|
||||
bool ConVar::IsBitSet( int flag ) const
|
||||
{
|
||||
return ( flag & m_pParent->m_nFlags ) ? true : false;
|
||||
}
|
||||
|
||||
char const *ConVar::GetHelpText( void ) const
|
||||
{
|
||||
return m_pParent->m_pszHelpString;
|
||||
}
|
||||
|
||||
void ConVar::AddFlags( int flags )
|
||||
{
|
||||
m_pParent->m_nFlags |= flags;
|
||||
}
|
||||
|
||||
bool ConVar::IsRegistered( void ) const
|
||||
{
|
||||
return m_pParent->m_bRegistered;
|
||||
}
|
||||
|
||||
char const *ConVar::GetName( void ) const
|
||||
{
|
||||
return m_pParent->m_pszName;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConVar::IsCommand( void ) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input :
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Init()
|
||||
{
|
||||
BaseClass::Init();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::InternalSetValue( char const *value )
|
||||
{
|
||||
float fNewValue;
|
||||
char tempVal[ 32 ];
|
||||
char *val;
|
||||
|
||||
Assert(m_pParent == this); // Only valid for root convars.
|
||||
|
||||
val = (char *)value;
|
||||
fNewValue = ( float )atof( value );
|
||||
|
||||
if ( ClampValue( fNewValue ) )
|
||||
{
|
||||
Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
|
||||
val = tempVal;
|
||||
}
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fNewValue;
|
||||
m_nValue = ( int )( m_fValue );
|
||||
|
||||
if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
|
||||
ChangeStringValue( val );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *tempVal -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::ChangeStringValue( char const *tempVal )
|
||||
{
|
||||
Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
|
||||
|
||||
char* pszOldValue = (char*)stackalloc( m_StringLength );
|
||||
memcpy( pszOldValue, m_pszString, m_StringLength );
|
||||
|
||||
int len = Q_strlen(tempVal) + 1;
|
||||
|
||||
if ( len > m_StringLength)
|
||||
{
|
||||
if (m_pszString)
|
||||
delete[] m_pszString;
|
||||
|
||||
m_pszString = new char[len];
|
||||
m_StringLength = len;
|
||||
}
|
||||
|
||||
memcpy( m_pszString, tempVal, len );
|
||||
|
||||
// Invoke any necessary callback function
|
||||
if ( m_fnChangeCallback )
|
||||
{
|
||||
m_fnChangeCallback( this, pszOldValue );
|
||||
}
|
||||
|
||||
GetCVarIF()->CallGlobalChangeCallback( this, pszOldValue );
|
||||
|
||||
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_fValue )
|
||||
return;
|
||||
|
||||
Assert( m_pParent == this ); // Only valid for root convars.
|
||||
|
||||
// Check bounds
|
||||
ClampValue( fNewValue );
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fNewValue;
|
||||
m_nValue = ( int )m_fValue;
|
||||
|
||||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||||
{
|
||||
char tempVal[ 32 ];
|
||||
Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
|
||||
ChangeStringValue( tempVal );
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert( !m_fnChangeCallback );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::InternalSetIntValue( int nValue )
|
||||
{
|
||||
if ( nValue == m_nValue )
|
||||
return;
|
||||
|
||||
Assert( m_pParent == this ); // Only valid for root convars.
|
||||
|
||||
float fValue = (float)nValue;
|
||||
if ( ClampValue( fValue ) )
|
||||
{
|
||||
nValue = ( int )( fValue );
|
||||
}
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fValue;
|
||||
m_nValue = nValue;
|
||||
|
||||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||||
{
|
||||
char tempVal[ 32 ];
|
||||
Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
|
||||
ChangeStringValue( tempVal );
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert( !m_fnChangeCallback );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Private creation
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
|
||||
char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
|
||||
bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
|
||||
{
|
||||
static char *empty_string = "";
|
||||
|
||||
m_pParent = this;
|
||||
|
||||
// Name should be static data
|
||||
m_pszDefaultValue = pDefaultValue ? pDefaultValue : empty_string;
|
||||
Assert( pDefaultValue );
|
||||
|
||||
m_StringLength = strlen( m_pszDefaultValue ) + 1;
|
||||
m_pszString = new char[m_StringLength];
|
||||
memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
|
||||
|
||||
m_bHasMin = bMin;
|
||||
m_fMinVal = fMin;
|
||||
m_bHasMax = bMax;
|
||||
m_fMaxVal = fMax;
|
||||
|
||||
m_fnChangeCallback = callback;
|
||||
|
||||
m_fValue = ( float )atof( m_pszString );
|
||||
|
||||
// Bounds Check, should never happen, if it does, no big deal
|
||||
if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
|
||||
{
|
||||
Assert( 0 );
|
||||
}
|
||||
|
||||
if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
|
||||
{
|
||||
Assert( 0 );
|
||||
}
|
||||
|
||||
m_nValue = ( int )m_fValue;
|
||||
|
||||
BaseClass::Create( pName, pHelpString, flags );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::SetValue(char const *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: Reset to default value
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Revert( void )
|
||||
{
|
||||
// Force default value again
|
||||
ConVar *var = ( ConVar * )m_pParent;
|
||||
var->SetValue( var->m_pszDefaultValue );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::RevertAll( void )
|
||||
{
|
||||
ConCommandBase *p = s_pConCommandBases;
|
||||
while ( p )
|
||||
{
|
||||
if ( !p->IsCommand() )
|
||||
{
|
||||
ConVar *var = ( ConVar * )p;
|
||||
var->Revert();
|
||||
}
|
||||
p = p->m_pNext;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *ConVar::GetDefault( void ) const
|
||||
{
|
||||
return m_pParent->m_pszDefaultValue;
|
||||
}
|
||||
|
||||
@ -1,1029 +0,0 @@
|
||||
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//
|
||||
//=============================================================================//
|
||||
|
||||
#ifdef _XBOX
|
||||
#include "xbox/xbox_platform.h"
|
||||
#include "xbox/xbox_win32stubs.h"
|
||||
#include "xbox/xbox_core.h"
|
||||
#endif
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "basetypes.h"
|
||||
#include "convar.h"
|
||||
#include "vstdlib/strtools.h"
|
||||
#include "icvar.h"
|
||||
#include "tier0/dbg.h"
|
||||
#ifdef _XBOX
|
||||
#include "vstdlib/ICommandLine.h"
|
||||
#endif
|
||||
#include "tier0/memdbgon.h"
|
||||
|
||||
ConCommandBase *ConCommandBase::s_pConCommandBases = NULL;
|
||||
IConCommandBaseAccessor *ConCommandBase::s_pAccessor = NULL;
|
||||
|
||||
#ifdef _XBOX
|
||||
static char const* GetCommandLineValue( char const *pVariableName )
|
||||
{
|
||||
int nLen = Q_strlen(pVariableName);
|
||||
char *pSearch = (char*)stackalloc(nLen + 2);
|
||||
pSearch[0] = '+';
|
||||
memcpy(&pSearch[1], pVariableName, nLen + 1);
|
||||
return CommandLine()->ParmValue(pSearch);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined( _XBOX ) && !defined( _RETAIL )
|
||||
void ConCommandBaseMgr::PublishCommands( bool bForce )
|
||||
{
|
||||
ConCommandBase *pCur;
|
||||
const char *commands[2048];
|
||||
const char *helptext[2048];
|
||||
int numCommands = 0;
|
||||
|
||||
if ( bForce )
|
||||
{
|
||||
for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
|
||||
{
|
||||
pCur->m_bRegistered = false;
|
||||
}
|
||||
}
|
||||
|
||||
// iterate and publish commands to the remote console
|
||||
for ( pCur=ConCommandBase::s_pConCommandBases; pCur; pCur=pCur->m_pNext )
|
||||
{
|
||||
if ( !pCur->m_bRegistered )
|
||||
{
|
||||
// add unregistered commands to list
|
||||
if ( numCommands < sizeof(commands)/sizeof(commands[0]) )
|
||||
{
|
||||
commands[numCommands] = pCur->m_pszName;
|
||||
helptext[numCommands] = pCur->m_pszHelpString;
|
||||
numCommands++;
|
||||
}
|
||||
|
||||
// mark as registered
|
||||
pCur->m_bRegistered = true;
|
||||
}
|
||||
}
|
||||
if ( numCommands )
|
||||
{
|
||||
XBX_rAddCommands( numCommands, commands, helptext );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef _XBOX
|
||||
bool ConCommandBaseMgr::Fixup(ConCommandBase* pConCommand)
|
||||
{
|
||||
ConCommandBase *pCur;
|
||||
ConCommandBase *pPrev2;
|
||||
ConCommandBase *pCur2;
|
||||
ConCommandBase *pNext2;
|
||||
const char *name;
|
||||
static int initCount = 0;
|
||||
|
||||
// xboxissue - cvars and its class hierarchy could not be made to instance per subsystem
|
||||
// without massive mangling and re-arranging, instead...
|
||||
// there is only a single chain and therefore single /init/fixup
|
||||
// missing: need to identify which subsystem
|
||||
// could pass as part of declaration in constructor, but how to hide parameter for pc
|
||||
// the accessors (aka callbacks to subsystems) to register with engine
|
||||
// cannot be invoked as their unlink logic expect private lists
|
||||
// so this just mimics the expected end result
|
||||
// must handle early and late constructors
|
||||
// late constructors are usually function scoped static
|
||||
if (!pConCommand)
|
||||
{
|
||||
// the caller is one-time-init
|
||||
if (++initCount > 1)
|
||||
{
|
||||
// the list has already been fixed
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// the caller is a console command constructor
|
||||
if (!initCount)
|
||||
{
|
||||
// the list has not been fixed yet
|
||||
// no special behavior
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
// the list has already been fixed
|
||||
// the console command is a late constructor
|
||||
// add in to fixed list
|
||||
bool hasParent = false;
|
||||
if (!pConCommand->IsCommand())
|
||||
{
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while (pCur)
|
||||
{
|
||||
if (pCur->IsCommand() && !stricmp(pCur->m_pszName, pConCommand->m_pszName))
|
||||
{
|
||||
// set its parent
|
||||
((ConVar*)pConCommand)->m_pParent = ((ConVar*)pCur)->m_pParent;
|
||||
hasParent = true;
|
||||
break;
|
||||
}
|
||||
pCur = pCur->m_pNext;
|
||||
}
|
||||
}
|
||||
if (!hasParent)
|
||||
{
|
||||
// add to head of list
|
||||
pConCommand->m_pNext = ConCommandBase::s_pConCommandBases;
|
||||
ConCommandBase::s_pConCommandBases = pConCommand;
|
||||
}
|
||||
else
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (initCount == 1)
|
||||
{
|
||||
// iterate the cvars and set their possible proxy parents
|
||||
// skip over registered (fixed) entries
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while (pCur)
|
||||
{
|
||||
if (!pCur->IsCommand() && !pCur->m_bRegistered)
|
||||
{
|
||||
// iterate from the next node until end of list
|
||||
name = pCur->m_pszName;
|
||||
pPrev2 = pCur;
|
||||
pCur2 = pCur->m_pNext;
|
||||
while (pCur2)
|
||||
{
|
||||
pNext2 = pCur2->m_pNext;
|
||||
if (!pCur2->IsCommand() && !stricmp(pCur2->m_pszName, name))
|
||||
{
|
||||
// found duplicate
|
||||
// unlink and fixup
|
||||
pCur2->m_pNext = NULL;
|
||||
pPrev2->m_pNext = pNext2;
|
||||
|
||||
// set its parent
|
||||
((ConVar*)pCur2)->m_pParent = ((ConVar*)pCur)->m_pParent;
|
||||
}
|
||||
else
|
||||
{
|
||||
// no unlink, advance to next node
|
||||
pPrev2 = pCur2;
|
||||
}
|
||||
|
||||
pCur2 = pNext2;
|
||||
}
|
||||
|
||||
char const *pValue = GetCommandLineValue(name);
|
||||
if (pValue)
|
||||
((ConVar*)pCur)->SetValue(pValue);
|
||||
}
|
||||
pCur = pCur->m_pNext;
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined( _RETAIL )
|
||||
XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Start" );
|
||||
|
||||
PublishCommands( false );
|
||||
|
||||
XBX_rTimeStampLog( Plat_FloatTime(), "xbx PublishCommands:Done" );
|
||||
#endif
|
||||
|
||||
// fixup has been performed
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConCommandBaseMgr.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
void ConCommandBaseMgr::OneTimeInit( IConCommandBaseAccessor *pAccessor )
|
||||
{
|
||||
#ifdef _XBOX
|
||||
// fixup the list
|
||||
ConCommandBaseMgr::Fixup(NULL);
|
||||
#else
|
||||
ConCommandBase *pCur, *pNext;
|
||||
|
||||
ConCommandBase::s_pAccessor = pAccessor;
|
||||
pCur = ConCommandBase::s_pConCommandBases;
|
||||
while ( pCur )
|
||||
{
|
||||
pNext = pCur->m_pNext;
|
||||
pCur->Init();
|
||||
pCur = pNext;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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( char const *pName, char const *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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *pName -
|
||||
// callback -
|
||||
// *pHelpString -
|
||||
// flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::Create( char const *pName, char const *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 _XBOX
|
||||
if (ConCommandBaseMgr::Fixup(this))
|
||||
return;
|
||||
#endif
|
||||
|
||||
if ( !( m_nFlags & FCVAR_UNREGISTERED ) )
|
||||
{
|
||||
#ifndef _XBOX
|
||||
m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = this;
|
||||
#else
|
||||
// xboxissue - engine cvars should be at head of list to
|
||||
// ensure they are set as the cvar master/parent during fixup
|
||||
if (!s_pConCommandBases || !(flags & FCVAR_NON_ENGINE))
|
||||
{
|
||||
// engine cvars, place at head of list
|
||||
m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = this;
|
||||
}
|
||||
else
|
||||
{
|
||||
// non-engine cvars, place at end of list
|
||||
ConCommandBase *cur = s_pConCommandBases;
|
||||
while (1)
|
||||
{
|
||||
if (!cur->m_pNext)
|
||||
{
|
||||
cur->m_pNext = this;
|
||||
m_pNext = NULL;
|
||||
break;
|
||||
}
|
||||
cur = cur->m_pNext;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
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 )
|
||||
return;
|
||||
|
||||
if ( m_bRegistered )
|
||||
return;
|
||||
|
||||
s_pAccessor->RegisterConCommandBase( this );
|
||||
|
||||
m_bRegistered = true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *name -
|
||||
// Output : ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommandBase const *ConCommandBase::FindCommand( char const *name )
|
||||
{
|
||||
ConCommandBase const *cmd = GetCommands();
|
||||
for ( ; cmd; cmd = cmd->GetNext() )
|
||||
{
|
||||
if ( !stricmp( name, cmd->GetName() ) )
|
||||
return cmd;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
const ConCommandBase *ConCommandBase::GetCommands( void )
|
||||
{
|
||||
return s_pConCommandBases;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *var -
|
||||
// Output : static
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::AddToList( ConCommandBase *var )
|
||||
{
|
||||
// This routine is only valid on root ConCommandBases
|
||||
var->m_pNext = s_pConCommandBases;
|
||||
s_pConCommandBases = var;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Return name of the command/var
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *ConCommandBase::GetName( void ) const
|
||||
{
|
||||
return m_pszName;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flag -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::RemoveFlaggedCommands( int flag )
|
||||
{
|
||||
ConCommandBase *pNewList;
|
||||
ConCommandBase *pCommand, *pNext;
|
||||
|
||||
pNewList = NULL;
|
||||
|
||||
pCommand = s_pConCommandBases;
|
||||
while ( pCommand )
|
||||
{
|
||||
pNext = pCommand->m_pNext;
|
||||
if ( !( pCommand->m_nFlags & flag ) )
|
||||
{
|
||||
pCommand->m_pNext = pNewList;
|
||||
pNewList = pCommand;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unlink
|
||||
pCommand->m_pNext = NULL;
|
||||
}
|
||||
|
||||
pCommand = pNext;
|
||||
}
|
||||
|
||||
s_pConCommandBases = pNewList;
|
||||
}
|
||||
|
||||
void ConCommandBase::RevertFlaggedCvars( int flag )
|
||||
{
|
||||
for (const ConCommandBase *var= GetCommands() ; var ; var=var->GetNext())
|
||||
{
|
||||
if ( var->IsCommand() )
|
||||
continue;
|
||||
|
||||
ConVar *cvar = ( ConVar * )var;
|
||||
|
||||
if ( !cvar->IsBitSet( flag ) )
|
||||
continue;
|
||||
|
||||
// It's == to the default value, don't count
|
||||
if ( !Q_strcasecmp( cvar->GetDefault(), cvar->GetString() ) )
|
||||
continue;
|
||||
|
||||
cvar->Revert();
|
||||
|
||||
// DevMsg( "%s = \"%s\" (reverted)\n", cvar->GetName(), cvar->GetString() );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flag -
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommandBase::IsBitSet( int flag ) const
|
||||
{
|
||||
return ( flag & m_nFlags ) ? true : false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::AddFlags( int flags )
|
||||
{
|
||||
m_nFlags |= flags;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : const ConCommandBase
|
||||
//-----------------------------------------------------------------------------
|
||||
const ConCommandBase *ConCommandBase::GetNext( void ) const
|
||||
{
|
||||
return m_pNext;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *next -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommandBase::SetNext( ConCommandBase *next )
|
||||
{
|
||||
m_pNext = next;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Copies string using local new/delete operators
|
||||
// Input : *from -
|
||||
// Output : char
|
||||
//-----------------------------------------------------------------------------
|
||||
char *ConCommandBase::CopyString( char const *from )
|
||||
{
|
||||
int len;
|
||||
char *to;
|
||||
|
||||
len = strlen( from );
|
||||
if ( len <= 0 )
|
||||
{
|
||||
to = new char[1];
|
||||
to[0] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
to = new char[len+1];
|
||||
Q_strncpy( to, from, len+1 );
|
||||
}
|
||||
return to;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Constructs a console command
|
||||
// Input : *pName - name of command
|
||||
// callback - function to call upon execution
|
||||
// *pHelpString - help text for command
|
||||
// flags - command flags, if any
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommand::ConCommand( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*= 0*/ )
|
||||
{
|
||||
Create( pName, callback, pHelpString, flags, completionFunc );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
//-----------------------------------------------------------------------------
|
||||
ConCommand::~ConCommand( void )
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommand::IsCommand( void ) const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Invoke the function if there is one
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommand::Dispatch( void )
|
||||
{
|
||||
if ( m_fnCommandCallback )
|
||||
{
|
||||
( *m_fnCommandCallback )();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Command without callback!!!
|
||||
Assert( 0 );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *partial -
|
||||
// context -
|
||||
// longest -
|
||||
// maxcommands -
|
||||
// **commands -
|
||||
// Output : int
|
||||
//-----------------------------------------------------------------------------
|
||||
int DefaultCompletionFunc( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Create the named command
|
||||
// Input : *pName -
|
||||
// callback -
|
||||
// *pHelpString -
|
||||
// flags -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConCommand::Create( char const *pName, FnCommandCallback callback, char const *pHelpString /*= 0*/, int flags /*= 0*/, FnCommandCompletionCallback completionFunc /*=0*/ )
|
||||
{
|
||||
// Set the callback
|
||||
m_fnCommandCallback = callback;
|
||||
|
||||
m_fnCompletionCallback = completionFunc ? completionFunc : DefaultCompletionFunc;
|
||||
m_bHasCompletionCallback = completionFunc != 0 ? true : false;
|
||||
|
||||
// Setup the rest
|
||||
BaseClass::Create( pName, pHelpString, flags );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *partial -
|
||||
// context -
|
||||
// longest -
|
||||
// maxcommands -
|
||||
// **commands -
|
||||
//-----------------------------------------------------------------------------
|
||||
int ConCommand::AutoCompleteSuggest( char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] )
|
||||
{
|
||||
Assert( m_fnCompletionCallback );
|
||||
if ( !m_fnCompletionCallback )
|
||||
return 0;
|
||||
|
||||
return ( m_fnCompletionCallback )( partial, commands );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConCommand::CanAutoComplete( void )
|
||||
{
|
||||
return m_bHasCompletionCallback;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags /* = 0 */ )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, FnChangeCallback callback )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, false, 0.0, false, 0.0, callback );
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------- //
|
||||
// ConVar.
|
||||
// ----------------------------------------------------------------------------- //
|
||||
ConVar::ConVar( char const *pName, char const *pDefaultValue, int flags, char const *pHelpString, bool bMin, float fMin, bool bMax, float fMax, FnChangeCallback callback )
|
||||
{
|
||||
Create( pName, pDefaultValue, flags, pHelpString, bMin, fMin, bMax, fMax, callback );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Free dynamic memory
|
||||
//-----------------------------------------------------------------------------
|
||||
ConVar::~ConVar( void )
|
||||
{
|
||||
if ( m_pszString )
|
||||
{
|
||||
delete[] m_pszString;
|
||||
m_pszString = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Install a change callback (there shouldn't already be one....)
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
void ConVar::InstallChangeCallback( FnChangeCallback callback )
|
||||
{
|
||||
Assert( !m_fnChangeCallback || !callback );
|
||||
m_fnChangeCallback = callback;
|
||||
|
||||
if (m_fnChangeCallback)
|
||||
{
|
||||
// Call it immediately to set the initial value...
|
||||
m_fnChangeCallback( this, m_pszString );
|
||||
}
|
||||
}
|
||||
|
||||
bool ConVar::IsBitSet( int flag ) const
|
||||
{
|
||||
return ( flag & m_pParent->m_nFlags ) ? true : false;
|
||||
}
|
||||
|
||||
char const *ConVar::GetHelpText( void ) const
|
||||
{
|
||||
return m_pParent->m_pszHelpString;
|
||||
}
|
||||
|
||||
void ConVar::AddFlags( int flags )
|
||||
{
|
||||
m_pParent->m_nFlags |= flags;
|
||||
}
|
||||
|
||||
bool ConVar::IsRegistered( void ) const
|
||||
{
|
||||
return m_pParent->m_bRegistered;
|
||||
}
|
||||
|
||||
char const *ConVar::GetName( void ) const
|
||||
{
|
||||
return m_pParent->m_pszName;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ConVar::IsCommand( void ) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input :
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Init()
|
||||
{
|
||||
BaseClass::Init();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::InternalSetValue( char const *value )
|
||||
{
|
||||
float fNewValue;
|
||||
char tempVal[ 32 ];
|
||||
char *val;
|
||||
|
||||
Assert(m_pParent == this); // Only valid for root convars.
|
||||
|
||||
val = (char *)value;
|
||||
fNewValue = ( float )atof( value );
|
||||
|
||||
if ( ClampValue( fNewValue ) )
|
||||
{
|
||||
Q_snprintf( tempVal,sizeof(tempVal), "%f", fNewValue );
|
||||
val = tempVal;
|
||||
}
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fNewValue;
|
||||
m_nValue = ( int )( m_fValue );
|
||||
|
||||
if ( !(m_nFlags & FCVAR_NEVER_AS_STRING) )
|
||||
ChangeStringValue( val );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *tempVal -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::ChangeStringValue( char const *tempVal )
|
||||
{
|
||||
Assert( !( m_nFlags & FCVAR_NEVER_AS_STRING ) );
|
||||
|
||||
char* pszOldValue = (char*)stackalloc( m_StringLength );
|
||||
memcpy( pszOldValue, m_pszString, m_StringLength );
|
||||
|
||||
int len = Q_strlen(tempVal) + 1;
|
||||
|
||||
if ( len > m_StringLength)
|
||||
{
|
||||
if (m_pszString)
|
||||
delete[] m_pszString;
|
||||
|
||||
m_pszString = new char[len];
|
||||
m_StringLength = len;
|
||||
}
|
||||
|
||||
memcpy( m_pszString, tempVal, len );
|
||||
|
||||
// Invoke any necessary callback function
|
||||
if ( m_fnChangeCallback )
|
||||
{
|
||||
m_fnChangeCallback( this, pszOldValue );
|
||||
}
|
||||
|
||||
GetCVarIF()->CallGlobalChangeCallback( this, pszOldValue );
|
||||
|
||||
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_fValue )
|
||||
return;
|
||||
|
||||
Assert( m_pParent == this ); // Only valid for root convars.
|
||||
|
||||
// Check bounds
|
||||
ClampValue( fNewValue );
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fNewValue;
|
||||
m_nValue = ( int )m_fValue;
|
||||
|
||||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||||
{
|
||||
char tempVal[ 32 ];
|
||||
Q_snprintf( tempVal, sizeof( tempVal), "%f", m_fValue );
|
||||
ChangeStringValue( tempVal );
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert( !m_fnChangeCallback );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::InternalSetIntValue( int nValue )
|
||||
{
|
||||
if ( nValue == m_nValue )
|
||||
return;
|
||||
|
||||
Assert( m_pParent == this ); // Only valid for root convars.
|
||||
|
||||
float fValue = (float)nValue;
|
||||
if ( ClampValue( fValue ) )
|
||||
{
|
||||
nValue = ( int )( fValue );
|
||||
}
|
||||
|
||||
// Redetermine value
|
||||
m_fValue = fValue;
|
||||
m_nValue = nValue;
|
||||
|
||||
if ( !( m_nFlags & FCVAR_NEVER_AS_STRING ) )
|
||||
{
|
||||
char tempVal[ 32 ];
|
||||
Q_snprintf( tempVal, sizeof( tempVal ), "%d", m_nValue );
|
||||
ChangeStringValue( tempVal );
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert( !m_fnChangeCallback );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Private creation
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Create( char const *pName, char const *pDefaultValue, int flags /*= 0*/,
|
||||
char const *pHelpString /*= NULL*/, bool bMin /*= false*/, float fMin /*= 0.0*/,
|
||||
bool bMax /*= false*/, float fMax /*= false*/, FnChangeCallback callback /*= NULL*/ )
|
||||
{
|
||||
static char *empty_string = "";
|
||||
|
||||
m_pParent = this;
|
||||
|
||||
// Name should be static data
|
||||
m_pszDefaultValue = pDefaultValue ? pDefaultValue : empty_string;
|
||||
Assert( pDefaultValue );
|
||||
|
||||
m_StringLength = strlen( m_pszDefaultValue ) + 1;
|
||||
m_pszString = new char[m_StringLength];
|
||||
memcpy( m_pszString, m_pszDefaultValue, m_StringLength );
|
||||
|
||||
m_bHasMin = bMin;
|
||||
m_fMinVal = fMin;
|
||||
m_bHasMax = bMax;
|
||||
m_fMaxVal = fMax;
|
||||
|
||||
m_fnChangeCallback = callback;
|
||||
|
||||
m_fValue = ( float )atof( m_pszString );
|
||||
|
||||
// Bounds Check, should never happen, if it does, no big deal
|
||||
if ( m_bHasMin && ( m_fValue < m_fMinVal ) )
|
||||
{
|
||||
Assert( 0 );
|
||||
}
|
||||
|
||||
if ( m_bHasMax && ( m_fValue > m_fMaxVal ) )
|
||||
{
|
||||
Assert( 0 );
|
||||
}
|
||||
|
||||
m_nValue = ( int )m_fValue;
|
||||
|
||||
BaseClass::Create( pName, pHelpString, flags );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Input : *value -
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::SetValue(char const *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: Reset to default value
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::Revert( void )
|
||||
{
|
||||
// Force default value again
|
||||
ConVar *var = ( ConVar * )m_pParent;
|
||||
var->SetValue( var->m_pszDefaultValue );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
//-----------------------------------------------------------------------------
|
||||
void ConVar::RevertAll( void )
|
||||
{
|
||||
ConCommandBase *p = s_pConCommandBases;
|
||||
while ( p )
|
||||
{
|
||||
if ( !p->IsCommand() )
|
||||
{
|
||||
ConVar *var = ( ConVar * )p;
|
||||
var->Revert();
|
||||
}
|
||||
p = p->m_pNext;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
// Output : char const
|
||||
//-----------------------------------------------------------------------------
|
||||
char const *ConVar::GetDefault( void ) const
|
||||
{
|
||||
return m_pParent->m_pszDefaultValue;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user