Bonjour,

J'ai un problème avec la OpenGL, et plus précisément avec GLEW. J'aimerais afficher dans une fenêtre deux vertices.

Voici mon code :

#include <iostream>

// GLEW
#include "lib/glew/GL/glew.h"

// GLFW
#include "lib/glfw/GLFW/glfw3.h"

// GL
#include "GL/gl.h"

// Notre classe de chargement de shaders
#include "include/Shader.h"


// Prototype des fonctions callback
//void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);

// Dimension de la fenetre
const GLuint WIDTH = 800, HEIGHT = 600;

// Fonction main, c'est ici qu'on initialise ce qui est relatif au contexte d'OpenGL et qu'on lance la boucle principale
int main(){
    std::cout << "Starting GLFW context, OpenGL 3.3" << std::endl;
    // Inititation de la lib GLFW
    glfwInit();
    // Precision sur la version OpenGL que l ’ on veut (3.3)
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //3
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); //.3
    // Desactive les fonctions deprectated d'OpenGL (version <3.3)
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // Empeche le changement de taille de la fenetre
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    // Creation de la fenetre de l'application
    GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "MaFenetre", nullptr, nullptr);    
    if (window == nullptr){
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    
    // On associe la fenetre creee au contexte d'OpenGL
    glfwMakeContextCurrent(window);
    // On associe notre fonction callback a des evenements declenches par la pression d'une touche
    //glfwSetKeyCallback(window, key_callback);

    // Variable global qui permet de demander a la lib GLEW de nous retrouver les fonctions de la version moderne d'OpenGL
    glewExperimental = GL_TRUE;
    // Initialisation de GLEW pour recuperer les pointeurs des fonctions implementees sur la machine (l'implementation du constructeur du GPU)
    if (glewInit() != GLEW_OK){
        std::cout << "Failed to initialize GLEW" << std::endl;
        return -1;
    }    

    // Instructions permettant de passer des dimensions de la fenetre (en pixel) aux dimensions d'OpenGL (comprises entre -1 et 1)
    int width, height;
    // On recupere les dimensions de la fenetre creee plus haut
    glfwGetFramebufferSize(window, &width, &height); 
    //glViewport(0, 0, width, height);
    

    // On construit et on compile nos Vertex et Fragment shaders
    Shader nosShaders("../shaders/c1/default.vertexshader", "../shaders/c1/default.fragmentshader");
    
    GLfloat vertices[] = {
       /*   Positions //       Couleurs      */
        1.0f, 1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f,
        -1.0f, 1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f,
        1.0f, -1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f,
        -1.0f, 1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f,
        1.0f, -1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f,
        -1.0f, -1.0f, 0.0f, 0.094f, 0.4f, 0.13f, 1.0f
    };

    // On declare les identifiants de nos VBO et VAO
    GLuint VBO, VAO;
    // On informe OpenGL que l'on a cree 1 VAO
    glGenVertexArrays(1, &VAO);
    // On informe OpenGL que l'on a cree 1 VBO
    glGenBuffers(1, &VBO);
    
    // On lie notre VAO comme objet courant a utiliser pour les operations qui suivent dans le contexte d'OpenGL
    glBindVertexArray(VAO);
    // On lie notre VBO comme buffer courant a utiliser pour les operations qui suivent dans le contexte d'OpenGL
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    // On associe au buffer courant vertices stockes dans "vertices"
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // On associe au VAO courant un nouvel attribut numerote 0 (dont les valeurs sont rangees dans le buffer courant)
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (GLvoid*)0);
    // On autorise l'utilisatoin de l'attribut numero 0 dans notre vertex shader
    glEnableVertexAttribArray(0);

    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
    glEnableVertexAttribArray(1);
    
    // On detache VBO du buffer courant dans le contexte OpenGL
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    // On detache VBA de l'objet courant dans le contexte OpenGL
    glBindVertexArray(0);


    // La boucle principale du programme
    while (!glfwWindowShouldClose(window)){
        // On verifie si des evenements a ete declenche par l'utilisateur, et on appelle les fonctions callback correspondantes
        glfwPollEvents();
        //glClear(GL_COLOR_BUFFER_BIT);
        

        // On dessines nos vertices
        // On informe OpenGL que l'on veut utiliser les shaders qu'on a crees
        nosShaders.Use();
        // On lie VAO comme objet courant dans le contexte d'OpenGL
        glBindVertexArray(VAO);
        // On dessine l'objet courant
        glDrawArrays(GL_TRIANGLES, 0, 6);
        // On detache VBA de l'objet courant dans le contexte OpenGL
        glBindVertexArray(0);


        // On echange les deux buffers de rendu pour mettre a jour la fenetre avec le nouveau contenu
        glfwSwapBuffers(window);
    }
    

    // On supprime les objets et buffer que l'on a crees precedement
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);


    // Fin du programme, on nettoie le contexte creee par la GLFW
    glfwTerminate();
    return 0;
}

// Notre fonction callback qui est appellee des qu'une touche est pressee ou relachee
/*void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode){
    std::cout << key << std::endl;
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
    	// Si la touche pressee est "ESCAPE", on demande a la GLFW de fermee la fenetre
        glfwSetWindowShouldClose(window, GL_TRUE);
}*/

Dans mon projet, il y a une classe Shader(Shader.cpp et Shader.h) pour charger les shaders. Les librairies GLEW et GLFW sont stockées dans le dossier lib.

Le fichier .pro :

TEMPLATE = app
CONFIG += console c++11
CONFIG -= app_bundle
CONFIG -= qt

SOURCES += cours1.cpp src/Shader.cpp
HEADERS += include/Shader.h \
    lib/glew/GL/glew.h \
    lib/glew/GL/glxew.h \
    lib/glew/GL/wglew.h \
    lib/glfw/GLFW/glfw3.h \
    lib/glfw/GLFW/glfw3native.h

unix:!macx: LIBS += -L$$PWD/lib/glfw/ -lglfw

INCLUDEPATH += $$PWD/lib/glfw
DEPENDPATH += $$PWD/lib/glfw

unix:!macx: LIBS += -L$$PWD/lib/glew/ -lGLEW

INCLUDEPATH += $$PWD/lib/glew
DEPENDPATH += $$PWD/lib/glew

DISTFILES += \
    lib/glew/libGLEW.so \
    lib/glew/libGLEW.so.2.0 \
    lib/glew/libGLEW.so.2.0.0 \
    lib/glfw/libglfw.so \
    lib/glfw/libglfw.so.3 \
    lib/glfw/libglfw.so.3.2

Le problème que j'obtiens est cette erreur de compilation :

:-1: error: main.o: undefined reference to symbol 'glDrawArrays'

Merci beaucoup de votre réponse

Erwan Viegas

Salut,

as tu essayer les solutions d'autres utilisateurs qui ont eu le même soucis ?