Pourquoi ce code n'affiche rien à l'écran

Question

J'ai suivi plusieurs tutoriels et je ne comprends pas pourquoi ce code n'affiche rien.

S'il vous plaît ne pas que LoadShaders fonctionne très bien.

J'ai fait un copier-coller, donc je ne pense pas que le problème vient de là ...

#include <iostream> 
#include <fstream> 
#include <vector> 
#include <GL/glew.h> 
#include <GL/gl.h>  
#include <GLFW/glfw3.h> 

GLFWwindow* window; 

int main(int argc, const char * argv[]) 
{ 
    if(!glfwInit()) 
    { 
     return -1; 
    } 
    glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // We want OpenGL 3.3 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 

    window = glfwCreateWindow(640, 480, "Test1", NULL, NULL); 
    if(window == NULL) 
    { 
     return -1; 
    } 
    glfwMakeContextCurrent(window); 

    glewExperimental = true; // Needed for core profile 
    if (glewInit() != GLEW_OK) 
    { 
     return -1; 
    } 

    GLuint programID = LoadShaders("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader"); 

    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE); 
    glClearColor(0.0f, 1.0f, 1.0f, 1.0f); 

    do 
    { 
     glfwPollEvents(); 

     glUseProgram(programID); 
     float vertices[] = {-0.5, -0.5, 0.0, 0.5, 0.5, -0.5}; 
     glClear(GL_COLOR_BUFFER_BIT); 
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices); 
     glEnableVertexAttribArray(0); 
     glDrawArrays(GL_TRIANGLES, 0, 3); 
     glDisableVertexAttribArray(0); 

     glfwSwapBuffers(window); 
    } 
    while(glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0); 

    glfwTerminate(); 

    return 0; 
} 

Merci pour votre aide

Note:

Voici SimpleFragmentShader.fragmentshader :

#version 330 core 
out vec3 color; 
void main() 
{ 
    color = vec3(1,0,0); 
} 

Et voici SimpleVertexShader.vertexshader:

#version 330 core 
layout(location = 0) in vec3 vertexPosition_modelspace; 
void main() 
{ 
    gl_Position.xyz = vertexPosition_modelspace; 
    gl_Position.w = 1.0; 
} 

S'il vous plaît remarquer que j'ai aussi essayé de travailler sur les coordonnées 3D comme ceci:

float vertices[] = {-0.5, -0.5,0.0, 0.0, 0.5,0.0, 0.5, -0.5,0.0}; 

glClear(GL_COLOR_BUFFER_BIT); 
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices); 
glEnableVertexAttribArray(0); 
glDrawArrays(GL_TRIANGLES, 0, 3); 
glDisableVertexAttribArray(0); 

Answer 1

Voir docs.GL - OpenGL 3.3 - glVertexAttribPointer:

GL_INVALID_OPERATION est généré dans le contexte de base s'il n'y a pas tableau Vertex Objet lié.

Vous devez créer Vertex Array Object et Vertex Buffer Object.

Générer (glGenVertexArrays) et bind (glBindVertexArray) un Vertex Array Object:

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

Générer (glGenBuffers) et bind (glBindBuffer) un Vertex Buffer Object:

GLuint vbo; 
glGenBuffers(1, &vbo); 
glBindBuffer(GL_ARRAY_BUFFER, vbo); 

Bind l'intégralité des données de mémoire tampon (glBufferData), active l'attribut vertex et définit le tableau des données d'attribut de vertex génériques:

float vertices[] = {-0.5, -0.5, 0.0, 0.5, 0.5, -0.5}; 
glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), vertices, GL_STATIC_DRAW); 
glEnableVertexAttribArray(0); 
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr); 
glBindVertexArray(0); 

Lorsque vous dessinez le maillage, il suffit de lier l'objet tableau de vertex:

glBindVertexArray(vao); 
glDrawArrays(GL_TRIANGLES, 0, 3); 
glBindVertexArray(0); 

Remarque, puisque vous utilisez un utilisateur défini la variable out dans votre fragment shader, vous devez lier la fragmentation de l'emplacement des données avec glBindFragDataLocation. Notez que ceci doit être fait après que le fragment shader ait été attaché au programme shader, mais avant que le programme shader ait été lié.

Answer 2

Vous n'êtes pas se lier à un emplacement de sortie de données frag:

GLuint programID = LoadShaders("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader"); 

// make sure you set which colour is the output from the fragment shader! 
glBindFragDataLocation(programID, 0, "color"); 

(C'est en supposant que vous utilisez openGL 3.3 sur le bureau, et non GLES3)

---

/modifier Et si vous voulez un OpenGL 4.5 version:

#include <iostream> 
#include <fstream> 
#include <vector> 
#include <GL/glew.h> 
#include <GL/gl.h>  
#include <GLFW/glfw3.h> 

GLFWwindow* window; 

int main(int argc, const char * argv[]) 
{ 
    if(!glfwInit()) 
    { 
    return -1; 
    } 
    glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5); 

    window = glfwCreateWindow(640, 480, "Test1", NULL, NULL); 
    if(window == NULL) 
    { 
    return -1; 
    } 
    glfwMakeContextCurrent(window); 

    glewExperimental = true; // Needed for core profile 
    if (glewInit() != GLEW_OK) 
    { 
    return -1; 
    } 
    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE); 

    GLuint programID = LoadShaders("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader"); 

    // make sure you set which colour is the output from the fragment shader! 
    glBindFragDataLocation(programID, 0, "color"); 

    glClearColor(0.0f, 1.0f, 1.0f, 1.0f); 

    GLuint vbo = 0, vao = 0; 
    const float vertices[] = {-0.5, -0.5, 0.0, 0.5, 0.5, -0.5}; 

    // create the vbo identifier 
    glCreateBuffers(1, &vbo); 

    // load the vertex data into the vertex buffer object (using immutable read only storage) 
    glNamedBufferStorage(vbo, 6 * sizeof(float), vertices, 0); 

    // create the vertex array object (vao) 
    GLuint vao = 0; 
    glCreateVertexArrays(1, &vao); 

    // attach vbo to slot 0 on the vao 
    glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(float) * 2); 

    // fetch attribute 0 from the buffer bound to slot 0 
    glVertexArrayAttribBinding(vao, 0, 0); 

    // enable the vertex attribute 0 
    glEnableVertexArrayAttrib(vao, 0); 

    // specify the data type found in attribute 0 
    glVertexArrayAttribFormat(vao, 0, 2, GL_FLOAT, false, 0); 

    do 
    { 
    glfwPollEvents(); 

    // specify which program to use 
    glUseProgram(programID); 

    // specify which buffers to bind to the shader inputs 
    glBindVertexArray(vao); 

    // draw the data 
    glDrawArrays(GL_TRIANGLES, 0, 3); 

    // done with the vao binding 
    glBindVertexArray(0);  

    glfwSwapBuffers(window); 
    } 
    while(glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0); 

    glfwTerminate(); 

    return 0; 
}