Affichage d'une texture

**studiobrionne** · 29/06/2013, 23h51

Bonjour je suis débutant en OpenGL et j'ai besoin de votre aide car je ne comprends pas encore tout ce qui se passe avec OpenGL.

Alors en suivant le tutoriel pour créer des applications 3D avec openGL 3.3, je n'arrive pas à afficher la texture et pourtant aucune erreur, sa compile mais écran noir...

Voici mes codes:

-SceneOpenGL.cpp

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
#include "SceneOpenGL.h"
#include "Texture.h"
 
 
// Permet d'éviter la ré-écriture du namespace glm::
 
using namespace glm;
 
 
// Constructeur de Destucteur
 
SceneOpenGL::SceneOpenGL(std::string titreFenetre, int largeurFenetre, int hauteurFenetre) : m_titreFenetre(titreFenetre), m_largeurFenetre(largeurFenetre),
                                                                                             m_hauteurFenetre(hauteurFenetre), m_fenetre(0), m_contexteOpenGL(0),
                                                                                             m_input()
{
 
}
 
 
SceneOpenGL::~SceneOpenGL()
{
    SDL_GL_DeleteContext(m_contexteOpenGL);
    SDL_DestroyWindow(m_fenetre);
    SDL_Quit();
}
 
 
// Méthodes
 
bool SceneOpenGL::initialiserFenetre()
{
    // Initialisation de la SDL
 
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        std::cout << "Erreur lors de l'initialisation de la SDL : " << SDL_GetError() << std::endl;
        SDL_Quit();
 
        return false;
    }
 
 
    // Version d'OpenGL
 
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
 
 
    // Double Buffer
 
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 
 
    // Création de la fenêtre
 
    m_fenetre = SDL_CreateWindow(m_titreFenetre.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, m_largeurFenetre, m_hauteurFenetre, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
 
    if(m_fenetre == 0)
    {
        std::cout << "Erreur lors de la creation de la fenetre : " << SDL_GetError() << std::endl;
        SDL_Quit();
 
        return false;
    }
 
 
    // Création du contexte OpenGL
 
    m_contexteOpenGL = SDL_GL_CreateContext(m_fenetre);
 
    if(m_contexteOpenGL == 0)
    {
        std::cout << SDL_GetError() << std::endl;
        SDL_DestroyWindow(m_fenetre);
        SDL_Quit();
 
        return false;
    }
 
    return true;
}
 
 
bool SceneOpenGL::initGL()
{
    #ifdef WIN32
 
        // On initialise GLEW
 
        GLenum initialisationGLEW( glewInit() );
 
 
        // 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;
}
 
 
void SceneOpenGL::bouclePrincipale()
{
    // Variables
 
    unsigned int frameRate (1000 / 50);
    Uint32 debutBoucle(0), finBoucle(0), tempsEcoule(0);
 
 
    // Matrices
 
    mat4 projection;
    mat4 modelview;
 
    projection = perspective(70.0, (double) m_largeurFenetre / m_hauteurFenetre, 1.0, 100.0);
    modelview = mat4(1.0);
 
 
    // Vertices
 
    float vertices[] = {-2, -2, -2,   2, -2, -2,   2, 2, -2,   // Triangle 1
                        -2, -2, -2,   -2, 2, -2,   2, 2, -2};  // Triangle 2
 
 
    // Coordonnées de texture
 
    float coordTexture[] = {0, 0,   1, 0,   1, 1,     // Triangle 1
                            0, 0,   0, 1,   1, 1};    // Triangle 2
 
 
    // Texture
 
    Texture texture("Caisse.jpg");
    texture.charger();
 
 
    // Shader
 
    Shader shaderTexture("Shaders/texture.vert", "Shaders/texture.frag");
    shaderTexture.charger();
 
// Boucle principale
 
while(!m_input.terminer())
{
    // On définit le temps de début de boucle
 
    debutBoucle = SDL_GetTicks();
 
 
    // Gestion des évènements
 
    m_input.updateEvenements();
 
    if(m_input.getTouche(SDL_SCANCODE_ESCAPE))
       break;
 
 
    // Nettoyage de l'écran
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 
    // Placement de la caméra
 
    modelview = lookAt(vec3(0, 0, 2), vec3(0, 0, 0), vec3(0, 1, 0));
 
 
    // Activation du shader
 
    glUseProgram(shaderTexture.getProgramID());
 
 
        // Envoi des vertices
 
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices);
        glEnableVertexAttribArray(0);
 
 
        // Envoi des coordonnées de texture
 
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, coordTexture);
        glEnableVertexAttribArray(2);
 
 
        // Envoi des matrices
 
        glUniformMatrix4fv(glGetUniformLocation(shaderTexture.getProgramID(), "projection"), 1, GL_FALSE, value_ptr(projection));
        glUniformMatrix4fv(glGetUniformLocation(shaderTexture.getProgramID(), "modelview"), 1, GL_FALSE, value_ptr(modelview));
 
 
        // Verrouillage de la texture
 
        glBindTexture(GL_TEXTURE_2D, texture.getID());
 
 
        // Rendu
 
        glDrawArrays(GL_TRIANGLES, 0, 6);
 
 
        // Déverrouillage de la texture
 
        glBindTexture(GL_TEXTURE_2D, 0);
 
 
        // Désactivation des tableaux
 
        glDisableVertexAttribArray(2);
        glDisableVertexAttribArray(0);
 
 
    // Désactivation du shader
 
    glUseProgram(0);
 
    // Actualisation de la fenêtre
 
    SDL_GL_SwapWindow(m_fenetre);
 
 
    // Calcul du temps écoulé
 
    finBoucle = SDL_GetTicks();
    tempsEcoule = finBoucle - debutBoucle;
 
 
    // Si nécessaire, on met en pause le programme
 
    if(tempsEcoule < frameRate)
        SDL_Delay(frameRate - tempsEcoule);
}
}

