无法获取FreeType进行渲染

Question

Working with OpenGL, GLM, GLAD, GLFW and FreeType attempting to get fonts to render. I've stepped through to make sure no OpenGL errors had occured while rendering, nothing posts an error code, but nothing renders to the screen. I'm also not sure if I'm using glm's ortho function correctly, because i'm not sure where to actually use the variable:

glm::mat4 projection = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);

This is my Draw Loop, it gets called after the scene Initializes:

void GameLoop::Run()
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);

    while (!glfwWindowShouldClose(m_game_window))
    {
        // Do That thing where you draw everything
    }
}

The Font constructor which loads the font into textures:

Salem::Graphics::Font::Font(std::string p_font_path)
{
    FT_Library ft;
    if (FT_Init_FreeType(&ft))
    {
        std::cout << "Error loading FreeType library" << std::endl;
    }

    FT_Face face;
    if (FT_New_Face(ft, p_font_path.c_str(), 0, &face))
    {
        std::cout << "Error loading font;\n" << p_font_path << std::endl;
    }

    FT_Set_Pixel_Sizes(face, 0, 28);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Disable byte-alignment restriction

    for (GLubyte c = 0; c < 128; c++)
    {
        if (FT_Load_Char(face, c, FT_LOAD_RENDER))
        {
            std::cout << "Failed to load a character glyph." << std::endl;
            continue;
        }

        GLuint texture;
        glGenTextures(1, &texture);
        glBindTexture(GL_TEXTURE_2D, texture);
        glTexImage2D(
                GL_TEXTURE_2D,
                0,
                GL_RED,
                face->glyph->bitmap.width,
                face->glyph->bitmap.rows,
                0,
                GL_RED,
                GL_UNSIGNED_BYTE,
                face->glyph->bitmap.buffer);

        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_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        Character character = {
                texture,
                glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
                glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
                face->glyph->advance.x
        };

        m_characters.insert(std::make_pair(c, character));
    }

    FT_Done_Face(face);
    FT_Done_FreeType(ft);
    std::cout << "Font loaded. " << std::endl;
}

My text's Initialize function:

void Text::Initialize()
{
    glm::mat4 projection = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);
    glGenVertexArrays(1, &m_vao);
    glGenBuffers(1, &m_vbo);

    glBindVertexArray(m_vao);
    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);

    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, nullptr, m_draw_method);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), nullptr);

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

And my text's draw function:

void Text::Draw()
{
    glm::mat4 projection = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);

    shader()->Use();
    glUniform3f(glGetUniformLocation(shader()->id(), "textColor"), m_color.x, m_color.y, m_color.z);
    glActiveTexture(GL_TEXTURE0);
    glBindVertexArray(m_vao);

    for (std::string::const_iterator c = m_text.begin(); c != m_text.end(); ++c)
    {
        Character ch = m_font.characters()[*c];

        GLfloat xPosition = m_position.x + ch.Bearing.x * m_scale;
        GLfloat yPosition = m_position.y - (ch.Size.y - ch.Bearing.y) * m_scale;

        GLfloat width = ch.Size.x * m_scale;
        GLfloat height = ch.Size.y * m_scale;

        GLfloat vertices[6][4] = {
                {xPosition,         yPosition + height, 0.0, 0.0},
                {xPosition,         yPosition,          0.0, 1.0},
                {xPosition + width, yPosition,          1.0, 1.0},

                {xPosition,         yPosition + height, 0.0, 0.0},
                {xPosition + width, yPosition,          1.0, 1.0},
                {xPosition + width, yPosition + height, 1.0, 0.0}
        };

        glBindTexture(GL_TEXTURE_2D, ch.TextureID);
        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
        //glBindBuffer(GL_ARRAY_BUFFER, 0);

        glDrawArrays(GL_TRIANGLES, 0, 6);

        m_position.x += (ch.Advance >> 6) * m_scale;
    }

    glBindVertexArray(0);
    glBindTexture(GL_TEXTURE_2D, 0);
}

Didn't want the post to be too long, if my shaders are needed, let me know.

Answer 1

Upon breaking up the code, i found a helpful resource which lead me to my problem. From https://learnopengl.com/#!In-Practice/Text-Rendering Project source, I found that my orthographic projection variable had to be passed to my shader program when I was Constructing the font. I did this by add the following code to my Font Constructor:

glm::mat4 projection = glm::ortho(0.0f, 800.0f, 0.0f, 600.0f);
p_shader->Use();
glUniformMatrix4fv(glGetUniformLocation(p_shader->id(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));