Bonjour,

Je me forme à OpenGL et j'ai réussi à utiliser les VAO, VBO et EBO le tout dans le main. J'ai essayé de remettre un peu d'ordre avec des classes. Sans utiliser d'EBO, j'arrive à afficher ma texture mais en les utilisant, je ne vois plus ma texture.

Voici le code :

main.cpp

#define GLEW_STATIC

#include <vector>
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "Display.hpp"
#include "Model.hpp"
#include "Shader.hpp"
#include "Texture.hpp"

int main(int argc, const char * argv[]) {
    
    Display display;
    
    std::vector<GLfloat> vertexPositions = {
        -0.5f, -0.5f,  0.0f,
         0.5f, -0.5f,  0.0f,
         0.5f,  0.5f,  0.0f,
        -0.5f,  0.5f,  0.0f,
    };
    
    std::vector<GLfloat> textureCoords = {
        0.0f, 1-0.0f,
        1.0f, 1-0.0f,
        1.0f, 1-1.0f,
        0.0f, 1-1.0f
    };
    
    std::vector<GLuint> indices = {
        0, 1, 2,
        0, 2, 3
    };
    
    Model model(vertexPositions, textureCoords, indices);
    Shader shader("vertex", "fragment");
    Texture texture("grass");
    
    while (display.isOpen()) {
        
        display.checkForClose();
        display.clear();
        
        model.bind();
        shader.bind();
        texture.bind();
        
        float time = glfwGetTime();
        
        glm::mat4 modelMat;
        modelMat = glm::translate(modelMat, glm::vec3(0.0f, cos(2*time), 0.0f));
        modelMat = glm::rotate(modelMat, time*1.3f, glm::vec3(0.0f, 1.0f, 0.0f));
        shader.setMat4("model", modelMat);

        glm::mat4 viewMat;
        viewMat = glm::translate(viewMat, glm::vec3(0.0f, 0.0f, -5.0f));
        shader.setMat4("view", viewMat);

        glm::mat4 projMat;
        projMat = glm::perspective(glm::radians(45.0f),
                                   (float)Display::WIDTH/(float)Display::HEIGHT,
                                   0.1f, 100.f);
        shader.setMat4("proj", projMat);
        
        glDrawElements(GL_TRIANGLES, model.getIndicesCount(), GL_UNSIGNED_INT, nullptr);
        
        texture.unbind();
        shader.unbind();
        model.unbind();
        
        display.swapBuffers();
        display.pollEvent();
        
    }
    
    display.close();
    return 0;
    
}

Model.cpp

#include "Model.hpp"

Model::Model(const std::vector<GLfloat>& vertexPositions,
             const std::vector<GLfloat>& textureCoords,
             const std::vector<GLuint>& indices) :
    m_vbosCount(0),
    m_indicesCount((GLuint)indices.size())
{
    
    glGenVertexArrays(1, &m_vao);
    glBindVertexArray(m_vao);
    
    addVbo(3, vertexPositions);
    addVbo(2, textureCoords);
    addEbo(indices);
    
    glBindVertexArray(0);
    
}

Model::~Model() {
    glDeleteVertexArrays(1, &m_vao);
    glDeleteBuffers((GLuint)m_buffers.size(), m_buffers.data());
}

void Model::bind() {
    glBindVertexArray(m_vao);
}

void Model::unbind() {
    glBindVertexArray(0);
}

GLuint Model::getIndicesCount() const {
    return m_indicesCount;
}

void Model::addVbo(int dim, const std::vector<GLfloat> &data) {
    
    GLuint vbo;
    
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER,
                 data.size() * sizeof(data[0]),
                 data.data(),
                 GL_STATIC_DRAW);
    glVertexAttribPointer(m_vbosCount,
                          dim,
                          GL_FLOAT,
                          GL_FALSE,
                          0,
                          (GLvoid*)0);
    glEnableVertexAttribArray(m_vbosCount++);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    
    m_buffers.push_back(vbo);
    
}

void Model::addEbo(const std::vector<GLuint>& indices) {
    
    GLuint ebo;
    
    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 indices.size() * sizeof(indices[0]),
                 indices.data(),
                 GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    
    m_buffers.push_back(ebo);
    
}

vertex.glsl

#version 410 core

layout (location = 0) in vec3 inVertexPositions;
layout (location = 1) in vec2 inTextureCoords;

out vec2 passTextureCoords;

uniform mat4 model;
uniform mat4 view;
uniform mat4 proj;

void main() {
    
    gl_Position = proj * view * model * vec4(inVertexPositions, 1.0f);
    passTextureCoords = inTextureCoords;
    
}

fragment.glsl

#version 410 core

in vec2 passTextureCoords;

out vec4 outColor;

uniform sampler2D textureUnit;

void main() {
    outColor = texture(textureUnit, passTextureCoords);
}

Pour information, je me base en partie sur la structure de Hopson sur Youtube : https://www.youtube.com/playlist?list=PLMZ_9w2XRxiZq1vfw1lrpCMRDufe2MKV_

Je pense qu'il y a quelque chose que je fais mal mais je ne trouve pas où.

