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.
308 lines
11 KiB
308 lines
11 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/>. |
|
|
|
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
|
|
|