-Texture.cpp

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
#include "Texture.h"
 
 
// Constructeur
 
Texture::Texture(std::string fichierImage) : m_id(0), m_fichierImage(fichierImage)
{
 
}
 
// Destructeur
 
Texture::~Texture()
{
 
}
 
 
// Méthodes
bool Texture::charger()
{
    // Chargement de l'image dans une surface SDL
 
    SDL_Surface *imageSDL = IMG_Load(m_fichierImage.c_str());
 
    if(imageSDL == 0)
    {
        std::cout << "Erreur : " << SDL_GetError() << std::endl;
        return false;
    }
 
 
    // Génération de l'ID
 
    glGenTextures(1, &m_id);
 
 
    // Verrouillage
 
    glBindTexture(GL_TEXTURE_2D, m_id);
 
 
    // Format de l'image
 
    GLenum formatInterne(0);
    GLenum format(0);
 
 
    // Détermination du format et du format interne pour les images à 3 composantes
 
    if(imageSDL->format->BytesPerPixel == 3)
    {
        // Format interne
 
        formatInterne = GL_RGB;
 
 
        // Format
 
        if(imageSDL->format->Rmask == 0xff)
            format = GL_RGB;
 
        else
            format = GL_BGR;
    }
 
 
    // Détermination du format et du format interne pour les images à 4 composantes
 
    else if(imageSDL->format->BytesPerPixel == 4)
    {
        // Format interne
 
        formatInterne = GL_RGBA;
 
 
        // Format
 
        if(imageSDL->format->Rmask == 0xff)
            format = GL_RGBA;
 
        else
            format = GL_BGRA;
    }
 
 
    // Dans les autres cas, on arrête le chargement
 
    else
    {
        std::cout << "Erreur, format interne de l'image inconnu" << std::endl;
        SDL_FreeSurface(imageSDL);
 
        return false;
    }
 
 
    // Copie des pixels
 
    glTexImage2D(GL_TEXTURE_2D, 0, formatInterne, imageSDL->w, imageSDL->h, 0, format, GL_UNSIGNED_BYTE, imageSDL->pixels);
 
 
    // Application des filtres
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
 
    // Déverrouillage
 
    glBindTexture(GL_TEXTURE_2D, 0);
 
 
    // Fin de la méthode
 
    SDL_FreeSurface(imageSDL);
    return true;
}
 
 
GLuint Texture::getID() const
{
    return m_id;
}
 
 
void Texture::setFichierImage(const std::string &fichierImage)
{
    m_fichierImage = fichierImage;
}

Si il faut du code supplémentaire je suis là.
Aidez moi SVP

PS:
Quand je mets n'importe quoi comme ici:

Code :

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

1
2
3
4
// Texture
 
Texture texture("dhrfgh.fegd");
texture.charger();

dans cette fonction "void SceneOpenGL::bouclePrincipale()"
Sa donne un écran noir --'

**LittleWhite** · 11/07/2013, 12h08

Bonjour,

Une texture noire apparaît dès que la texture est invalide dans OpenGL.

Après, il y a plusieurs possibilités :

la texture est mal initialisée (glTexParameteri()), mais sur ce point là, cela me semble bon ;
l'identifiant envoyé au shader n'est pas celui de la texture ou est mal envoyé, du coup, le shader ne trouve pas la texture (surement ce cas là)

Pour trouver l'erreur plus rapidement, vous pouvez essayer de rajouter des glGetError() après chaque appel OpenGL -> http://jeux.developpez.com/faq/openg...EMES_get_error ou encore, utilisez gDebugger.

Affichage d'une texture

OpenGL

Discussions similaires

Partager

Partager