Impossible d'appliquer une texture avec Glut et Opengl

Version imprimable

Bonjour,

Je suis entrain d'essayer d'appliquer une texture sur un objet QUAD seulement quand je souhaite charger une image JPG il me fait une magnifique erreur de segmentation au lancement du programme.
Il compile correctement mais ne veut pas se lancer.

Textures.hpp :

Code:

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
 
#ifndef TEXTURES_HPP
#define TEXTURES_HPP
 
#include <GL/gl.h>
 
#include <GL/glut.h>
 
 
 
#include <iostream>
 
 
#include <png.h>
#include "jpeglib.h"
#include "jerror.h"
 
 
class Textures
 
{
GLuint TexNum[2];
 
public:
 
	int LoadJPG (const char * filename, int nb );
	int LoadPNG (const char * filename, int nb );
 
};
 
 
 
#endif

Textures.cpp :

Code:

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
 
#include "Textures.hpp"
 
 
int Textures::LoadJPG(const char * filename, int nb ) {
    struct  jpeg_decompress_struct cinfo;       // les infos du fichiers
 
    struct  jpeg_error_mgr jerr;                // les erreurs
 
    GLubyte *ligne;                             // une ligne (?)
 
    GLubyte *image;                             // l'image sous forme de données
 
    int     ImageSize;                          // Taille de l'image
 
 
 
    cinfo.err = jpeg_std_error(&jerr);
 
    jpeg_create_decompress(&cinfo);
 
 
 
    // Lit le fichier et son header, puis le décompresse
 
    FILE *fichier=fopen(filename, "rb");  
 
    jpeg_stdio_src(&cinfo, fichier);
 
    jpeg_read_header(&cinfo, TRUE);
 
    jpeg_start_decompress ( &cinfo );
 
 
 
    ImageSize = cinfo.image_width * cinfo.image_height * 3;    
 
    image = (GLubyte *) malloc ( ImageSize );
 
    ligne=image;
 
 
 
    while ( cinfo.output_scanline < cinfo.output_height )
 
     {
 
        ligne = image + 3 * cinfo.image_width * cinfo.output_scanline;
 
        jpeg_read_scanlines ( &cinfo, &ligne, 1 );
 
     }
 
 
 
    jpeg_finish_decompress(&cinfo);
 
    jpeg_destroy_decompress(&cinfo);
 
 
 
    // Traitements de la texture par OpenGL
 
    int error = glPixelStorei(GL_UNPACK_ALIGNMENT,1);        // Construit la texture sous forme de données
 
    glGenTextures(nb, &TexNum[nb]);              // Génère une ID pour la texture OpenGL                                             
 
 
 
    glBindTexture(GL_TEXTURE_2D, TexNum[nb]);    // Pointe la texture
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 
 
 
    // Génère la texture OpenGL en mémoire
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, cinfo.image_width, cinfo.image_height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
 
 
 
    fclose (fichier);
 
    free (image);
 
    return TexNum[nb];
}
 
int Textures::LoadPNG (const char * filename, int nb ) {
	return 0;
}

Fontaine.hpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef FONTAINE_HPP
#define FONTAINE_HPP
 
 
#include <GL/gl.h>
#include <GL/glut.h>
 
#include <iostream>
#include <cmath>
 
#include "Textures.hpp"
 
 
class Fontaine
{
	public:
		Fontaine();
		void chargerTextures();	
		void draw(void);
};
 
 
#endif

Fontaine.cpp :

Code:

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
 
#include "Fontaine.hpp"
 
GLuint texture[2];
Textures text;
 
void Fontaine::chargerTextures()
 
{
 
    texture[0] = text.LoadJPG("img/veg008.jpg", 0);
}
 
Fontaine::Fontaine() {
	Fontaine::chargerTextures();
}
 
