OpenGL着色器不会渲染Triangle

Question

我在这个项目中工作（https://github.com/lupeeumeeu/WorldCraft），一切正常，我可以改变背景颜色，但它不会渲染三角形，我试图设置吨和吨的断点，但不能找不到任何问题，我认为这个问题应该是在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）