OpenGL Shader wird nicht gerendert Dreieck

Question

Ich arbeite in diesem Projekt (https://github.com/lupeeumeeu/WorldCraft), alles funktioniert gut, ich kann die Hintergrundfarbe ändern, aber es nicht das Dreieck, ich habe versucht, Tonnen und Tonnen von Haltepunkten zu setzen , aber konnte kein Problem finden, ich denke, das Problem sollte um trhe dreieck.cpp oder die Manager sein, ich habe versucht, die in2gpu Tutorial zu folgen, aber ich habe auch ein wenig geändert.

Ein Bild Link nur ein bisschen zu erklären: https://imgur.com/a/HN7t2

Main.cpp:

#include "..\WorldCraft\Core\Init\Init.h" 
#include "Core\Managers\Scene_Manager.h" 
#include "Core\Render\Triangle.h" 

using namespace Core; 
using namespace Init; 

int main(int argc, char **argv) 
{ 
    WindowConfig windowconfig(std::string("WorldCraft"), 800, 600, 400, 200, true);//name, x, y, w, h, reshape 
    OpenGLVersion version(4, 5, true);//M.m version opengl, msaa 
    BufferConfig bufferconfig(true, true, true, true); // Buffers 

    Core::Init::Init::Initialize(windowconfig, version, bufferconfig, argc, argv); 

    Core::Managers::Scene_Manager* mainMenu = new Core::Managers::Scene_Manager(); 
    Core::Init::Init::SetListener(mainMenu); 

    Core::Render::Triangle* triangle = new Core::Render::Triangle(); 
    triangle->SetProgram(Core::Managers::Shader_Manager::GetShader("CommonShader")); 
    triangle->Create(); 

    mainMenu->GetModels_Manager()->SetModel("triangle", triangle); 

    Core::Init::Init::Run(); 

    delete mainMenu; 
    return 0; 
} 

Scene_Manager.cpp:

#include "Scene_Manager.h" 

using namespace Core; 
using namespace Managers; 

Scene_Manager::Scene_Manager() 
{ 
    glEnable(GL_DEPTH_TEST); 

    shader_manager = new Shader_Manager(); 
    shader_manager->CreateProgram("CommonShader", "Core//Shaders//Common//Vertex_Shader.glsl" 
     , "Core//Shaders//Common//Fragment_Shader.glsl"); 

    view_matrix = glm::mat4(1.0f, 0.0f, 0.0f, 0.0f, 
     0.0f, 1.0f, 0.0f, 0.0f, 
     0.0f, 0.0f, -1.0f, 0.0f, 
     0.0f, 0.0f, 10.0f, 1.0f); 

    models_manager = new Models_Manager(); 
} 

Scene_Manager::~Scene_Manager() 
{ 
    delete shader_manager; 
    delete models_manager; 
} 

void Scene_Manager::NotifyBeginFrame() 
{ 
    models_manager->Update(); 
} 

void Scene_Manager::NotifyDisplayFrame() 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glClearColor(0.0, 0.0, 0.0, 1.0); 

    models_manager->Draw(); 
    models_manager->Draw(projection_matrix, view_matrix); 
} 

void Scene_Manager::NotifyEndFrame() 
{ 

} 

void Scene_Manager::NotifyReshape(int width, int height, int previous_width, int previous_height) 
{ 
    float ar = (float)glutGet(GLUT_WINDOW_WIDTH)/(float)glutGet(GLUT_WINDOW_HEIGHT); 
    float angle = 45.0f, near1 = 0.1f, far1 = 2000.0f; 

    projection_matrix[0][0] = 1.0f/(ar * tan(angle/2.0f)); 
    projection_matrix[1][1] = 1.0f/tan(angle/2.0f); 
    projection_matrix[2][2] = (-near1 - far1)/(near1 - far1); 
    projection_matrix[2][3] = 1.0f; 
    projection_matrix[3][2] = 2.0f * near1 * far1/(near1 - far1); 
} 

Core::Managers::Models_Manager* Scene_Manager::GetModels_Manager() 
{ 
    return models_manager; 
} 

Scene_Manager.h:

#pragma once 
#include "Models_Manager.h" 
#include "Shader_Manager.h" 
#include "../Init/FrameNotifier.h" 

namespace Core 
{ 
    namespace Managers 
    { 
     class Scene_Manager : public Init::FrameNotifier 
     { 
     public: 
      Scene_Manager(); 
      ~Scene_Manager(); 

      virtual void NotifyBeginFrame(); 
      virtual void NotifyDisplayFrame(); 
      virtual void NotifyEndFrame(); 
      virtual void NotifyReshape(int width, int height, int previous_width, int previous_height); 

      Managers::Models_Manager* GetModels_Manager(); 

