폰트 캐싱

namespace StringShow
{
    const int FONT_MAP_WIDTH = 1024;
    const int FONT_MAP_HEIGHT = 1024;
    int m_fontSize = 0, m_fontHeight = 0, m_fontAscender = 0;
    int m_fontBoxHeight = 0;  //캐싱 버퍼에서 폰트의 라인의 높이다.
    char* m_fontMap = NULL;
    Point2<int> m_pos = {0, 0};

    struct Glyph
    {
            FT_Face face;
            TCHAR ch;
            int size;
            bool operator < (const Glyph& g) const
            {
                if(face < g.face)
                    return true;
                else if(face > g.face)
                    return false;
                if(ch < g.ch)
                    return true;
                else if(ch > g.ch)
                    return false;
                if(size < g.size)
                    return true;
                return false;
            }
    };

    struct GlyphData
    {
        int advancex, advancey;
        int fontHeight; //폰트 높이
        int fontAscender; //기준선에서 올라간 높이
        int posx, posy, width, height;
        int glyphLeft, glyphTop;
        int atlasWidth, atlasHeight;
        int use;
    };

    typedef std::map<Glyph, GlyphData> GlphContainer;   
    GlphContainer m_glyphList;

    ............

#define FONT_LINE_GAP 10  //행간을 주어 글자를 읽기 편하도록 한다.
STOREFONT_ERROR StringShow::StoreFont(char* buff, int width, int height, int x, int y, FT_Face& face, TCHAR ch, GlyphData& gd)
{
    //글리프 인덱스 구함
    int index = FT_Get_Char_Index(face, ch);

    //로드 글리프
    int error = FT_Load_Glyph(face, index, FT_LOAD_DEFAULT | FT_LOAD_NO_BITMAP);
    if(error)
        return FT_Load_Glyph_ERROR;

    //랜더링
    error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
    if(error)
        return FT_Render_Glyph_ERROR;

    //화면에 출력하기 위해 bitmap의 width, rows를 구한다.
    int bitmapWidth = face->glyph->bitmap.width;
    int bitmapHeight = face->glyph->bitmap.rows;
    char* bitmapBuff = (char*)face->glyph->bitmap.buffer;
    int bitmapLeft = face->glyph->bitmap_left;
    int bitmapTop = face->glyph->bitmap_top;

    if(( bitmapWidth  + x) > width)
        return WIDTH_OVER_ERROR;  //폰트가 width 이미지 크기보다 크다.

    if(( bitmapHeight  + y) > height)
        return HEIGHT_OVER_ERROR;  //폰트가 height 이미지 크기보다 크다.

    //GlyphData 설정
    gd.advancex = face->glyph->advance.x >> 6;
    gd.advancey = GetFontHeight();
    gd.fontHeight = GetFontHeight();
    gd.fontAscender = GetFontAscender();
    gd.posx = x;
    gd.posy = y;
    gd.width = bitmapWidth;
    gd.height = bitmapHeight;
    gd.glyphLeft = bitmapLeft;
    gd.glyphTop = bitmapTop;
    gd.atlasWidth = FONT_MAP_WIDTH;
    gd.atlasHeight = FONT_MAP_HEIGHT;
    gd.use = 1;

    for (int n = 0 ; n < bitmapHeight; n++)
    {
        for(int m = 0; m < bitmapWidth; m++)
        {
            buff[width*(n + y) + m + x]  = bitmapBuff[bitmapWidth*n + m];
        }
    }

    return NONE_STORE_FONT_ERROR;
}

StringShow::GlyphData StringShow::GetFontChar(char* buff, FT_Face& face, TCHAR ch)
{
    int fontSize = GetFontSize();
    Glyph g = {face, ch, fontSize};
    GlyphData glyphData = {0, };

    GlphContainer::iterator it = m_glyphList.find(g);
    if(it != m_glyphList.end())
    {
        it->second.use = 1;
        return it->second;
    }

    Point2<int> size = {0, 0};
    STOREFONT_ERROR res = StringShow::StoreFont(buff, FONT_MAP_WIDTH, FONT_MAP_HEIGHT, m_pos.x, m_pos.y, face, ch, glyphData);
    size.x = face->glyph->bitmap.width;
    size.y = face->glyph->bitmap.rows;

    if(res == WIDTH_OVER_ERROR)
    {
        m_pos.x = 0;
        m_pos.y += StringShow::GetFontBoxHeight();
        StringShow::StoreFont(buff, FONT_MAP_WIDTH, FONT_MAP_HEIGHT, m_pos.x, m_pos.y, face, ch, glyphData);
    }
    else if(res > 0)
    {
        return glyphData;
    }

    m_pos.x += size.x;
    m_glyphList[g] = glyphData;

    return glyphData;
}

int RenderFont(char* buff, const StringShow::GlyphData& gd, int x, int y, TCHAR ch)
{
    int width = 1024;
    int height = 1024;

    const char* src = (const char *)StringShow::m_fontMap;

    //화면에 출력하기 위해 bitmap의 width, rows를 구한다.
    int bitmapWidth = gd.width;
    int bitmapHeight = gd.height;
    char* bitmapBuff = (char *)StringShow::m_fontMap;
    int bitmapLeft = gd.glyphLeft;
    int bitmapTop = gd.glyphTop;
    int fontHeight = gd.fontHeight;

    if(( bitmapWidth  + x + bitmapLeft) > width)
        return 1;  //폰트가 width 이미지 크기보다 크다.

    for (int n = 0 ; n < bitmapHeight; n++)
    {
        for(int m = 0; m < bitmapWidth; m++)
        {
            buff[width*(n + y + (gd.fontAscender-bitmapTop)) + m + x + bitmapLeft]  = src[StringShow::FONT_MAP_WIDTH*(n + gd.posy) + m + gd.posx];
        }
    }

    return 0;
}


int StringShow::DrawString(FT_Face& face, const char* szPath, TCHAR *str, char* outBuff)
{    
    Point2<int> pos = {0, 0};

    int len = (int)_tcslen(str);
    for(int n = 0; n < len; n++)
    {
        StringShow::GlyphData gd = GetFontChar(StringShow::m_fontCacheMap, face, str[n]);
        if(gd.advancex == 0 || gd.advancey == 0)
        {
            //Font를 캐싱버퍼에 저장 할수 없을때 width, height는 0이다.
            continue;
        }

        if(RenderFont(outBuff, gd, pos.x, pos.y, str[n]) == 1)
        {
            pos.x = 0;
            pos.y += (gd.advancey + FONT_LINE_GAP);
            RenderFont(outBuff, gd, pos.x, pos.y, str[n]);
        }
        pos.x += gd.advancex;
    }
    StringShow::WritePGM(szPath, FONT_MAP_WIDTH, FONT_MAP_HEIGHT, (const char *)StringShow::m_fontMap);
    StringShow::WritePGM("out4.pgm", 1024, 1024, (const char *)outBuff);
    return 0;
}

int StringShow::SaveFont()
{
    FT_Library library;

    if (FT_Init_FreeType(&library))
        return -1;

    char* outBuff = new char[1024*1024];
    memset(outBuff, 0, 1024*1024);

    //폰트 읽기
    FT_Face face;
    //궁서 페이스는 batang.ttc의 두번째에 있다.
    //int error = FT_New_Face(library,"c:\\windows\\fonts\\batang.ttc", 2, &face);  
    //int error = FT_New_Face(library,"c:\\windows\\fonts\\arial.ttf", 0,&face);
    int error = FT_New_Face(library,"나눔고딕.ttf", 0, &face);
    SetFontSize(80);
   
    //폰트 크기 설정
    error = FT_Set_Char_Size(face, 0, GetFontSize()*64, 96, 96);
    //error = FT_Set_Pixel_Sizes(face, 0, 256);

    int fontBoxHeight = ::FT_MulFix(face->bbox.yMax - face->bbox.yMin, face->size->metrics.y_scale)/64;
    StringShow::SetFotBoxHeight( fontBoxHeight);

    int fontHeight = face->size->metrics.height/64;
    int fontAscender = face->size->metrics.ascender / 64;
    SetFontHeight(fontHeight);
    SetFontAscender(fontAscender);

    StringShow::DrawString(face, "test4.pgm", _T("폰트 뷁 값 Hello, World! 아름다운 우리나라 폰트세상"), outBuff);

    //face 정리
    FT_Done_Face(face);

    //종료시 라이브러리 정리
    FT_Done_FreeType(library);

    delete [] outBuff;
    return 0;
}