//-----------------------------------------------------------------------------
// 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;
}
