//-----------------------------------------------------------------------------
// Name: Glyphs.cpp
//
// Desc: Functions and global variables for keeping track of font glyphs
//
// Hist: 09.06.02 - Revised Fontmaker sample
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include "stdafx.h"
#include "Glyphs.h"
#include "FontMaker.h"
const COLORREF COLOR_WHITE = RGB(255,255,255);
const COLORREF COLOR_BLACK = RGB( 0, 0, 0);
const COLORREF COLOR_BLUE = RGB( 0, 0,255);
//-----------------------------------------------------------------------------
// Name: CTextureFont()
// Desc: Constructor
//-----------------------------------------------------------------------------
CTextureFont::CTextureFont()
{
ZeroMemory( this, sizeof( *this ) );
m_bIncludeNullCharacter = TRUE;
m_bAntialiasEffect = TRUE;
// Texture info
m_dwTextureWidth = 256;
m_dwTextureHeight = 256;
// Default glyph range
WORD wStartGlyph = 32;
WORD wEndGlyph = 255;
ExtractValidGlyphsFromRange( wStartGlyph, wEndGlyph );
}
//-----------------------------------------------------------------------------
// Name: ~CTextureFont()
// Desc: Destructor
//-----------------------------------------------------------------------------
CTextureFont::~CTextureFont()
{
DestroyObjects();
if ( m_hFont )
DeleteObject( m_hFont );
if ( m_pBits )
delete[] m_pBits;
m_pBits = NULL;
m_hFont = NULL;
}
//-----------------------------------------------------------------------------
// ClearFont
//-----------------------------------------------------------------------------
void CTextureFont::ClearFont()
{
DestroyObjects();
ZeroMemory( &m_LogFont, sizeof(LOGFONT) );
m_strFontName[0] = '\0';
m_hFont = NULL;
m_dwTextureWidth = 256;
m_dwTextureHeight = 256;
m_bAntialiasEffect = FALSE;
m_bShadowEffect = FALSE;
m_bOutlineEffect = FALSE;
m_nBlur = 0;
m_nScanlines = 0;
}
//-----------------------------------------------------------------------------
// Name: DestroyObjects()
// Desc: Cleans up all allocated resources for the class
//-----------------------------------------------------------------------------
VOID CTextureFont::DestroyObjects()
{
if ( m_pGlyphs )
delete[] m_pGlyphs;
if ( m_ValidGlyphs )
delete[] m_ValidGlyphs;
if ( m_TranslatorTable )
delete[] m_TranslatorTable;
if ( m_pCustomFilename )
{
TL_Free( (void*)m_pCustomFilename );
m_pCustomFilename = NULL;
for (DWORD i=0; i<m_dwNumGlyphs; i++)
{
if ( m_pCustomGlyphFiles[i] )
{
TL_Free( m_pCustomGlyphFiles[i] );
m_pCustomGlyphFiles[i] = NULL;
}
}
}
m_cMaxGlyph = 0;
m_dwNumGlyphs = 0;
m_pGlyphs = NULL;
m_ValidGlyphs = NULL;
m_TranslatorTable = NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
HRESULT CTextureFont::InsertGlyph( WORD wGlyph )
{
m_cMaxGlyph = 0;
m_dwNumGlyphs = 0;
m_ValidGlyphs[wGlyph] = 1;
for ( DWORD c=0; c<=65535; c++ )
{
if ( m_ValidGlyphs[c] )
{
m_dwNumGlyphs++;
m_cMaxGlyph = (WCHAR)c;
}
}
BuildTranslatorTable();
theApp.CalculateAndRenderGlyphs();
return S_OK;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
HRESULT CTextureFont::DeleteGlyph( WORD wGlyph )
{
m_cMaxGlyph = 0;
m_dwNumGlyphs = 0;
m_ValidGlyphs[wGlyph] = 0;
for ( DWORD c=0; c<=65535; c++ )
{
if ( m_ValidGlyphs[c] )
{
m_dwNumGlyphs++;
m_cMaxGlyph = (WCHAR)c;
}
}
BuildTranslatorTable();
theApp.CalculateAndRenderGlyphs();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: ExtractValidGlyphsFromRange()
// Desc: Set global variables to indicate we will be drawing all glyphs in the
// range specified.
//-----------------------------------------------------------------------------
HRESULT CTextureFont::ExtractValidGlyphsFromRange( WORD wStartGlyph, WORD wEndGlyph )
{
// Cleanup any previous entries
if( m_ValidGlyphs )
delete[] m_ValidGlyphs;
m_cMaxGlyph = 0;
m_dwNumGlyphs = 0;
m_ValidGlyphs = NULL;
// Allocate memory for the array of vaild glyphs
m_ValidGlyphs = new BYTE[65536];
ZeroMemory( m_ValidGlyphs, 65536 );
for( DWORD c=(DWORD)wStartGlyph; c<=(DWORD)wEndGlyph; c++ )
{
m_ValidGlyphs[c] = 1;
m_dwNumGlyphs++;
}
m_cMaxGlyph = wEndGlyph;
BuildTranslatorTable();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: ExtractValidGlyphsFromRange()
// Desc: Set global variables to indicate we will be drawing all glyphs that
// are present in the specified text file.
//-----------------------------------------------------------------------------
HRESULT CTextureFont::ExtractValidGlyphsFromFile( const CHAR* strFileName )
{
// Open the file
FILE* file = fopen( strFileName, "rb" );
if( NULL == file )
return E_FAIL;
// Cleanup any previous entries
if( m_ValidGlyphs )
delete[] m_ValidGlyphs;
m_cMaxGlyph = 0;
m_dwNumGlyphs = 0;
m_ValidGlyphs = NULL;
// Allocate memory for the array of vaild glyphs
m_ValidGlyphs = new BYTE[65536];
ZeroMemory( m_ValidGlyphs, 65536 );
// Skip the unicode marker
BOOL bIsUnicode = (fgetwc(file) == 0xfeff) ? TRUE : FALSE;
if( bIsUnicode == FALSE )
rewind( file );
// Record which glyphs are valid
WCHAR c;
while( (WCHAR)EOF != ( c = bIsUnicode ? fgetwc(file) : fgetc(file) ) )
{
while( c == L'\\' )
{
c = bIsUnicode ? fgetwc(file) : fgetc(file);
// Handle octal-coded characters
if( isdigit(c) )
{
int code = (c - L'0');
c = bIsUnicode ? fgetwc(file) : fgetc(file);
if( isdigit(c) )
{
code = code*8 + (c - L'0');
c = bIsUnicode ? fgetwc(file) : fgetc(file);
if( isdigit(c) )
{
code = code*8 + (c - L'0');
c = bIsUnicode ? fgetwc(file) : fgetc(file);
}
}
if( m_ValidGlyphs[code] == 0 )
{
if( code > m_cMaxGlyph )
m_cMaxGlyph = (WCHAR)code;
m_dwNumGlyphs++;
m_ValidGlyphs[code] = 2;
}
}
else
{
// Add the backslash character
if( L'\\' > m_cMaxGlyph )
m_cMaxGlyph = L'\\';
if( m_ValidGlyphs[L'\\'] == 0 )
{
m_dwNumGlyphs++;
m_ValidGlyphs[L'\\'] = 1;
}
}
}
if( m_ValidGlyphs[c] == 0 )
{
// If the character is a printable one, add it
if( c != L'\n' && c != L'\r' && c != 0xffff )
{
m_dwNumGlyphs++;
m_ValidGlyphs[c] = 1;
if( c > m_cMaxGlyph )
m_cMaxGlyph = c;
}
}
}
// Done with the file
fclose( file );
BuildTranslatorTable();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: BuildTranslatorTable()
// Desc: Builds a table to translate from a WCHAR to a glyph index.
//-----------------------------------------------------------------------------
HRESULT CTextureFont::BuildTranslatorTable()
{
if ( m_TranslatorTable )
delete[] m_TranslatorTable;
// Insure the \0 is there
if ( m_bIncludeNullCharacter && 0 == m_ValidGlyphs[0] )
{
m_dwNumGlyphs++;
m_ValidGlyphs[0] = 1;
}
// Fill the string of all valid glyphs and build the translator table
m_TranslatorTable = new WORD[m_cMaxGlyph+1];
ZeroMemory( m_TranslatorTable, sizeof(WORD)*(m_cMaxGlyph+1) );
if ( !m_pCustomFilename )
{
// ttf has glyphs that are sequential
DWORD dwGlyph = 0;
for ( DWORD i=0; i<65536; i++ )
{
if ( m_ValidGlyphs[i] )
{
m_TranslatorTable[i] = (WORD)dwGlyph;
dwGlyph++;
}
}
}
else
{
// custom font has glyphs that are scattered
DWORD dwGlyph = 0;
for ( DWORD i=0; i<m_dwNumGlyphs; i++ )
{
if ( !i && m_bIncludeNullCharacter )
{
m_TranslatorTable[0] = 0;
dwGlyph++;
continue;
}
m_TranslatorTable[m_customGlyphs[i-1]] = (WORD)dwGlyph;
dwGlyph++;
}
}
return S_OK;
}
void StripQuotedToken( char *pToken )
{
int len = strlen( pToken );
if ( !len )
return;
if ( pToken[0] == '\"' && pToken[len-1] == '\"' )
{
memcpy( pToken, pToken+1, len-1 );
pToken[len-2] = '\0';
}
}
//-----------------------------------------------------------------------------
// ReadCustomFontFile
//-----------------------------------------------------------------------------
HRESULT CTextureFont::ReadCustomFontFile( CHAR* strFileName )
{
char *pToken;
char fontName[128];
bool bSuccess;
unsigned char glyphs[256];
char *glyphFiles[512];
char basePath[MAX_PATH];
int numGlyphs;
char filename[MAX_PATH];
bSuccess = false;
numGlyphs = 0;
ClearFont();
TL_LoadScriptFile( strFileName );
strcpy( basePath, strFileName );
TL_StripFilename( basePath );
TL_AddSeperatorToPath( basePath, basePath );
fontName[0] = '\0';
while ( 1 )
{
pToken = TL_GetToken( true );
if ( !pToken || !pToken[0] )
break;
StripQuotedToken( pToken );
// get font name
if ( !stricmp( pToken, "fontName" ) )
{
pToken = TL_GetToken( true );
if ( !pToken || !pToken[0] )
goto cleanUp;
StripQuotedToken( pToken );
strcpy( fontName, pToken );
continue;
}
// get glyph
if ( strlen( pToken ) != 1 )
goto cleanUp;
glyphs[numGlyphs] = pToken[0];
// get glyph file
pToken = TL_GetToken( true );
if ( !pToken || !pToken[0] )
goto cleanUp;
StripQuotedToken( pToken );
sprintf( filename, "%s%s", basePath, pToken );
glyphFiles[numGlyphs] = TL_CopyString( filename );
numGlyphs++;
if ( numGlyphs >= 256 )
break;
}
if ( numGlyphs == 0 )
goto cleanUp;
m_pCustomFilename = TL_CopyString( strFileName );
strcpy ( m_strFontName, fontName );
m_dwTextureWidth = 256;
m_dwTextureHeight = 256;
m_ValidGlyphs = new BYTE[65536];
ZeroMemory( m_ValidGlyphs, 65536 );
m_dwNumGlyphs = numGlyphs;
m_cMaxGlyph = 0;
for (int i=0; i<numGlyphs; i++)
{
m_ValidGlyphs[glyphs[i]] = 1;
if ( m_cMaxGlyph < glyphs[i] )
m_cMaxGlyph = glyphs[i];
m_customGlyphs[i] = glyphs[i];
m_pCustomGlyphFiles[i] = glyphFiles[i];
}
BuildTranslatorTable();
bSuccess = true;
cleanUp:
TL_FreeScriptFile();
return bSuccess ? S_OK : E_FAIL;
}
//-----------------------------------------------------------------------------
// Name: ReadFontInfoFile()
// Desc: Loads the font's glyph info from a file
//-----------------------------------------------------------------------------
HRESULT CTextureFont::ReadFontInfoFile( CHAR* strFileName )
{
BitmapFont_t bitmapFont;
// open the info file
FILE* file = fopen( strFileName, "rb" );
if ( NULL == file )
return E_FAIL;
memset( &bitmapFont, 0, sizeof( BitmapFont_t ) );
fread( &bitmapFont, 1, sizeof( BitmapFont_t ), file );
if ( bitmapFont.m_id != BITMAPFONT_ID || bitmapFont.m_Version != BITMAPFONT_VERSION )
{
return E_FAIL;
}
theApp.SetTextureSize( bitmapFont.m_PageWidth, bitmapFont.m_PageHeight );
ZeroMemory( m_ValidGlyphs, 65536 );
m_dwNumGlyphs = 0;
m_cMaxGlyph = 0;
for (int i=0; i<256; i++)
{
if ( bitmapFont.m_TranslateTable[i] )
{
m_ValidGlyphs[i] = 1;
m_cMaxGlyph = i;
m_dwNumGlyphs++;
}
}
BuildTranslatorTable();
// success
fclose( file );
theApp.OnGlyphsCustom();
theApp.CalculateAndRenderGlyphs();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: WriteFontInfoFile()
// Desc: Writes the font's glyph info to a file
//-----------------------------------------------------------------------------
HRESULT CTextureFont::WriteFontInfoFile( CHAR* strFileName )
{
BitmapFont_t bitmapFont;
BitmapGlyph_t bitmapGlyph;
// Create the info file
FILE* file = fopen( strFileName, "wb" );
if ( NULL == file )
return E_FAIL;
bitmapFont.m_id = BITMAPFONT_ID;
bitmapFont.m_Version = BITMAPFONT_VERSION;
bitmapFont.m_PageWidth = (short)m_dwTextureWidth;
bitmapFont.m_PageHeight = (short)m_dwTextureHeight;
bitmapFont.m_Ascent = 0;
bitmapFont.m_NumGlyphs = (short)m_dwNumGlyphs;
// generate flags
bitmapFont.m_Flags = 0;
if ( m_bAntialiasEffect )
{
bitmapFont.m_Flags |= BF_ANTIALIASED;
}
if ( m_bShadowEffect )
{
bitmapFont.m_Flags |= BF_DROPSHADOW;
}
if ( m_bOutlineEffect )
{
bitmapFont.m_Flags |= BF_OUTLINED;
}
if ( m_nBlur )
{
bitmapFont.m_Flags |= BF_BLURRED;
}
if ( m_nScanlines )
{
bitmapFont.m_Flags |= BF_SCANLINES;
}
if ( m_LogFont.lfItalic )
{
bitmapFont.m_Flags |= BF_ITALIC;
}
if ( m_LogFont.lfWeight > 400 )
{
bitmapFont.m_Flags |= BF_BOLD;
}
if ( m_pCustomFilename )
{
bitmapFont.m_Flags |= BF_CUSTOM;
}
// determine max char width from all glyphs
bitmapFont.m_MaxCharWidth = 0;
for (unsigned int i=0; i<m_dwNumGlyphs; i++ )
{
if ( bitmapFont.m_MaxCharWidth < m_pGlyphs[i].w )
{
bitmapFont.m_MaxCharWidth = m_pGlyphs[i].w;
}
}
bitmapFont.m_MaxCharHeight = 0;
for (unsigned int i=0; i<m_dwNumGlyphs; i++ )
{
if ( bitmapFont.m_MaxCharHeight < m_pGlyphs[i].h )
{
bitmapFont.m_MaxCharHeight = m_pGlyphs[i].h;
}
}
// maps a char index to its actual glyph
for (int i=0; i<256; i++)
{
if ( i <= m_cMaxGlyph )
{
bitmapFont.m_TranslateTable[i] = (unsigned char)m_TranslatorTable[i];
}
else
{
bitmapFont.m_TranslateTable[i] = 0;
}
}
// write out the header
fwrite( &bitmapFont, sizeof( BitmapFont_t ), 1, file );
// Write out the vertical padding caused by effects
// FLOAT fTopPadding = ( m_bOutlineEffect ? 1.0f : 0.0f );
// FLOAT fBottomPadding = ( m_bOutlineEffect ? ( m_bShadowEffect ? 2.0f : 1.0f ) : ( m_bShadowEffect ? 2.0f : 0.0f ) );
// FLOAT fFontYAdvance = fFontHeight - fTopPadding - fBottomPadding;
// Write the glyph attributes to the file
for (unsigned int i=0; i<m_dwNumGlyphs; i++ )
{
bitmapGlyph.x = m_pGlyphs[i].x;
bitmapGlyph.y = m_pGlyphs[i].y;
bitmapGlyph.w = m_pGlyphs[i].w;
bitmapGlyph.h = m_pGlyphs[i].h;
bitmapGlyph.a = m_pGlyphs[i].a;
bitmapGlyph.b = m_pGlyphs[i].b;
bitmapGlyph.c = m_pGlyphs[i].c;
fwrite( &bitmapGlyph, sizeof( BitmapGlyph_t ), 1, file );
}
// success
fclose( file );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: WriteTargaFile()
// Desc: Writes 32-bit RGBA data to a .tga file
//-----------------------------------------------------------------------------
HRESULT WriteTargaFile( CHAR* strFileName, DWORD dwWidth, DWORD dwHeight,
DWORD* pRGBAData )
{
struct TargaHeader
{
BYTE IDLength;
BYTE ColormapType;
BYTE ImageType;
BYTE ColormapSpecification[5];
WORD XOrigin;
WORD YOrigin;
WORD ImageWidth;
WORD ImageHeight;
BYTE PixelDepth;
BYTE ImageDescriptor;
} tga;
// Create the file
FILE* file = fopen( strFileName, "wb" );
if( NULL == file )
return E_FAIL;
// Write the TGA header
ZeroMemory( &tga, sizeof(tga) );
tga.IDLength = 0;
tga.ImageType = 2;
tga.ImageWidth = (WORD)dwWidth;
tga.ImageHeight = (WORD)dwHeight;
tga.PixelDepth = 32;
tga.ImageDescriptor = 0x28;
fwrite( &tga, sizeof(TargaHeader), 1, file );
// Write the pixels
fwrite( pRGBAData, sizeof(DWORD), dwHeight*dwWidth, file );
// Close the file and return okay
fclose( file );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: WriteFontImageFile()
// Desc: Writes 32-bit RGBA data to a .tga file
//-----------------------------------------------------------------------------
HRESULT CTextureFont::WriteFontImageFile( CHAR* strFileName, bool bAdditiveMode, bool bCustomFont )
{
// Convert the bits to have an alpha channel
DWORD* pRGBAData = new DWORD[m_dwTextureWidth*m_dwTextureHeight];
FLOAT l;
for ( DWORD i=0; i<m_dwTextureWidth*m_dwTextureHeight; i++ )
{
FLOAT a = ( ( 0xff000000 & m_pBits[i] ) >> 24L ) / 255.0f;
FLOAT r = ( ( 0x00ff0000 & m_pBits[i] ) >> 16L ) / 255.0f;
FLOAT g = ( ( 0x0000ff00 & m_pBits[i] ) >> 8L ) / 255.0f;
FLOAT b = ( ( 0x000000ff & m_pBits[i] ) >> 0L ) / 255.0f;
if ( bCustomFont )
{
if ( a == 0.0f && b == 1.0f )
{
// pure transluscent
a = 0;
r = g = b = 0.0f;
}
int red = (int)(r * 255.0f);
int green = (int)(g * 255.0f);
int blue = (int)(b * 255.0f);
int alpha = (int)(a * 255.0f);
pRGBAData[i] = (alpha<<24L) | (red<<16L) | (green<<8L) | (blue<<0L);
}
else
{
if ( bAdditiveMode )
{
// all channels should be same
if (( r != g ) || ( r != b ))
{
}
l = r;
a = 1.0f;
}
else
{
a = r + (1-b);
if ( a )
l = r / a;
else
l = 1;
}
DWORD alpha = (DWORD)( a * 255.0f );
DWORD lum = (DWORD)( l * 255.0f );
pRGBAData[i] = (alpha<<24L) | (lum<<16L) | (lum<<8L) | (lum<<0L);
}
}
// Write the file
HRESULT hr = WriteTargaFile( strFileName, m_dwTextureWidth,
m_dwTextureHeight, pRGBAData );
// Cleanup and return
delete[] pRGBAData;
return hr;
}
void GetBitmapBits2( HBITMAP hBitmap, int width, int height, void *pBits )
{
memset( pBits, 0, width*height*4 );
HDC hDC = CreateCompatibleDC( NULL );
BITMAPINFO bitmapInfo = {0};
bitmapInfo.bmiHeader.biSize = sizeof( bitmapInfo.bmiHeader );
bitmapInfo.bmiHeader.biWidth = width;
bitmapInfo.bmiHeader.biHeight = -height;
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
GetDIBits( hDC, hBitmap, 0, height, pBits, &bitmapInfo ,DIB_RGB_COLORS );
DeleteDC( hDC );
}
void SetBitmapBits2( HBITMAP hBitmap, int width, int height, void *pBits )
{
HDC hDC = CreateCompatibleDC( NULL );
BITMAPINFO bitmapInfo = {0};
bitmapInfo.bmiHeader.biSize = sizeof( bitmapInfo.bmiHeader );
bitmapInfo.bmiHeader.biWidth = width;
bitmapInfo.bmiHeader.biHeight = -height;
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
SetDIBits( hDC, hBitmap, 0, height, pBits, &bitmapInfo ,DIB_RGB_COLORS );
DeleteDC( hDC );
}
//-----------------------------------------------------------------------------
// SetTextureBits
//
// Blit the rect back into the bitmap
//-----------------------------------------------------------------------------
void SetTextureBits( HBITMAP hBitmap, int bitmapWidth, int bitmapHeight, int x, int y, int w, int h, unsigned char *pRGBA )
{
// get the enitre bitmap
unsigned char *pBitmapBits = (unsigned char *)malloc( bitmapWidth * bitmapHeight * 4);
GetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits );
// copy into bitmap bits
unsigned char *pSrc = pRGBA;
for (int yy=y; yy<y+h; yy++)
{
if ( yy >= bitmapHeight )
{
// past end of bitmap
break;
}
unsigned char *pDst = pBitmapBits + (yy*bitmapWidth + x)*4;
for (int xx=0; xx<w; xx++)
{
if ( xx+x < bitmapWidth )
{
pDst[0] = pSrc[0];
pDst[1] = pSrc[1];
pDst[2] = pSrc[2];
pDst[3] = pSrc[3];
}
pSrc += 4;
pDst += 4;
}
}
SetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits );
free( pBitmapBits );
}
//-----------------------------------------------------------------------------
// GetTextureBits
//
// Blit the rect out of the bitmap
//-----------------------------------------------------------------------------
unsigned char *GetTextureBits( HBITMAP hBitmap, int bitmapWidth, int bitmapHeight, int x, int y, int w, int h )
{
// get the enitre bitmap
unsigned char *pBitmapBits = new unsigned char[bitmapWidth * bitmapHeight * 4];
GetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits );
unsigned char *pRGBA = new unsigned char[w * h * 4];
memset( pRGBA, 0, w*h*4 );
// copy out bits
unsigned char *pDst = pRGBA;
for (int yy=y; yy<y+h; yy++)
{
if ( yy >= bitmapHeight )
{
// past last row of bitmap
break;
}
unsigned char *pSrc = pBitmapBits + (yy*bitmapWidth + x)*4;
for (int xx=0; xx<w; xx++)
{
if ( xx + x < bitmapWidth )
{
pDst[0] = pSrc[0];
pDst[1] = pSrc[1];
pDst[2] = pSrc[2];
pDst[3] = pSrc[3];
}
pSrc += 4;
pDst += 4;
}
}
delete [] pBitmapBits;
return pRGBA;
}
int g_blur;
float *g_pGaussianDistribution;
//-----------------------------------------------------------------------------
// Purpose: Gets the blur value for a single pixel
//-----------------------------------------------------------------------------
void GetBlurValueForPixel(unsigned char *src, int blur, float *gaussianDistribution, int srcX, int srcY, int srcWide, int srcTall, unsigned char *dest)
{
int r = 0, g = 0, b = 0, a = 0;
float accum = 0.0f;
// scan the positive x direction
int maxX = min(srcX + blur, srcWide);
int minX = max(srcX - blur, 0);
for (int x = minX; x <= maxX; x++)
{
int maxY = min(srcY + blur, srcTall - 1);
int minY = max(srcY - blur, 0);
for (int y = minY; y <= maxY; y++)
{
unsigned char *srcPos = src + ((x + (y * srcWide)) * 4);
unsigned char red = srcPos[2];
unsigned char green = srcPos[1];
unsigned char blue = srcPos[0];
// muliply by the value matrix
float weight = gaussianDistribution[x - srcX + blur];
float weight2 = gaussianDistribution[y - srcY + blur];
accum += (red * (weight * weight2));
}
}
// blurring decreased the range, for xbox kick some back
accum *= 1.30f;
// all the values are the same for fonts, just use the calculated alpha
r = g = b = (int)accum;
dest[0] = min(b, 255);
dest[1] = min(g, 255);
dest[2] = min(r, 255);
}
//-----------------------------------------------------------------------------
// ApplyGaussianBlurToTexture
//-----------------------------------------------------------------------------
void ApplyGaussianBlurToTexture( int blur, int rgbaX, int rgbaY, int rgbaWide, int rgbaTall, unsigned char *rgba)
{
// calculate our gaussian distribution for if we're blurred
if ( blur > 1 && blur != g_blur )
{
g_blur = blur;
g_pGaussianDistribution = new float[blur * 2 + 1];
double sigma = 0.683f * blur;
for (int x = 0; x <= (blur * 2); x++)
{
int val = x - blur;
g_pGaussianDistribution[x] = (float)((1.0 / sqrt(2.0 * 3.14 * sigma * sigma)) * pow(2.7, -1.0 * (val * val) / (2.0 * sigma * sigma)));
// brightening factor
g_pGaussianDistribution[x] *= 1;
}
}
// alloc a new buffer
unsigned char *src = (unsigned char *)_alloca(rgbaWide * rgbaTall * 4);
memcpy(src, rgba, rgbaWide * rgbaTall * 4);
unsigned char *dest = rgba;
for (int y = 0; y < rgbaTall; y++)
{
for (int x = 0; x < rgbaWide; x++)
{
// scan the source pixel
GetBlurValueForPixel(src, blur, g_pGaussianDistribution, x, y, rgbaWide, rgbaTall, dest);
// move to the next
dest += 4;
}
}
}
//-----------------------------------------------------------------------------
// ApplyScanlineEffectToTexture
//-----------------------------------------------------------------------------
void ApplyScanlineEffectToTexture( int scanLines, int rgbaX, int rgbaY, int rgbaWide, int rgbaTall, unsigned char *rgba)
{
if (scanLines < 2)
return;
float scale;
scale = 0;
// darken all the areas except the scanlines
for (int y = 0; y < rgbaTall; y++)
{
// skip the scan lines
if (y % scanLines == 0)
continue;
DWORD *pBits = (DWORD*)&rgba[(rgbaX + ((y + rgbaY) * rgbaWide)) * 4];
// darken the other lines
for (int x = 0; x < rgbaWide; x++, pBits++)
{
FLOAT r = ( ( 0x00ff0000 & pBits[0] ) >> 16L ) / 255.0f;
FLOAT g = ( ( 0x0000ff00 & pBits[0] ) >> 8L ) / 255.0f;
FLOAT b = ( ( 0x000000ff & pBits[0] ) >> 0L ) / 255.0f;
r *= scale;
g *= scale;
b *= scale;
pBits[0] = (((int)(r * 255.0f))<<16) | (((int)(g * 255.0f))<<8) | ((int)(b * 255.0f));
pBits[0] |= 0xFF000000;
}
}
}
//-----------------------------------------------------------------------------
// Name: RenderTTFGlyphs()
// Desc: Draws the list of font glyphs in the scroll view
//-----------------------------------------------------------------------------
GLYPH_ATTR* CTextureFont::RenderTTFGlyphs( HFONT hFont, HBITMAP hBitmap,
DWORD dwTextureWidth, DWORD dwTextureHeight,
BOOL bOutlineEffect, BOOL bShadowEffect,
int nScanlineEffect, int nBlurEffect,
BOOL bAntialias,
BYTE* ValidGlyphs, DWORD dwNumGlyphs )
{
// Create a DC
HDC hDC = CreateCompatibleDC( NULL );
// Associate the drawing surface
SelectObject( hDC, hBitmap );
// Create a clip region
HRGN rgn = CreateRectRgn( 0, 0, dwTextureWidth, dwTextureHeight );
SelectClipRgn( hDC, rgn );
// Setup the DC for the font
SetTextColor( hDC, COLOR_WHITE );
SelectObject( hDC, hFont );
SetTextAlign( hDC, TA_LEFT|TA_TOP|TA_UPDATECP );
SetMapMode( hDC, MM_TEXT );
SetBkMode( hDC, TRANSPARENT );
if ( nScanlineEffect || nBlurEffect )
{
SetBkColor( hDC, COLOR_BLACK );
if ( nBlurEffect < 2 )
nBlurEffect = 2;
if ( nScanlineEffect < 2 )
nScanlineEffect = 2;
}
else
{
SetBkColor( hDC, COLOR_BLUE );
}
// Fill the background in blue
RECT rect;
SetRect( &rect, 0, 0, dwTextureWidth, dwTextureHeight );
ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL );
// Get the effective font height
WCHAR str[2] = L"A";
SIZE size;
GetTextExtentPoint32W( hDC, str, 1, &size );
DWORD dwLeftOrigin = 1;
DWORD dwTopOrigin = 1;
GLYPH_ATTR* pGlyphs = new GLYPH_ATTR[dwNumGlyphs];
memset( pGlyphs, 0, dwNumGlyphs*sizeof( GLYPH_ATTR ) );
// Loop through all printable character and output them to the bitmap..
// Meanwhile, keep track of the corresponding tex coords for each character.
DWORD x = dwLeftOrigin;
DWORD y = dwTopOrigin;
int sx;
int sy;
int numGlyphs = 0;
for( DWORD i=0; i<65536; i++ )
{
if ( 0 == ValidGlyphs[i])
continue;
str[0] = (WCHAR)i;
if ( i==0 && ValidGlyphs[i] == 1 )
{
// account for unprintable, but don't render it
numGlyphs++;
continue;
}
GetTextExtentPoint32W( hDC, str, 1, &size );
// Get char width a different way
int charwidth;
GetCharWidth32( hDC, str[0], str[0], &charwidth );
// Get the ABC widths for the letter
ABC abc;
if ( FALSE == GetCharABCWidthsW( hDC, str[0], str[0], &abc ) )
{
abc.abcA = 0;
abc.abcB = size.cx;
abc.abcC = 0;
}
int w = abc.abcB;
int h = size.cy;
// Determine padding for effects
int left_padding = 0;
int right_padding = 0;
int top_padding = 0;
int bottom_padding = 0;
if ( bOutlineEffect || bShadowEffect )
{
if ( bOutlineEffect )
left_padding = 1;
if ( bOutlineEffect )
{
if ( bShadowEffect )
right_padding = 2;
else
right_padding = 1;
}
else
{
if ( bShadowEffect )
right_padding = 2;
else
right_padding = 0;
}
if ( bOutlineEffect )
top_padding = 1;
if ( bOutlineEffect )
{
if ( bShadowEffect )
bottom_padding = 2;
else
bottom_padding = 1;
}
else
{
if ( bShadowEffect )
bottom_padding = 2;
else
bottom_padding = 0;
}
}
else if ( nBlurEffect )
{
left_padding = nBlurEffect;
right_padding = nBlurEffect;
}
if ( ValidGlyphs[i] == 2 )
{
// Handle special characters
// Advance to the next line, if necessary
if ( x + h + left_padding + right_padding >= (int)dwTextureWidth )
{
x = dwLeftOrigin;
y += h + top_padding + bottom_padding + 1;
}
sx = x;
sy = y;
// Draw a square box for a placeholder for custom glyph graphics
w = h + left_padding + right_padding;
h = h + top_padding + bottom_padding;
abc.abcA = 0;
abc.abcB = w;
abc.abcC = 0;
RECT rect;
SetRect( &rect, x, y, x+w, y+h );
SetBkColor( hDC, COLOR_BLACK );
ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL );
}
else
{
// Hack to adjust for Kanji
if ( str[0] > 0x1000 )
{
w = h;
}
// Advance to the next line, if necessary
if ( x + w + left_padding + right_padding + 1 >= (int)dwTextureWidth )
{
x = dwLeftOrigin;
y += h + top_padding + bottom_padding + 1;
}
sx = x;
sy = y;
// Adjust ccordinates to account for the leading edge
if ( abc.abcA >= 0 )
x += abc.abcA;
else
sx -= abc.abcA;
// Hack to adjust for Kanji
if ( str[0] > 0x1000 )
{
sx += abc.abcA;
}
// Add padding to the width and height
w += left_padding + right_padding;
h += top_padding + bottom_padding;
abc.abcA -= left_padding;
abc.abcB += left_padding + right_padding;
abc.abcC -= right_padding;
if ( bOutlineEffect || bShadowEffect )
{
if ( bOutlineEffect )
{
SetTextColor( hDC, COLOR_BLACK );
MoveToEx( hDC, sx+0, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+1, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+2, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+0, sy+1, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+2, sy+1, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+0, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+1, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
MoveToEx( hDC, sx+2, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
if ( bShadowEffect )
{
MoveToEx( hDC, sx+3, sy+3, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
}
// Output the letter
SetTextColor( hDC, COLOR_WHITE );
MoveToEx( hDC, sx+1, sy+1, NULL ); ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL );
}
else
{
if ( bShadowEffect )
{
SetTextColor( hDC, COLOR_BLACK );
MoveToEx( hDC, sx+2, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL );
}
// Output the letter
SetTextColor( hDC, COLOR_WHITE );
MoveToEx( hDC, sx, sy, NULL ); ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL );
}
}
else if ( nBlurEffect )
{
// blur effect
SetTextColor( hDC, COLOR_WHITE );
MoveToEx( hDC, sx + nBlurEffect, sy, NULL );
ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL );
// apply blur effect
unsigned char *pBGRA = GetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h );
if ( pBGRA )
{
ApplyGaussianBlurToTexture( nBlurEffect, 0, 0, w, h, pBGRA );
SetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h, pBGRA );
delete [] pBGRA;
}
}
else
{
// normal, no effect
// Output the letter
SetTextColor( hDC, COLOR_WHITE );
MoveToEx( hDC, sx, sy, NULL );
ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL );
}
// apply scanline effect
if ( nScanlineEffect )
{
unsigned char *pBGRA = GetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h );
if ( pBGRA )
{
ApplyScanlineEffectToTexture( nScanlineEffect, 0, 0, w, h, pBGRA );
SetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h, pBGRA );
delete [] pBGRA;
}
}
// Hack for extended characters (like Kanji) that don't seem to report
// correct ABC widths. In this case, use the width calculated from
// drawing the glyph.
if( str[0] > 0x1000 )
{
POINT pos;
GetCurrentPositionEx( hDC, &pos );
abc.abcB = pos.x - sx;
if( abc.abcC < 0 )
abc.abcB -= abc.abcC;
w = abc.abcB;
}
}
// Store the glyph attributes
pGlyphs[numGlyphs].x = x;
pGlyphs[numGlyphs].y = y;
pGlyphs[numGlyphs].w = w;
pGlyphs[numGlyphs].h = h;
pGlyphs[numGlyphs].a = abc.abcA;
pGlyphs[numGlyphs].b = abc.abcB;
pGlyphs[numGlyphs].c = abc.abcC;
pGlyphs[numGlyphs].fLeft = ((FLOAT)(x+0)) / dwTextureWidth;
pGlyphs[numGlyphs].fTop = ((FLOAT)(y+0)) / dwTextureHeight;
pGlyphs[numGlyphs].fRight = ((FLOAT)(x+w)) / dwTextureWidth;
pGlyphs[numGlyphs].fBottom = ((FLOAT)(y+h)) / dwTextureHeight;
numGlyphs++;
// Advance the cursor to the next position
x += w + 1;
}
SelectClipRgn( hDC, NULL );
DeleteObject( rgn );
DeleteDC( hDC );
return pGlyphs;
}
//-----------------------------------------------------------------------------
// Name: RenderCustomGlyphs()
// Desc: Draws the list of font glyphs in the scroll view
//-----------------------------------------------------------------------------
GLYPH_ATTR* CTextureFont::RenderCustomGlyphs( HBITMAP hBitmap )
{
int i;
int w;
int h;
byte_t *pTGAPixels;
m_maxCustomCharHeight = 0;
// Create a DC
HDC hDC = CreateCompatibleDC( NULL );
// Associate the drawing surface
SelectObject( hDC, hBitmap );
// Create a clip region
HRGN rgn = CreateRectRgn( 0, 0, m_dwTextureWidth, m_dwTextureHeight );
SelectClipRgn( hDC, rgn );
// clear the background
unsigned char *pBGRA = GetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, 0, 0, m_dwTextureWidth, m_dwTextureHeight );
for (i=0; i<(int)(m_dwTextureHeight*m_dwTextureWidth); i++)
{
pBGRA[i*4+0] = 0xFF;
pBGRA[i*4+1] = 0x00;
pBGRA[i*4+2] = 0x00;
pBGRA[i*4+3] = 0x00;
}
SetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, 0, 0, m_dwTextureWidth, m_dwTextureHeight, pBGRA );
// build the glyph table
GLYPH_ATTR* pGlyphs = new GLYPH_ATTR[m_dwNumGlyphs];
memset( pGlyphs, 0, m_dwNumGlyphs*sizeof( GLYPH_ATTR ) );
int x = 0;
int y = 0;
int maxHeight = 0;
for( DWORD i=0; i<m_dwNumGlyphs; i++ )
{
if ( !i )
{
// account for null
continue;
}
else if ( TL_Exists( m_pCustomGlyphFiles[i-1] ) )
{
TL_LoadTGA( m_pCustomGlyphFiles[i-1], &pTGAPixels, &w, &h );
// convert to expected order
for (int j=0; j<h*w; j++)
{
int r = pTGAPixels[j*4+0];
int g = pTGAPixels[j*4+1];
int b = pTGAPixels[j*4+2];
pTGAPixels[j*4+0] = b;
pTGAPixels[j*4+1] = g;
pTGAPixels[j*4+2] = r;
}
}
else
{
// build a "bad" symbol
pTGAPixels = (byte_t*)TL_Malloc( 32*32*4 );
w = 32;
h = 32;
for (int j=0; j<32*32; j++)
{
pTGAPixels[j*4+0] = 0x00;
pTGAPixels[j*4+1] = 0x00;
pTGAPixels[j*4+2] = 0xFF;
pTGAPixels[j*4+3] = 0xFF;
}
}
if ( m_maxCustomCharHeight < h )
{
m_maxCustomCharHeight = h;
}
if ( maxHeight < h )
{
maxHeight = h;
}
if ( x + w > (int)m_dwTextureWidth )
{
// skip to new row
y += maxHeight;
x = 0;
maxHeight = h;
}
SetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, x, y, w, h, pTGAPixels );
TL_Free( pTGAPixels );
// Store the glyph attributes
pGlyphs[i].x = x;
pGlyphs[i].y = y;
pGlyphs[i].w = w;
pGlyphs[i].h = h;
pGlyphs[i].a = 0;
pGlyphs[i].b = w;
pGlyphs[i].c = 0;
pGlyphs[i].fLeft = ((FLOAT)(x+0)) / m_dwTextureWidth;
pGlyphs[i].fTop = ((FLOAT)(y+0)) / m_dwTextureHeight;
pGlyphs[i].fRight = ((FLOAT)(x+w)) / m_dwTextureWidth;
pGlyphs[i].fBottom = ((FLOAT)(y+h)) / m_dwTextureHeight;
x += w;
}
SelectClipRgn( hDC, NULL );
DeleteObject( rgn );
DeleteDC( hDC );
delete [] pBGRA;
return pGlyphs;
}
//-----------------------------------------------------------------------------
// Name: CalculateAndRenderGlyphs()
// Desc: Draws the list of font glyphs
//-----------------------------------------------------------------------------
HRESULT CTextureFont::CalculateAndRenderGlyphs()
{
// Create a bitmap
HBITMAP hBitmap = CreateBitmap( m_dwTextureWidth, m_dwTextureHeight, 1, 32, NULL );
if ( m_pGlyphs )
delete[] m_pGlyphs;
if ( m_pCustomFilename )
{
m_pGlyphs = RenderCustomGlyphs( hBitmap );
}
else
{
// Create a font
if ( m_hFont )
{
DeleteObject( m_hFont );
}
if ( m_bAntialiasEffect )
{
m_LogFont.lfQuality = ANTIALIASED_QUALITY;
}
else
{
m_LogFont.lfQuality = NONANTIALIASED_QUALITY;
}
m_hFont = CreateFontIndirect( &m_LogFont );
m_pGlyphs = RenderTTFGlyphs(
m_hFont,
hBitmap,
m_dwTextureWidth,
m_dwTextureHeight,
m_bOutlineEffect,
m_bShadowEffect,
m_nScanlines,
m_nBlur,
m_bAntialiasEffect,
m_ValidGlyphs,
m_dwNumGlyphs );
}
// Store the resulting bits
if ( m_pBits )
delete[] m_pBits;
m_pBits = new DWORD[ m_dwTextureWidth * m_dwTextureHeight ];
GetBitmapBits2( hBitmap, m_dwTextureWidth, m_dwTextureHeight, m_pBits );
DeleteObject( hBitmap );
return S_OK;
}