void Fontaine::draw(void) {
	//int n = 15;int m = 15;
 
	glPushMatrix();
		/*for ( int j = 0 ; j < m ; j++ ) {
			float hi = 1.0F-j*2.0F/m;
			float hf = hi-2.0F/m;
			glBegin(GL_QUAD_STRIP);
			for( int i = 0 ; i <= n ; i++ ){
				float a = (2*M_PI*i)/n;
				float sn = -sin(a);
				float cs = cos(a);
				glNormal3f(cs,0.0F,sn);
				glVertex3f(cs,hi,sn);
				glVertex3f(cs,hf,sn); 
			}
   			 glEnd(); 
    		}*/
    		glBindTexture(GL_TEXTURE_2D, texture[0]);
		glBegin(GL_QUADS);
			glTexCoord2d(-5,-5);
 
			glVertex3d(-5,-5,5);
 
			glTexCoord2d(5,-5);
 
			glVertex3d(5,-5,5);
 
			glTexCoord2d(5,-5);
 
			glVertex3d(5,-5,-5);
 
			glTexCoord2d(-5,-5);
 
			glVertex3d(-5,-5,-5);
 
		glEnd();
	glPopMatrix();
}

L'erreur de segmentation provient du fichier Textures.cpp dans la méthode Textures::LoadJPG et des lignes suivantes :
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glGenTextures(nb, &TexNum[nb]);

J'avoue que je suis bloqué et que j'ai beau chercher sur le web depuis le début de l'après midi. Si vous connaissez une astuce ou une bibliothèque sous Ubuntu qui permet de m'aider je suis preneur.

Merci d'avance

Bonne soirée

28/10/2010, 00h37
LittleWhite
Bonjour,

J'ai envie de dire, pourquoi ne pas utiliser une bibliothèque qui fait tout pour nous (Devil ?)

Il me semble bizarre que ce soir le glPixelStore qui plante ... mais bon ... si c'est absolument sur que c'est cette fonction, il faudrai tester sur une autre carte graphique pour voir.

Et surtout que je viens de remarquer que vous faites:
Code:

1 2 glGenTextures(nb, &TexNum[nb]);
Avec un nb, qui me semble à zero ... je ne suis pas sur qu'OpenGL va apprécié de généré 0 texture ...

Bonjour LittleWhite,

Le problème venait du fait que j'essayais de mettre en mémoire une texture alors que je n'avais pas encore instancié OPENGL dans mon programme.
Mais cela m'a juste supprimer l'erreur de fragmentation.

En fait je me suis penché sur la SDL car écrire les fonctions pour lire des JPG ou PNG c'est long et fastidieux. Mais je n'arrive toujours pas à appliquer une texture. Je vais donc te remettre les fichiers que j'ai amélioré avec la SDL. Je sais pas si tu pourras m'aider.

Lanceur.hpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#ifndef LANCEUR_HPP
#define LANCEUR_HPP
 
 
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <iostream>
#include <cmath>
 
#include "Fontaine.hpp"
 
 
 
class Lanceur
{
	public:
		void drawScene(void);
};
 
 
#endif

Lanceur.cpp :

Code:

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
 
#include "Lanceur.hpp"
#include "sdlglutils.h"
 
const float PI = 3.1415926535f;
static const float blanc[] = { 1.0F,1.0F,1.0F,1.0F };
Fontaine _fontaine;
 
void init(void) {
	//const GLfloat shininess[] = { 50.0 };
	//glMaterialfv(GL_FRONT,GL_SPECULAR,blanc);
	//glMaterialfv(GL_FRONT,GL_SHININESS,shininess);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,blanc);
 
 
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
 
	glDepthFunc(GL_LESS);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_NORMALIZE);
	glEnable(GL_AUTO_NORMAL);
	glEnable(GL_TEXTURE_2D);
 
	_fontaine.chargerTextures();
}
 
 
void drawScene(void) {
	glClearColor(0.5F,0.5F,1.0F,1.0F) ;
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	const GLfloat light0_position[] = { 1.0,1.0,1.0,0.0 };
	glLightfv(GL_LIGHT0,GL_POSITION,light0_position);
 
	//_fontaine = new Fontaine();
	_fontaine.draw();
 
 
 
	glutSwapBuffers();
}
 
