CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPipeline/plTextFont.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
//																			 //
//	plTextFont Class Functions												 //
//	Cyan, Inc.																 //
//																			 //
//// Version History //////////////////////////////////////////////////////////
//																			 //
//	2.19.2001 mcn - Created.  												 //
//																			 //
///////////////////////////////////////////////////////////////////////////////

#include "hsWindows.h"
#include "HeadSpin.h"
#include "plTextFont.h"
#include "plDebugText.h"

#define DisplayableChar(c) (c >= 0 && c <= 128)

//// Constructor & Destructor /////////////////////////////////////////////////

plTextFont::plTextFont( plPipeline *pipe )
{
	fMaxNumIndices = 1024;
	fInitialized = false;
	fPipe = pipe;
}

plTextFont::~plTextFont()
{
	IUnlink();
}

//// IInitFontTexture /////////////////////////////////////////////////////////

UInt16	*plTextFont::IInitFontTexture( void )
{
	int		nHeight, x, y, c;
	char	myChar[ 2 ] = "x";
	UInt16	*tBits;

	DWORD		*bitmapBits;
	BITMAPINFO	bmi;
	HDC			hDC;
	HBITMAP		hBitmap;
	HFONT		hFont;
	SIZE		size;
	BYTE		bAlpha;

	
	// Figure out our texture size
	if(	fSize > 40 )
		fTextureWidth = fTextureHeight = 1024;
	else if( fSize > 20 )
		fTextureWidth = fTextureHeight = 512;
	else
		fTextureWidth = fTextureHeight = 256;


	// Create a new DC and bitmap that we can draw characters to
	memset( &bmi.bmiHeader, 0, sizeof( BITMAPINFOHEADER ) );
	bmi.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
	bmi.bmiHeader.biWidth = fTextureWidth;
	bmi.bmiHeader.biHeight = -(int)fTextureHeight;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biBitCount = 32;
	
	hDC = CreateCompatibleDC( nil );
	hBitmap = CreateDIBSection( hDC, &bmi, DIB_RGB_COLORS, (void **)&bitmapBits, nil, 0 );
	SetMapMode( hDC, MM_TEXT );

	nHeight = -MulDiv( fSize, GetDeviceCaps( hDC, LOGPIXELSY ), 72 );
	fFontHeight = -nHeight;

	hFont = CreateFont( nHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
						CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, VARIABLE_PITCH, fFace );
	hsAssert( hFont != nil, "Cannot create Windows font" );

	SelectObject( hDC, hBitmap );
	SelectObject( hDC, hFont );

	// Set text colors
	SetTextColor( hDC, RGB( 255, 255, 255 ) );
	SetBkColor( hDC, 0 );
	SetTextAlign( hDC, TA_TOP );

	// Loop through characters, drawing them one at a time
	RECT	r;
	r.left = r.top = 0;
	r.right = r.bottom = 10;
	FillRect( hDC, &r, (HBRUSH)GetStockObject( GRAY_BRUSH ) );

	// (Make first character a black dot, for filling rectangles)
	SetPixel( hDC, 0, 0, RGB( 255, 255, 255 ) );
	for( c = 32, x = 1, y = 0; c < 127; c++ )
	{
		myChar[ 0 ] = c;
		GetTextExtentPoint32( hDC, myChar, 1, &size );

		if( (UInt32)( x + size.cx + 1 ) > fTextureWidth )
		{
			x = 0;
			y += size.cy + 1;
		}

		ExtTextOut( hDC, x, y, ETO_OPAQUE, nil, myChar, 1, nil );

		fCharInfo[ c ].fW = (UInt16)size.cx;
		fCharInfo[ c ].fH = (UInt16)size.cy;
		fCharInfo[ c ].fUVs[ 0 ].fX = (float)x / (float)fTextureWidth;
		fCharInfo[ c ].fUVs[ 0 ].fY = (float)y / (float)fTextureHeight;
		fCharInfo[ c ].fUVs[ 1 ].fX = (float)( x + size.cx ) / (float)fTextureWidth;
		fCharInfo[ c ].fUVs[ 1 ].fY = (float)( y + size.cy ) / (float)fTextureHeight;
		fCharInfo[ c ].fUVs[ 0 ].fZ = fCharInfo[ c ].fUVs[ 1 ].fZ = 0;

		x += size.cx + 1;
	}
	fCharInfo[ 32 ].fUVs[ 1 ].fX = fCharInfo[ 32 ].fUVs[ 0 ].fX;

	// Special case the tab key
	fCharInfo[ '\t' ].fUVs[ 1 ].fX = fCharInfo[ '\t' ].fUVs[ 0 ].fX = fCharInfo[ 32 ].fUVs[ 0 ].fX;
	fCharInfo[ '\t' ].fUVs[ 1 ].fY = fCharInfo[ '\t' ].fUVs[ 0 ].fY = 0;
	fCharInfo[ '\t' ].fUVs[ 0 ].fZ = fCharInfo[ '\t' ].fUVs[ 1 ].fZ = 0;
	fCharInfo[ '\t' ].fW = fCharInfo[ 32 ].fW * 4;
	fCharInfo[ '\t' ].fH = fCharInfo[ 32 ].fH;

	/// Now create the data block
	UInt16	*data = TRACKED_NEW UInt16[ fTextureWidth * fTextureHeight ];
	tBits = data;
	for( y = 0; y < fTextureHeight; y++ )
	{
		for( x = 0; x < fTextureWidth; x++ )
		{
			bAlpha = (BYTE)( ( bitmapBits[ fTextureWidth * y + x ] & 0xff ) >> 4 );

			if( bitmapBits[ fTextureWidth * y + x ] )
				*tBits = 0xffff;
			else
				*tBits = 0;

			tBits++;
		}
	}

	// Cleanup and return
	DeleteObject( hBitmap );
	DeleteDC( hDC );
	DeleteObject( hFont );

	return data;
}

