CWE-ou-minkata/Sources/Plasma/PubUtilLib/plGImage/plFont.h

/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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==*/
///////////////////////////////////////////////////////////////////////////////
//																			 //
//	plFont Class Header														 //
//	Seems like we've come full circle again. This is our generic Plasma		 //
//	bitmap font class/format. Quick list of things it supports, or needs to: //
//		- Antialiasing, either in the font def or at rendertime				 //
//		- Doublebyte character sets											 //
//		- Platform independence, of course									 //
//		- Render to reasonably arbitrary mipmap								 //
//		- Character-level kerning, both before and after, as well as		 //
//		  negative kerning (for ligatures)									 //
//																			 //
//	Cyan, Inc.																 //
//																			 //
//// Version History //////////////////////////////////////////////////////////
//																			 //
//	5.4.2003 mcn - Created.													 //
//																			 //
///////////////////////////////////////////////////////////////////////////////

#ifndef _plFont_h
#define _plFont_h

#include "hsTypes.h"
#include "hsColorRGBA.h"
#include "hsTemplates.h"
#include "pcSmallRect.h"

#include "pnKeyedObject/hsKeyedObject.h"

#include <wchar.h>

class plBDFConvertCallback
{
	public:
		virtual void	NumChars( UInt16 chars ) {}
		virtual void	CharDone( void ) {}
};

//// Class Definition /////////////////////////////////////////////////////////

class plMipmap;
class plBDFHeaderParser;
class plBDFPropertiesParser;
class plBDFCharsParser;
class plFont : public hsKeyedObject
{
	public:

		enum RenderFlags
		{
			kRenderItalic		= 0x00000001,
			kRenderBold			= 0x00000002,
			kRenderScaleAA		= 0x00000004,
			kRenderClip			= 0x00000008,
			kRenderWrap			= 0x00000010,

			kRenderJustXLeft	= 0,
			kRenderJustXRight	= 0x00000020,	// X right justify
			kRenderJustXCenter	= 0x00000040,	// X center justify (left default)
			kRenderJustXForceLeft=0x00000080,	// Force left (no kerning)
			kRenderJustXMask	= 0x000000e0,

			kRenderJustYBaseline = 0,
			kRenderJustYTop		= 0x00000100,	// Y top justify
			kRenderJustYCenter	= 0x00000200,	// Y center justify
			kRenderJustYBottom	= 0x00000400,	// Y bottom justify (baseline is default)
			kRenderJustYMask	= 0x00000700,

			kRenderIntoAlpha	= 0x00000800,	// This option causes grayscale (AA) fonts to 
												// render into the alpha channel instead of the color
												// channel, so that the resulting pixels touched always
												// have the renderColor and the alpha = to the font pixel.
												// By default, we use the font pixel as an alpha blending
												// value between the renderColor and the destColor and
												// leave the alpha as-is
												// This flag has no effect on monochrome fonts
			kRenderAlphaPremultiplied = 0x00001000, // Destination has color values premultiplied by alpha
			kRenderShadow             = 0x00002000, // Render text shadows
		};

		enum Flags
		{
			kFlagBold		= 0x00000001,
			kFlagItalic		= 0x00000002
		};

	protected:

		friend class plBDFHeaderParser;
		friend class plBDFPropertiesParser;
		friend class plBDFCharsParser;

		// Font face and size. This is just used for IDing purposes, not for rendering
		char	fFace[ 256 ];
		UInt8	fSize;
		UInt32	fFlags;

		// Size of the whole font bitmap. Fonts are stored vertically, one
		// character at a time, so fWidth is really the max width of any one
		// character bitmap, with of course the proper padding
		UInt32	fWidth, fHeight;

		// Bpp of our font bitmap. We're grayscale, remember...
		UInt8	fBPP;

		// Bitmap data!
		UInt8	*fBMapData;

		// Our character class, for per-char info
		class plCharacter
		{
			public:
				UInt32	fBitmapOff;		// Offset in the font bitmap in bytes 
										// to the first byte of the character
				UInt32	fHeight;		// Height in pixels of this character
				Int32	fBaseline;		// Number of pixels down from the top of 
										// the char bitmap to the baseline.
				
				hsScalar	fLeftKern;	// Kerning values for this char, in pixels
				hsScalar	fRightKern;	// Note that the right kern is relative to 
										// the right side of the bitmap area, which
										// is the width of the font bitmap, so
										// basically each character is the same width,
										// just kerned back!
										// (left kerning currently unsupported, just 
										// in here in case we need to eventually)

				plCharacter& operator=(const int zero) 
				{ 
					fBitmapOff=0;
					fHeight = 0;
					fBaseline = 0;
					fLeftKern = 0;
					fRightKern = 0;

					return *this;
				}

				plCharacter();
				void	Read( hsStream *s );
				void	Write( hsStream *s );
		};

		// First character we encode--everything below this we don't render
		UInt16	fFirstChar;

		// Our characters, stored in an hsTArray for easy construction
		hsTArray<plCharacter>	fCharacters;

		// Max character bitmap height and max ascent for any character
		UInt32	fMaxCharHeight;
		Int32	fFontAscent, fFontDescent;

		typedef void (plFont::*CharRenderFunc)( const plCharacter &c );

		// Render info
		class plRenderInfo
		{
			public:
				Int16		fFirstLineIndent;
				Int16		fX, fY, fNumCols, fFarthestX, fLastX, fLastY;
				Int16		fMaxWidth, fMaxHeight, fMaxAscent, fMaxDescent;
				Int16		fLineSpacing;
				UInt8		*fDestPtr;
				UInt32		fDestStride;
				UInt8		fDestBPP;
				UInt32		fColor;
				plMipmap	*fMipmap;
				UInt32		fFlags;
				pcSmallRect	fClipRect;
				hsScalar	fFloatWidth;

