glfont.h

Go to the documentation of this file.

#pragma once
 
#ifdef WIN32
    #include <windows.h>
    #include <gl/GL.h>
    #include <gl/GLU.h>
#else
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <fontconfig/fontconfig.h>
#endif
 
#include <ft2build.h>
#include FT_FREETYPE_H
 
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/gfxlibinterfaces.h>
#include <adtf_platform_inc.h>
 
#define _USE_MATH_DEFINES
#include <cmath>
#ifndef M_PI
namespace
{
const double M_PI = std::acos(-1.0);
const double M_PI_2 = M_PI / 2.0;
} // namespace
#endif
#include <stdio.h>
 
#ifdef max
    #undef max
#endif
#include <algorithm>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
 
class cGLCanvas;

class cGLFont : public IFont
{
protected:
    static FT_Library g_hFreeTypeLibrary;
    static tInt g_nLibraryRefCount;
    static const tInt g_nCharsetSize = 128;
 
protected:
    FT_Face m_hFace; 
    GLuint* m_hTextures; 
    GLuint m_nTextureBase; 
    tInt m_nHeight; 
    tInt m_aCharWidth[256]; 
 
    static constexpr tInt m_nTextureScale = 8; 

    tBool m_bOpposedYAxis;
    tBool m_bScaleWithCoordinateSystem;
    tBool m_bRotationWithCoordinateSystem;
    tBool m_bTextBaselineOnTop;
 
public:
    cGLFont()
    {
        cGLFont::Initialize();
 
        m_hTextures = NULL;
        m_nTextureBase = 0;
        m_hFace = NULL;
        m_bOpposedYAxis = tFalse;
        m_bRotationWithCoordinateSystem = tFalse;
        m_bScaleWithCoordinateSystem = tFalse;
        m_bTextBaselineOnTop = tFalse;
    }

    ~cGLFont()
    {
        CleanUp();
 
        cGLFont::Uninitialize();
    }

    static tResult Initialize()
    {
        if (g_nLibraryRefCount == 0)
        {
            FT_Error l_nError = FT_Init_FreeType(&g_hFreeTypeLibrary);
            if (l_nError != 0)
            {
                g_hFreeTypeLibrary = NULL;
                RETURN_ERROR(ERR_UNKNOWN);
            }
        }
 
        g_nLibraryRefCount++;
 
        RETURN_NOERROR;
    }

    static tResult Uninitialize()
    {
        if (g_nLibraryRefCount > 0)
        {
            g_nLibraryRefCount--;
 
            if (g_nLibraryRefCount == 0)
            {
                if (g_hFreeTypeLibrary != NULL)
                {
                    FT_Done_FreeType(g_hFreeTypeLibrary);
                    g_hFreeTypeLibrary = NULL;
                }
            }
        }
 
        RETURN_NOERROR;
    }