//// Create ///////////////////////////////////////////////////////////////////

void	plTextFont::Create( char *face, UInt16 size )
{
	// Init normal stuff
	strncpy( fFace, face, sizeof( fFace ) );
	fSize = size;
}

//// IInitObjects /////////////////////////////////////////////////////////////

void	plTextFont::IInitObjects( void )
{
	UInt16	*data;


	// Create texture
	data = IInitFontTexture();
	hsAssert( data != nil, "Cannot create font texture" );

	ICreateTexture( data );
	delete [] data;

	// Create state blocks
	IInitStateBlocks();

	fInitialized = true;
}

//// DrawString ///////////////////////////////////////////////////////////////

void	plTextFont::DrawString( const char *string, int sX, int sY, UInt32 hexColor, 
								UInt8 style, UInt32 rightEdge )
{
	static hsTArray<plFontVertex>	verts;
	
	int		i, j, width, height, count, thisCount, italOffset;
	float	x = (float)sX;
	char	c, *strPtr;


	if( !fInitialized )
		IInitObjects();

	/// Set up to draw
	italOffset = ( style & plDebugText::kStyleItalic ) ? fSize / 2: 0;
	count = strlen( string );
	strPtr = (char *)string;
	while( count > 0 )
	{
		thisCount = ( count > 64 ) ? 64 : count;
		count -= thisCount;

		// Create an array for our vertices
		verts.SetCountAndZero( thisCount * ( ( style & plDebugText::kStyleBold ) ? 12 : 6 ) );
	
		// Fill them all up now
		for( i = 0; i < thisCount * ( ( style & plDebugText::kStyleBold ) ? 12 : 6 ); i++ )
		{
			verts[ i ].fColor = hexColor;
			verts[ i ].fPoint.fZ = 0;
		}

		for( i = 0, j = 0; i < thisCount; i++, j += 6 )
		{
			c = strPtr[ i ];
			// make sure its a character we will display
			if ( DisplayableChar(c) )
			{
				width = fCharInfo[ c ].fW + 1;
				height = fCharInfo[ c ].fH + 1;

				if( rightEdge > 0 && x + width + italOffset >= rightEdge )
				{
					count = 0;
					thisCount = i;
					break;
				}

				verts[ j ].fPoint.fX = x + italOffset;
				verts[ j ].fPoint.fY = (float)sY;
				verts[ j ].fUV = fCharInfo[ c ].fUVs[ 0 ];

				verts[ j + 1 ].fPoint.fX = x + width + italOffset;
				verts[ j + 1 ].fPoint.fY = (float)sY;
				verts[ j + 1 ].fUV = fCharInfo[ c ].fUVs[ 0 ];
				verts[ j + 1 ].fUV.fX = fCharInfo[ c ].fUVs[ 1 ].fX;

				verts[ j + 2 ].fPoint.fX = x;
				verts[ j + 2 ].fPoint.fY = (float)sY + height;
				verts[ j + 2 ].fUV = fCharInfo[ c ].fUVs[ 0 ];
				verts[ j + 2 ].fUV.fY = fCharInfo[ c ].fUVs[ 1 ].fY;

				verts[ j + 3 ].fPoint.fX = x;
				verts[ j + 3 ].fPoint.fY = (float)sY + height;
				verts[ j + 3 ].fUV = fCharInfo[ c ].fUVs[ 0 ];
				verts[ j + 3 ].fUV.fY = fCharInfo[ c ].fUVs[ 1 ].fY;

				verts[ j + 4 ].fPoint.fX = x + width + italOffset;
				verts[ j + 4 ].fPoint.fY = (float)sY;
				verts[ j + 4 ].fUV = fCharInfo[ c ].fUVs[ 0 ];
				verts[ j + 4 ].fUV.fX = fCharInfo[ c ].fUVs[ 1 ].fX;

				verts[ j + 5 ].fPoint.fX = x + width;
				verts[ j + 5 ].fPoint.fY = (float)sY + height;
				verts[ j + 5 ].fUV = fCharInfo[ c ].fUVs[ 1 ];

				x += width + 1;
			}
		}

		if( thisCount == 0 )
			break;

		if( style & plDebugText::kStyleBold )
		{
			for( i = 0; i < thisCount * 6; i++, j++ )
			{
				verts[ j ] = verts[ i ];
				verts[ j ].fPoint.fX = verts[ j ].fPoint.fX + 1.0f;
			}
		}

		/// TEMPORARY DEBUG ONLY: see if we can catch this stupid random draw bug
#if 0
		for( i = 0; i < thisCount * ( ( style & plDebugText::kStyleBold ) ? 12 : 6 ); i += 3 )
		{
			for( j = 0; j < 3; j++ )
			{
				hsAssert( verts[ i + j ].fPoint.fX >= 0, "Text point out of range" );
				hsAssert( verts[ i + j ].fPoint.fY >= 0, "Text point out of range" );
				hsAssert( verts[ i + j ].fPoint.fX < 1024, "Text point out of range" );
				hsAssert( verts[ i + j ].fPoint.fY < 768, "Text point out of range" );
			}
			int	lt = ( verts[ i ].fPoint.fX < verts[ i + 1 ].fPoint.fX ? verts[ i ].fPoint.fX : verts[ i + 1 ].fPoint.fX );
			lt = ( verts[ i + 2 ].fPoint.fX < lt ? verts[ i + 2 ].fPoint.fX : lt );

			int	tp = ( verts[ i ].fPoint.fY < verts[ i + 1 ].fPoint.fY ? verts[ i ].fPoint.fY : verts[ i + 1 ].fPoint.fY );
			tp = ( verts[ i + 2 ].fPoint.fY < tp ? verts[ i + 2 ].fPoint.fY : tp );

			int	rt = ( verts[ i ].fPoint.fX > verts[ i + 1 ].fPoint.fX ? verts[ i ].fPoint.fX : verts[ i + 1 ].fPoint.fX );
			rt = ( verts[ i + 2 ].fPoint.fX > rt ? verts[ i + 2 ].fPoint.fX : rt );

			int	bt = ( verts[ i ].fPoint.fY > verts[ i + 1 ].fPoint.fY ? verts[ i ].fPoint.fY : verts[ i + 1 ].fPoint.fY );
			bt = ( verts[ i + 2 ].fPoint.fY > bt ? verts[ i + 2 ].fPoint.fY : bt );

			hsAssert( rt - lt < 32, "Text character too big" );
			hsAssert( bt - tp < 32, "Text character too big" );
		}
#endif
		/// TEMPORARY DEBUG ONLY: see if we can catch this stupid random draw bug

		
		/// Draw a set of tris now
		IDrawPrimitive( thisCount * ( ( style & plDebugText::kStyleBold ) ? 4 : 2 ), verts.AcquireArray() );

		strPtr += thisCount;
	}

	/// All done!
}

