Font.cpp

Go to the documentation of this file.

#include "Application.hpp"


Font::Font(TextRenderer* textRenderer, string const & name, const uint size)
    : m_name(name)
    , m_size(size)
    , m_textRenderer(textRenderer)
{
    stringstream ss; ss << "content\\fonts\\" << name << ".ttf";
    string file = ss.str();

    FT_Error error;
    FT_Face face;

    error = FT_New_Face( textRenderer->m_ftLib,
                        file.c_str(),
                        0,
                        &face );
    if ( error == FT_Err_Unknown_File_Format )
    {
        cerr << "ERROR: Loading font '" << file << "' failed (Unknown file format)" << endl;
        exit(EXIT_FAILURE);
    }
    else if ( error )
    {
        cerr << "ERROR: Loading font '" << file << "' failed (Could not read font-file)" << endl;
        exit(EXIT_FAILURE);
    }

    FT_Set_Char_Size(face,0,size*64,72,72);

    m_atlasSize = uvec2(0,0);

    map<int, uvec2> charToCoords;

    uint x = 0;
    uint y = 0;
    uint rowHeight = 0;
    for(uint row = 0; row < 15; row++) 
    {
        x = 0;
        rowHeight = 0;
        for(uint col = 0; col < 15; col++) 
        {
            uint i = 32 + row*15+col;

            error = FT_Load_Char(face, i, FT_LOAD_RENDER);
            if(error) 
            {
                cerr << "ERROR: Loading font '" << file << "' failed (char '"<< i <<"')" << endl;
                exit(EXIT_FAILURE);
            }
            auto& g = face->glyph;
        
            rowHeight = glm::max(rowHeight,(uint)g->bitmap.rows);

            charToCoords[i] = uvec2(x, y);

            x += g->bitmap.width + 5;
        }
        y += rowHeight + 5;
        m_atlasSize.x = glm::max(m_atlasSize.x, x);
    }

    m_atlasSize.y = y;


    m_atlasSize.x = static_cast<int>(glm::pow(2.0,glm::ceil(glm::log2(static_cast<double>(m_atlasSize.x)))));
    m_atlasSize.y = static_cast<int>(glm::pow(2.0,glm::ceil(glm::log2(static_cast<double>(m_atlasSize.y)))));
    
    m_atlasData.resize(m_atlasSize.x*m_atlasSize.y);
    memset(m_atlasData.data(),0,m_atlasSize.x*m_atlasSize.y*sizeof(char));
    
    
    float ymin = 1000000000.0;
    float ymax = 0;
    x = 0; 
    for(int i = 32; i < 256; i++) 
    {
        if(FT_Load_Char(face, i, FT_LOAD_RENDER))
            continue;
 
        auto& g             = face->glyph;      
        auto& pixelCoords   = charToCoords[i];

        for ( int tx = 0 ; tx < g->bitmap.width ; tx ++)
            for ( int ty = 0 ; ty < g-> bitmap.rows; ty ++)
            {
                m_atlasData[m_atlasSize.x * (ty+pixelCoords.y) + pixelCoords.x + tx] = g->bitmap.buffer[(g->bitmap.rows-ty-1) * g->bitmap.pitch + tx];
            }
            
        auto& glyph = m_glyphs[i];

        glyph.size = vec2( g->bitmap.width, g->bitmap.rows );
        glyph.advance = vec2( g->metrics.horiAdvance >> 6, g->metrics.vertAdvance >> 6 );
        glyph.location = vec2( g->metrics.horiBearingX >> 6 , (g->metrics.horiBearingY - g->metrics.height) >> 6 );
        glyph.texCoord1 = vec2(pixelCoords.x/static_cast<float>(m_atlasSize.x),pixelCoords.y/static_cast<float>(m_atlasSize.y));
        glyph.texCoord2 = vec2((pixelCoords.x + glyph.size.x)/static_cast<float>(m_atlasSize.x),(pixelCoords.y + glyph.size.y)/static_cast<float>(m_atlasSize.y));

        ymin = static_cast<float>(glm::min(glyph.location.y,ymin));
        ymax = static_cast<float>(glm::max(glyph.location.y + glyph.size.y, ymax));
    }

    m_lineHeight = (ymax-ymin);

    FT_Done_Face(face);

    glGenTextures(1, &m_atlas);
    
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_atlas);
    
    glPixelStorei(GL_PACK_ALIGNMENT,1);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_atlasSize.x, m_atlasSize.y, 0, GL_RED, GL_UNSIGNED_BYTE, m_atlasData.data());
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glPixelStorei(GL_PACK_ALIGNMENT,4);
    glBindTexture(GL_TEXTURE_2D, 0);
}
Font::~Font()
{
    glDeleteTextures(1, &m_atlas);
}
vec2 Font::measure(string const & text)
{   
    vec2 size(0,0);

    auto& wndSize = m_textRenderer->m_app->getWindow().getSize();

    for(auto& c : text) 
    { 
        if (c == 0) break;

        auto& gi = m_glyphs.find(c);
        if ( gi == m_glyphs.end() )
            continue;

        auto& g = gi->second;

        size.x += g.advance.x / wndSize.x;
        size.y = glm::max(size.y, g.advance.y / wndSize.y);
    }
    
    return size;
}
void Font::prepare(string const & text)
{
    auto& wndSize = m_textRenderer->m_app->getWindow().getSize();
    auto vertices = &(m_textRenderer->m_vertices);

    vertices->clear();

    float x = 0;
    for(auto& c : text) 
    { 
        if (c == 0) break;

        auto& gi = m_glyphs.find(c);
        if ( gi == m_glyphs.end() )
            continue;

        auto& g = gi->second;

        float localX = x + g.location.x/wndSize.x;
        float localY = g.location.y/wndSize.y;

        float localW = g.size.x/wndSize.x;
        float localH = g.size.y/wndSize.y;

        x += g.advance.x/wndSize.x;
            
        if ( g.size.x == 0 || g.size.y == 0 ) continue;


        vertices->push_back(vec4( localX,               localY,             g.texCoord1.x,      g.texCoord1.y)); 
        vertices->push_back(vec4( localX + localW,      localY,             g.texCoord2.x,      g.texCoord1.y));
        vertices->push_back(vec4( localX,               localY + localH,    g.texCoord1.x,      g.texCoord2.y));
        vertices->push_back(vec4( localX,               localY + localH,    g.texCoord1.x,      g.texCoord2.y));
        vertices->push_back(vec4( localX + localW,      localY,             g.texCoord2.x,      g.texCoord1.y));
        vertices->push_back(vec4( localX + localW,      localY + localH,    g.texCoord2.x,      g.texCoord2.y));
    }
}
void Font::draw(string const & text, vec4 const & color, vec2 position, HAlign hAlign, VAlign vAlign, vec2 const & scale)
{
    if (hAlign != HAlign::Left || vAlign != VAlign::Bottom)
    {
        auto size = measure(text);

        switch(hAlign)
        {
            case(HAlign::Center): position.x -= size.x*0.5f; break;
            case(HAlign::Right):   position.x -= size.x; break;
            default: break;
        }
        switch(vAlign)
        {
            case(VAlign::Middle): position.y -= size.y*0.5f; break;
            case(VAlign::Top):    position.y -= size.y; break;
            default: break;
        }
    }

    prepare(text);
    
    glBindTexture(GL_TEXTURE_2D, m_atlas);
    
    auto shader = m_textRenderer->m_shader;
    shader->uniform("color", color);
    shader->uniform("location", position);
    shader->uniform("scale", scale);

    m_textRenderer->drawBuffer();
}