/* Fonction executee lors d'un changement       */
/* de la taille de la fenetre OpenGL            */
 
void reshape(int x,int y) {
	glViewport(0,0,x,y); 
	glMatrixMode(GL_PROJECTION) ;
	glLoadIdentity() ;
	gluPerspective(18.0F,(float) x/y,1.0,500.0) ;
	glMatrixMode(GL_MODELVIEW) ;
	glLoadIdentity() ;
	gluLookAt(0,30,-50,0,0,0,0.0,1.0,0.0);
}
 
/* Fonction executee lors de l'appui            */
/* d'une touche alphanumerique du clavier       */
 
void keyboard(unsigned char key,int x,int y) {
	switch (key) {
		case 'a' :
		{ 
			static int face = 1;
			face = !face;
			glPolygonMode(GL_FRONT_AND_BACK,( face ) ? GL_FILL : GL_LINE); }
			glutPostRedisplay();
		break;
		case 0x1B :
			exit(0);
		break; 
	}
}
 
 
int main(int argc, char** argv) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(1000, 600);
 
	glutCreateWindow("Ma fontaine");
	init();
 
	glutDisplayFunc(drawScene);
	glutKeyboardFunc(keyboard);
	glutReshapeFunc(reshape);
 
 
 
	glutMainLoop();
	return 0;
}

Fontaine.hpp :

Code:

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
 
#ifndef FONTAINE_HPP
#define FONTAINE_HPP
 
 
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
 
 
#include <iostream>
#include <cmath>
 
 
class Fontaine
{
GLuint texture[1];
	public:
		Fontaine();
		void chargerTextures();	
		void draw(void);
};
 
 
#endif

Fontaine.cpp :

Code:

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
 
#include "Fontaine.hpp"
#include "sdlglutils.h"
 
 
 
void Fontaine::chargerTextures()
{
    texture[0] = loadTexture("img/veg008.jpg");
}
 
Fontaine::Fontaine() {
 
}
 
void Fontaine::draw(void) {
	GLUquadric* params;
	params = gluNewQuadric();
	gluQuadricTexture(params,GL_TRUE);
 
	std::cout << "Creation du sol" << std::endl;
    	glBindTexture(GL_TEXTURE_2D, texture[0]);
		glBegin(GL_QUADS);
		glTexCoord2d(-5,-5);
		glVertex3d(-5,-5,5);
 
		glTexCoord2d(5,-5);
		glVertex3d(5,-5,5);
 
		glTexCoord2d(5,-5);
		glVertex3d(5,-5,-5);
 
		glTexCoord2d(-5,-5);
		glVertex3d(-5,-5,-5);
	glEnd();
}

sdlglutils.h :

Code:

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
 
#ifndef SDLGLUTILS_H
 
#define SDLGLUTILS_H
 
 
 
#include <GL/gl.h>
 
#include <SDL/SDL.h>
 
 
 
#ifndef GL_CLAMP_TO_EDGE
 
#define GL_CLAMP_TO_EDGE 0x812F
 
#endif
 
 
 
GLuint loadTexture(const char * filename,bool useMipMap = true);
 
SDL_Cursor * cursorFromXPM(const char * xpm[]);
 
 
 
#endif //SDLGLUTILS_H

sdlglutils.cpp :

Code:

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
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
#include "sdlglutils.h"
 
#include <SDL/SDL.h>
 
#include <SDL/SDL_image.h>
 
#include <GL/glu.h>
 
 
 
#include <cstring>
 
#include <cstdlib>
 
#include <iostream>
 
 
 
 
 
SDL_Surface * flipSurface(SDL_Surface * surface);
 
 
 
GLuint loadTexture(const char * filename,bool useMipMap)
 