//// CalcStringWidth //////////////////////////////////////////////////////////

UInt32	plTextFont::CalcStringWidth( const char *string )
{
	int		i, width = 0;


	if( !fInitialized )
		IInitObjects();
	
	for( i = 0; i < strlen( string ); i++ )
	{
		// make sure its a character we will display
		if ( DisplayableChar(string[i]) )
			width += fCharInfo[ string[ i ] ].fW + 2;
	}

	return width;
}

//// DrawRect /////////////////////////////////////////////////////////////////
//	TEMPORARY function to draw a flat-shaded 2D rectangle to the screen. Used
//	to create a background for our console; will be obliterated once we figure
//	a better way to do so.

void	plTextFont::DrawRect( int left, int top, int right, int bottom, UInt32 hexColor )
{
	static hsTArray<plFontVertex>	verts;
	int								i;


	if( !fInitialized )
		IInitObjects();

	/// Draw!
	verts.SetCountAndZero( 6 );
	for( i = 0; i < 6; i++ )
	{
		verts[ i ].fColor = hexColor;
		verts[ i ].fPoint.fZ = 0;
		verts[ i ].fUV.fX = verts[ i ].fUV.fY = 0;
	}

	verts[ 0 ].fPoint.fX = verts[ 2 ].fPoint.fX = verts[ 3 ].fPoint.fX = (float)left;
	verts[ 1 ].fPoint.fX = verts[ 4 ].fPoint.fX = verts[ 5 ].fPoint.fX = (float)right;
	verts[ 0 ].fPoint.fY = verts[ 1 ].fPoint.fY = verts[ 4 ].fPoint.fY = (float)top;
	verts[ 2 ].fPoint.fY = verts[ 3 ].fPoint.fY = verts[ 5 ].fPoint.fY = (float)bottom;

	// omg I had this at 6...just slap the dunce cap on me...-mcn
	IDrawPrimitive( 2, verts.AcquireArray() );

	/// All done!
}

