FreeType kann nicht zum Rendern erstellt werden

Question

Mit OpenGL, GLM, GLAD, GLFW und FreeType versuchen, Schriften zum Rendern zu bekommen. Ich bin durchgetreten, um sicherzustellen, dass beim Rendern keine OpenGL-Fehler aufgetreten sind, nichts postet einen Fehlercode, aber nichts rendert den Bildschirm. Ich bin auch nicht sicher, ob ich glm die ortho-Funktion richtig bin mit, weil ich nicht sicher bin, wo eigentlich die Variable verwenden:

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

Das ist mein Draw Loop, es aufgerufen wird, nachdem die Szene Initialisiert:

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 
    } 
} 

Der Font-Konstruktor, der die Schriftart in Texturen lädt:

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; 
} 

initialisieren Funktion My Text:

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); 
} 

und Draw-Funktion meines Textes:

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); 
} 

Hat die Post nicht wollen, zu lang sein, wenn meine Shadern benötigt werden, lassen Sie mich wissen.

Answer 1

Nachdem ich den Code aufgebrochen habe, fand ich eine hilfreiche Ressource, die mich zu meinem Problem führte. Von https://learnopengl.com/#!In-Practice/Text-Rendering Projektquelle, fand ich, dass meine orthographische Projektionsvariable an mein Shader-Programm übergeben werden musste, als ich die Schriftart konstruierte. Ich habe dies getan, indem ich meinen Font-Konstruktor den folgenden Code hinzufüge:

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));