Vfrdtyky

An OpenGL project can't display any object anymore. I tried to remake everything from scratch but it still doesn't works.

Main Code

#include <vector>

#include <iostream>

#include <glm/glm.hpp>

#include <glm/gtc/type_ptr.hpp>

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <imgui.h>

#include <imgui_impl_glfw_gl3.h>

#include "Loader.h"



void on_error(int error, const char* description)

{

    std::cout << "GLFW error " << error << " : "" << description << """ << std::endl;

}



int main()

{

    //Init glfw

    glfwSetErrorCallback(on_error);

    if (!glfwInit()) return  -1;

    glfwWindowHint(GLFW_SAMPLES, 4);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);



    //Init window

    auto window = glfwCreateWindow(1920, 1080, "gl_Crane", NULL, NULL);

    if (!window) { glfwTerminate(); return -1; }

    glfwMakeContextCurrent(window);



    //Init glew

    glewExperimental = true;

    if (glewInit() != GLEW_OK) { glfwTerminate(); return -1; }



    //Some opengl options

    glEnable(GL_DEPTH_TEST);

    glEnable(GL_DEBUG_OUTPUT);

    glDepthFunc(GL_LESS);

    //glEnable(GL_CULL_FACE);



    //matrices

    std::vector<glm::vec3> vertices = {

        {-.2f, -.2f, 0}, {0, .2f, 0}, {.2f, -.2f, 0}

    };

    std::vector<glm::vec3> colors = {

        {1, 0, 0}, {0, 1, 0}, {0, 0, 1}

    };

    std::vector<GLushort> indexes = {

        0, 1, 2

    };



    //vertexArray

    GLuint vertex_array;

    glGenVertexArrays(1, &vertex_array);

    glBindVertexArray(vertex_array);



    //vertexbuffer

    GLuint vertex_buffer;

    glGenBuffers(1, &vertex_buffer);

    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * vertices.size(), vertices.data(), GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3), nullptr);



    //colorbuffer

    GLuint color_buffer;

    glGenBuffers(1, &color_buffer);

    glBindBuffer(GL_ARRAY_BUFFER, color_buffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * colors.size(), colors.data(), GL_STATIC_DRAW);

    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3), nullptr);



    //indexbuffer

    GLuint index_buffer;

    glGenBuffers(1, &index_buffer);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer);

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * indexes.size(), indexes.data(), GL_STATIC_DRAW);



    glBindVertexArray(0);



    //Init shader

    auto shader_program = new ShaderProgram;

    shader_program->initFromFiles("../Crane/simple.vert", "../Crane/simple.frag");

    //shader_program->addUniform("MVP");





    ImGui_ImplGlfwGL3_Init(window, true);

    glfwSwapInterval(1);



    while (!glfwWindowShouldClose(window))

    {

    ImGui_ImplGlfwGL3_NewFrame();

    ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);



        //maj viewport

        int display_w, display_h;

        glfwGetFramebufferSize(window, &display_h, &display_w);

        glViewport(0, 0, display_w, display_h);



        //clear screen

        glClearColor(.2f, .2f, .2f, 0);

        glClear(GL_COLOR_BUFFER_BIT);



        //draw stuff

        shader_program->use();

        glBindVertexArray(vertex_array);

        glEnableVertexAttribArray(0);

        glEnableVertexAttribArray(1);



        //auto mvp = glm::mat4(1);

        //glUniformMatrix4fv(shader_program->uniform("MVP"), 1, GL_FALSE, glm::value_ptr(mvp));

        glDrawElements(GL_TRIANGLES, indexes.size(), GL_UNSIGNED_SHORT, nullptr);



        glDisableVertexAttribArray(0);

        glDisableVertexAttribArray(1);

        glBindVertexArray(0);



        shader_program->disable();

        ImGui::Render();

        glfwSwapBuffers(window);

        glfwPollEvents();

    }

    shader_program->disable();

    ImGui_ImplGlfwGL3_Shutdown();

    glfwTerminate();

    return 0;

}

Fragment shader

#version 430

in vec3 fColors;

out vec4 fragColors;

void main()

{

    fragColors = vec4(fColors, 1.0);

}

Vertex shader

#version 430    

layout (location = 0) in vec4 vertexPosition; 

layout (location = 1) in vec3 vertexColor; 

out vec3 fColors; 

void main() 

{ 

    fColors = vertexColor; 

    gl_Position = vertexPosition; 

}

Additionally, I use the shader loader from here :
r3dux shader loader

In your program the Depth Test (glEnable(GL_DEPTH_TEST)).

The depth of a fragment is stored in a separate buffer. This buffer has to be cleared too, at the begin of every frame, as you do it with the color buffer. See glClear:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Of course, if you would disable the depth test, then you would "see" the triangle, too.