//// Draw3DBorder /////////////////////////////////////////////////////////////
//	Draws a 3d border, upper-left with the first color, lower-right with the
//	second. I just LOOOOVE temporary functions :)
//	Note: this way sucks. Live with it.

void	plTextFont::Draw3DBorder( int left, int top, int right, int bottom, UInt32 hexColor1, UInt32 hexColor2 )
{
	static hsTArray<plFontVertex>	verts;
	int								i;


	if( !fInitialized )
		IInitObjects();

	/// Draw!
	verts.SetCountAndZero( 8 );
	for( i = 0; i < 8; i++ )
	{
		verts[ i ].fColor = hexColor1;
		verts[ i ].fPoint.fZ = 0;
		verts[ i ].fUV.fX = verts[ i ].fUV.fY = 0;
	}

	verts[ 1 ].fPoint.fX = verts[ 2 ].fPoint.fX = verts[ 3 ].fPoint.fX = verts[ 4 ].fPoint.fX = (float)left;
	verts[ 0 ].fPoint.fX = verts[ 5 ].fPoint.fX = verts[ 6 ].fPoint.fX = verts[ 7 ].fPoint.fX = (float)right;

	verts[ 0 ].fPoint.fY = verts[ 1 ].fPoint.fY = verts[ 2 ].fPoint.fY = verts[ 7 ].fPoint.fY = (float)top;
	verts[ 3 ].fPoint.fY = verts[ 4 ].fPoint.fY = verts[ 5 ].fPoint.fY = verts[ 6 ].fPoint.fY = (float)bottom;

	for( i = 4; i < 8; i++ )
		verts[ i ].fColor = hexColor2;

	IDrawLines( 4, verts.AcquireArray() );

	/// All done!
}