//-----------------------------------------------------------------------------
// Purpose: chooses and loads the text page to display that describes mapName map
//-----------------------------------------------------------------------------
void CTeamMenu::LoadMapPage( const char *mapName )
{
// Save off the map name so we can re-load the page in ApplySchemeSettings().
Q_strncpy( m_szMapName, mapName, strlen( mapName ) + 1 );
char mapRES[ MAX_PATH ];
char uilanguage[ 64 ];
engine->GetUILanguage( uilanguage, sizeof( uilanguage ) );
Q_snprintf( mapRES, sizeof( mapRES ), "resource/maphtml/%s_%s.html", mapName, uilanguage );
bool bFoundHTML = false;
if ( !g_pFullFileSystem->FileExists( mapRES ) )
{
// try english
Q_snprintf( mapRES, sizeof( mapRES ), "resource/maphtml/%s_english.html", mapName );
}
else
{
bFoundHTML = true;
}
if( bFoundHTML || g_pFullFileSystem->FileExists( mapRES ) )
{
// it's a local HTML file
char localURL[ _MAX_PATH + 7 ];
Q_strncpy( localURL, "file://", sizeof( localURL ) );
char pPathData[ _MAX_PATH ];
g_pFullFileSystem->GetLocalPath( mapRES, pPathData, sizeof(pPathData) );
Q_strncat( localURL, pPathData, sizeof( localURL ), COPY_ALL_CHARACTERS );
// force steam to dump a local copy
g_pFullFileSystem->GetLocalCopy( pPathData );
m_pMapInfo->SetVisible( false );
#if defined( ENABLE_HTML_WINDOW )
m_pMapInfoHTML->SetVisible( true );
m_pMapInfoHTML->OpenURL( localURL, NULL );
#endif
InvalidateLayout();
Repaint();
return;
}
else
{
m_pMapInfo->SetVisible( true );
#if defined( ENABLE_HTML_WINDOW )
m_pMapInfoHTML->SetVisible( false );
#endif
}
Q_snprintf( mapRES, sizeof( mapRES ), "maps/%s.txt", mapName);
// if no map specific description exists, load default text
if( !g_pFullFileSystem->FileExists( mapRES ) )
{
if ( g_pFullFileSystem->FileExists( "maps/default.txt" ) )
{
Q_snprintf ( mapRES, sizeof( mapRES ), "maps/default.txt");
}
else
{
m_pMapInfo->SetText( "" );
return;
}
}
FileHandle_t f = g_pFullFileSystem->Open( mapRES, "r" );
// read into a memory block
int fileSize = g_pFullFileSystem->Size(f);
int dataSize = fileSize + sizeof( wchar_t );
if ( dataSize % 2 )
++dataSize;
wchar_t *memBlock = (wchar_t *)malloc(dataSize);
memset( memBlock, 0x0, dataSize);
int bytesRead = g_pFullFileSystem->Read(memBlock, fileSize, f);
if ( bytesRead < fileSize )
{
// NULL-terminate based on the length read in, since Read() can transform \r\n to \n and
// return fewer bytes than we were expecting.
char *data = reinterpret_cast<char *>( memBlock );
data[ bytesRead ] = 0;
data[ bytesRead+1 ] = 0;
}
#ifndef WIN32
if ( ((ucs2 *)memBlock)[0] == 0xFEFF )
{
// convert the win32 ucs2 data to wchar_t
dataSize*=2;// need to *2 to account for ucs2 to wchar_t (4byte) growth
wchar_t *memBlockConverted = (wchar_t *)malloc(dataSize);
V_UCS2ToUnicode( (ucs2 *)memBlock, memBlockConverted, dataSize );
free(memBlock);
memBlock = memBlockConverted;
}
#else
// null-terminate the stream (redundant, since we memset & then trimmed the transformed buffer already)
memBlock[dataSize / sizeof(wchar_t) - 1] = 0x0000;
#endif
// ensure little-endian unicode reads correctly on all platforms
CByteswap byteSwap;
byteSwap.SetTargetBigEndian( false );
byteSwap.SwapBufferToTargetEndian( memBlock, memBlock, dataSize/sizeof(wchar_t) );
// check the first character, make sure this a little-endian unicode file
if ( memBlock[0] != 0xFEFF )
{
// its a ascii char file
m_pMapInfo->SetText( reinterpret_cast<char *>( memBlock ) );
}
else
{
m_pMapInfo->SetText( memBlock+1 );
}
// go back to the top of the text buffer
m_pMapInfo->GotoTextStart();
g_pFullFileSystem->Close( f );
free(memBlock);
InvalidateLayout();
Repaint();
}
//-----------------------------------------------------------------------------
// Load the bsp file
//-----------------------------------------------------------------------------
bool LoadBSPFile( const char* pFilename, void **ppBSPBuffer, int *pBSPSize )
{
CByteswap byteSwap;
*ppBSPBuffer = NULL;
*pBSPSize = 0;
FILE *fp = fopen( pFilename, "rb" );
if ( fp )
{
fseek( fp, 0, SEEK_END );
int size = ftell( fp );
fseek( fp, 0, SEEK_SET );
*ppBSPBuffer = malloc( size );
if ( !*ppBSPBuffer )
{
Warning( "Failed to alloc %d bytes\n", size );
goto cleanUp;
}
*pBSPSize = size;
fread( *ppBSPBuffer, size, 1, fp );
fclose( fp );
}
else
{
if ( !g_bQuiet )
{
Warning( "Missing %s\n", pFilename );
}
goto cleanUp;
}
dheader_t *pBSPHeader = (dheader_t *)*ppBSPBuffer;
if ( pBSPHeader->ident != IDBSPHEADER )
{
if ( pBSPHeader->ident != BigLong( IDBSPHEADER ) )
{
if ( !g_bQuiet )
{
Warning( "BSP %s has bad id: got %d, expected %d\n", pFilename, pBSPHeader->ident, IDBSPHEADER );
}
goto cleanUp;
}
else
{
// bsp is for 360, swap the header
byteSwap.ActivateByteSwapping( true );
byteSwap.SwapFieldsToTargetEndian( pBSPHeader );
}
}
if ( pBSPHeader->version < MINBSPVERSION || pBSPHeader->version > BSPVERSION )
{
if ( !g_bQuiet )
{
Warning( "BSP %s has bad version: got %d, expected %d\n", pFilename, pBSPHeader->version, BSPVERSION );
}
goto cleanUp;
}
// sucess
return true;
cleanUp:
if ( *ppBSPBuffer )
{
free( *ppBSPBuffer );
*ppBSPBuffer = NULL;
}
return false;
}
const void *FindSceneFile( CFlex *instance, const char *filename, bool allowBlockingIO )
{
// See if it's already loaded
int i;
for ( i = 0; i < m_FileList.Size(); i++ )
{
CFlexSceneFile *file = m_FileList[ i ];
if ( file && !stricmp( file->filename, filename ) )
{
// Make sure translations (local to global flex controller) are set up for this instance
EnsureTranslations( instance, ( const flexsettinghdr_t * )file->buffer );
return file->buffer;
}
}
if ( !allowBlockingIO )
{
return NULL;
}
// Load file into memory
void *buffer = NULL;
int len = filesystem->ReadFileEx( UTIL_VarArgs( "expressions/%s.vfe", filename ), "GAME", &buffer, false, true );
if ( !len )
return NULL;
// Create scene entry
CFlexSceneFile *pfile = new CFlexSceneFile;
// Remember filename
Q_strncpy( pfile->filename, filename, sizeof( pfile->filename ) );
// Remember data pointer
pfile->buffer = buffer;
// Add to list
m_FileList.AddToTail( pfile );
// Swap the entire file
if ( IsX360() )
{
CByteswap swap;
swap.ActivateByteSwapping( true );
byte *pData = (byte*)buffer;
flexsettinghdr_t *pHdr = (flexsettinghdr_t*)pData;
swap.SwapFieldsToTargetEndian( pHdr );
// Flex Settings
flexsetting_t *pFlexSetting = (flexsetting_t*)((byte*)pHdr + pHdr->flexsettingindex);
for ( int i = 0; i < pHdr->numflexsettings; ++i, ++pFlexSetting )
{
swap.SwapFieldsToTargetEndian( pFlexSetting );
flexweight_t *pWeight = (flexweight_t*)(((byte*)pFlexSetting) + pFlexSetting->settingindex );
for ( int j = 0; j < pFlexSetting->numsettings; ++j, ++pWeight )
{
swap.SwapFieldsToTargetEndian( pWeight );
}
}
// indexes
pData = (byte*)pHdr + pHdr->indexindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numindexes );
// keymappings
pData = (byte*)pHdr + pHdr->keymappingindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numkeys );
// keyname indices
pData = (byte*)pHdr + pHdr->keynameindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numkeys );
}
// Fill in translation table
EnsureTranslations( instance, ( const flexsettinghdr_t * )pfile->buffer );
// Return data
return pfile->buffer;
}
//-----------------------------------------------------------------------------
// Purpose: creates the font. returns false if the font cannot be mounted.
//-----------------------------------------------------------------------------
bool CBitmapFont::Create( const char *pFontFilename, float scalex, float scaley, int flags )
{
MEM_ALLOC_CREDIT();
if ( !pFontFilename || !pFontFilename[0] )
{
return false;
}
CUtlSymbol symbol;
char fontName[MAX_PATH];
Q_FileBase( pFontFilename, fontName, MAX_PATH );
Q_strlower( fontName );
symbol = fontName;
// find a match that can use same entries
BitmapFontTable_t *pFontTable = NULL;
for ( int i=0; i<g_BitmapFontTable.Count(); i++ )
{
if ( symbol == g_BitmapFontTable[i].m_szName )
{
m_bitmapFontHandle = i;
pFontTable = &g_BitmapFontTable[m_bitmapFontHandle];
break;
}
}
if ( !pFontTable )
{
void *pBuf = NULL;
int nLength;
nLength = FontManager().FileSystem()->ReadFileEx( pFontFilename, "GAME", &pBuf );
if ( nLength <= 0 || !pBuf )
{
// not found
return false;
}
if ( ((BitmapFont_t*)pBuf)->m_id != LittleLong( BITMAPFONT_ID ) || ((BitmapFont_t*)pBuf)->m_Version != LittleLong( BITMAPFONT_VERSION ) )
{
// bad version
return false;
}
if ( IsX360() )
{
CByteswap swap;
swap.ActivateByteSwapping( true );
swap.SwapFieldsToTargetEndian( (BitmapFont_t*)pBuf );
swap.SwapFieldsToTargetEndian( (BitmapGlyph_t*)((char*)pBuf + sizeof( BitmapFont_t )), ((BitmapFont_t*)pBuf)->m_NumGlyphs );
}
// create it
m_bitmapFontHandle = g_BitmapFontTable.AddToTail();
pFontTable = &g_BitmapFontTable[m_bitmapFontHandle];
pFontTable->m_szName = fontName;
pFontTable->m_pBitmapFont = new BitmapFont_t;
memcpy( pFontTable->m_pBitmapFont, pBuf, sizeof( BitmapFont_t ) );
pFontTable->m_pBitmapGlyphs = new BitmapGlyph_t[pFontTable->m_pBitmapFont->m_NumGlyphs];
memcpy( pFontTable->m_pBitmapGlyphs, (unsigned char*)pBuf + sizeof(BitmapFont_t), pFontTable->m_pBitmapFont->m_NumGlyphs*sizeof(BitmapGlyph_t) );
FontManager().FileSystem()->FreeOptimalReadBuffer( pBuf );
// load the art resources
char textureName[MAX_PATH];
Q_snprintf( textureName, MAX_PATH, "vgui/fonts/%s", fontName );
pFontTable->m_pTexture = FontManager().MaterialSystem()->FindTexture( textureName, TEXTURE_GROUP_VGUI );
#ifdef _DEBUG
if ( pFontTable->m_pBitmapFont->m_PageWidth != pFontTable->m_pTexture->GetActualWidth() ||
pFontTable->m_pBitmapFont->m_PageHeight != pFontTable->m_pTexture->GetActualHeight() )
{
// font is out of sync with its art
Assert( 0 );
return false;
}
#endif
// the font texture lives forever, ensure it doesn't get purged
pFontTable->m_pTexture->IncrementReferenceCount();
}
// setup font properties
m_scalex = scalex;
m_scaley = scaley;
// flags are derived from the baked font
m_iFlags = vgui::ISurface::FONTFLAG_BITMAP;
int bitmapFlags = pFontTable->m_pBitmapFont->m_Flags;
if ( bitmapFlags & BF_ANTIALIASED )
{
m_iFlags |= vgui::ISurface::FONTFLAG_ANTIALIAS;
}
if ( bitmapFlags & BF_ITALIC )
{
m_iFlags |= vgui::ISurface::FONTFLAG_ITALIC;
}
if ( bitmapFlags & BF_BLURRED )
{
m_iFlags |= vgui::ISurface::FONTFLAG_GAUSSIANBLUR;
m_iBlur = 1;
}
if ( bitmapFlags & BF_SCANLINES )
{
m_iScanLines = 1;
}
if ( bitmapFlags & BF_OUTLINED )
{
m_iFlags |= vgui::ISurface::FONTFLAG_OUTLINE;
m_iOutlineSize = 1;
}
if ( bitmapFlags & BF_DROPSHADOW )
{
m_iFlags |= vgui::ISurface::FONTFLAG_DROPSHADOW;
m_iDropShadowOffset = 1;
}
if ( flags & vgui::ISurface::FONTFLAG_ADDITIVE )
{
m_bAdditive = true;
m_iFlags |= vgui::ISurface::FONTFLAG_ADDITIVE;
}
m_iMaxCharWidth = (float)pFontTable->m_pBitmapFont->m_MaxCharWidth * m_scalex;
m_iHeight = (float)pFontTable->m_pBitmapFont->m_MaxCharHeight * m_scaley;
m_iAscent = (float)pFontTable->m_pBitmapFont->m_Ascent * m_scaley;
// mark as valid
m_szName = symbol;
return true;
}
