void CCompileCaptionsApp::DescribeCaptions( char const *file )
{
CUtlBuffer buf;
if ( !g_pFullFileSystem->ReadFile( file, NULL, buf ) )
{
Error( "Unable to read '%s' into buffer\n", file );
}
CompiledCaptionHeader_t header;
buf.Get( &header, sizeof( header ) );
if ( header.magic != COMPILED_CAPTION_FILEID )
Error( "Invalid file id for %s\n", file );
if ( header.version != COMPILED_CAPTION_VERSION )
Error( "Invalid file version for %s\n", file );
// Read the directory
CUtlSortVector< CaptionLookup_t, CCaptionLookupLess > directory;
directory.EnsureCapacity( header.directorysize );
directory.CopyArray( (const CaptionLookup_t *)buf.PeekGet(), header.directorysize );
directory.RedoSort( true );
buf.SeekGet( CUtlBuffer::SEEK_HEAD, header.dataoffset );
int i;
CUtlVector< CaptionBlock_t > blocks;
for ( i = 0; i < header.numblocks; ++i )
{
CaptionBlock_t& newBlock = blocks[ blocks.AddToTail() ];
Q_memset( newBlock.data, 0, sizeof( newBlock.data ) );
buf.Get( newBlock.data, header.blocksize );
}
CUtlMap< unsigned int, StringIndex_t > inverseMap( 0, 0, DefLessFunc( unsigned int ) );
for ( StringIndex_t idx = g_pVGuiLocalize->GetFirstStringIndex(); idx != INVALID_LOCALIZE_STRING_INDEX; idx = g_pVGuiLocalize->GetNextStringIndex( idx ) )
{
const char *name = g_pVGuiLocalize->GetNameByIndex( idx );
CaptionLookup_t dummy;
dummy.SetHash( name );
inverseMap.Insert( dummy.hash, idx );
}
// Now print everything out...
for ( i = 0; i < header.directorysize; ++i )
{
const CaptionLookup_t& entry = directory[ i ];
char const *name = g_pVGuiLocalize->GetNameByIndex( inverseMap.Element( inverseMap.Find( entry.hash ) ) );
const CaptionBlock_t& block = blocks[ entry.blockNum ];
const wchar_t *data = (const wchar_t *)&block.data[ entry.offset ];
wchar_t *temp = ( wchar_t * )_alloca( entry.length * sizeof( short ) );
wcsncpy( temp, data, ( entry.length / sizeof( short ) ) - 1 );
vprint( 0, "%3.3d: (%40.40s) hash(%15.15u), block(%4.4d), offset(%4.4d), len(%4.4d) %S\n",
i, name, entry.hash, entry.blockNum, entry.offset, entry.length, temp );
}
}
//-----------------------------------------------------------------------------
// A Scene image file contains all the compiled .XCD
//-----------------------------------------------------------------------------
bool CSceneImage::CreateSceneImageFile( CUtlBuffer &targetBuffer, char const *pchModPath, bool bLittleEndian, bool bQuiet, ISceneCompileStatus *pStatus )
{
CUtlVector<fileList_t> vcdFileList;
CUtlSymbolTable vcdSymbolTable( 0, 32, true );
Msg( "\n" );
// get all the VCD files according to the seacrh paths
char searchPaths[512];
g_pFullFileSystem->GetSearchPath( "GAME", false, searchPaths, sizeof( searchPaths ) );
char *pPath = strtok( searchPaths, ";" );
while ( pPath )
{
int currentCount = vcdFileList.Count();
char szPath[MAX_PATH];
V_ComposeFileName( pPath, "scenes/*.vcd", szPath, sizeof( szPath ) );
scriptlib->FindFiles( szPath, true, vcdFileList );
Msg( "Scenes: Searching '%s' - Found %d scenes.\n", szPath, vcdFileList.Count() - currentCount );
pPath = strtok( NULL, ";" );
}
if ( !vcdFileList.Count() )
{
Msg( "Scenes: No Scene Files found!\n" );
return false;
}
// iterate and convert all the VCD files
bool bGameIsTF = V_stristr( pchModPath, "\\tf" ) != NULL;
for ( int i=0; i<vcdFileList.Count(); i++ )
{
const char *pFilename = vcdFileList[i].fileName.String();
const char *pSceneName = V_stristr( pFilename, "scenes\\" );
if ( !pSceneName )
{
continue;
}
if ( !bLittleEndian && bGameIsTF && V_stristr( pSceneName, "high\\" ) )
{
continue;
}
// process files in order they would be found in search paths
// i.e. skipping later processed files that match an earlier conversion
UtlSymId_t symbol = vcdSymbolTable.Find( pSceneName );
if ( symbol == UTL_INVAL_SYMBOL )
{
vcdSymbolTable.AddString( pSceneName );
pStatus->UpdateStatus( pFilename, bQuiet, i, vcdFileList.Count() );
if ( !CreateTargetFile_VCD( pFilename, "", false, bLittleEndian ) )
{
Error( "CreateSceneImageFile: Failed on '%s' conversion!\n", pFilename );
}
}
}
if ( !g_SceneFiles.Count() )
{
// nothing to do
return true;
}
Msg( "Scenes: Finalizing %d unique scenes.\n", g_SceneFiles.Count() );
// get the string pool
CUtlVector< unsigned int > stringOffsets;
CUtlBuffer stringPool;
g_ChoreoStringPool.GetTableAndPool( stringOffsets, stringPool );
if ( !bQuiet )
{
Msg( "Scenes: String Table: %d bytes\n", stringOffsets.Count() * sizeof( int ) );
Msg( "Scenes: String Pool: %d bytes\n", stringPool.TellMaxPut() );
}
// first header, then lookup table, then string pool blob
int stringPoolStart = sizeof( SceneImageHeader_t ) + stringOffsets.Count() * sizeof( int );
// then directory
int sceneEntryStart = stringPoolStart + stringPool.TellMaxPut();
// then variable sized summaries
int sceneSummaryStart = sceneEntryStart + g_SceneFiles.Count() * sizeof( SceneImageEntry_t );
// then variable sized compiled binary scene data
int sceneDataStart = 0;
// construct header
SceneImageHeader_t imageHeader = { 0 };
imageHeader.nId = SCENE_IMAGE_ID;
imageHeader.nVersion = SCENE_IMAGE_VERSION;
imageHeader.nNumScenes = g_SceneFiles.Count();
imageHeader.nNumStrings = stringOffsets.Count();
imageHeader.nSceneEntryOffset = sceneEntryStart;
if ( !bLittleEndian )
{
imageHeader.nId = BigLong( imageHeader.nId );
imageHeader.nVersion = BigLong( imageHeader.nVersion );
imageHeader.nNumScenes = BigLong( imageHeader.nNumScenes );
imageHeader.nNumStrings = BigLong( imageHeader.nNumStrings );
imageHeader.nSceneEntryOffset = BigLong( imageHeader.nSceneEntryOffset );
}
targetBuffer.Put( &imageHeader, sizeof( imageHeader ) );
// header is immediately followed by string table and pool
for ( int i = 0; i < stringOffsets.Count(); i++ )
{
unsigned int offset = stringPoolStart + stringOffsets[i];
if ( !bLittleEndian )
{
offset = BigLong( offset );
}
targetBuffer.PutInt( offset );
}
Assert( stringPoolStart == targetBuffer.TellMaxPut() );
targetBuffer.Put( stringPool.Base(), stringPool.TellMaxPut() );
// construct directory
CUtlSortVector< SceneImageEntry_t, CSceneImageEntryLessFunc > imageDirectory;
imageDirectory.EnsureCapacity( g_SceneFiles.Count() );
// build directory
// directory is linear sorted by filename checksum for later binary search
for ( int i = 0; i < g_SceneFiles.Count(); i++ )
{
SceneImageEntry_t imageEntry = { 0 };
// name needs to be normalized for determinstic later CRC name calc
// calc crc based on scenes\anydir\anyscene.vcd
char szCleanName[MAX_PATH];
V_strncpy( szCleanName, g_SceneFiles[i].fileName.String(), sizeof( szCleanName ) );
V_strlower( szCleanName );
V_FixSlashes( szCleanName );
char *pName = V_stristr( szCleanName, "scenes\\" );
if ( !pName )
{
// must have scenes\ in filename
Error( "CreateSceneImageFile: Unexpected lack of scenes prefix on %s\n", g_SceneFiles[i].fileName.String() );
}
CRC32_t crcFilename = CRC32_ProcessSingleBuffer( pName, strlen( pName ) );
imageEntry.crcFilename = crcFilename;
// temp store an index to its file, fixup later, necessary to access post sort
imageEntry.nDataOffset = i;
if ( imageDirectory.Find( imageEntry ) != imageDirectory.InvalidIndex() )
{
// filename checksums must be unique or runtime binary search would be bogus
Error( "CreateSceneImageFile: Unexpected filename checksum collision!\n" );
}
imageDirectory.Insert( imageEntry );
}
// determine sort order and start of data after dynamic summaries
CUtlVector< int > writeOrder;
writeOrder.EnsureCapacity( g_SceneFiles.Count() );
sceneDataStart = sceneSummaryStart;
for ( int i = 0; i < imageDirectory.Count(); i++ )
{
// reclaim offset, indicates write order of scene file
int iScene = imageDirectory[i].nDataOffset;
writeOrder.AddToTail( iScene );
// march past each variable sized summary to determine start of scene data
int numSounds = g_SceneFiles[iScene].soundList.Count();
sceneDataStart += sizeof( SceneImageSummary_t ) + ( numSounds - 1 ) * sizeof( int );
}
// finalize and write directory
Assert( sceneEntryStart == targetBuffer.TellMaxPut() );
int nSummaryOffset = sceneSummaryStart;
int nDataOffset = sceneDataStart;
for ( int i = 0; i < imageDirectory.Count(); i++ )
{
int iScene = writeOrder[i];
imageDirectory[i].nDataOffset = nDataOffset;
imageDirectory[i].nDataLength = g_SceneFiles[iScene].compiledBuffer.TellMaxPut();
imageDirectory[i].nSceneSummaryOffset = nSummaryOffset;
if ( !bLittleEndian )
{
imageDirectory[i].crcFilename = BigLong( imageDirectory[i].crcFilename );
imageDirectory[i].nDataOffset = BigLong( imageDirectory[i].nDataOffset );
imageDirectory[i].nDataLength = BigLong( imageDirectory[i].nDataLength );
imageDirectory[i].nSceneSummaryOffset = BigLong( imageDirectory[i].nSceneSummaryOffset );
}
targetBuffer.Put( &imageDirectory[i], sizeof( SceneImageEntry_t ) );
int numSounds = g_SceneFiles[iScene].soundList.Count();
nSummaryOffset += sizeof( SceneImageSummary_t ) + (numSounds - 1) * sizeof( int );
nDataOffset += g_SceneFiles[iScene].compiledBuffer.TellMaxPut();
}
// finalize and write summaries
Assert( sceneSummaryStart == targetBuffer.TellMaxPut() );
for ( int i = 0; i < imageDirectory.Count(); i++ )
{
int iScene = writeOrder[i];
int msecs = g_SceneFiles[iScene].msecs;
int soundCount = g_SceneFiles[iScene].soundList.Count();
if ( !bLittleEndian )
{
msecs = BigLong( msecs );
soundCount = BigLong( soundCount );
}
targetBuffer.PutInt( msecs );
targetBuffer.PutInt( soundCount );
for ( int j = 0; j < g_SceneFiles[iScene].soundList.Count(); j++ )
{
int soundId = g_SceneFiles[iScene].soundList[j];
if ( !bLittleEndian )
{
soundId = BigLong( soundId );
}
targetBuffer.PutInt( soundId );
}
}
// finalize and write data
Assert( sceneDataStart == targetBuffer.TellMaxPut() );
for ( int i = 0; i < imageDirectory.Count(); i++ )
{
int iScene = writeOrder[i];
targetBuffer.Put( g_SceneFiles[iScene].compiledBuffer.Base(), g_SceneFiles[iScene].compiledBuffer.TellMaxPut() );
}
if ( !bQuiet )
{
Msg( "Scenes: Final size: %.2f MB\n", targetBuffer.TellMaxPut() / (1024.0f * 1024.0f ) );
}
// cleanup
g_SceneFiles.Purge();
return true;
}
