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 "HeadSpin.h"
#include "hsColorRGBA.h"
#include "hsTemplates.h"
#include "pcSmallRect.h"

#include "pnKeyedObject/hsKeyedObject.h"

#include <wchar.h>

class plBDFConvertCallback
{
    public:
        virtual void    NumChars( uint16_t 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
        plString  fFace;
        uint8_t   fSize;
        uint32_t  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_t  fWidth, fHeight;

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

        // Bitmap data!
        uint8_t   *fBMapData;

        // Our character class, for per-char info
        class plCharacter
        {
            public:
                uint32_t  fBitmapOff;     // Offset in the font bitmap in bytes 
                                        // to the first uint8_t of the character
                uint32_t  fHeight;        // Height in pixels of this character
                int32_t   fBaseline;      // Number of pixels down from the top of 
                                        // the char bitmap to the baseline.
                
                float    fLeftKern;  // Kerning values for this char, in pixels
                float    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_t  fFirstChar;

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

        // Max character bitmap height and max ascent for any character
        uint32_t  fMaxCharHeight;
        int32_t   fFontAscent, fFontDescent;

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

        // Render info
        class plRenderInfo
        {
            public:
                int16_t       fFirstLineIndent;
                int16_t       fX, fY, fNumCols, fFarthestX, fLastX, fLastY;
                int16_t       fMaxWidth, fMaxHeight, fMaxAscent, fMaxDescent;
                int16_t       fLineSpacing;
                uint8_t       *fDestPtr;
                uint32_t      fDestStride;
                uint8_t       fDestBPP;
                uint32_t      fColor;
                plMipmap    *fMipmap;
                uint32_t      fFlags;
                pcSmallRect fClipRect;
                float    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_t   *IGetFreeCharData( uint32_t &newOffset );

        void    IRenderLoop( const wchar_t *string, int32_t maxCount );
        void    IRenderString( plMipmap *mip, uint16_t x, uint16_t y, const wchar_t *string, bool 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_t IGetCharPixel( const plCharacter &c, int32_t x, int32_t y )
        {
            // only for 8-bit characters
            return (x < 0 || y < 0 || (uint32_t)x >= fWidth || (uint32_t)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 );

        plString    GetFace( void ) const { return fFace; }
        uint8_t     GetSize( void ) const { return fSize; }
        uint16_t    GetFirstChar( void ) const { return fFirstChar; }
        uint16_t    GetNumChars( void ) const { return fCharacters.GetCount(); }
        uint32_t    GetFlags( void ) const { return fFlags; }
        float       GetDescent( void ) const { return (float)fFontDescent; }
        float       GetAscent( void ) const { return (float)fFontAscent; }

        uint32_t      GetBitmapWidth( void ) const { return fWidth; }
        uint32_t      GetBitmapHeight( void ) const { return fHeight; }
        uint8_t       GetBitmapBPP( void ) const { return fBPP; }

        void    SetFace( const plString &face ) { fFace = face; }
        void    SetSize( uint8_t size ) { fSize = size; }
        void    SetFlags( uint32_t flags ) { fFlags = flags; }
        void    SetFlag( uint32_t flag, bool on ) { if( on ) fFlags |= flag; else fFlags &= ~flag; }
        bool    IsFlagSet( uint32_t flag ) { if( fFlags & flag ) return true; return false; }

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

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

        void    RenderString( plMipmap *mip, uint16_t x, uint16_t y, const plString &string, uint16_t *lastX = nil, uint16_t *lastY = nil );
        void    RenderString( plMipmap *mip, uint16_t x, uint16_t y, const wchar_t *string, uint16_t *lastX = nil, uint16_t *lastY = nil );

        uint16_t  CalcStringWidth( const plString &string );
        uint16_t  CalcStringWidth( const wchar_t *string );
        void    CalcStringExtents( const plString &string, uint16_t &width, uint16_t &height, uint16_t &ascent, uint32_t &firstClippedChar, uint16_t &lastX, uint16_t &lastY );
        void    CalcStringExtents( const wchar_t *string, uint16_t &width, uint16_t &height, uint16_t &ascent, uint32_t &firstClippedChar, uint16_t &lastX, uint16_t &lastY );

        bool    LoadFromFNT( const plFileName &path );
        bool    LoadFromFNTStream( hsStream *stream );

        bool    LoadFromBDF( const plFileName &path, plBDFConvertCallback *callback );
        bool    LoadFromBDFStream( hsStream *stream, plBDFConvertCallback *callback );

        bool    LoadFromP2FFile( const plFileName &path );

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

#endif // _plFont_h