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 );
}
}
/// load the directory
void PlaceDirectory::Load( CUtlBuffer &fileBuffer, int version )
{
// read number of entries
IndexType count = fileBuffer.GetUnsignedShort();
m_directory.RemoveAll();
// read each entry
char placeName[256];
unsigned short len;
for( int i=0; i<count; ++i )
{
len = fileBuffer.GetUnsignedShort();
fileBuffer.Get( placeName, MIN( sizeof( placeName ), len ) );
Place place = TheNavMesh->NameToPlace( placeName );
if (place == UNDEFINED_PLACE)
{
Warning( "Warning: NavMesh place %s is undefined?\n", placeName );
}
AddPlace( place );
}
if ( version > 11 )
{
m_hasUnnamedAreas = fileBuffer.GetUnsignedChar() != 0;
}
}
bool CNetworkStringTable::ReadStringTable( CUtlBuffer& buf )
{
DeleteAllStrings();
int numstrings = buf.GetInt();
for ( int i = 0 ; i < numstrings; i++ )
{
char stringname[4096];
buf.GetString( stringname, sizeof( stringname ) );
if ( buf.GetChar() == 1 )
{
int userDataSize = (int)buf.GetShort();
Assert( userDataSize > 0 );
byte *data = new byte[ userDataSize + 4 ];
Assert( data );
buf.Get( data, userDataSize );
AddString( true, stringname, userDataSize, data );
delete[] data;
}
else
{
AddString( true, stringname );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Unserialization of low-res data
//-----------------------------------------------------------------------------
bool CVTFTexture::LoadLowResData( CUtlBuffer &buf )
{
// Allocate low-res bits
InitLowResImage( m_nLowResImageWidth, m_nLowResImageHeight, m_LowResImageFormat );
int nLowResImageSize = ImageLoader::GetMemRequired( m_nLowResImageWidth,
m_nLowResImageHeight, m_LowResImageFormat, false );
buf.Get( m_pLowResImageData, nLowResImageSize );
return buf.IsValid();
}
void CStaticPropMgr::UnserializeLeafList( CUtlBuffer& buf )
{
int nCount = buf.GetInt();
m_StaticPropLeaves.Purge();
if ( nCount > 0 )
{
m_StaticPropLeaves.AddMultipleToTail( nCount );
buf.Get( m_StaticPropLeaves.Base(), nCount * sizeof(StaticPropLeafLump_t) );
}
}
//-----------------------------------------------------------------------------
// Unserialization of image data
//-----------------------------------------------------------------------------
bool CVTFTexture::LoadImageData( CUtlBuffer &buf, const VTFFileHeader_t &header, int nSkipMipLevels )
{
// Fix up the mip count + size based on how many mip levels we skip...
if (nSkipMipLevels > 0)
{
Assert( m_nMipCount > nSkipMipLevels );
if (header.numMipLevels < nSkipMipLevels)
{
// NOTE: This can only happen with older format .vtf files
Warning("Warning! Encountered old format VTF file; please rebuild it!\n");
return false;
}
ComputeMipLevelDimensions( nSkipMipLevels, &m_nWidth, &m_nHeight );
m_nMipCount -= nSkipMipLevels;
}
// read the texture image (including mipmaps if they are there and needed.)
int iImageSize = ComputeFaceSize( );
iImageSize *= m_nFaceCount * m_nFrameCount;
// For backwards compatibility, we don't read in the spheremap fallback on
// older format .VTF files...
int nFacesToRead = m_nFaceCount;
if (IsCubeMap())
{
if ((header.version[0] == 7) && (header.version[1] < 1))
nFacesToRead = 6;
}
// NOTE: We load the bits this way because we store the bits in memory
// differently that the way they are stored on disk; we store on disk
// differently so we can only load up
// NOTE: The smallest mip levels are stored first!!
AllocateImageData( iImageSize );
for (int iMip = m_nMipCount; --iMip >= 0; )
{
// NOTE: This is for older versions...
if (header.numMipLevels - nSkipMipLevels <= iMip)
continue;
int iMipSize = ComputeMipSize( iMip );
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame)
{
for (int iFace = 0; iFace < nFacesToRead; ++iFace)
{
unsigned char *pMipBits = ImageData( iFrame, iFace, iMip );
buf.Get( pMipBits, iMipSize );
}
}
}
return buf.IsValid();
}
void CVradStaticPropMgr::UnserializeModelDict( CUtlBuffer& buf )
{
int count = buf.GetInt();
while ( --count >= 0 )
{
StaticPropDictLump_t lump;
buf.Get( &lump, sizeof(StaticPropDictLump_t) );
CreateCollisionModel( lump.m_Name );
}
}
//-----------------------------------------------------------------------------
// Is it a PSD file?
//-----------------------------------------------------------------------------
bool IsPSDFile( CUtlBuffer &buf )
{
int nGet = buf.TellGet();
PSDHeader_t header;
buf.Get( &header, sizeof(header) );
buf.SeekGet( CUtlBuffer::SEEK_HEAD, nGet );
if ( BigLong( header.m_nSignature ) != PSD_SIGNATURE )
return false;
if ( BigShort( header.m_nVersion ) != 1 )
return false;
return ( BigShort( header.m_nDepth ) == 8 );
}
//-----------------------------------------------------------------------------
// Creates a collision model (based on the render geometry!)
//-----------------------------------------------------------------------------
void CVradStaticPropMgr::CreateCollisionModel( char const* pModelName )
{
CUtlBuffer buf;
CUtlBuffer bufvtx;
CUtlBuffer bufphy;
int i = m_StaticPropDict.AddToTail( );
m_StaticPropDict[i].m_pModel = 0;
if (!LoadStudioModel( pModelName, buf ))
{
VectorCopy( vec3_origin, m_StaticPropDict[i].m_Mins );
VectorCopy( vec3_origin, m_StaticPropDict[i].m_Maxs );
return;
}
// if (!LoadStudioModelVtx( pModelName, bufvtx ))
// return;
studiohdr_t* pHdr = (studiohdr_t*)buf.Base();
// OptimizedModel::FileHeader_t* pVtxHdr = (OptimizedModel::FileHeader_t*)bufvtx.Base();
VectorCopy( pHdr->hull_min, m_StaticPropDict[i].m_Mins );
VectorCopy( pHdr->hull_max, m_StaticPropDict[i].m_Maxs );
if ( LoadStudioCollisionModel( pModelName, bufphy ) )
{
phyheader_t header;
bufphy.Get( &header, sizeof(header) );
vcollide_t *pCollide = &m_StaticPropDict[i].m_loadedModel;
s_pPhysCollision->VCollideLoad( pCollide, header.solidCount, (const char *)bufphy.PeekGet(), bufphy.TellPut() - bufphy.TellGet() );
m_StaticPropDict[i].m_pModel = m_StaticPropDict[i].m_loadedModel.solids[0];
/*
static int propNum = 0;
char tmp[128];
sprintf( tmp, "staticprop%03d.txt", propNum );
DumpCollideToGlView( pCollide, tmp );
++propNum;
*/
}
else
{
// mark this as unused
m_StaticPropDict[i].m_loadedModel.solidCount = 0;
// CPhysCollide* pPhys = CreatePhysCollide( pHdr, pVtxHdr );
m_StaticPropDict[i].m_pModel = ComputeConvexHull( pHdr );
}
}
//-----------------------------------------------------------------------------
// Unserialize static prop model dictionary
//-----------------------------------------------------------------------------
void CStaticPropMgr::UnserializeModelDict( CUtlBuffer& buf )
{
int count = buf.GetInt();
while ( --count >= 0 )
{
StaticPropDictLump_t lump;
buf.Get( &lump, sizeof(StaticPropDictLump_t) );
StaticPropDict_t dict;
dict.m_pModel = (model_t *)modelloader->GetModelForName(
lump.m_Name, IModelLoader::FMODELLOADER_STATICPROP );
m_StaticPropDict.AddToTail( dict );
}
}
//-----------------------------------------------------------------------------
// Deals with compressed channels
//-----------------------------------------------------------------------------
static void PSDReadCompressedChannels( CUtlBuffer &buf, int nChannelsCount, PSDMode_t mode, PSDPalette_t &palette, Bitmap_t &bitmap )
{
unsigned char *pChannelRow = (unsigned char*)_alloca( bitmap.m_nWidth );
for ( int i=0; i<nChannelsCount; ++i )
{
int nIndex = s_pChannelIndex[mode][i];
Assert( nIndex != -1 );
unsigned char *pDest = bitmap.m_pBits;
for( int j=0; j < bitmap.m_nHeight; ++j )
{
unsigned char *pSrc = pChannelRow;
unsigned int nPixelsRemaining = bitmap.m_nWidth;
while ( nPixelsRemaining > 0 )
{
int nCount = buf.GetChar();
if ( nCount >= 0 )
{
// If nCount is between 0 + 7F, it means copy the next nCount+1 bytes directly
++nCount;
Assert( (unsigned int)nCount <= nPixelsRemaining );
buf.Get( pSrc, nCount );
}
else
{
// If nCount is between 80 and FF, it means replicate the next byte -Count+1 times
nCount = -nCount + 1;
Assert( (unsigned int)nCount <= nPixelsRemaining );
unsigned char nPattern = buf.GetUnsignedChar();
memset( pSrc, nPattern, nCount );
}
pSrc += nCount;
nPixelsRemaining -= nCount;
}
Assert( nPixelsRemaining == 0 );
// Collate the channels together
for ( int k = 0; k < bitmap.m_nWidth; ++k, pDest += 4 )
{
pDest[nIndex] = pChannelRow[k];
}
}
}
PSDConvertToRGBA8888( nChannelsCount, mode, palette, bitmap );
}
static void UnserializeSpriteDict( CUtlBuffer& buf )
{
// Get origin offset for each model...
int count = buf.GetInt();
while ( --count >= 0 )
{
DetailSpriteDictLump_t lump;
buf.Get( &lump, sizeof(DetailSpriteDictLump_t) );
// For these sprites, x goes out the front, y right, z up
int i = g_SpriteCenterOffset.AddToTail();
g_SpriteCenterOffset[i].x = 0.0f;
g_SpriteCenterOffset[i].y = lump.m_LR.x + lump.m_UL.x;
g_SpriteCenterOffset[i].z = lump.m_LR.y + lump.m_UL.y;
g_SpriteCenterOffset[i] *= 0.5f;
}
}
bool Unserialize( CUtlBuffer &buf, VMatrix &dest )
{
if ( !buf.IsValid() )
return false;
if ( buf.IsText() )
{
int nRetVal = buf.Scanf( "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
&dest[ 0 ][ 0 ], &dest[ 0 ][ 1 ], &dest[ 0 ][ 2 ], &dest[ 0 ][ 3 ],
&dest[ 1 ][ 0 ], &dest[ 1 ][ 1 ], &dest[ 1 ][ 2 ], &dest[ 1 ][ 3 ],
&dest[ 2 ][ 0 ], &dest[ 2 ][ 1 ], &dest[ 2 ][ 2 ], &dest[ 2 ][ 3 ],
&dest[ 3 ][ 0 ], &dest[ 3 ][ 1 ], &dest[ 3 ][ 2 ], &dest[ 3 ][ 3 ] );
return (nRetVal == 16);
}
buf.Get( &dest, sizeof(VMatrix) );
return true;
}
bool Unserialize( CUtlBuffer &buf, CUtlBinaryBlock &dest )
{
if ( !buf.IsText() )
{
int nLen = buf.GetInt( );
dest.SetLength( nLen );
if ( dest.Length() != 0 )
{
buf.Get( dest.Get(), dest.Length() );
}
if ( nLen != dest.Length() )
{
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLen - dest.Length() );
return false;
}
return buf.IsValid();
}
int nEndGet;
int nByteCount = CountBinaryBytes( buf, &nEndGet );
if ( nByteCount < 0 )
return false;
buf.EatWhiteSpace();
int nDest = 0;
dest.SetLength( nByteCount );
while( buf.TellGet() < nEndGet )
{
char c1 = buf.GetChar();
char c2 = buf.GetChar();
unsigned char b1 = HexCharToInt( c1 );
unsigned char b2 = HexCharToInt( c2 );
if ( b1 == 0xFF || b2 == 0xFF )
return false;
dest[ nDest++ ] = b2 | ( b1 << 4 );
buf.EatWhiteSpace();
}
return true;
}
void CStaticPropMgr::UnserializeModels( CUtlBuffer& buf )
{
// Version check
if ( Mod_GameLumpVersion( GAMELUMP_STATIC_PROPS ) < 4 )
{
Warning("Really old map format! Static props can't be loaded...\n");
return;
}
int count = buf.GetInt();
// Gotta preallocate the static props here so no rellocations take place
// the leaf list stores pointers to these tricky little guys.
m_StaticProps.AddMultipleToTail(count);
for ( int i = 0; i < count; ++i )
{
StaticPropLump_t lump;
buf.Get( &lump, sizeof(StaticPropLump_t) );
m_StaticProps[i].Init( i, lump, m_StaticPropDict[lump.m_PropType].m_pModel );
// For distance-based fading, keep a list of the things that need
// to be faded out. Not sure if this is the optimal way of doing it
// but it's easy for now; we'll have to test later how large this list gets.
// If it's <100 or so, we should be fine
if (lump.m_Flags & STATIC_PROP_FLAG_FADES)
{
int idx = m_StaticPropFade.AddToTail();
StaticPropFade_t& fade = m_StaticPropFade[idx];
fade.m_Model = i;
fade.m_MinDistSq = lump.m_FadeMinDist * lump.m_FadeMinDist;
fade.m_MaxDistSq = lump.m_FadeMaxDist * lump.m_FadeMaxDist;
if (fade.m_MaxDistSq != fade.m_MinDistSq)
fade.m_FalloffFactor = 255.0f / (fade.m_MaxDistSq - fade.m_MinDistSq);
else
fade.m_FalloffFactor = 255.0f;
}
// Add the prop to the K-D tree for collision
m_StaticProps[i].InsertPropIntoKDTree( );
}
}
void CVradStaticPropMgr::UnserializeModels( CUtlBuffer& buf )
{
int count = buf.GetInt();
m_StaticProps.AddMultipleToTail(count);
for ( int i = 0; i < count; ++i )
{
StaticPropLump_t lump;
buf.Get( &lump, sizeof(StaticPropLump_t) );
VectorCopy( lump.m_Origin, m_StaticProps[i].m_Origin );
VectorCopy( lump.m_Angles, m_StaticProps[i].m_Angles );
m_StaticProps[i].m_ModelIdx = lump.m_PropType;
m_StaticProps[i].m_Handle = TREEDATA_INVALID_HANDLE;
// Add the prop to the tree for collision, but only if it isn't
// marked as not casting a shadow
if ((lump.m_Flags & STATIC_PROP_NO_SHADOW) == 0)
InsertPropIntoTree( i );
}
}
//-----------------------------------------------------------------------------
// Returns information about the PSD file
//-----------------------------------------------------------------------------
bool PSDGetInfo( CUtlBuffer &buf, int *pWidth, int *pHeight, ImageFormat *pImageFormat, float *pSourceGamma )
{
int nGet = buf.TellGet();
PSDHeader_t header;
buf.Get( &header, sizeof(header) );
buf.SeekGet( CUtlBuffer::SEEK_HEAD, nGet );
if ( BigLong( header.m_nSignature ) != PSD_SIGNATURE )
return false;
if ( BigShort( header.m_nVersion ) != 1 )
return false;
if ( BigShort( header.m_nDepth ) != 8 )
return false;
*pWidth = BigLong( header.m_nColumns );
*pHeight = BigLong( header.m_nRows );
*pImageFormat = BigShort( header.m_nChannels ) == 3 ? IMAGE_FORMAT_RGB888 : IMAGE_FORMAT_RGBA8888;
*pSourceGamma = ARTWORK_GAMMA;
return true;
}
//-----------------------------------------------------------------------------
// Get PSD file image resources
//-----------------------------------------------------------------------------
PSDImageResources PSDGetImageResources( CUtlBuffer &buf )
{
int nGet = buf.TellGet();
// Header
PSDHeader_t header;
buf.Get( &header, sizeof( header ) );
// Then palette
unsigned int numBytesPalette = BigLong( buf.GetUnsignedInt() );
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, numBytesPalette );
// Then image resources
unsigned int numBytesImgResources = BigLong( buf.GetUnsignedInt() );
PSDImageResources imgres( numBytesImgResources, ( unsigned char * ) buf.PeekGet() );
// Restore the seek
buf.SeekGet( CUtlBuffer::SEEK_HEAD, nGet );
return imgres;
}
static void PSDReadUncompressedChannels( CUtlBuffer &buf, int nChannelsCount, PSDMode_t mode, PSDPalette_t &palette, Bitmap_t &bitmap )
{
unsigned char *pChannelRow = (unsigned char*)_alloca( bitmap.m_nWidth );
for ( int i=0; i<nChannelsCount; ++i )
{
int nIndex = s_pChannelIndex[mode][i];
Assert( nIndex != -1 );
unsigned char *pDest = bitmap.m_pBits;
for( int j=0; j < bitmap.m_nHeight; ++j )
{
buf.Get( pChannelRow, bitmap.m_nWidth );
// Collate the channels together
for ( int k = 0; k < bitmap.m_nWidth; ++k, pDest += 4 )
{
pDest[nIndex] = pChannelRow[k];
}
}
}
PSDConvertToRGBA8888( nChannelsCount, mode, palette, bitmap );
}
//-----------------------------------------------------------------------------
// Unserialization
//-----------------------------------------------------------------------------
static void UnserializeModelDict( CUtlBuffer& buf )
{
// Get origin offset for each model...
int count = buf.GetInt();
while ( --count >= 0 )
{
DetailObjectDictLump_t lump;
buf.Get( &lump, sizeof(DetailObjectDictLump_t) );
int i = g_ModelCenterOffset.AddToTail();
CUtlBuffer mdlbuf;
if (LoadStudioModel( lump.m_Name, mdlbuf ))
{
studiohdr_t* pHdr = (studiohdr_t*)mdlbuf.Base();
VectorAdd( pHdr->hull_min, pHdr->hull_max, g_ModelCenterOffset[i] );
g_ModelCenterOffset[i] *= 0.5f;
}
else
{
g_ModelCenterOffset[i].Init(0,0,0);
}
}
}
//-----------------------------------------------------------------------------
// Creates a collision model (based on the render geometry!)
//-----------------------------------------------------------------------------
void CVradStaticPropMgr::CreateCollisionModel( char const* pModelName )
{
CUtlBuffer buf;
CUtlBuffer bufvtx;
CUtlBuffer bufphy;
int i = m_StaticPropDict.AddToTail();
m_StaticPropDict[i].m_pModel = NULL;
m_StaticPropDict[i].m_pStudioHdr = NULL;
if ( !LoadStudioModel( pModelName, buf ) )
{
VectorCopy( vec3_origin, m_StaticPropDict[i].m_Mins );
VectorCopy( vec3_origin, m_StaticPropDict[i].m_Maxs );
return;
}
studiohdr_t* pHdr = (studiohdr_t*)buf.Base();
// necessary for vertex access
SetCurrentModel( pHdr );
VectorCopy( pHdr->hull_min, m_StaticPropDict[i].m_Mins );
VectorCopy( pHdr->hull_max, m_StaticPropDict[i].m_Maxs );
if ( LoadStudioCollisionModel( pModelName, bufphy ) )
{
phyheader_t header;
bufphy.Get( &header, sizeof(header) );
vcollide_t *pCollide = &m_StaticPropDict[i].m_loadedModel;
s_pPhysCollision->VCollideLoad( pCollide, header.solidCount, (const char *)bufphy.PeekGet(), bufphy.TellPut() - bufphy.TellGet() );
m_StaticPropDict[i].m_pModel = m_StaticPropDict[i].m_loadedModel.solids[0];
/*
static int propNum = 0;
char tmp[128];
sprintf( tmp, "staticprop%03d.txt", propNum );
DumpCollideToGlView( pCollide, tmp );
++propNum;
*/
}
else
{
// mark this as unused
m_StaticPropDict[i].m_loadedModel.solidCount = 0;
// CPhysCollide* pPhys = CreatePhysCollide( pHdr, pVtxHdr );
m_StaticPropDict[i].m_pModel = ComputeConvexHull( pHdr );
}
// clone it
m_StaticPropDict[i].m_pStudioHdr = (studiohdr_t *)malloc( buf.Size() );
memcpy( m_StaticPropDict[i].m_pStudioHdr, (studiohdr_t*)buf.Base(), buf.Size() );
if ( !LoadVTXFile( pModelName, m_StaticPropDict[i].m_pStudioHdr, m_StaticPropDict[i].m_VtxBuf ) )
{
// failed, leave state identified as disabled
m_StaticPropDict[i].m_VtxBuf.Purge();
}
}
bool CBaseGameStats::LoadFromFile( void )
{
if ( filesystem->FileExists( gamestats->GetStatSaveFileName(), GAMESTATS_PATHID ) )
{
char fullpath[ 512 ];
filesystem->RelativePathToFullPath( gamestats->GetStatSaveFileName(), GAMESTATS_PATHID, fullpath, sizeof( fullpath ) );
StatsLog( "Loading stats from '%s'\n", fullpath );
}
CUtlBuffer buf;
if ( filesystem->ReadFile( gamestats->GetStatSaveFileName(), GAMESTATS_PATHID, buf ) )
{
bool bRetVal = true;
int version = buf.GetShort();
if ( version > GAMESTATS_FILE_VERSION )
return false; //file is beyond our comprehension
// Set global parse version
CBGSDriver.m_iLoadedVersion = version;
buf.Get( CBGSDriver.m_szLoadedUserID, 16 );
CBGSDriver.m_szLoadedUserID[ sizeof( CBGSDriver.m_szLoadedUserID ) - 1 ] = 0;
if ( s_szPseudoUniqueID[ 0 ] != 0 )
{
if ( Q_stricmp( CBGSDriver.m_szLoadedUserID, s_szPseudoUniqueID ) )
{
//UserID changed, blow away log!!!
filesystem->RemoveFile( gamestats->GetStatSaveFileName(), GAMESTATS_PATHID );
filesystem->RemoveFile( GAMESTATS_LOG_FILE, GAMESTATS_PATHID );
Warning( "Userid changed, clearing stats file\n" );
CBGSDriver.m_szLoadedUserID[0] = '\0';
CBGSDriver.m_iLoadedVersion = -1;
gamestats->m_BasicStats.Clear();
gamestats->LoadingEvent_PlayerIDDifferentThanLoadedStats();
bRetVal = false;
}
if ( version <= GAMESTATS_FILE_VERSION_OLD5 )
{
gamestats->m_BasicStats.Clear();
bRetVal = false;
}
else
{
// Peek ahead in buffer to see if we have the "no default stats" secret flag set.
int iCheckForStandardStatsInFile = *( int * )buf.PeekGet();
bool bValid = true;
if ( iCheckForStandardStatsInFile != GAMESTATS_STANDARD_NOT_SAVED )
{
//the GAMESTATS_STANDARD_NOT_SAVED flag coincides with user completion time, rewind so the gamestats parser can grab it
bValid = gamestats->m_BasicStats.ParseFromBuffer( buf, version );
}
else
{
// skip over the flag
buf.GetInt();
}
if( !bValid )
{
m_BasicStats.Clear();
}
if( ( buf.TellPut() - buf.TellGet() ) != 0 ) //more data left, must be custom data
{
gamestats->LoadCustomDataFromBuffer( buf );
}
}
}
return bRetVal;
}
else
{
filesystem->RemoveFile( GAMESTATS_LOG_FILE, GAMESTATS_PATHID );
}
return false;
}
//-----------------------------------------------------------------------------
// Unserialization
//-----------------------------------------------------------------------------
bool CVTFTexture::Unserialize( CUtlBuffer &buf, bool bBufferHeaderOnly, int nSkipMipLevels )
{
// When unserializing, we can skip a certain number of mip levels,
// and we also can just load everything but the image data
VTFFileHeader_t header;
memset( &header, 0, sizeof(VTFFileHeader_t) );
buf.Get( &header, sizeof(VTFFileHeader_t) );
if (!buf.IsValid())
{
Warning("*** Error unserializing VTF file... is the file empty?\n");
return false;
}
// Validity check
if ( Q_strncmp( header.fileTypeString, "VTF", 4 ) )
{
Warning("*** Tried to load a non-VTF file as a VTF file!\n");
return false;
}
if( header.version[0] != VTF_MAJOR_VERSION )
{
Warning("*** Encountered VTF file with an invalid version!\n");
return false;
}
if( (header.flags & TEXTUREFLAGS_ENVMAP) && (header.width != header.height) )
{
Warning("*** Encountered VTF non-square cubemap!\n");
return false;
}
if( header.width <= 0 || header.height <= 0 )
{
Warning( "*** Encountered VTF invalid texture size!\n" );
return false;
}
m_nWidth = header.width;
m_nHeight = header.height;
m_Format = header.imageFormat;
m_nFlags = header.flags;
m_nFrameCount = header.numFrames;
// NOTE: We're going to store space for all mip levels, even if we don't
// have data on disk for them. This is for backward compatibility
m_nMipCount = ComputeMipCount();
m_nFaceCount = (m_nFlags & TEXTUREFLAGS_ENVMAP) ? CUBEMAP_FACE_COUNT : 1;
m_vecReflectivity = header.reflectivity;
m_flBumpScale = header.bumpScale;
// FIXME: Why is this needed?
m_iStartFrame = header.startFrame;
// FIXME: Remove
// This is to make sure old-format .vtf files are read properly
m_pVersion[0] = header.version[0];
m_pVersion[1] = header.version[1];
if( header.lowResImageWidth == 0 || header.lowResImageHeight == 0 )
{
m_nLowResImageWidth = 0;
m_nLowResImageHeight = 0;
}
else
{
m_nLowResImageWidth = header.lowResImageWidth;
m_nLowResImageHeight = header.lowResImageHeight;
}
m_LowResImageFormat = header.lowResImageFormat;
// Helpful for us to be able to get VTF info without reading in a ton
if (bBufferHeaderOnly)
return true;
if (!LoadLowResData( buf ))
return false;
if (!LoadImageData( buf, header, nSkipMipLevels ))
return false;
return true;
}
void CSentence::ParseCloseCaption( CUtlBuffer& buf )
{
char token[ 4096 ];
while ( 1 )
{
// Format is
// language_name
// {
// PHRASE char streamlength "streambytes" starttime endtime
// PHRASE unicode streamlength "streambytes" starttime endtime
// }
buf.GetString( token );
if ( !stricmp( token, "}" ) )
break;
char language_name[ 128 ];
int language_id;
strcpy( language_name, token );
language_id = CCloseCaptionPhrase::LanguageForName( language_name );
Assert( language_id != -1 );
buf.GetString( token );
if ( stricmp( token, "{" ) )
break;
buf.GetString( token );
while ( 1 )
{
if ( !stricmp( token, "}" ) )
break;
if ( stricmp( token, "PHRASE" ) )
break;
char cc_type[32];
char cc_stream[ 512 ];
int cc_length;
float start, end;
memset( cc_stream, 0, sizeof( cc_stream ) );
buf.GetString( token );
strcpy( cc_type, token );
bool unicode = false;
if ( !stricmp( cc_type, "unicode" ) )
{
unicode = true;
}
else if ( stricmp( cc_type, "char" ) )
{
Assert( 0 );
}
buf.GetString( token );
cc_length = atoi( token );
Assert( cc_length >= 0 && cc_length < sizeof( cc_stream ) );
// Skip space
buf.GetChar();
buf.Get( cc_stream, cc_length );
cc_stream[ cc_length ] = 0;
wchar_t converted[ 256 ];
// FIXME: Do unicode parsing, raw data parsing
if ( unicode )
{
memcpy( converted, cc_stream, cc_length );
cc_length /= 2;
converted[ cc_length ] = L'\0';
}
else
{
#ifndef SWDS // FIXME!!!!!!
ConvertANSIToUnicode( cc_stream, converted, sizeof( converted ) );
#endif
}
// Skip space
buf.GetChar();
buf.GetString( token );
start = atof( token );
buf.GetString( token );
end = atof( token );
CCloseCaptionPhrase *phrase = new CCloseCaptionPhrase( converted );
phrase->SetStartTime( start );
phrase->SetEndTime( end );
//phrase->SetType( cc_type );
AddCloseCaptionPhrase( language_id, phrase );
buf.GetString( token );
}
}
}
// This is obsolete, so it doesn't do anything with the data which is parsed.
void CSentence::ParseCloseCaption( CUtlBuffer& buf )
{
char token[ 4096 ];
while ( 1 )
{
// Format is
// language_name
// {
// PHRASE char streamlength "streambytes" starttime endtime
// PHRASE unicode streamlength "streambytes" starttime endtime
// }
buf.GetString( token );
if ( !stricmp( token, "}" ) )
break;
buf.GetString( token );
if ( stricmp( token, "{" ) )
break;
buf.GetString( token );
while ( 1 )
{
if ( !stricmp( token, "}" ) )
break;
if ( stricmp( token, "PHRASE" ) )
break;
char cc_type[32];
char cc_stream[ 4096 ];
int cc_length;
memset( cc_stream, 0, sizeof( cc_stream ) );
buf.GetString( token );
Q_strncpy( cc_type, token, sizeof( cc_type ) );
bool unicode = false;
if ( !stricmp( cc_type, "unicode" ) )
{
unicode = true;
}
else if ( stricmp( cc_type, "char" ) )
{
Assert( 0 );
}
buf.GetString( token );
cc_length = atoi( token );
Assert( cc_length >= 0 && cc_length < sizeof( cc_stream ) );
// Skip space
buf.GetChar();
buf.Get( cc_stream, cc_length );
cc_stream[ cc_length ] = 0;
// Skip space
buf.GetChar();
buf.GetString( token );
buf.GetString( token );
buf.GetString( token );
}
}
}
//-----------------------------------------------------------------------------
// Reads the PSD file into the specified buffer
//-----------------------------------------------------------------------------
bool PSDReadFileRGBA8888( CUtlBuffer &buf, Bitmap_t &bitmap )
{
PSDHeader_t header;
buf.Get( &header, sizeof(header) );
if ( BigLong( header.m_nSignature ) != PSD_SIGNATURE )
return false;
if ( BigShort( header.m_nVersion ) != 1 )
return false;
if ( BigShort( header.m_nDepth ) != 8 )
return false;
PSDMode_t mode = (PSDMode_t)BigShort( header.m_nMode );
int nChannelsCount = BigShort( header.m_nChannels );
if ( mode == MODE_MULTICHANNEL || mode == MODE_LAB )
return false;
switch ( mode )
{
case MODE_RGBA:
if ( nChannelsCount < 3 )
return false;
break;
case MODE_GREYSCALE:
case MODE_PALETTIZED:
if ( nChannelsCount != 1 && nChannelsCount != 2 )
return false;
break;
case MODE_CMYK:
if ( nChannelsCount < 4 )
return false;
break;
default:
Warning( "Unsupported PSD color mode!\n" );
return false;
}
int nWidth = BigLong( header.m_nColumns );
int nHeight = BigLong( header.m_nRows );
// Skip parts of memory we don't care about
int nColorModeSize = BigLong( buf.GetUnsignedInt() );
Assert( nColorModeSize % 3 == 0 );
unsigned char *pPaletteBits = (unsigned char*)_alloca( nColorModeSize );
PSDPalette_t palette;
palette.m_pRed = palette.m_pGreen = palette.m_pBlue = 0;
if ( nColorModeSize )
{
int nPaletteSize = nColorModeSize / 3;
buf.Get( pPaletteBits, nColorModeSize );
palette.m_pRed = pPaletteBits;
palette.m_pGreen = palette.m_pRed + nPaletteSize;
palette.m_pBlue = palette.m_pGreen + nPaletteSize;
}
int nImageResourcesSize = BigLong( buf.GetUnsignedInt() );
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nImageResourcesSize );
int nLayersSize = BigLong( buf.GetUnsignedInt() );
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLayersSize );
unsigned short nCompressionType = BigShort( buf.GetShort() );
bitmap.Init( nWidth, nHeight, IMAGE_FORMAT_RGBA8888 );
bool bSecondPassCMYKA = ( nChannelsCount > 4 && mode == MODE_CMYK );
if ( nCompressionType == 0 )
{
PSDReadUncompressedChannels( buf, ( nChannelsCount > 4 ) ? 4 : nChannelsCount, mode, palette, bitmap );
}
else
{
// Skip the data that indicates the length of each compressed row in bytes
// NOTE: There are two bytes per row per channel
unsigned int nLineLengthData = sizeof(unsigned short) * bitmap.m_nHeight * nChannelsCount;
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLineLengthData );
PSDReadCompressedChannels( buf, ( nChannelsCount > 4 ) ? 4 : nChannelsCount, mode, palette, bitmap );
}
// Read the alpha in a second pass for CMYKA
if ( bSecondPassCMYKA )
{
if ( nCompressionType == 0 )
{
PSDReadUncompressedChannels( buf, 1, MODE_COUNT, palette, bitmap );
}
else
{
PSDReadCompressedChannels( buf, 1, MODE_COUNT, palette, bitmap );
}
}
return true;
}