    tResult Create(const cGLCanvas* /*pCanvas*/, const char* strFilename, tInt nHeight, tStyle eFontStyle)
    {
        if (g_hFreeTypeLibrary == NULL)
        {
            RETURN_ERROR(ERR_UNKNOWN);
        }
 
        char l_strFontPath[MAX_PATH];
 
#ifdef WIN32
        char l_strWinDir[MAX_PATH];
        char l_strPhysPath[MAX_PATH];
 
        if (strchr(strFilename, '.') != NULL)
        {
            adtf::util::cStringUtil::Copy(l_strPhysPath, strFilename, tSize(-1), tSize(MAX_PATH));
        }
        else
        {
            // filename actually is the family name ?
            if (!_fnLookupFontFile(strFilename, l_strPhysPath))
            {
                adtf::util::cStringUtil::Copy(l_strPhysPath, strFilename, MAX_PATH - 5);
                strcat_s(l_strPhysPath, MAX_PATH, ".ttf");
            }
        }
 
        ::GetSystemWindowsDirectory(l_strWinDir, sizeof(l_strWinDir));
        sprintf_s(l_strFontPath, MAX_PATH, "%s\\Fonts\\%s", l_strWinDir, l_strPhysPath);
#else
 
        FcInit();
        FcPattern* psPat = FcNameParse((FcChar8*) strFilename);
        FcConfigSubstitute(0, psPat, FcMatchPattern);
        FcDefaultSubstitute(psPat);
 
        FcFontSet* psFs = FcFontSetCreate();
        FcResult sResult;
        FcPattern* psMatch = FcFontMatch(0, psPat, &sResult);
        if (psMatch)
        {
            FcFontSetAdd(psFs, psMatch);
        }
 
        FcPatternDestroy(psPat);
 
        FcChar8* strFile;
        if (psFs->nfont > 0 && FcPatternGetString(psFs->fonts[0], FC_FILE, 0, &strFile) == FcResultMatch)
        {
            adtf::util::cStringUtil::Copy(l_strFontPath, (const tChar*) strFile, -1, MAX_PATH);
        }
        else
            l_strFontPath[0] = 0;
 
        FcFontSetDestroy(psFs);
#endif
 
        tInt l_nError;
        l_nError = FT_New_Face(g_hFreeTypeLibrary, l_strFontPath, 0, &m_hFace);
        if (l_nError)
        {
            // FT_Err_Cannot_Open_Resource
            RETURN_ERROR(ERR_UNKNOWN);
        }
 
        m_nHeight = nHeight * 64;
 
        FT_Set_Char_Size(m_hFace, nHeight << 6, nHeight << 6, 96 * m_nTextureScale, 96 * m_nTextureScale);
 
        m_hTextures = new GLuint[g_nCharsetSize];
        if (m_hTextures == NULL)
        {
            RETURN_ERROR(ERR_MEMORY);
        }
 
        m_nTextureBase = glGenLists(g_nCharsetSize);
        glGenTextures(g_nCharsetSize, m_hTextures);
 
        for (tInt c = 0; c < g_nCharsetSize; c++)
        {
            BuildDisplayList((char) c, eFontStyle);
        }
 
        FT_Done_Face(m_hFace);
        m_hFace = NULL;
 
        RETURN_NOERROR;
    }

    tResult CleanUp()
    {
        if (m_nTextureBase > 0)
        {
            glDeleteLists(m_nTextureBase, g_nCharsetSize);
            glDeleteTextures(g_nCharsetSize, m_hTextures);
 
            m_nTextureBase = 0;
        }
 
        if (m_hTextures != NULL)
        {
            delete[] m_hTextures;
            m_hTextures = NULL;
        }
 
        RETURN_NOERROR;
    }

    void Print(tInt x, tInt y, tFloat64 fAngle, const char* strFormat, va_list ArgList)
    {
        PrintImpl(1, (tFloat32) x, (tFloat32) y, fAngle, strFormat, ArgList);
    }

    void Print(tFloat32 x, tFloat32 y, tFloat64 fAngle, const char* strFormat, va_list ArgList)
    {
        PrintImpl(0, x, y, fAngle, strFormat, ArgList);
    }

    tVoid FlipTextHorizontally(tBool bOpposedYAxis)
    {
        m_bOpposedYAxis = bOpposedYAxis;
    }

    tVoid TextScaleWithCoordinateSystem(tBool bScaleWithCoordinateSystem)
    {
        m_bScaleWithCoordinateSystem = bScaleWithCoordinateSystem;
    };

    tVoid TextRotateWithCoordinateSystem(tBool bRotateWithCoordinateSystem)
    {
        m_bRotationWithCoordinateSystem = bRotateWithCoordinateSystem;
    };

    tVoid TextBaselineOnTop(tBool bTextBaselineOnTop)
    {
        m_bTextBaselineOnTop = bTextBaselineOnTop;
    };
 
public: // Implements IFont
    tResult Release()
    {
        CleanUp();
 
        delete this;
 
        RETURN_NOERROR;
    }
 
    tInt GetHeight() const
    {
        return m_nHeight;
    }
 
