|
|
|
|
/*==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==*/
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// //
|
|
|
|
|
// 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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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 IRenderCharNull( const plCharacter &c );
|
|
|
|
|
|
|
|
|
|
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
|