{
 
	std::cout << "Chargement des textures" << std::endl;
 
 
 
    GLuint glID;
 
    SDL_Surface * picture_surface = NULL;
 
    SDL_Surface *gl_surface = NULL;
 
    SDL_Surface * gl_fliped_surface = NULL;
 
    Uint32 rmask, gmask, bmask, amask;
 
 
 
    picture_surface = IMG_Load(filename);
 
    if (picture_surface == NULL)
 
        return 0;
 
 
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
 
 
 
    rmask = 0xff000000;
 
    gmask = 0x00ff0000;
 
    bmask = 0x0000ff00;
 
    amask = 0x000000ff;
 
#else
 
 
 
    rmask = 0x000000ff;
 
    gmask = 0x0000ff00;
 
    bmask = 0x00ff0000;
 
    amask = 0xff000000;
 
#endif
 
 
 
    SDL_PixelFormat format = *(picture_surface->format);
 
    format.BitsPerPixel = 32;
 
    format.BytesPerPixel = 4;
 
    format.Rmask = rmask;
 
    format.Gmask = gmask;
 
    format.Bmask = bmask;
 
    format.Amask = amask;
 
 
 
    gl_surface = SDL_ConvertSurface(picture_surface,&format,SDL_SWSURFACE);
 
 
 
    gl_fliped_surface = flipSurface(gl_surface);
 
 
 
    glGenTextures(1, &glID);
 
 
 
    /*glBindTexture(GL_TEXTURE_2D, glID);
 
 
 
 
 
    if (useMipMap)
 
    {
 
 
 
        gluBuild2DMipmaps(GL_TEXTURE_2D, 4, gl_fliped_surface->w,
 
                          gl_fliped_surface->h, GL_RGBA,GL_UNSIGNED_BYTE,
 
                          gl_fliped_surface->pixels);
 
 
 
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
 
                        GL_LINEAR_MIPMAP_LINEAR);
 
 
 
    }
 
    else
 
    {
 
        glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w,
 
                     gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE,
 
                     gl_fliped_surface->pixels);
 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
    }
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 
 
 
 
 
    SDL_FreeSurface(gl_fliped_surface);
 
    SDL_FreeSurface(gl_surface);
 
    SDL_FreeSurface(picture_surface);*/
 
 
 
    return glID;
 
}
 
 
 
int takeScreenshot(const char * filename)
 
{
 
    GLint viewport[4];
 
    Uint32 rmask, gmask, bmask, amask;
 
    SDL_Surface * picture, * finalpicture;
 
 
 
    glGetIntegerv(GL_VIEWPORT, viewport);
 
 
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
 
 
 
    rmask = 0xff000000;
 
    gmask = 0x00ff0000;
 
    bmask = 0x0000ff00;
 
    amask = 0x000000ff;
 
#else
 
 
 
    rmask = 0x000000ff;
 
    gmask = 0x0000ff00;
 
    bmask = 0x00ff0000;
 
    amask = 0xff000000;
 
#endif
 
 
 
    picture = SDL_CreateRGBSurface(SDL_SWSURFACE,viewport[2],viewport[3], 32,
 
                                   rmask, gmask, bmask, amask);
 
    SDL_LockSurface(picture);
 
    glReadPixels(viewport[0],viewport[1],viewport[2],viewport[3],GL_RGBA,
 
                 GL_UNSIGNED_BYTE,picture->pixels);
 
    SDL_UnlockSurface(picture);
 
 
 
    finalpicture = flipSurface(picture);
 
 
 
    if (SDL_SaveBMP(finalpicture, filename))
 
    {
 
        return -1;
 
    }
 
    SDL_FreeSurface(finalpicture);
 
    SDL_FreeSurface(picture);
 
 
 
    return 0;
 
}
 
 
 
SDL_Surface * flipSurface(SDL_Surface * surface)
 