    tBool MeasureText(const char* str, tInt& nWidth, tInt& nHeight) const
    {
        if (str == NULL)
        {
            return tFalse;
        }
 
        tInt nMaxWidth = 0;
        tInt nCurWidth = 0;
        tInt nLineCount = 0;
 
        do
        {
            if (*str == '\n' || *str == 0)
            {
                nMaxWidth = std::max(nMaxWidth, nCurWidth);
                nCurWidth = 0;
                nLineCount++;
            }
            else
            {
                nCurWidth += m_aCharWidth[static_cast<tInt>(*str)];
            }
        } while (*str++);
 
        nWidth = nMaxWidth / 64;
        tFloat32 fLineHeight = (tFloat32) m_nHeight / 0.63f;
        nHeight = (tInt) (nLineCount * fLineHeight / 64.0f);
        return tTrue;
    }
 
protected:
    tResult BuildDisplayList(char ch, tStyle eFontStyle)
    {
        tInt l_nError;
 
        // The First Thing We Do Is Get FreeType To Render Our Character
        // Into A Bitmap.  This Actually Requires A Couple Of FreeType Commands:
 
        // Load The Glyph For Our Character.
        l_nError = FT_Load_Glyph(m_hFace, FT_Get_Char_Index(m_hFace, ch), FT_LOAD_DEFAULT);
        if (l_nError)
        {
            RETURN_ERROR(ERR_UNKNOWN);
        }
 
        FT_Render_Mode l_nRenderMode;
        switch (eFontStyle)
        {
            case STYLE_Antialiased:
            {
                l_nRenderMode = FT_RENDER_MODE_NORMAL;
                break;
            }
            case STYLE_Mono:
            {
                l_nRenderMode = FT_RENDER_MODE_MONO;
                break;
            }
            default:
            {
                l_nRenderMode = FT_RENDER_MODE_NORMAL;
                break;
            }
        }
 
        l_nError = FT_Render_Glyph(m_hFace->glyph, l_nRenderMode);
        if (l_nError)
        {
            RETURN_ERROR(ERR_UNKNOWN);
        }
 
        FT_GlyphSlot slot = m_hFace->glyph;
        FT_Bitmap& bitmap = slot->bitmap;
 
        // Use Our Helper Function To Get The Widths Of
        // The Bitmap Data That We Will Need In Order To Create
        // Our Texture.
        int width = _fnGetNextPowerOfTwo(bitmap.width);
        int height = _fnGetNextPowerOfTwo(bitmap.rows);
 
        // Allocate Memory For The Texture Data.
        GLubyte* l_pTextureBuffer = new GLubyte[2 * width * height];
 
        tInt l_nValue;
        if (bitmap.pixel_mode == FT_PIXEL_MODE_MONO)
        {
            tInt l_nSrc;
            tInt l_nMask;
            for (int j = 0; j < height; j++)
            {
                for (int i = 0; i < width; i++)
                {
                    if (i < bitmap.width && j < bitmap.rows)
                    {
                        l_nSrc = bitmap.buffer[i / 8 + bitmap.pitch * j];
                        l_nMask = (1 << (7 - (i % 8)));
                        l_nValue = ((l_nSrc & l_nMask) != 0) ? 255 : 0;
                    }
                    else
                    {
                        l_nValue = 0;
                    }
 
                    l_pTextureBuffer[2 * (i + j * width)] = l_pTextureBuffer[2 * (i + j * width) + 1] =
                        (GLubyte) l_nValue;
                }
            }
        }
        else if (bitmap.pixel_mode == FT_PIXEL_MODE_GRAY)
        {
            for (int j = 0; j < height; j++)
            {
                for (int i = 0; i < width; i++)
                {
                    if (i < bitmap.width && j < bitmap.rows)
                    {
                        l_nValue = bitmap.buffer[i + bitmap.pitch * j];
                    }
                    else
                    {
                        l_nValue = 0;
                    }
 
                    l_pTextureBuffer[2 * (i + j * width)] = l_pTextureBuffer[2 * (i + j * width) + 1] =
                        (GLubyte) l_nValue;
                }
            }
        }
        else
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        glEnable(GL_TEXTURE_2D);
 
        // Now We Just Setup Some Texture Parameters.
        glBindTexture(GL_TEXTURE_2D, m_hTextures[static_cast<tInt>(ch)]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 
        // Here We Actually Create The Texture Itself, Notice
        // That We Are Using GL_LUMINANCE_ALPHA To Indicate That
        // We Are Using 2 Channel Data.
        gluBuild2DMipmaps(GL_TEXTURE_2D, 2, width, height, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, l_pTextureBuffer);
 
        // With The Texture Created, We Don't Need The Expanded Data Anymore.
        delete[] l_pTextureBuffer;
 
        // Now We Create The Display List
        glNewList(m_nTextureBase + ch, GL_COMPILE);
        glBindTexture(GL_TEXTURE_2D, m_hTextures[static_cast<tInt>(ch)]);
        glPushMatrix();
 
        // First We Need To Move Over A Little So That
        // The Character Has The Right Amount Of Space
        // Between It And The One Before It.
        glTranslatef((GLfloat) slot->bitmap_left, 0.0f, 0.0f);
 
        // Now We Move Down A Little In The Case That The
        // Bitmap Extends Past The Bottom Of The Line
        // This Is Only True For Characters Like 'g' Or 'y'.
        glTranslatef(0.0f, (GLfloat) bitmap.rows - slot->bitmap_top, 0.0f);
 
        // Now We Need To Account For The Fact That Many Of
        // Our Textures Are Filled With Empty Padding Space.
        // We Figure What Portion Of The Texture Is Used By
        // The Actual Character And Store That Information In
        // The x And y Variables, Then When We Draw The
        // Quad, We Will Only Reference The Parts Of The Texture
        // That Contains The Character Itself.
        float u = (float) bitmap.width / (float) width;
        float v = (float) bitmap.rows / (float) height;
 
        // Here We Draw The Texturemapped Quads.
        // The Bitmap That We Got From FreeType Was Not
        // Oriented Quite Like We Would Like It To Be,
        // But We Link The Texture To The Quad
        // In Such A Way That The Result Will Be Properly Aligned.
 
        tInt cx = bitmap.width;
        tInt cy = bitmap.rows;
 
        tInt l_nFontHeight = ((slot->metrics.vertAdvance + 63) / 64);
 
        glBegin(GL_QUADS);
        glNormal3f(0.0f, 0.0f, -1.0f);
        glTexCoord2d(0, 0);
        glVertex2i(0, l_nFontHeight - cy - 1);
        glTexCoord2d(0, v);
        glVertex2i(0, l_nFontHeight - 1);
        glTexCoord2d(u, v);
        glVertex2i(cx, l_nFontHeight - 1);
        glTexCoord2d(u, 0);
        glVertex2i(cx, l_nFontHeight - cy - 1);
        glEnd();
 
        glPopMatrix();
        glTranslatef((GLfloat) (m_hFace->glyph->advance.x) / 64.0f, 0.0f, 0.0f);
 
        m_aCharWidth[static_cast<tInt>(ch)] = m_hFace->glyph->advance.x;
        // Increment The Raster Position As If We Were A Bitmap Font.
        // (Only Needed If You Want To Calculate Text Length)
        // glBitmap(0,0,0,0,face->glyph->advance.x >> 6,0,NULL);
 
        // Finish The Display List
        glEndList();
 
        glDisable(GL_TEXTURE_2D);
 
        RETURN_NOERROR;
    }

    void PrintImpl(tUInt32 ui32Flags, tFloat32 x, tFloat32 y, tFloat64 fAngle, const char* strFormat, va_list ArgList)
    {
        tBool bUseIntCoords = (ui32Flags != 0);
 
        // We Make The Height A Little Bigger.  There Will Be Some Space Between Lines.
        tFloat32 fLineHeight = (tFloat32) m_nHeight / 0.63f;
        tChar strBuffer[4096]; // Holds Our String
 
        if (strFormat == NULL) // If There's No Text
        {
            *strBuffer = 0; // Do Nothing
        }
        else
        {
#ifdef WIN32
            vsprintf_s(strBuffer, 4096, strFormat, ArgList);
#else
            vsprintf(strBuffer, strFormat, ArgList);
#endif
        }
 
        const char* start_line = strBuffer;
        std::vector<std::string> lines;
        const tChar* ptr;
        for (ptr = strBuffer; *ptr != '\0'; ptr++)
        {
            if (*ptr == '\n')
            {
                std::string line;
                for (const tChar* ptr2 = start_line; ptr2 < ptr; ptr2++)
                {
                    line.append(1, *ptr2); // append char
                }
 
                lines.push_back(line);
 
                start_line = ptr + 1;
            }
        }
 
        if (start_line)
        {
            std::string line;
            for (const tChar* ptr2 = start_line; ptr2 < ptr; ptr2++)
            {
                line.append(1, *ptr2);
            }
 
            lines.push_back(line);
        }
 
        glPushAttrib(GL_LIST_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT | GL_TRANSFORM_BIT);
        glMatrixMode(GL_MODELVIEW);
        glEnable(GL_TEXTURE_2D);
 
        // In case Alpha Blending was not enabled we do not need to disable it again
        // because glPopAttrib will do it for us (see flags GL_ENABLE_BIT)
        if (!glIsEnabled(GL_BLEND))
        {
            glEnable(GL_BLEND);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
 
        glListBase(m_nTextureBase);
 
        {
            glPushMatrix();
 
            // Apply translation first
            glTranslated(x, y, 0.0);
 
            if (!m_bScaleWithCoordinateSystem || !m_bRotationWithCoordinateSystem)
            {
                // compute the projected position of the text's origin point
 
                GLdouble modelview[16];
                glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
 
                // Extract scalation from the ModelMatrix
                GLdouble fScaleX = sqrt(modelview[0] * modelview[0] + modelview[4] * modelview[4]);
 
                GLdouble fScaleY = sqrt(modelview[1] * modelview[1] + modelview[5] * modelview[5]);
                glLoadIdentity();
 
                glTranslated(modelview[12], modelview[13], modelview[14]);
 
                if (m_bRotationWithCoordinateSystem)
                {
                    // Extract rotation from the ModelMatrix
                    GLdouble fRotation = atan2(modelview[1] / fScaleX, modelview[0] / fScaleY);
                    // Set rotation
                    glRotated(fRotation / M_PI * 180, 0, 0, 1);
                }
 
                if (m_bScaleWithCoordinateSystem)
                {
                    // Set scalation
                    glScaled(fScaleX, fScaleY, 0.0);
                }
            }
 
            if (!m_bOpposedYAxis)
            {
                // Flip horizontally first, BuildDisplayList assumes (0,1,0) = UP
                glRotated(180.0, 1.0, 0.0, 0.0);
            }
 
            // Rotate whole text block to requested orientation
            glRotated(fAngle, 0.0, 0.0, 1.0);
 
            // Revert internal supersampling
            glScaled(1.0 / m_nTextureScale, 1.0 / m_nTextureScale, 1);
        }
 
        for (int i = 0; i < (int) lines.size(); i++)
        {
            const tChar* strLine = lines[i].c_str();
            tInt nLineLen = (tInt) lines[i].length();
 
            // Align to either top or bottom of text block
            int iLineCorrection = m_bTextBaselineOnTop ? 0 : static_cast<int>(lines.size());
            GLdouble fLineOffset = (fLineHeight * (i - iLineCorrection)) * m_nTextureScale / 64;
 
            if (bUseIntCoords)
            {
                fLineOffset = static_cast<GLdouble>(static_cast<tInt>(fLineOffset));
            }
 
            glPushMatrix();
 
            glTranslated(0.0, fLineOffset, 0.0);
 
            // output line of text
            glCallLists(nLineLen, GL_UNSIGNED_BYTE, strLine);
 
            glPopMatrix();
        }
 
        glPopMatrix();
 
        glPopAttrib();
    }
 
    static inline bool _fnLookupFontFile(const char* strFamily, char* strFilenameBuffer)
    {
        bool bResult = false;
 
#ifdef WIN32
        if (strFamily == NULL)
        {
            return false;
        }
 
        int nFamilyLen = (int) adtf::util::cStringUtil::GetLength(strFamily);
 
        HKEY hKey = NULL;
        RegOpenKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", &hKey);
 
        char strValueBuffer[512];
        DWORD dwValueBufferSize;
        DWORD dwType;
        char strDataBuffer[512];
        DWORD dwDataBufferSize;
        LONG nResult;
        DWORD nIdx = 0;
 
        while (tTrue)
        {
            dwValueBufferSize = sizeof(strValueBuffer);
            dwType = 0;
            dwDataBufferSize = sizeof(strDataBuffer);
 
            nResult = RegEnumValue(hKey, nIdx, strValueBuffer, &dwValueBufferSize, NULL, &dwType, (BYTE*) strDataBuffer,
                                   &dwDataBufferSize);
            if (nResult != ERROR_SUCCESS)
            {
                break;
            }
 
            if (dwType == REG_SZ)
            {
                if (_strnicmp(strFamily, strValueBuffer, nFamilyLen) == 0)
                {
                    adtf::util::cStringUtil::Copy(strFilenameBuffer, strDataBuffer);
                    bResult = tTrue;
                    break;
                }
            }
 
            nIdx++;
        }
 
        RegCloseKey(hKey);
 
#else
        // not implemented outside WIN32
#endif
 
        return bResult;
    }
 
    static inline int _fnGetNextPowerOfTwo(int a)
    {
        int rval = 2;
        while (rval < a)
        {
            rval <<= 1;
        }
 
        return rval;
    }
};
 
inline FT_Library cGLFont::g_hFreeTypeLibrary = NULL;
inline tInt cGLFont::g_nLibraryRefCount = 0;
 
} // namespace dengar
 
using dengar::cGLFont;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf