void SetModel( edict_t* pEdict, const char* pszModelName )
{
auto pMap = CMap::GetInstance()->GetGlobalModelReplacement();
const char* pszNewName = pMap ? pMap->LookupFile( pszModelName ) : pszModelName;
g_hlenginefuncs.pfnSetModel( pEdict, pszNewName );
}
int PrecacheModel( const char* pszModelName )
{
auto pMap = CMap::GetInstance()->GetGlobalModelReplacement();
const char* pszNewName = pMap ? pMap->LookupFile( pszModelName ) : pszModelName;
return g_hlenginefuncs.pfnPrecacheModel( pszNewName );
}
// Find a file entry by ID.
const CAkFilePackageLUT::AkFileEntry * CAkFilePackageLUT::LookupFile(
AkFileID in_uID, // File ID.
AkFileSystemFlags * in_pFlags // Special flags. Do not pass NULL.
)
{
AKASSERT( in_pFlags && in_pFlags->uCompanyID == AKCOMPANYID_AUDIOKINETIC );
if ( in_pFlags->uCodecID == AKCODECID_BANK
&& m_pSoundBanks
&& m_pSoundBanks->HasFiles() )
{
return LookupFile( in_uID, m_pSoundBanks, in_pFlags->bIsLanguageSpecific );
}
else if ( m_pStmFiles && m_pStmFiles->HasFiles() )
{
// We assume that the file is a streamed audio file.
return LookupFile( in_uID, m_pStmFiles, in_pFlags->bIsLanguageSpecific );
}
// No table loaded.
return NULL;
}
void BinLog::WriteOp(BinLogOp op, int plug, ...)
{
if (!m_state)
return;
FILE *fp = fopen(m_logfile.chars(), "ab");
if (!fp)
return;
if (g_binlog_maxsize && op != BinLog_End)
{
fseek(fp, 0, SEEK_END);
if (ftell(fp) > (g_binlog_maxsize * (1024 * 1024)))
{
fclose(fp);
Close();
Open();
fp = fopen(m_logfile.chars(), "ab");
if (!fp)
return;
}
}
unsigned char c = static_cast<char>(op);
time_t t = time(NULL);
float gt = gpGlobals->time;
fwrite(&c, sizeof(char), 1, fp);
fwrite(&t, sizeof(time_t), 1, fp);
fwrite(>, sizeof(float), 1, fp);
fwrite(&plug, sizeof(int), 1, fp);
va_list ap;
va_start(ap, plug);
AMX *amx = NULL;
bool debug = false;
AMX_DBG *dbg = NULL;
CPluginMngr::CPlugin *pl = NULL;
if (plug != -1)
{
pl = g_plugins.findPlugin(plug);
if ((debug = pl->isDebug()))
{
amx = pl->getAMX();
dbg = static_cast<Debugger *>(amx->userdata[UD_DEBUGGER])->m_pAmxDbg;
}
}
switch (c)
{
case BinLog_Registered:
{
const char *title = va_arg(ap, const char *);
const char *vers = va_arg(ap, const char *);
c = (char)strlen(title);
fwrite(&c, sizeof(char), 1, fp);
fwrite(title, sizeof(char), c+1, fp);
c = (char)strlen(vers);
fwrite(&c, sizeof(char), 1 ,fp);
fwrite(vers, sizeof(char), c+1, fp);
break;
}
case BinLog_NativeCall:
{
int file;
int native = va_arg(ap, int);
int params = va_arg(ap, int);
fwrite(&native, sizeof(int), 1, fp);
fwrite(¶ms, sizeof(int), 1, fp);
if (debug)
{
file = LookupFile(dbg, amx->cip);
fwrite(&file, sizeof(int), 1, fp);
} else {
file = 0;
fwrite(&file, sizeof(int), 1, fp);
}
break;
}
case BinLog_NativeRet:
{
cell retval = va_arg(ap, cell);
fwrite(&retval, sizeof(cell), 1, fp);
break;
}
case BinLog_NativeError:
{
int err = va_arg(ap, int);
const char *msg = va_arg(ap, const char *);
short len = (short)strlen(msg);
fwrite(&err, sizeof(int), 1, fp);
fwrite(&len, sizeof(short), 1, fp);
fwrite(msg, sizeof(char), len+1, fp);
break;
}
case BinLog_CallPubFunc:
{
int file;
int num = va_arg(ap, int);
fwrite(&num, sizeof(int), 1, fp);
if (debug)
{
file = LookupFile(dbg, amx->cip);
fwrite(&file, sizeof(int), 1, fp);
} else {
file = 0;
fwrite(&file, sizeof(int), 1, fp);
}
break;
}
case BinLog_SetLine:
{
int file;
int line = va_arg(ap, int);
fwrite(&line, sizeof(int), 1, fp);
if (debug)
{
file = LookupFile(dbg, amx->cip);
fwrite(&file, sizeof(int), 1, fp);
} else {
file = 0;
fwrite(&file, sizeof(int), 1, fp);
}
break;
}
case BinLog_FormatString:
{
int param = va_arg(ap, int);
int maxlen = va_arg(ap, int);
const char *str = va_arg(ap, const char *);
short len = (short)strlen(str);
fwrite(¶m, sizeof(int), 1, fp);
fwrite(&maxlen, sizeof(int), 1, fp);
fwrite(&len, sizeof(short), 1, fp);
fwrite(str, sizeof(char), len+1, fp);
break;
}
case BinLog_NativeParams:
{
cell *params = va_arg(ap, cell *);
cell num = params[0] / sizeof(cell);
fwrite(&num, sizeof(cell), 1, fp);
for (cell i=1; i<=num; i++)
fwrite(&(params[i]), sizeof(cell), 1, fp);
break;
}
case BinLog_GetString:
{
cell addr = va_arg(ap, cell);
const char *str = va_arg(ap, const char *);
short len = (short)strlen(str);
fwrite(&addr, sizeof(cell), 1, fp);
fwrite(&len, sizeof(short), 1, fp);
fwrite(str, sizeof(char), len+1, fp);
break;
}
case BinLog_SetString:
{
cell addr = va_arg(ap, cell);
int maxlen = va_arg(ap, int);
const char *str = va_arg(ap, const char *);
short len = (short)strlen(str);
fwrite(&addr, sizeof(cell), 1, fp);
fwrite(&maxlen, sizeof(int), 1, fp);
fwrite(&len, sizeof(short), 1, fp);
fwrite(str, sizeof(char), len+1, fp);
break;
}
};
va_end(ap);
fclose(fp);
}
void CLibraryMaps::OnFileRemove(CLibraryFile* pFile)
{
CLibraryFile* pOld;
if ( pFile->m_nIndex )
{
pOld = LookupFile( pFile->m_nIndex );
if ( pOld == pFile )
{
m_pIndexMap.RemoveKey( pFile->m_nIndex );
if ( pOld->IsAvailable() )
{
m_nFiles --;
m_nVolume -= pFile->m_nSize;
}
}
}
pOld = LookupFileByName( pFile->GetNameLC(), pFile->m_nSize, FALSE, FALSE );
if ( pOld == pFile ) m_pNameMap.RemoveKey( pFile->GetNameLC() );
if ( pFile->IsAvailable() )
{
CString strPath( pFile->GetPath() );
ToLower( strPath );
pOld = LookupFileByPath( strPath );
if ( pOld == pFile )
m_pPathMap.RemoveKey( strPath );
}
if ( POSITION pos = m_pDeleted.Find( pFile ) )
m_pDeleted.RemoveAt( pos );
if ( pFile->m_oSHA1 )
{
CLibraryFile** pPrev = &m_pSHA1Map[ pFile->m_oSHA1[ 0 ] & HASH_MASK ];
for ( CLibraryFile* pOther = *pPrev ; pOther ; pOther = pOther->m_pNextSHA1 )
{
if ( pOther == pFile )
{
*pPrev = pOther->m_pNextSHA1;
break;
}
pPrev = &pOther->m_pNextSHA1;
}
pFile->m_pNextSHA1 = NULL;
}
if ( pFile->m_oTiger )
{
CLibraryFile** pPrev = &m_pTigerMap[ pFile->m_oTiger[ 0 ] & HASH_MASK ];
for ( CLibraryFile* pOther = *pPrev ; pOther ; pOther = pOther->m_pNextTiger )
{
if ( pOther == pFile )
{
*pPrev = pOther->m_pNextTiger;
break;
}
pPrev = &pOther->m_pNextTiger;
}
pFile->m_pNextTiger = NULL;
}
if ( pFile->m_oED2K )
{
CLibraryFile** pPrev = &m_pED2KMap[ pFile->m_oED2K[ 0 ] & HASH_MASK ];
for ( CLibraryFile* pOther = *pPrev ; pOther ; pOther = pOther->m_pNextED2K )
{
if ( pOther == pFile )
{
*pPrev = pOther->m_pNextED2K;
break;
}
pPrev = &pOther->m_pNextED2K;
}
pFile->m_pNextED2K = NULL;
}
if ( pFile->m_oBTH )
{
CLibraryFile** pPrev = &m_pBTHMap[ pFile->m_oBTH[ 0 ] & HASH_MASK ];
for ( CLibraryFile* pOther = *pPrev ; pOther ; pOther = pOther->m_pNextBTH )
{
if ( pOther == pFile )
{
*pPrev = pOther->m_pNextBTH;
break;
}
pPrev = &pOther->m_pNextBTH;
}
pFile->m_pNextBTH = NULL;
}
if ( pFile->m_oMD5 )
{
CLibraryFile** pPrev = &m_pMD5Map[ pFile->m_oMD5[ 0 ] & HASH_MASK ];
for ( CLibraryFile* pOther = *pPrev ; pOther ; pOther = pOther->m_pNextMD5 )
{
if ( pOther == pFile )
{
*pPrev = pOther->m_pNextMD5;
break;
}
pPrev = &pOther->m_pNextMD5;
}
pFile->m_pNextMD5 = NULL;
}
}
void CLibraryMaps::OnFileAdd(CLibraryFile* pFile)
{
BOOL bSkipStats = FALSE;
if ( pFile->m_nIndex )
{
if ( CLibraryFile* pOld = LookupFile( pFile->m_nIndex ) )
{
if ( pOld != pFile )
{
pFile->m_nIndex = AllocateIndex();
m_pIndexMap.SetAt( pFile->m_nIndex, pFile );
}
else
{
bSkipStats = TRUE;
}
}
else
{
m_pIndexMap.SetAt( pFile->m_nIndex, pFile );
}
}
else
{
pFile->m_nIndex = AllocateIndex();
m_pIndexMap.SetAt( pFile->m_nIndex, pFile );
}
if ( pFile->IsAvailable() && ! bSkipStats )
{
m_nVolume += pFile->m_nSize;
m_nFiles ++;
}
m_pNameMap.SetAt( pFile->GetNameLC(), pFile );
if ( pFile->IsAvailable() )
{
CString strPath( pFile->GetPath() );
ToLower( strPath );
m_pPathMap.SetAt( strPath, pFile );
}
else if ( m_pDeleted.Find( pFile ) == NULL )
{
m_pDeleted.AddTail( pFile );
}
if ( pFile->m_oSHA1 )
{
CLibraryFile** pHash = &m_pSHA1Map[ pFile->m_oSHA1[ 0 ] & HASH_MASK ];
pFile->m_pNextSHA1 = *pHash;
*pHash = pFile;
}
if ( pFile->m_oTiger )
{
CLibraryFile** pHash = &m_pTigerMap[ pFile->m_oTiger[ 0 ] & HASH_MASK ];
pFile->m_pNextTiger = *pHash;
*pHash = pFile;
}
if ( pFile->m_oED2K )
{
CLibraryFile** pHash = &m_pED2KMap[ pFile->m_oED2K[ 0 ] & HASH_MASK ];
pFile->m_pNextED2K = *pHash;
*pHash = pFile;
}
if ( pFile->m_oBTH )
{
CLibraryFile** pHash = &m_pBTHMap[ pFile->m_oBTH[ 0 ] & HASH_MASK ];
pFile->m_pNextBTH = *pHash;
*pHash = pFile;
}
if ( pFile->m_oMD5 )
{
CLibraryFile** pHash = &m_pMD5Map[ pFile->m_oMD5[ 0 ] & HASH_MASK ];
pFile->m_pNextMD5 = *pHash;
*pHash = pFile;
}
}
DWORD CLibraryMaps::AllocateIndex()
{
while ( ( m_nNextIndex & 3 ) == 0 || LookupFile( m_nNextIndex ) ) m_nNextIndex++;
return m_nNextIndex;
}