{
 
    int current_line,pitch;
 
    SDL_Surface * fliped_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
 
                                   surface->w,surface->h,
 
                                   surface->format->BitsPerPixel,
 
                                   surface->format->Rmask,
 
                                   surface->format->Gmask,
 
                                   surface->format->Bmask,
 
                                   surface->format->Amask);
 
 
 
 
 
 
 
    SDL_LockSurface(surface);
 
    SDL_LockSurface(fliped_surface);
 
 
 
    pitch = surface->pitch;
 
    for (current_line = 0; current_line < surface->h; current_line ++)
 
    {
 
        memcpy(&((unsigned char* )fliped_surface->pixels)[current_line*pitch],
 
               &((unsigned char* )surface->pixels)[(surface->h - 1  -
 
                                                    current_line)*pitch],
 
               pitch);
 
    }
 
 
 
    SDL_UnlockSurface(fliped_surface);
 
    SDL_UnlockSurface(surface);
 
    return fliped_surface;
 
}

Je compile avec ceci :
g++ -Wall -o Fontaine Lanceur.cpp Fontaine.cpp Particle.cpp Textures.cpp sdlglutils.cpp -lglut -lGLU -ljpeg -L/usr/lib -lSDL -lSDL_image -lGL

Je n'obtient aucune erreur

Quand je lance :
Erreur de segmentation...

EDIT : Mon message date d'hier soir, quand j'ai relancer ce matin la texture apparaissait avec la SDL.. Je ne comprend pas mais cela fonctionne.

28/10/2010, 10h50
LittleWhite

Je suis du genre a dire, soit on fait le fenetre avec GLUT, soit on la fait avec SDL, mais on ne melange pas les deux.
Sinon, il vous manque les codes d'initialisation de la SDL et de SDL_image (SDL_Init() ; IMG_Init())
Je pense que c'est ce qui pose probleme.
28/10/2010, 11h23
akrogames

Merci pour tout.

Je penses refaire le tout avec SDL cela sera plus simple j'ai l'impression.

Bonne journée

Bonjour,

je viens peut-être un peu tard mais j'ai retrouvé un ancien bout de code que j'avais qui appliquais des textures avec Glut et OpenGL (ici une texture pour faire un sol). Je le poste quand même malgré que vous passez à SDL qui est plus simple à mon gout.

GestionTextures.cpp

Code:

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
 
#include "GestionTextures.h"
 
 
GLuint texture;
JSAMPROW j;
 
 
 
/* fonction qui récupère les informations du fichier image (jpeg)
   qui va servir de texture */
Texture lectureImageTexture (char *fichier) {
 
	Texture infosTexture;
	FILE *image;
 
	struct jpeg_decompress_struct decompressionJPEG;
	struct jpeg_error_mgr errJPEG;
 
	/* ouverture du fichier image */
	if ((image = fopen(fichier, "rb")) == NULL) {
 
		fprintf(stdout, " Erreur : Impossible d'ouvrir le fichier\n");
	}
 
 
	/* création de la structure qui va servir à décompresser l'image jpeg */
	jpeg_create_decompress(&decompressionJPEG);
	jpeg_stdio_src(&decompressionJPEG, image);
	decompressionJPEG.err = jpeg_std_error(&errJPEG);
 
	//lecture de l'entête du fichier image et démarrage de la décompression
	jpeg_read_header(&decompressionJPEG, TRUE);
	jpeg_start_decompress(&decompressionJPEG);
 
	/* initialisation des propriétés de l'image */
	infosTexture.largeurTexture = decompressionJPEG.image_width;
	infosTexture.hauteurTexture = decompressionJPEG.image_height;
	infosTexture.internalFormat = decompressionJPEG.num_components;
 
	if (decompressionJPEG.jpeg_color_space==JCS_GRAYSCALE) {
 
		fprintf(stdout, "Erreur : l'image doit etre au format RGB\n");
	 } 
	else {
 
		infosTexture.formatTexture = GL_RGB;
	}
 
 
	infosTexture.pixelsTexture = (GLubyte *) malloc(sizeof (GLubyte) * infosTexture.largeurTexture
								  * infosTexture.hauteurTexture * infosTexture.internalFormat);
 
	/* parcours de l'image pour en extraire les pixels */
	for (int i = 0; i < infosTexture.hauteurTexture; i++) {
 
		j = (infosTexture.pixelsTexture + (infosTexture.hauteurTexture - (i + 1)) * infosTexture.largeurTexture
			* infosTexture.internalFormat);
 
		jpeg_read_scanlines(&decompressionJPEG, &j, 1);
	}
 
	/* destruction de la structure qui a servie à décompresser l'image jpeg */
	jpeg_finish_decompress(&decompressionJPEG);
	jpeg_destroy_decompress(&decompressionJPEG);
 
	fclose(image);
 
	return infosTexture;
}
 
 
/* fonction qui transforme l'image chargée en texture manipulable avec
   OpenGL à partir des informations récupérées par le fonction précédente */
