Discussion :

[Eurekha]

Bonjour,

J'ai codé un petit programme qui affiche, pour l'instant, un modèle (cube) à l'écran. Ceci fonctionne pour OpenGL 3.1
Cependant, lorsque je passe à la version 3.3 d'OpenGL, le programme ne fonctionne plus, et me retourne l'erreur suivante :

Process returned 3 (0x3)

Mon programme utilise les VBO et les VAO. J'ai également mis à jour le pilote de ma carte graphique.

Mais je ne sais pas du tout pourquoi j'obtiens cette erreur à l'exécution du programme.

Merci d'avance pour vos réponses

Eurekha

[wax78]

La carte graphique est bien >= 3.3 ?

[Eurekha]

Oui c'est une NVIDIA GeForce GTX 560 Ti et le pilote supporte opengl 4

Eurekha

[wax78]

Ok, tu sais determiner sur quelle fonction ca plante ? Et si oui, poster le bout de code ?

[LittleWhite]

Bonjour,

Si le code de retour est 3, alors il faut voir où, dans le code, vous avez un return 3;. Ensuite, vous regardez pourquoi ce cas arrive, car nous, on ne peux pas deviner où votre programme provoque une erreur.

[dragonjoker59]

Bonjour !

Quelle plateforme ?
Quelle ligne provoque l'erreur ?
L'est où le code ?

[Eurekha]

Merci à tous pour vos réponses. Je vais essayer d'être le plus complet et précis possible.
Je suis sous windows 8.1, et je code sous Code::Blocks 13.12

Le programme cesse de tourner pendant le chargement du VBO et du VAO, à la ligne 36 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
void Cube::charger()
{
    // Destruction d'un éventuel ancien VBO
 
    if(glIsBuffer(m_vboID) == GL_TRUE)
        glDeleteBuffers(1, &m_vboID);
 
 
    // Génération de l'ID
 
    glGenBuffers(1, &m_vboID);
 
 
    // Verrouillage du VBO
 
    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
 
 
        // Allocation de la mémoire vidéo
 
        glBufferData(GL_ARRAY_BUFFER, m_tailleVerticesBytes + m_tailleCoordTextureBytes, 0, GL_STATIC_DRAW);
 
 
        // Transfert des données
 
        glBufferSubData(GL_ARRAY_BUFFER, 0, m_tailleVerticesBytes, m_vertices);
        glBufferSubData(GL_ARRAY_BUFFER, m_tailleVerticesBytes, m_tailleCoordTextureBytes, m_coordTexture);
 
 
    // Déverrouillage de l'objet
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
 
    // Destruction d'un éventuel ancien VAO
 
    if(glIsVertexArray(m_vaoID) == GL_TRUE)
        glDeleteVertexArrays(1, &m_vaoID);
 
 
    // Génération de l'identifiant du VAO
 
    glGenVertexArrays(1, &m_vaoID);
 
 
    // Verrouillage du VAO
 
    glBindVertexArray(m_vaoID);
 
 
        // Verrouillage du VBO
 
        glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
 
 
            // Accès aux vertices dans la mémoire vidéo
 
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
            glEnableVertexAttribArray(0);
 
 
            // Envoi des coordonnées de texture
 
            glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(m_tailleVerticesBytes));
            glEnableVertexAttribArray(2);
 
 
        // Déverrouillage du VBO
 
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
 
    // Déverrouillage du VAO
 
    glBindVertexArray(0);
}

Le .h de la classe cube :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#ifndef DEF_CUBE
#define DEF_CUBE
 
 
// Includes OpenGL
 
#ifdef WIN32
#include <GL/glew.h>
 
#else
#define GL3_PROTOTYPES 1
#include <GL3/gl3.h>
 
#endif
 
 
// Includes GLM
 
#include <glm/glm.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/type_ptr.hpp>
 
 
// Includes
 
#include "Shader.h"
#include "Texture.h"
#include "Bloc.h"
#include <iostream>
#include <string>
#include <vector>
 
using namespace glm;
using namespace std;
 
// Classe Cube
 
class Cube : public Bloc
{
    public:
 
    Cube(vector <float> coordTexture, float i, float j, float k, bool cote[6], Shader *shader, Texture *texture);
    ~Cube();
 
    void charger();
    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
 
 
    protected:
 
    float m_vertices[108];
    float m_coordTexture[72];
    bool m_cote[6];
    GLuint m_vboID;
    int m_tailleVerticesBytes;
    int m_tailleCoordTextureBytes;
    GLuint m_vaoID;
};
 
#endif

Par ailleurs, on m'a conseillé sur un autre forum de récupérer les erreurs opengl grâce à une petite boucle. Cette boucle me renvoie effectivement une erreur n°1280. J'ai également pu remonter à l'endroit du code où cette erreur est générée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
bool SceneOpenGL::initGL()
{
    #ifdef WIN32
 
        // On initialise GLEW
 
        GLenum initialisationGLEW( glewInit() ); // Fonction qui génère l'erreur GL
 
        // C'est ici que l'erreur est affichée à l'écran
        GLenum error;
        while ((error = glGetError()) != GL_NO_ERROR)
        {
            std::cout << "OpenGL error: " << error << std::endl;
        }
 
 
        // Si l'initialisation a échoué :
 
        if(initialisationGLEW != GLEW_OK)
        {
            // On affiche l'erreur grâce à la fonction : glewGetErrorString(GLenum code)
 
            std::cout << "Erreur d'initialisation de GLEW : " << glewGetErrorString(initialisationGLEW) << std::endl;
 
 
            // On quitte la SDL
 
            SDL_GL_DeleteContext(m_contexteOpenGL);
            SDL_DestroyWindow(m_fenetre);
            SDL_Quit();
 
            return false;
        }
 
    #endif
 
 
    // Activation du Depth Buffer
 
    glEnable(GL_DEPTH_TEST);
 
 
    // Tout s'est bien passé, on retourne true
 
    return true;
}

Merci à tous pour votre aide

Eurekha

[Eurekha]

Finalement, j'ai réussi à régler le problème.
Il vient de glewinit(), et le problème est connu (cf https://www.opengl.org/wiki/OpenGL_Loading_Library)

Merci à tous pour votre aide