887 lines
23 KiB
C++
887 lines
23 KiB
C++
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
#include <windows.h>
|
||
|
|
#include <tier0/dbg.h>
|
||
|
|
#include <io.h>
|
||
|
|
#include <WorldSize.h>
|
||
|
|
#include "fgdlib/GameData.h"
|
||
|
|
#include "fgdlib/HelperInfo.h"
|
||
|
|
#include "KeyValues.h"
|
||
|
|
#include "filesystem_tools.h"
|
||
|
|
#include "tier1/strtools.h"
|
||
|
|
#include "utlmap.h"
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include "tier0/memdbgon.h"
|
||
|
|
|
||
|
|
#pragma warning(disable:4244)
|
||
|
|
|
||
|
|
|
||
|
|
const int MAX_ERRORS = 5;
|
||
|
|
|
||
|
|
|
||
|
|
static GameDataMessageFunc_t g_pMsgFunc = NULL;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Sets the function used for emitting error messages while loading gamedata files.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void GDSetMessageFunc(GameDataMessageFunc_t pFunc)
|
||
|
|
{
|
||
|
|
g_pMsgFunc = pFunc;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Fetches the next token from the file.
|
||
|
|
// Input : tr -
|
||
|
|
// ppszStore - Destination buffer, one of the following:
|
||
|
|
// pointer to NULL - token will be placed in an allocated buffer
|
||
|
|
// pointer to non-NULL buffer - token will be placed in buffer
|
||
|
|
// ttexpecting -
|
||
|
|
// pszExpecting -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static bool DoGetToken(TokenReader &tr, char **ppszStore, int nSize, trtoken_t ttexpecting, const char *pszExpecting)
|
||
|
|
{
|
||
|
|
trtoken_t ttype;
|
||
|
|
|
||
|
|
if (*ppszStore != NULL)
|
||
|
|
{
|
||
|
|
// Reads the token into the given buffer.
|
||
|
|
ttype = tr.NextToken(*ppszStore, nSize);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Allocates a buffer to hold the token.
|
||
|
|
ttype = tr.NextTokenDynamic(ppszStore);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ttype == TOKENSTRINGTOOLONG)
|
||
|
|
{
|
||
|
|
GDError(tr, "unterminated string or string too long");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Check for a bad token type.
|
||
|
|
//
|
||
|
|
char *pszStore = *ppszStore;
|
||
|
|
bool bBadTokenType = false;
|
||
|
|
if ((ttype != ttexpecting) && (ttexpecting != TOKENNONE))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If we were expecting a string and got an integer, don't worry about it.
|
||
|
|
// We can translate from integer to string.
|
||
|
|
//
|
||
|
|
if (!((ttexpecting == STRING) && (ttype == INTEGER)))
|
||
|
|
{
|
||
|
|
bBadTokenType = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bBadTokenType && (pszExpecting == NULL))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// We didn't get the expected token type but no expected
|
||
|
|
// string was specified.
|
||
|
|
//
|
||
|
|
char *pszTokenName;
|
||
|
|
switch (ttexpecting)
|
||
|
|
{
|
||
|
|
case IDENT:
|
||
|
|
{
|
||
|
|
pszTokenName = "identifier";
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case INTEGER:
|
||
|
|
{
|
||
|
|
pszTokenName = "integer";
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case STRING:
|
||
|
|
{
|
||
|
|
pszTokenName = "string";
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case OPERATOR:
|
||
|
|
default:
|
||
|
|
{
|
||
|
|
pszTokenName = "symbol";
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
GDError(tr, "expecting %s", pszTokenName);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
else if (bBadTokenType || ((pszExpecting != NULL) && !IsToken(pszStore, pszExpecting)))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// An expected string was specified, and we got either the wrong type or
|
||
|
|
// the right type but the wrong string,
|
||
|
|
//
|
||
|
|
GDError(tr, "expecting '%s', but found '%s'", pszExpecting, pszStore);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : tr -
|
||
|
|
// error -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GDError(TokenReader &tr, const char *error, ...)
|
||
|
|
{
|
||
|
|
char szBuf[128];
|
||
|
|
va_list vl;
|
||
|
|
va_start(vl, error);
|
||
|
|
vsprintf(szBuf, error, vl);
|
||
|
|
va_end(vl);
|
||
|
|
|
||
|
|
if (g_pMsgFunc)
|
||
|
|
{
|
||
|
|
// HACK: should use an enumeration for error level
|
||
|
|
g_pMsgFunc(1, tr.Error(szBuf));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tr.GetErrorCount() >= MAX_ERRORS)
|
||
|
|
{
|
||
|
|
if (g_pMsgFunc)
|
||
|
|
{
|
||
|
|
// HACK: should use an enumeration for error level
|
||
|
|
g_pMsgFunc(1, " - too many errors; aborting.");
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Fetches the next token from the file.
|
||
|
|
// Input : tr - The token reader object with which to fetch the token.
|
||
|
|
// pszStore - Buffer in which to place the token, NULL to discard the token.
|
||
|
|
// ttexpecting - The token type that we are expecting. If this is not TOKENNONE
|
||
|
|
// and token type read is different, the operation will fail.
|
||
|
|
// pszExpecting - The token string that we are expecting. If this string
|
||
|
|
// is not NULL and the token string read is different, the operation will fail.
|
||
|
|
// Output : Returns TRUE if the operation succeeded, FALSE if there was an error.
|
||
|
|
// If there was an error, the error will be reported in the message window.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GDGetToken(TokenReader &tr, char *pszStore, int nSize, trtoken_t ttexpecting, const char *pszExpecting)
|
||
|
|
{
|
||
|
|
Assert(pszStore != NULL);
|
||
|
|
if (pszStore != NULL)
|
||
|
|
{
|
||
|
|
return DoGetToken(tr, &pszStore, nSize, ttexpecting, pszExpecting);
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Fetches the next token from the file.
|
||
|
|
// Input : tr - The token reader object with which to fetch the token.
|
||
|
|
// pszStore - Buffer in which to place the token, NULL to discard the token.
|
||
|
|
// ttexpecting - The token type that we are expecting. If this is not TOKENNONE
|
||
|
|
// and token type read is different, the operation will fail.
|
||
|
|
// pszExpecting - The token string that we are expecting. If this string
|
||
|
|
// is not NULL and the token string read is different, the operation will fail.
|
||
|
|
// Output : Returns TRUE if the operation succeeded, FALSE if there was an error.
|
||
|
|
// If there was an error, the error will be reported in the message window.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GDSkipToken(TokenReader &tr, trtoken_t ttexpecting, const char *pszExpecting)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Read the next token into a buffer and discard it.
|
||
|
|
//
|
||
|
|
char szDiscardBuf[MAX_TOKEN];
|
||
|
|
char *pszDiscardBuf = szDiscardBuf;
|
||
|
|
return DoGetToken(tr, &pszDiscardBuf, sizeof(szDiscardBuf), ttexpecting, pszExpecting);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Fetches the next token from the file, allocating a buffer exactly
|
||
|
|
// large enough to hold the token.
|
||
|
|
// Input : tr -
|
||
|
|
// ppszStore -
|
||
|
|
// ttexpecting -
|
||
|
|
// pszExpecting -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GDGetTokenDynamic(TokenReader &tr, char **ppszStore, trtoken_t ttexpecting, const char *pszExpecting)
|
||
|
|
{
|
||
|
|
if (ppszStore == NULL)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
*ppszStore = NULL;
|
||
|
|
return DoGetToken(tr, ppszStore, -1, ttexpecting, pszExpecting);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Constructor.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
GameData::GameData(void)
|
||
|
|
{
|
||
|
|
m_nMaxMapCoord = 8192;
|
||
|
|
m_nMinMapCoord = -8192;
|
||
|
|
m_InstanceClass = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Destructor.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
GameData::~GameData(void)
|
||
|
|
{
|
||
|
|
ClearData();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void GameData::ClearData(void)
|
||
|
|
{
|
||
|
|
// delete classes.
|
||
|
|
int nCount = m_Classes.Count();
|
||
|
|
for (int i = 0; i < nCount; i++)
|
||
|
|
{
|
||
|
|
GDclass *pm = m_Classes.Element(i);
|
||
|
|
delete pm;
|
||
|
|
}
|
||
|
|
m_Classes.RemoveAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Loads a gamedata (FGD) file into this object.
|
||
|
|
// Input : pszFilename -
|
||
|
|
// Output : Returns TRUE on success, FALSE on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
BOOL GameData::Load(const char *pszFilename)
|
||
|
|
{
|
||
|
|
TokenReader tr;
|
||
|
|
|
||
|
|
if(GetFileAttributes(pszFilename) == 0xffffffff)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
if(!tr.Open(pszFilename))
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
trtoken_t ttype;
|
||
|
|
char szToken[128];
|
||
|
|
|
||
|
|
while (1)
|
||
|
|
{
|
||
|
|
if (tr.GetErrorCount() >= MAX_ERRORS)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
ttype = tr.NextToken(szToken, sizeof(szToken));
|
||
|
|
|
||
|
|
if(ttype == TOKENEOF)
|
||
|
|
break;
|
||
|
|
|
||
|
|
if(ttype != OPERATOR || !IsToken(szToken, "@"))
|
||
|
|
{
|
||
|
|
if(!GDError(tr, "expected @"))
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// check what kind it is, and parse a new object
|
||
|
|
if (tr.NextToken(szToken, sizeof(szToken)) != IDENT)
|
||
|
|
{
|
||
|
|
if(!GDError(tr, "expected identifier after @"))
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (IsToken(szToken, "baseclass") || IsToken(szToken, "pointclass") || IsToken(szToken, "solidclass") || IsToken(szToken, "keyframeclass") ||
|
||
|
|
IsToken(szToken, "moveclass") || IsToken(szToken, "npcclass") || IsToken(szToken, "filterclass"))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// New class.
|
||
|
|
//
|
||
|
|
GDclass *pNewClass = new GDclass;
|
||
|
|
if (!pNewClass->InitFromTokens(tr, this))
|
||
|
|
{
|
||
|
|
tr.IgnoreTill(OPERATOR, "@"); // go to next section
|
||
|
|
delete pNewClass;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (IsToken(szToken, "baseclass")) // Not directly available to user.
|
||
|
|
{
|
||
|
|
pNewClass->SetBaseClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "pointclass")) // Generic point class.
|
||
|
|
{
|
||
|
|
pNewClass->SetPointClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "solidclass")) // Tied to solids.
|
||
|
|
{
|
||
|
|
pNewClass->SetSolidClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "npcclass")) // NPC class - can be spawned by npc_maker.
|
||
|
|
{
|
||
|
|
pNewClass->SetPointClass(true);
|
||
|
|
pNewClass->SetNPCClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "filterclass")) // Filter class - can be used as a filter
|
||
|
|
{
|
||
|
|
pNewClass->SetPointClass(true);
|
||
|
|
pNewClass->SetFilterClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "moveclass")) // Animating
|
||
|
|
{
|
||
|
|
pNewClass->SetMoveClass(true);
|
||
|
|
pNewClass->SetPointClass(true);
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "keyframeclass")) // Animation keyframes
|
||
|
|
{
|
||
|
|
pNewClass->SetKeyFrameClass(true);
|
||
|
|
pNewClass->SetPointClass(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check and see if this new class matches an existing one. If so we will override the previous definition.
|
||
|
|
int nExistingClassIndex = 0;
|
||
|
|
GDclass *pExistingClass = ClassForName(pNewClass->GetName(), &nExistingClassIndex);
|
||
|
|
if (NULL != pExistingClass)
|
||
|
|
{
|
||
|
|
m_Classes.InsertAfter(nExistingClassIndex, pNewClass);
|
||
|
|
m_Classes.Remove(nExistingClassIndex);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_Classes.AddToTail(pNewClass);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "include"))
|
||
|
|
{
|
||
|
|
if (GDGetToken(tr, szToken, sizeof(szToken), STRING))
|
||
|
|
{
|
||
|
|
// Let's assume it's in the same directory.
|
||
|
|
char justPath[MAX_PATH], loadFilename[MAX_PATH];
|
||
|
|
if ( Q_ExtractFilePath( pszFilename, justPath, sizeof( justPath ) ) )
|
||
|
|
{
|
||
|
|
Q_snprintf( loadFilename, sizeof( loadFilename ), "%s%s", justPath, szToken );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Q_strncpy( loadFilename, szToken, sizeof( loadFilename ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
// First try our fully specified directory
|
||
|
|
if (!Load(loadFilename))
|
||
|
|
{
|
||
|
|
// Failing that, try our start directory
|
||
|
|
if (!Load(szToken))
|
||
|
|
{
|
||
|
|
GDError(tr, "error including file: %s", szToken);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (IsToken(szToken, "mapsize"))
|
||
|
|
{
|
||
|
|
if (!ParseMapSize(tr))
|
||
|
|
{
|
||
|
|
// Error in map size specifier, skip to next @ sign.
|
||
|
|
tr.IgnoreTill(OPERATOR, "@");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( IsToken( szToken, "materialexclusion" ) )
|
||
|
|
{
|
||
|
|
if ( !LoadFGDMaterialExclusions( tr ) )
|
||
|
|
{
|
||
|
|
// FGD exclusions not defined; skip to next @ sign.
|
||
|
|
tr.IgnoreTill(OPERATOR, "@");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( IsToken( szToken, "autovisgroup" ) )
|
||
|
|
{
|
||
|
|
if ( !LoadFGDAutoVisGroups( tr ) )
|
||
|
|
{
|
||
|
|
// FGD AutoVisGroups not defined; skip to next @ sign.
|
||
|
|
tr.IgnoreTill(OPERATOR, "@");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
GDError(tr, "unrecognized section name %s", szToken);
|
||
|
|
tr.IgnoreTill(OPERATOR, "@");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tr.GetErrorCount() > 0)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
tr.Close();
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Parses the "mapsize" specifier, which should be of the form:
|
||
|
|
//
|
||
|
|
// mapsize(min, max)
|
||
|
|
//
|
||
|
|
// ex: mapsize(-8192, 8192)
|
||
|
|
//
|
||
|
|
// Input : tr -
|
||
|
|
// Output : Returns true on success, false on failure.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GameData::ParseMapSize(TokenReader &tr)
|
||
|
|
{
|
||
|
|
if (!GDSkipToken(tr, OPERATOR, "("))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
char szToken[128];
|
||
|
|
if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
int nMin = atoi(szToken);
|
||
|
|
|
||
|
|
if (!GDSkipToken(tr, OPERATOR, ","))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!GDGetToken(tr, szToken, sizeof(szToken), INTEGER))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
int nMax = atoi(szToken);
|
||
|
|
|
||
|
|
if (nMin != nMax)
|
||
|
|
{
|
||
|
|
m_nMinMapCoord = min(nMin, nMax);
|
||
|
|
m_nMaxMapCoord = max(nMin, nMax);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!GDSkipToken(tr, OPERATOR, ")"))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
// Input : pszName -
|
||
|
|
// piIndex -
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
GDclass *GameData::ClassForName(const char *pszName, int *piIndex)
|
||
|
|
{
|
||
|
|
int nCount = m_Classes.Count();
|
||
|
|
for (int i = 0; i < nCount; i++)
|
||
|
|
{
|
||
|
|
GDclass *mp = m_Classes.Element(i);
|
||
|
|
if(!strcmp(mp->GetName(), pszName))
|
||
|
|
{
|
||
|
|
if(piIndex)
|
||
|
|
piIndex[0] = i;
|
||
|
|
return mp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// These are 'standard' keys that every entity uses, but they aren't specified that way in the .fgd
|
||
|
|
static const char *RequiredKeys[] =
|
||
|
|
{
|
||
|
|
"Origin",
|
||
|
|
"Angles",
|
||
|
|
NULL
|
||
|
|
};
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will set up the initial class about to be instanced
|
||
|
|
// Input : pszClassName - the class name of the entity to be instanced
|
||
|
|
// pszInstancePrefix - the prefix to be used for all name fields
|
||
|
|
// Origin - the origin offset of the instance
|
||
|
|
// Angles - the angle rotation of the instance
|
||
|
|
// Output : if successful, will return the game data class of the class name
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
GDclass *GameData::BeginInstanceRemap( const char *pszClassName, const char *pszInstancePrefix, Vector &Origin, QAngle &Angle )
|
||
|
|
{
|
||
|
|
m_InstanceOrigin = Origin;
|
||
|
|
m_InstanceAngle = Angle;
|
||
|
|
AngleMatrix( m_InstanceAngle, m_InstanceOrigin, m_InstanceMat );
|
||
|
|
|
||
|
|
strcpy( m_InstancePrefix, pszInstancePrefix );
|
||
|
|
|
||
|
|
if ( m_InstanceClass )
|
||
|
|
{
|
||
|
|
delete m_InstanceClass;
|
||
|
|
m_InstanceClass = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( strcmpi( pszClassName, "info_overlay_accessor" ) == 0 )
|
||
|
|
{ // yucky hack for a made up entity in the bsp process
|
||
|
|
pszClassName = "info_overlay";
|
||
|
|
}
|
||
|
|
|
||
|
|
GDclass *BaseClass = ClassForName( pszClassName );
|
||
|
|
if ( BaseClass )
|
||
|
|
{
|
||
|
|
m_InstanceClass = new GDclass();
|
||
|
|
m_InstanceClass->Parent = this;
|
||
|
|
m_InstanceClass->AddBase( BaseClass );
|
||
|
|
|
||
|
|
for( int i = 0; RequiredKeys[ i ]; i++ )
|
||
|
|
{
|
||
|
|
if ( m_InstanceClass->VarForName( RequiredKeys[ i ] ) == NULL )
|
||
|
|
{
|
||
|
|
BaseClass = ClassForName( RequiredKeys[ i ] );
|
||
|
|
if ( BaseClass )
|
||
|
|
{
|
||
|
|
m_InstanceClass->AddBase( BaseClass );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_InstanceClass = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return m_InstanceClass;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
enum tRemapOperation
|
||
|
|
{
|
||
|
|
REMAP_NAME = 0,
|
||
|
|
REMAP_POSITION,
|
||
|
|
REMAP_ANGLE,
|
||
|
|
REMAP_ANGLE_NEGATIVE_PITCH,
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
static CUtlMap< GDIV_TYPE, tRemapOperation > RemapOperation;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: function to sort the class type for the RemapOperations map
|
||
|
|
// Input : type1 - the first type to compare against
|
||
|
|
// type2 - the second type to compare against
|
||
|
|
// Output : returns true if the first type is less than the second one
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static bool CUtlType_LessThan( const GDIV_TYPE &type1, const GDIV_TYPE &type2 )
|
||
|
|
{
|
||
|
|
return ( type1 < type2 );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will attempt to remap a key's value
|
||
|
|
// Input : pszKey - the name of the key
|
||
|
|
// pszInvalue - the original value
|
||
|
|
// AllowNameRemapping - only do name remapping if this parameter is true.
|
||
|
|
// this is generally only false on the instance level.
|
||
|
|
// Output : returns true if the value changed
|
||
|
|
// pszOutValue - the new value if changed
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GameData::RemapKeyValue( const char *pszKey, const char *pszInValue, char *pszOutValue, TNameFixup NameFixup )
|
||
|
|
{
|
||
|
|
if ( RemapOperation.Count() == 0 )
|
||
|
|
{
|
||
|
|
RemapOperation.SetLessFunc( &CUtlType_LessThan );
|
||
|
|
RemapOperation.Insert( ivAngle, REMAP_ANGLE );
|
||
|
|
RemapOperation.Insert( ivTargetDest, REMAP_NAME );
|
||
|
|
RemapOperation.Insert( ivTargetSrc, REMAP_NAME );
|
||
|
|
RemapOperation.Insert( ivOrigin, REMAP_POSITION );
|
||
|
|
RemapOperation.Insert( ivAxis, REMAP_ANGLE );
|
||
|
|
RemapOperation.Insert( ivAngleNegativePitch, REMAP_ANGLE_NEGATIVE_PITCH );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !m_InstanceClass )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
GDinputvariable *KVVar = m_InstanceClass->VarForName( pszKey );
|
||
|
|
if ( !KVVar )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
GDIV_TYPE KVType = KVVar->GetType();
|
||
|
|
int KVRemapIndex = RemapOperation.Find( KVType );
|
||
|
|
if ( KVRemapIndex == RemapOperation.InvalidIndex() )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
strcpy( pszOutValue, pszInValue );
|
||
|
|
|
||
|
|
switch( RemapOperation[ KVRemapIndex ] )
|
||
|
|
{
|
||
|
|
case REMAP_NAME:
|
||
|
|
if ( KVType != ivInstanceVariable )
|
||
|
|
{
|
||
|
|
RemapNameField( pszInValue, pszOutValue, NameFixup );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REMAP_POSITION:
|
||
|
|
{
|
||
|
|
Vector inPoint( 0.0f, 0.0f, 0.0f ), outPoint;
|
||
|
|
|
||
|
|
sscanf ( pszInValue, "%f %f %f", &inPoint.x, &inPoint.y, &inPoint.z );
|
||
|
|
VectorTransform( inPoint, m_InstanceMat, outPoint );
|
||
|
|
sprintf( pszOutValue, "%g %g %g", outPoint.x, outPoint.y, outPoint.z );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REMAP_ANGLE:
|
||
|
|
if ( m_InstanceAngle.x != 0.0f || m_InstanceAngle.y != 0.0f || m_InstanceAngle.z != 0.0f )
|
||
|
|
{
|
||
|
|
QAngle inAngles( 0.0f, 0.0f, 0.0f ), outAngles;
|
||
|
|
matrix3x4_t angToWorld, localMatrix;
|
||
|
|
|
||
|
|
sscanf ( pszInValue, "%f %f %f", &inAngles.x, &inAngles.y, &inAngles.z );
|
||
|
|
|
||
|
|
AngleMatrix( inAngles, angToWorld );
|
||
|
|
MatrixMultiply( m_InstanceMat, angToWorld, localMatrix );
|
||
|
|
MatrixAngles( localMatrix, outAngles );
|
||
|
|
|
||
|
|
sprintf( pszOutValue, "%g %g %g", outAngles.x, outAngles.y, outAngles.z );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REMAP_ANGLE_NEGATIVE_PITCH:
|
||
|
|
if ( m_InstanceAngle.x != 0.0f || m_InstanceAngle.y != 0.0f || m_InstanceAngle.z != 0.0f )
|
||
|
|
{
|
||
|
|
QAngle inAngles( 0.0f, 0.0f, 0.0f ), outAngles;
|
||
|
|
matrix3x4_t angToWorld, localMatrix;
|
||
|
|
|
||
|
|
sscanf ( pszInValue, "%f", &inAngles.x ); // just the pitch
|
||
|
|
inAngles.x = -inAngles.x;
|
||
|
|
|
||
|
|
AngleMatrix( inAngles, angToWorld );
|
||
|
|
MatrixMultiply( m_InstanceMat, angToWorld, localMatrix );
|
||
|
|
MatrixAngles( localMatrix, outAngles );
|
||
|
|
|
||
|
|
sprintf( pszOutValue, "%g", -outAngles.x ); // just the pitch
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ( strcmpi( pszInValue, pszOutValue ) != 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: this function will attempt to remap a name field.
|
||
|
|
// Input : pszInvalue - the original value
|
||
|
|
// AllowNameRemapping - only do name remapping if this parameter is true.
|
||
|
|
// this is generally only false on the instance level.
|
||
|
|
// Output : returns true if the value changed
|
||
|
|
// pszOutValue - the new value if changed
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GameData::RemapNameField( const char *pszInValue, char *pszOutValue, TNameFixup NameFixup )
|
||
|
|
{
|
||
|
|
strcpy( pszOutValue, pszInValue );
|
||
|
|
|
||
|
|
if ( pszInValue[ 0 ] && pszInValue[ 0 ] != '@' )
|
||
|
|
{ // ! at the start of a value means it is global and should not be remaped
|
||
|
|
switch( NameFixup )
|
||
|
|
{
|
||
|
|
case NAME_FIXUP_PREFIX:
|
||
|
|
sprintf( pszOutValue, "%s-%s", m_InstancePrefix, pszInValue );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case NAME_FIXUP_POSTFIX:
|
||
|
|
sprintf( pszOutValue, "%s-%s", pszInValue, m_InstancePrefix );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return ( strcmpi( pszInValue, pszOutValue ) != 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Gathers any FGD-defined material directory exclusions
|
||
|
|
// Input :
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GameData::LoadFGDMaterialExclusions( TokenReader &tr )
|
||
|
|
{
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "[" ) )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
while ( 1 )
|
||
|
|
{
|
||
|
|
char szToken[128];
|
||
|
|
bool bMatchFound = false;
|
||
|
|
|
||
|
|
if ( tr.PeekTokenType( szToken, sizeof( szToken ) ) == OPERATOR )
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if ( GDGetToken( tr, szToken, sizeof( szToken ), STRING ) )
|
||
|
|
{
|
||
|
|
// Make sure we haven't loaded this from another FGD
|
||
|
|
for ( int i = 0; i < m_FGDMaterialExclusions.Count(); i++ )
|
||
|
|
{
|
||
|
|
if ( !stricmp( szToken, m_FGDMaterialExclusions[i].szDirectory ) )
|
||
|
|
{
|
||
|
|
bMatchFound = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse the string
|
||
|
|
if ( bMatchFound == false )
|
||
|
|
{
|
||
|
|
int index = m_FGDMaterialExclusions.AddToTail();
|
||
|
|
Q_strncpy( m_FGDMaterialExclusions[index].szDirectory, szToken, sizeof( m_FGDMaterialExclusions[index].szDirectory ) );
|
||
|
|
m_FGDMaterialExclusions[index].bUserGenerated = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Closing square brace.
|
||
|
|
//
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "]" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Gathers any FGD-defined Auto VisGroups
|
||
|
|
// Input :
|
||
|
|
// Output :
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool GameData::LoadFGDAutoVisGroups( TokenReader &tr )
|
||
|
|
{
|
||
|
|
int gindex = 0; // Index of AutoVisGroups
|
||
|
|
int cindex = 0; // Index of Classes
|
||
|
|
|
||
|
|
char szToken[128];
|
||
|
|
|
||
|
|
// Handle the Parent -- World Geometry, Entities, World Detail
|
||
|
|
if ( GDSkipToken( tr, OPERATOR, "=" ) )
|
||
|
|
{
|
||
|
|
// We expect a name
|
||
|
|
if ( !GDGetToken( tr, szToken, sizeof( szToken ), STRING ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
gindex = m_FGDAutoVisGroups.AddToTail();
|
||
|
|
Q_strncpy( m_FGDAutoVisGroups[gindex].szParent, szToken, sizeof( m_FGDAutoVisGroups[gindex].szParent ) );
|
||
|
|
|
||
|
|
// We expect a Class
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "[" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Handle the Class(es) -- Brush Entities, Occluders, Lights
|
||
|
|
while ( 1 )
|
||
|
|
{
|
||
|
|
if ( GDGetToken( tr, szToken, sizeof( szToken ), STRING ) )
|
||
|
|
{
|
||
|
|
cindex = m_FGDAutoVisGroups[gindex].m_Classes.AddToTail();
|
||
|
|
Q_strncpy( m_FGDAutoVisGroups[gindex].m_Classes[cindex].szClass, szToken, sizeof( m_FGDAutoVisGroups[gindex].m_Classes[cindex].szClass ) );
|
||
|
|
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "[" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse objects/entities -- func_detail, point_template, light_spot
|
||
|
|
while ( 1 )
|
||
|
|
{
|
||
|
|
if ( tr.PeekTokenType( szToken, sizeof( szToken ) ) == OPERATOR )
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !GDGetToken( tr, szToken, sizeof( szToken ), STRING ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_FGDAutoVisGroups[gindex].m_Classes[cindex].szEntities.CopyAndAddToTail( szToken );
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "]" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
// See if we have another Class coming up
|
||
|
|
if ( tr.PeekTokenType( szToken, sizeof( szToken ) ) == STRING )
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If no more Classes, we now expect a terminating ']'
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "]" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
// We're done
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
// We don't have another Class; look for a terminating brace
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ( !GDSkipToken( tr, OPERATOR, "]" ) )
|
||
|
|
{
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Safety net
|
||
|
|
GDError( tr, "Malformed AutoVisGroup -- Last processed: %s", szToken );
|
||
|
|
return( FALSE );
|
||
|
|
}
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include "tier0/memdbgoff.h"
|