GLuint chargementImageTexture (char *fichier) {
 
	Texture imageTexture;
	GLuint numTexture = 0;
 
	/* récupération des propriétés de l'image */
	imageTexture = lectureImageTexture(fichier);
 
	if (imageTexture.pixelsTexture) {
 
		/* génération de la texture */
		glGenTextures(1, &imageTexture.identTexture);
		glBindTexture(GL_TEXTURE_2D, imageTexture.identTexture);
 
		/* paramètres de flitrage sur la texture */
		glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
		gluBuild2DMipmaps (GL_TEXTURE_2D, imageTexture.internalFormat, imageTexture.largeurTexture,
			imageTexture.hauteurTexture, imageTexture.formatTexture, GL_UNSIGNED_BYTE, imageTexture.pixelsTexture);
 
		numTexture = imageTexture.identTexture;
 
		free (imageTexture.pixelsTexture);
 
	}
 
	return numTexture;
}

GestionTextures.h

Code:

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
#ifndef GESTIONTEXTURES_H
#define GESTIONTEXTURES_H
 
#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
#include<jerror.h>
#include <string.h>
#include<jpeglib.h>
 
 
/* structure regroupant les informations propres à une texture */
 
struct Texture
{
  GLsizei largeurTexture;
  GLsizei hauteurTexture;
 
  GLenum formatTexture;  // RGB
  GLint internalFormat;  
 
  GLuint identTexture;
 
  GLubyte *pixelsTexture;
 
};
 
Texture lectureImageTexture (char *fichier);
GLuint chargementImageTexture (char *fichier);
 
 
#endif

Main.cpp

Code:

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
 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
 
#include "GestionTextures.h"
#include "Main.h"
 
#define longueurTexture 256
#define largeurTexture 256
 
GLuint textureSol;
GLuint test;
double angleRotZ = 0;
 
int menu;
int figure;
 
 
static float blanc[] = { 1.0F,1.0F,1.0F,1.0F };
 
 
/* Fonction d'initialisation des parametres     */
/* OpenGL ne changeant pas au cours de la vie   */
/* du programme                                 */
 
void init(void) {
 
  glClearColor (0.5f, 0.5f, 0.5f, 1.0f);
  glShadeModel (GL_SMOOTH);
  //const GLfloat shininess[] = { 50.0 };
  //glMaterialfv(GL_FRONT,GL_SPECULAR,blanc);
  //glMaterialfv(GL_FRONT,GL_SHININESS,shininess);
  //glLightfv(GL_LIGHT0,GL_DIFFUSE,rouge);
  //glLightfv(GL_LIGHT1,GL_DIFFUSE,jaune);
  //glLightfv(GL_LIGHT2,GL_DIFFUSE,bleu);
  //glEnable(GL_LIGHTING);
  //glEnable(GL_LIGHT0);
  //glEnable(GL_LIGHT1);
  //glEnable(GL_LIGHT2);
 
  //glEnable(GL_LIGHTING);
  //glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
  //glEnable(GL_NORMALIZE);
  //glEnable(GL_AUTO_NORMAL);
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
}
 
