IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Impossible d'appliquer une texture avec Glut et Opengl


Sujet :

OpenGL

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre très actif

    Inscrit en
    Août 2005
    Messages
    401
    Détails du profil
    Informations forums :
    Inscription : Août 2005
    Messages : 401
    Par défaut Impossible d'appliquer une texture avec Glut et Opengl
    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 : 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
     
    #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 : 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
     
    #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 : 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
     
    #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 : 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
     
    #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

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    27 129
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 27 129
    Billets dans le blog
    149
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ...
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Membre très actif

    Inscrit en
    Août 2005
    Messages
    401
    Détails du profil
    Informations forums :
    Inscription : Août 2005
    Messages : 401
    Par défaut
    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 : 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
     
    #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 : 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
     
    #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 : 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
     
    #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 : 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
     
    #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 : 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
     
    #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 : 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
    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.

  4. #4
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    27 129
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 27 129
    Billets dans le blog
    149
    Par défaut
    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.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #5
    Membre très actif

    Inscrit en
    Août 2005
    Messages
    401
    Détails du profil
    Informations forums :
    Inscription : Août 2005
    Messages : 401
    Par défaut
    Merci pour tout.

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

    Bonne journée

  6. #6
    Membre confirmé
    Profil pro
    Administrateur réseau
    Inscrit en
    Mai 2009
    Messages
    58
    Détails du profil
    Informations personnelles :
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Administrateur réseau

    Informations forums :
    Inscription : Mai 2009
    Messages : 58
    Par défaut
    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 : 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
     
    #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 : 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
    #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 : 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
     
    #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);
    }

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Impossible de remplir une table avec Wamp
    Par RuesToulonnaises dans le forum Requêtes
    Réponses: 2
    Dernier message: 19/03/2007, 20h18
  2. appliquer une texture sur une grille
    Par franc82 dans le forum OpenGL
    Réponses: 6
    Dernier message: 02/03/2007, 16h17
  3. Impossible de prendre une valeur avec Console.Read( ?
    Par Tux1 dans le forum Windows Forms
    Réponses: 9
    Dernier message: 07/01/2007, 16h29
  4. impossible de comparer une chaine avec use strict
    Par erc_fun dans le forum Langage
    Réponses: 6
    Dernier message: 05/10/2006, 10h56
  5. Réponses: 5
    Dernier message: 18/09/2004, 21h30

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo