You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

283 lines
12 KiB

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