/*
void initlights(void) { 
  GLfloat pos[] = { 0.0F,0.0F,-1.0F,0.0F }; 
  GLfloat shininess[] = { 50.0F }; 
  glEnable(GL_LIGHT0); 
  glEnable(GL_LIGHTING); 
  //glLightfv(GL_LIGHT0,GL_AMBIENT,couleurGrisFonce()); 
  glLightfv(GL_LIGHT0,GL_DIFFUSE,blanc); 
  glMaterialfv(GL_FRONT,GL_SPECULAR,blanc); 
  glMaterialfv(GL_FRONT,GL_SHININESS,shininess); 
} 
*/
 
/* Scene dessinee */
 
 
void scene(void) {
 
  glPushMatrix();
 
  glEnable(GL_TEXTURE_2D);
  glBindTexture (GL_TEXTURE_2D, textureSol);
  glBegin(GL_QUADS);
    glTexCoord2i(0,0);      glVertex3i(-30,-30,-1);
    glTexCoord2i(10,0);     glVertex3i(30,-30,-1);
    glTexCoord2i(10,10);    glVertex3i(30,30,-1);
    glTexCoord2i(0,10);     glVertex3i(-30,30,-1);
  glEnd();
 
  glBindTexture(GL_TEXTURE_2D, test);
    glBegin(GL_QUADS);
    glColor3ub (255, 255, 255);
    //glColor3ub (0, 0, 0);  // coloration des face pour mieux se repérer (rouge)
    glTexCoord2d(0,1);   glVertex3d(1, 1, 1);
    glTexCoord2d(0,0);   glVertex3d(1, 1, -1);
    glTexCoord2d(1,0);   glVertex3d(-1, 1, -1);
    glTexCoord2d(1,1);   glVertex3d(-1, 1, 1);
    glEnd();
 
 
    glBegin(GL_QUADS);
    //glColor3ub (255, 255, 255);  // vert
    glTexCoord2d(0,1);  glVertex3d(1, -1, 1);
    glTexCoord2d(0,0);  glVertex3d(1, -1, -1);
    glTexCoord2d(1,0);  glVertex3d(1, 1, -1);
    glTexCoord2d(1,1);  glVertex3d(1, 1, 1);
    glEnd();
 
 
    glBegin(GL_QUADS);
    //glColor3ub (0, 255, 255);  // bleu
    glTexCoord2d(0,1);  glVertex3d(-1, -1, 1);
    glTexCoord2d(0,0);  glVertex3d(-1, -1, -1);
    glTexCoord2d(1,0);  glVertex3d(1, -1, -1);
    glTexCoord2d(1,1);  glVertex3d(1, -1, 1);
    glEnd();
 
 
    glBegin(GL_QUADS);
    //glColor3ub (255, 0, 0);  // bleu clair
    glTexCoord2d(0,1);  glVertex3d(-1, 1, 1);
    glTexCoord2d(0,0);  glVertex3d(-1, 1, -1);
    glTexCoord2d(1,0);  glVertex3d(-1, -1, -1);
    glTexCoord2d(1,1);  glVertex3d(-1, -1, 1);
    glEnd();
 
 
    glBegin(GL_QUADS);
    //glColor3ub(0,255,255); //face cyan
    glTexCoord2d(1,1);  glVertex3d(1,1,-1);
    glTexCoord2d(0,1);  glVertex3d(1,-1,-1);
    glTexCoord2d(0,0);  glVertex3d(-1,-1,-1);
    glTexCoord2d(1,0);  glVertex3d(-1,1,-1);
    glEnd();
 
 
    glBegin(GL_QUADS);
    //glColor3ub(255,0,255); //face magenta
    glTexCoord2d(1,1);  glVertex3d(1,-1,1);
    glTexCoord2d(0,1);  glVertex3d(1,1,1);
    glTexCoord2d(0,0);  glVertex3d(-1,1,1);
    glTexCoord2d(1,0);  glVertex3d(-1,-1,1);
    glEnd();
	glDisable (GL_TEXTURE_2D);
  glPopMatrix();
 
 
  //glEnable(GL_AUTO_NORMAL); 
  //glEnable(GL_NORMALIZE); 
  //glShadeModel(GL_SMOOTH); 
  //glEnable(GL_DEPTH_TEST);
  //glDepthFunc(GL_LESS);
  //initlights();
 
}
 
 
 