Je suis aussi en version 4.1 alors que le tutoriel est en 3.3, est-ce que ça pourrait venir de là ?

Merci d'avance

Yo! Je viens de commencer il n'y a pas si longtemps alors peut etre que je dis n'importe quoi, mais est ce que c'est possible que quand tu appelle addEBO, tu as bind ton VBO des coordonnés de texture et pas de vertex Positions?

-
Edité par KirbXCoucou 22 février 2018 à 14:38:15

KirbXCoucou a écrit:

Yo! Je viens de commencer il n'y a pas si longtemps alors peut etre que je dis n'importe quoi, mais est ce que c'est possible que quand tu appelle addEBO, tu as bind ton VBO des coordonnés de texture et pas de vertex Positions?

Je ne vois pas ce que tu veux dire KirbCoucou. Tu peux me donner la ligne du fichier qui as soulevé ta question ?

    addVbo(3, vertexPositions);
    addVbo(2, textureCoords);
    addEbo(indices);
     

Enfait, si c'est ce que je pense, c'est même different. Quand tu génère ton EBO,  et que tu fais appelle a 

glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 indices.size() * sizeof(indices[0]),
                 indices.data(),
                 GL_STATIC_DRAW);

il me semble qu'il faut un avoir binder un VBO. Hors à la fin de ton addVBO tu bind 0 dans ton VBO.
Donc quand tu bind ton EBO tu bind rien finalement.

-
Edité par KirbXCoucou 22 février 2018 à 15:14:01

Effectivement merci ça fonctionne !

Par contre je me pose une question :

#include "Model.hpp"

Model::Model(const std::vector<GLfloat>& vertexPositions,
             const std::vector<GLfloat>& textureCoords,
             const std::vector<GLuint>& indices) :
    m_vbosCount(0),
    m_indicesCount((GLuint)indices.size())
{
    
    glGenVertexArrays(1, &m_vao);
    glBindVertexArray(m_vao);
    
    addVbo(3, vertexPositions);
    addVbo(2, textureCoords);
    addEbo(indices);
    
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    
}

Model::~Model() {
    glDeleteVertexArrays(1, &m_vao);
    glDeleteBuffers((GLuint)m_buffers.size(), m_buffers.data());
}

void Model::bind() {
    glBindVertexArray(m_vao);
}

void Model::unbind() {
    glBindVertexArray(0);
}

GLuint Model::getIndicesCount() const {
    return m_indicesCount;
}

void Model::addVbo(int dim, const std::vector<GLfloat> &data) {
    
    GLuint vbo;
    
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER,
                 data.size() * sizeof(data[0]),
                 data.data(),
                 GL_STATIC_DRAW);
    glVertexAttribPointer(m_vbosCount,
                          dim,
                          GL_FLOAT,
                          GL_FALSE,
                          0,
                          (GLvoid*)0);
    glEnableVertexAttribArray(m_vbosCount++);
//    glBindBuffer(GL_ARRAY_BUFFER, 0);
    
    m_buffers.push_back(vbo);
    
}

void Model::addEbo(const std::vector<GLuint>& indices) {
    
    GLuint ebo;
    
    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 indices.size() * sizeof(indices[0]),
                 indices.data(),
                 GL_STATIC_DRAW);
//    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    
    m_buffers.push_back(ebo);
    
}

Après modifications, dans le constructeur, vu que le dernier buffer bindé est un ebo, c'est pas embêtant de unbindé un vbo ?

Hum, j'ai pas compris ta question :/

Dans addVBO() et addEBO(), je bind des buffers via glBindBuffer(). Vu que je n'unbind plus dans ces deux fonctions, le dernier buffer bindé est un EBO. Or dans le constructeur, à la fin, j'unbind un VBO à la ligne 18 du code ci dessus.

Ca ne pose pas problème que je bind en dernier un EBO et que j'unbind après un VBO ?

Mmmmmh!
Je pense pas.

OpenGL est une machine à état, ça veut dire que tu as binder ton VBO, tu as binder ton EBO, fais les modifications nécéssaires sur ton EBO avec le VBO binder. Ensuite, tu peux unbind ton VBO sans problème. Pour le réutiliser il faudra le binder juste.
Mais je pense pas que ce soit un problème à proprement parler

Pour faire quelque chose de plus propre, est ce que je peux unbind le VBO et l'EBO à la fin du constructeur ?

Tu peux, mais quand tu voudras dessiner avec glDrawElements, il faudra rebinder ducoup.

C'est pas fait automatiquement quand je bind le VAO ?

Mmmh, si personne d'autre ne réponds, il faut essayé, ça il me semble que oui, mais j'en suis pas sûr :/

EDIT :

Si jamais ça peut t'aider : Si tu comprends l'anglais :
Ce tuto c'est très bien, par contre c'est openGL3 ducoup il y a des choses qui doivent changer :/

-
Edité par KirbXCoucou 22 février 2018 à 16:53:27

J'ai unbind le EBO aussi et tout fonctionne parfaitement

Je suis aussi sur ce tutoriel mais merci (pour l'instant tout fonctionne même en 4.1)

Merci pour ton aide, sujet résolu !