OpenGLシェーダはトライアングルをレンダリングしません

Question

私はこのプロジェクト（https://github.com/lupeeumeeu/WorldCraft）で作業していますが、すべてうまくいきます。バックグラウンドカラーを変更できますが、三角形をレンダリングしません。トンとトン数のブレークポイントを設定しようとしましたしかし、問題を見つけることができなかった、私は問題がtrhe triangle.cppまたはマネージャーの周りにあるべきだと思う、私はin2gpuのチュートリアルに従おうとしましたが、私も少し修正しました。 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

私はそれがカメラの設定（view_matrixとprojection_matrix）