     private: 
      Core::Managers::Shader_Manager* shader_manager; 
      Core::Managers::Models_Manager* models_manager; 
      glm::mat4 projection_matrix; 
      glm::mat4 view_matrix; 
     }; 
    } 
} 

Models_Manager.cpp:

#include "Models_Manager.h" 

using namespace Core::Managers; 
using namespace Core::Render; 

Models_Manager::Models_Manager() 
{ 
    Triangle* triangle = new Triangle(); 
    triangle->SetProgram(Shader_Manager::GetShader("CommonShader")); 
    triangle->Create(); 
    gameModelList_NDC["triangle"] = triangle; 
} 

Models_Manager::~Models_Manager() 
{ 
    for (auto model : gameModelList) 
    { 
     delete model.second; 
    } 

    gameModelList.clear(); 

    for (auto model : gameModelList_NDC) 
    { 
     delete model.second; 
    } 

    gameModelList_NDC.clear(); 
} 

void Models_Manager::Update() 
{ 
    for (auto model : gameModelList) 
    { 
     model.second->Update(); 
    } 

    for (auto model : gameModelList_NDC) 
    { 
     model.second->Update(); 
    } 
} 

void Models_Manager::Draw() 
{ 
    for (auto model : gameModelList_NDC) 
    { 
     model.second->Draw(); 
    } 
} 

void Models_Manager::Draw(const glm::mat4& projection_matrix, const glm::mat4& view_matrix) 
{ 
    for (auto model : gameModelList) 
    { 
     model.second->Draw(projection_matrix, view_matrix); 
    } 
} 

void Models_Manager::DeleteModel(const std::string& gameModelName) 
{ 
    IGameObject* model = gameModelList[gameModelName]; 
    model->Destroy(); 
    gameModelList.erase(gameModelName); 
} 

void Models_Manager::DeleteModel_NDC(const std::string& gameModelName) 
{ 
    IGameObject* model = gameModelList_NDC[gameModelName]; 
    model->Destroy(); 
    gameModelList_NDC.erase(gameModelName); 
} 

const IGameObject& Models_Manager::GetModel(const std::string& gameModelName) const 
{ 
    return (*gameModelList.at(gameModelName)); 
} 

const IGameObject& Models_Manager::GetModel_NDC(const std::string& gameModelName) const 
{ 
    return (*gameModelList_NDC.at(gameModelName)); 
} 

void Models_Manager::SetModel(const std::string& gameObjectName, IGameObject* gameObject) 
{ 
    gameModelList[gameObjectName.c_str()] = gameObject; 
} 

Triangle.cpp:

#include "Triangle.h" 

using namespace Core; 
using namespace Render; 

Triangle::Triangle(){} 

Triangle::~Triangle(){} 

static void PrintError(GLenum errorCode) 
{ 

    switch (errorCode) 
    { 

    case GL_NO_ERROR: 
     break; 
    case GL_INVALID_ENUM: 
     std::cout << "An unacceptable value is specified for an enumerated argument."; 
     break; 
    case GL_INVALID_VALUE: 
     std::cout << "A numeric argument is out of range."; 
     break; 
    default: 
     break; 
    } 
} 

void Triangle::Create() 
{ 
    GLuint vao; 
    GLuint vbo; 

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

    std::vector<VertexFormat> vertices; 
    vertices.push_back(VertexFormat(glm::vec3(0.25, -0.25, -1.0), glm::vec4(1, 0, 0, 1))); 
    vertices.push_back(VertexFormat(glm::vec3(-0.25, -0.25, -1.0), glm::vec4(0, 1, 0, 1))); 
    vertices.push_back(VertexFormat(glm::vec3(0.25, 0.25, -1.0), glm::vec4(0, 0, 1, 1))); 

    glGenBuffers(1, &vbo); 
    glBindBuffer(GL_ARRAY_BUFFER, vbo); 
    PrintError(glGetError()); 

    glBufferData(GL_ARRAY_BUFFER, sizeof(VertexFormat) * 3, &vertices[0], GL_STATIC_DRAW); 
    glEnableVertexAttribArray(0); 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(VertexFormat), (void*)0); 
    glEnableVertexAttribArray(1); 
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(VertexFormat), (void*)(offsetof(VertexFormat, VertexFormat::color))); 

    glBindVertexArray(0); 
    this->vao = vao; 
    this->vbos.push_back(vbo); 
} 

void Triangle::Update() {} 

void Triangle::Draw() 
{ 
    glUseProgram(program); 
    glBindVertexArray(vao); 
    glDrawArrays(GL_TRIANGLES, 0, 3); 
} 

Answer 1

ich den Fehler gefunden, war es das duplizierte Dreieck, ohne die Kamerakonfiguration (view_matrix und projection_matrix)