tf2/tf2_src/vgui2/vgui_surfacelib/Win32Font_x360.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Xbox 360 support for TrueType Fonts. The only cuurent solution is to use XUI
// to mount the TTF, and rasterize glyph into a render target. XUI does not support
// rasterization directly to a system memory region.
//
//=====================================================================================//

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <malloc.h>
#include <tier0/dbg.h>
#include <vgui/ISurface.h>
#include <tier0/mem.h>
#include <utlbuffer.h>
#include "filesystem.h"
#include "materialsystem/imaterialsystem.h"
#include "FontEffects.h"
#include "vgui_surfacelib/Win32Font.h"
#include "vgui_surfacelib/FontManager.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

bool s_bSupportsUnicode = true;

//-----------------------------------------------------------------------------
// Determine possible style from parameters.
//-----------------------------------------------------------------------------
int GetStyleFromParameters( int iFlags, int iWeight )
{
	// Available xbox TTF styles are very restricted.
	int style = XUI_FONT_STYLE_NORMAL;
	if ( iFlags & vgui::ISurface::FONTFLAG_ITALIC )
		style |= XUI_FONT_STYLE_ITALIC;
	if ( iFlags & vgui::ISurface::FONTFLAG_UNDERLINE )
		style |= XUI_FONT_STYLE_UNDERLINE;
	if ( iWeight > 400 )
		style |= XUI_FONT_STYLE_BOLD;
	return style;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWin32Font::CWin32Font()
{
	m_szName = UTL_INVAL_SYMBOL;
	m_iTall = 0;
	m_iWeight = 0;
	m_iHeight = 0;
	m_iAscent = 0;
	m_iFlags = 0;
	m_iMaxCharWidth = 0;
	m_hFont = NULL;
	m_hDC = NULL;
	m_bAntiAliased = false;
	m_iBlur = 0;
	m_iScanLines = 0;
	m_bRotary = false;
	m_bAdditive = false;
	m_rgiBitmapSize[0] = 0;
	m_rgiBitmapSize[1] = 0;

	Q_memset( m_ABCWidthsCache, 0, sizeof( m_ABCWidthsCache ) );
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CWin32Font::~CWin32Font()
{
	CloseResource();
}

//-----------------------------------------------------------------------------
// Purpose: Creates the font.
//-----------------------------------------------------------------------------
bool CWin32Font::Create( const char *windowsFontName, int tall, int weight, int blur, int scanlines, int flags )
{
	// setup font properties
	m_iTall = tall;
	m_iWeight = weight;
	m_iFlags = flags;
	m_bAntiAliased = (flags & vgui::ISurface::FONTFLAG_ANTIALIAS) ? 1 : 0;
	m_iDropShadowOffset = (flags & vgui::ISurface::FONTFLAG_DROPSHADOW) ? 1 : 0;
	m_iOutlineSize = (flags & vgui::ISurface::FONTFLAG_OUTLINE) ? 1 : 0;
	m_iBlur = blur;
	m_iScanLines = scanlines;
	m_bRotary = (flags & vgui::ISurface::FONTFLAG_ROTARY) ? 1 : 0;
	m_bAdditive = (flags & vgui::ISurface::FONTFLAG_ADDITIVE) ? 1 : 0;

	int style = GetStyleFromParameters( flags, weight );

	// must support > 128, there are characters in this range in the custom fonts
	COMPILE_TIME_ASSERT( ABCWIDTHS_CACHE_SIZE == 256 );

	XUIFontMetrics fontMetrics;
	XUICharMetrics charMetrics[256];

	// many redundant requests are made that are actually the same font metrics
	// find it in the metric cache first based on the true specific keys
	if ( !FontManager().GetCachedXUIMetrics( windowsFontName, tall, style, &fontMetrics, charMetrics ) )
	{
		m_hFont = FontManager().MaterialSystem()->OpenTrueTypeFont( windowsFontName, tall, style );
		if ( !m_hFont )
		{
			return false;
		}

		// getting the metrics is an expensive i/o operation, cache results
		FontManager().MaterialSystem()->GetTrueTypeFontMetrics( m_hFont, &fontMetrics, charMetrics );
		FontManager().SetCachedXUIMetrics( windowsFontName, tall, style, &fontMetrics, charMetrics );
	}

	m_szName = windowsFontName;

	m_iHeight = fontMetrics.fMaxHeight + m_iDropShadowOffset + 2 * m_iOutlineSize;
	m_iMaxCharWidth = fontMetrics.fMaxWidth;
	m_iAscent = fontMetrics.fMaxAscent;

	// determine cell bounds
	m_rgiBitmapSize[0] = m_iMaxCharWidth + m_iOutlineSize * 2;
	m_rgiBitmapSize[1] = m_iHeight;

	// get char spacing
	// a is space before character (can be negative)
	// b is the width of the character
	// c is the space after the character
	Assert( ABCWIDTHS_CACHE_SIZE <= 256 );
	Q_memset( m_ABCWidthsCache, 0, sizeof( m_ABCWidthsCache ) );

	for ( int i = 1; i < ABCWIDTHS_CACHE_SIZE; i++ )
	{
		int a,b,c;

		// Determine real a,b,c mapping from XUI Character Metrics
		a = charMetrics[i].fMinX - 1; // Add one column of padding to make up for font rendering blurring into left column (and adjust in b)
		b = charMetrics[i].fMaxX - charMetrics[i].fMinX + 1;
		c = charMetrics[i].fAdvance - charMetrics[i].fMaxX; // NOTE: We probably should add a column here, but it's rarely needed in our current fonts so we're opting to save memory instead

		// Widen for blur, outline, and shadow. Need to widen b and reduce a and c.
		m_ABCWidthsCache[i].a = a - m_iBlur - m_iOutlineSize;
		m_ABCWidthsCache[i].b = b + ( ( m_iBlur + m_iOutlineSize ) * 2 ) + m_iDropShadowOffset;
		m_ABCWidthsCache[i].c = c - m_iBlur - m_iDropShadowOffset - m_iOutlineSize;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: generates texture data (written into appropriate font page subrects) for multiple chars
//-----------------------------------------------------------------------------
void CWin32Font::GetCharsRGBA( newChar_t *newChars, int numNewChars, unsigned char *pRGBA )
{
	if ( !m_hFont )
	{
		// demand request for font glyph, re-create font
		int style = GetStyleFromParameters( m_iFlags, m_iWeight );
		m_hFont = FontManager().MaterialSystem()->OpenTrueTypeFont( GetName(), m_iTall, style );
	}

	wchar_t	*pWch		= (wchar_t *)_alloca( numNewChars*sizeof(wchar_t) );
	int	*pOffsetX		= (int *)_alloca( numNewChars*sizeof(int) );
	int	*pOffsetY		= (int *)_alloca( numNewChars*sizeof(int) );
	int	*pWidth			= (int *)_alloca( numNewChars*sizeof(int) );
	int	*pHeight		= (int *)_alloca( numNewChars*sizeof(int) );
	int	*pRGBAOffset	= (int *)_alloca( numNewChars*sizeof(int) );
	for ( int i = 0; i < numNewChars; i++ )
	{
		int a, c, wide;
		GetCharABCWidths( newChars[i].wch, a, wide, c );
		pWch[i]			= newChars[i].wch;
		pOffsetX[i]		= -a;
		pOffsetY[i]		= 0;
		pWidth[i]		= newChars[i].fontWide;
		pHeight[i]		= newChars[i].fontTall;
		pRGBAOffset[i]	= newChars[i].offset;
	}
	if ( !FontManager().MaterialSystem()->GetTrueTypeGlyphs( m_hFont, numNewChars, pWch, pOffsetX, pOffsetY, pWidth, pHeight, pRGBA, pRGBAOffset ) )
	{
		// failure
		return;
	}

	for ( int i = 0; i < numNewChars; i++ )
	{
		// apply requested effects in specified order
		unsigned char *pCharRGBA = pRGBA + newChars[i].offset;
		ApplyDropShadowToTexture( newChars[i].fontWide, newChars[i].fontTall, pCharRGBA, m_iDropShadowOffset );
		ApplyOutlineToTexture( newChars[i].fontWide, newChars[i].fontTall, pCharRGBA, m_iOutlineSize );
		ApplyGaussianBlurToTexture( newChars[i].fontWide, newChars[i].fontTall, pCharRGBA, m_iBlur );
		ApplyScanlineEffectToTexture( newChars[i].fontWide, newChars[i].fontTall, pCharRGBA, m_iScanLines );
		ApplyRotaryEffectToTexture( newChars[i].fontWide, newChars[i].fontTall, pCharRGBA, m_bRotary );
	}
}

//-----------------------------------------------------------------------------
// Purpose: writes the char into the specified 32bpp texture at specified rect
//-----------------------------------------------------------------------------
void CWin32Font::GetCharRGBA( wchar_t ch, int rgbaWide, int rgbaTall, unsigned char *pRGBA )
{
	newChar_t newChar;
	newChar.wch = ch;
	newChar.fontWide = rgbaWide;
	newChar.fontTall = rgbaTall;
	newChar.offset = 0;
	GetCharsRGBA( &newChar, 1, pRGBA );
}

//-----------------------------------------------------------------------------
// Purpose: returns true if the font is equivalent to that specified
//-----------------------------------------------------------------------------
bool CWin32Font::IsEqualTo(const char *windowsFontName, int tall, int weight, int blur, int scanlines, int flags)
{
	// do an true comparison that accounts for non-supported behaviors that gets remapped
	// avoids creating fonts that are graphically equivalent, though specified differently
	if ( !stricmp( windowsFontName, m_szName.String() ) &&
		m_iTall == tall && 
		m_iBlur == blur &&
		m_iScanLines == scanlines )
	{
		// only these flags affect the font glyphs
		int validFlags = vgui::ISurface::FONTFLAG_DROPSHADOW | 
						vgui::ISurface::FONTFLAG_OUTLINE | 
						vgui::ISurface::FONTFLAG_ROTARY |
						vgui::ISurface::FONTFLAG_ITALIC |
						vgui::ISurface::FONTFLAG_UNDERLINE;
		if ( ( m_iFlags & validFlags ) == ( flags & validFlags ) )
		{
			if ( GetStyleFromParameters( m_iFlags, m_iWeight ) == GetStyleFromParameters( flags, weight ) )
			{
				// the font is equivalent
				return true;
			}
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: returns true only if this font is valid for use
//-----------------------------------------------------------------------------
bool CWin32Font::IsValid()
{
	if ( m_szName != UTL_INVAL_SYMBOL )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: set the font to be the one to currently draw with in the gdi
//-----------------------------------------------------------------------------
void CWin32Font::SetAsActiveFont( HDC hdc )
{
}

//-----------------------------------------------------------------------------
// Purpose: gets the abc widths for a character
//-----------------------------------------------------------------------------
void CWin32Font::GetCharABCWidths( int ch, int &a, int &b, int &c )
{
	Assert( IsValid() );

	if ( ch < ABCWIDTHS_CACHE_SIZE )
	{
		// use the cache entry
		a = m_ABCWidthsCache[ch].a;
		b = m_ABCWidthsCache[ch].b;
		c = m_ABCWidthsCache[ch].c;
	}
	else
	{
		// cannot support getting character metrics outside of the font initialization
		DevMsg( "CWin32Font: Cannot resolve character %d in font %s\n", ch, m_szName.String() );
		Assert( 0 );

		a = 0;
		b = 0;
		c = 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose: returns the height of the font, in pixels
//-----------------------------------------------------------------------------
int CWin32Font::GetHeight()
{
	Assert( IsValid() );
	return m_iHeight;
}

//-----------------------------------------------------------------------------
// Purpose: returns the ascent of the font, in pixels (ascent=units above the base line)
//-----------------------------------------------------------------------------
int CWin32Font::GetAscent()
{
	Assert( IsValid() );
	return m_iAscent;
}

//-----------------------------------------------------------------------------
// Purpose: returns the maximum width of a character, in pixels
//-----------------------------------------------------------------------------
int CWin32Font::GetMaxCharWidth()
{
	Assert( IsValid() );
	return m_iMaxCharWidth;
}

//-----------------------------------------------------------------------------
// Purpose: returns the flags used to make this font, used by the dynamic resizing code
//-----------------------------------------------------------------------------
int CWin32Font::GetFlags()
{
	Assert( IsValid() );
	return m_iFlags;
}

void CWin32Font::CloseResource()
{
	if ( !m_hFont )
	{
		return;
	}

	// many fonts are blindly precached by vgui and never used
	// save memory and don't hold font open, re-open if glyph actually requested used during draw
	FontManager().MaterialSystem()->CloseTrueTypeFont( m_hFont );
	m_hFont = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Get the kerned size of a char, for win32 just pass thru for now
//-----------------------------------------------------------------------------
void CWin32Font::GetKernedCharWidth( wchar_t ch, wchar_t chBefore, wchar_t chAfter, float &wide, float &abcA )
{
	int a,b,c;
	GetCharABCWidths(ch, a, b, c );
	wide = ( a + b + c);
	abcA = a;
}