				const wchar_t	*fVolatileStringPtr;	// Just so we know where we clipped

				CharRenderFunc	fRenderFunc;
		};

		plRenderInfo	fRenderInfo;

		void	IClear( bool onConstruct = false );
		void	ICalcFontAscent( void );

		UInt8	*IGetFreeCharData( UInt32 &newOffset );

		void	IRenderLoop( const wchar_t *string, Int32 maxCount );
		void	IRenderString( plMipmap *mip, UInt16 x, UInt16 y, const wchar_t *string, hsBool justCalc );

		// Various render functions
		void	IRenderChar1To32( const plCharacter &c );
		void	IRenderChar1To32AA( const plCharacter &c );
		void	IRenderChar8To32( const plCharacter &c );
		void	IRenderChar8To32Alpha( const plCharacter &c );
		void	IRenderChar8To32FullAlpha( const plCharacter &c );
		void	IRenderChar8To32AlphaPremultiplied( const plCharacter &c );
		void	IRenderChar8To32AlphaPremShadow( const plCharacter &c );
		void	IRenderCharNull( const plCharacter &c );

		UInt32 IGetCharPixel( const plCharacter &c, Int32 x, Int32 y )
		{
			// only for 8-bit characters
			return (x < 0 || y < 0 || (UInt32)x >= fWidth || (UInt32)y >= c.fHeight) ? 0 : *(fBMapData + c.fBitmapOff + y*fWidth + x);
		}

	public:

		plFont();
		virtual ~plFont();

		CLASSNAME_REGISTER( plFont );
		GETINTERFACE_ANY( plFont, hsKeyedObject );

		virtual void	Read( hsStream *s, hsResMgr *mgr );
		virtual void	Write( hsStream *s, hsResMgr *mgr );

		const char	*GetFace( void ) const { return fFace; }
		UInt8		GetSize( void ) const { return fSize; }
		UInt16		GetFirstChar( void ) const { return fFirstChar; }
		UInt16		GetNumChars( void ) const { return fCharacters.GetCount(); }
		UInt32		GetFlags( void ) const { return fFlags; }
		hsScalar	GetDescent( void ) const { return (hsScalar)fFontDescent; }
		hsScalar	GetAscent( void ) const { return (hsScalar)fFontAscent; }

		UInt32		GetBitmapWidth( void ) const { return fWidth; }
		UInt32		GetBitmapHeight( void ) const { return fHeight; }
		UInt8		GetBitmapBPP( void ) const { return fBPP; }

		void	SetFace( const char *face );
		void	SetSize( UInt8 size );
		void	SetFlags( UInt32 flags ) { fFlags = flags; }
		void	SetFlag( UInt32 flag, hsBool on ) { if( on ) fFlags |= flag; else fFlags &= ~flag; }
		hsBool	IsFlagSet( UInt32 flag ) { if( fFlags & flag ) return true; return false; }

		void	SetRenderColor( UInt32 color );
		void	SetRenderFlag( UInt32 flag, hsBool on ) { if( on ) fRenderInfo.fFlags |= flag; else fRenderInfo.fFlags &= ~flag; }
		hsBool	IsRenderFlagSet( UInt32 flag ) { return ( fRenderInfo.fFlags & flag ) ? true : false; }
		void	SetRenderClipRect( Int16 x, Int16 y, Int16 width, Int16 height );
		void	SetRenderXJustify( UInt32 j ) { fRenderInfo.fFlags &= ~kRenderJustXMask; fRenderInfo.fFlags |= j; }
		void	SetRenderYJustify( UInt32 j ) { fRenderInfo.fFlags &= ~kRenderJustYMask; fRenderInfo.fFlags |= j; }
		void	SetRenderFirstLineIndent( Int16 indent ) { fRenderInfo.fFirstLineIndent = indent; }
		void	SetRenderLineSpacing( Int16 spacing ) { fRenderInfo.fLineSpacing = spacing; }

		// Sets flags too
		void	SetRenderClipping( Int16 x, Int16 y, Int16 width, Int16 height );
		void	SetRenderWrapping( Int16 x, Int16 y, Int16 width, Int16 height );

		void	RenderString( plMipmap *mip, UInt16 x, UInt16 y, const char *string, UInt16 *lastX = nil, UInt16 *lastY = nil );
		void	RenderString( plMipmap *mip, UInt16 x, UInt16 y, const wchar_t *string, UInt16 *lastX = nil, UInt16 *lastY = nil );

		UInt16	CalcStringWidth( const char *string );
		UInt16	CalcStringWidth( const wchar_t *string );
		void	CalcStringExtents( const char *string, UInt16 &width, UInt16 &height, UInt16 &ascent, UInt32 &firstClippedChar, UInt16 &lastX, UInt16 &lastY );
		void	CalcStringExtents( const wchar_t *string, UInt16 &width, UInt16 &height, UInt16 &ascent, UInt32 &firstClippedChar, UInt16 &lastX, UInt16 &lastY );

		hsBool	LoadFromFNT( const char *path );
		hsBool	LoadFromFNTStream( hsStream *stream );

		hsBool	LoadFromBDF( const char *path, plBDFConvertCallback *callback );
		hsBool	LoadFromBDFStream( hsStream *stream, plBDFConvertCallback *callback );

		hsBool	LoadFromP2FFile( const char *path );

		hsBool	ReadRaw( hsStream *stream );
		hsBool	WriteRaw( hsStream *stream );
};

#endif // _plFont_h