/* Fonction executee lors d'un rafraichissement */
/* de la fenetre de dessin                      */
 
void display(void) {
 
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
 
  // placement de la camera sur l'axe Z
  gluLookAt(3, 4, 2, 0, 0, 0, 0, 0, 1);
 
  glRotated (angleRotZ, 0, 0, 1);
 
  /*
  const GLfloat light0_position[] = { 1.0,1.0,1.0,0.0 };
  const GLfloat light1_position[] = { -1.0,1.0,1.0,0.0 };
  const GLfloat light2_position[] = { 1.0,-1.0,1.0,0.0 };
  glLightfv(GL_LIGHT0,GL_POSITION,light0_position);
  glLightfv(GL_LIGHT1,GL_POSITION,light1_position);
  glLightfv(GL_LIGHT2,GL_POSITION,light2_position);
  glPushMatrix();
  if (figure == 1) {
 
	  glutSolidSphere(0.6, 20, 20);
  }
  */
  scene();
  //glPopMatrix();
  glFlush();
  glutSwapBuffers();
}
 
 
void rubriquesMenu (int rubrique) {
 
	switch (rubrique) {
	case 1 : //glutSolidSphere(1.2, 25, 20);
			 figure = 1;
			 break;
	}
	glutPostRedisplay();
}
 
 
void
reshape (int x, int y)
{
  glViewport(0,0,x,y); 
  glMatrixMode(GL_PROJECTION) ;
  glLoadIdentity() ;
  gluPerspective(80.0F,(float) x/y,1.0,40.0) ;
  glMatrixMode(GL_MODELVIEW) ;
  glLoadIdentity() ;
  gluLookAt(0.0,0.0,20.0,0.0,0.0,0.0,0.0,1.0,0.0);
}
 
/* Fonction principale */
 
 
void idle(void) {
 
  angleRotZ +=  0.5;
 
  glutPostRedisplay() ;
}
 
 
int main(int argc,char **argv) {
  glutInit(&argc,argv);  // initialisation de glut
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);  //DEPTH pour gérer la profondeur | Double pour utiliser les double buffering
  glutInitWindowSize(850,600); 
  glutInitWindowPosition(300,200); 
  glutCreateWindow("Un labyrinthe en OpenGL"); 
  menu = glutCreateMenu(rubriquesMenu);
  glutAddMenuEntry("Option 1", 1);
  glutAddMenuEntry("Option 2", 2);
  glutAttachMenu(GLUT_RIGHT_BUTTON);
 
  textureSol = chargementImageTexture("Textures/veg008.jpg");
  test = chargementImageTexture("Textures/snow008.jpg");
 
  init();
  //glutKeyboardFunc(keyboard);  // gestion des evenement clavier
  //glutSpecialFunc(manipCylindre);  // fonction pour la manipulation du cylindre (touches directionnelles)
  glutReshapeFunc(reshape);  // fonction a exécuter pour la modification de la taille de fenetre d'affichage
  glutIdleFunc(idle);   // fonction executer si le programme ne fait rien
  glutDisplayFunc(display);  // spécifié a glut quelle méthode déssine
  glutMainLoop();  // boucle infinie (boucle principal d'affichage)
  return(0);
}