TextRenderer::TextRenderer(Application* app)
    : m_app(app)
    , m_shader(app->getShaders().get("font"))
{
    auto error = FT_Init_FreeType( &m_ftLib );
    if ( error ) 
    {
        cerr << "ERROR: Could not init freetype-lib." << endl;
        exit(EXIT_FAILURE);
    }

    
    glGenBuffers(1, &m_verticesBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_verticesBuffer);
    glBufferData(GL_ARRAY_BUFFER, 0, nullptr, GL_STREAM_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &m_vao);
    glBindVertexArray(m_vao);

    glBindBuffer(GL_ARRAY_BUFFER, m_verticesBuffer);
    GLint positionIndex = Shader::position;
    glEnableVertexAttribArray(positionIndex);
    glVertexAttribPointer(positionIndex, 4, GL_FLOAT, GL_FALSE, 0, 0);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    m_shader->use();
    m_shader->uniform("texAtlas", (int)0);
}
TextRenderer::~TextRenderer()
{
    glDeleteBuffers(1, &m_verticesBuffer);
    glDeleteVertexArrays(1, &m_vao);

    FT_Done_FreeType(m_ftLib);
}
Font* TextRenderer::getFont(string const & name, uint const size)
{
    stringstream ss; ss << name << ":" << size;
    string key = ss.str();
    auto found = m_fonts.find(key);

    if (found != m_fonts.end())
        return found->second.get();

    auto& entry = m_fonts[key];
    entry.reset(new Font(this, name, size));
    return entry.get();
}
void TextRenderer::begin()
{
    m_shader->use();

    glBindVertexArray(m_vao);

    glActiveTexture(GL_TEXTURE0);
}   
void TextRenderer::end()
{
    glBindVertexArray(0);

    glBindTexture(GL_TEXTURE_2D, 0);
}
void TextRenderer::drawBuffer()
{
    glBindBuffer(GL_ARRAY_BUFFER, m_verticesBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vec4)*m_vertices.size(), m_vertices.data(), GL_STREAM_DRAW);       
    glBindBuffer(GL_ARRAY_BUFFER, 0);
        
    glDrawArrays(GL_TRIANGLES, 0, m_vertices.size());   
}