Bonjour, bonjour.
Désolé de vous déranger encore (j'ai un peu l'impression de pourrir le forum) mais bon voilà trouver les erreurs tout seul quand on est débutant, c'est pas facile... A l'avenir je réutiliserai ce topic pour traiter de mes problèmes sur OpenGL...

Alors voilà mon problème : de tuto d'ici et d'ailleurs j'ai tenté d'apprendre OpenGL. J'étais arrivé à faire un cube que l'on tourne à la souris, mais comme le code était super pourri (tout dans main.cpp, plein de variables globales, ...);
j'ai esseye de le retravaillé un peu (il encore super pas bien [je suis débutant ], si vous avez des remarques... mais le problème d'abord svp ! ) et voilà où j'en arrive, ça tourne mais la texture à disparu comme par miracle ! Pourtant elle bien stockée en mémoire dans toute les fonctions qui l'utilisent... Ou est mon erreur de manip ? Comment rendre des couleurs à mon cube ?

Si le code n'est pas assez clair : dites-le je le recommenterais
si le code est trop moche. : euuuuh... esseyer de m'aider tout de même, pitié !

Je vous remercie à l'avance : Merci !


header.h:

#ifndef DEF_HEADER
#define DEF_HEADER

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include <cstdlib>
#include <vector>
#include <math.h>
#include <iostream>
#include <fstream>

#include "draw.h"
#include "header.h"
#include "vectors.h"

#endif

verctors.h:

#ifndef DEF_VECT
#define DEF_VECT



typedef struct Coord Coord;
struct Coord
{
    double x;
    double y;
    double z;
};

typedef struct Lumiere Lumiere;
struct Lumiere
{
    GLfloat col[4];
    GLfloat pos[4];
};

typedef struct Data Data;
struct Data
{
    std::vector<double> angle;
    std::vector<Coord> pos;
    std::vector<GLuint> texture;
    std::vector<Lumiere> lum;
};

Data creer_donnees();
int LoadGLTextures(char* nom_fichier);

#endif

draw.h:

#ifndef DEF_DRAW
#define DEF_DRAW

#define PI 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628

void dessiner(struct Data *zdata);
void cube(GLuint texture);
void pyramide();

#endif

main.cpp:

#include "header.h"

using namespace std;

int main(int argc, char *argv[])
{
    SDL_Surface *screen =NULL;
    SDL_Event event;
    bool turn = false, loop = true, light = false;
    SDL_Rect current_mouse, last_mouse;
    last_mouse.x = 0;
    last_mouse.y = 0;

    Data data = creer_donnees();
    if(data.texture[0])
    cerr<<"la texture est dans le main"<<endl;
    else
    cerr<<"la texture n'est pas enregistrée dans data.texture[0] !"<<endl;


    //initialisatin SDL
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("SDL GL Application", NULL);
    screen = SDL_SetVideoMode(640, 480, 32, SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_OPENGLBLIT);

    //initialisation OpenGL
    glEnable(GL_TEXTURE_2D);
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)640.0/480.0,1,1000);
    glEnable(GL_DEPTH_TEST);
    glLightfv(GL_LIGHT1, GL_AMBIENT, data.lum[0].col);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, data.lum[1].col);
    glLightfv(GL_LIGHT1, GL_POSITION, data.lum[1].pos);
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHTING);

    //1er affichage de la scene
    dessiner(&data);

    //initialistion des compteur
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;

    //boucle principale
    while(loop)
    {
        start_time = SDL_GetTicks();
        while (SDL_PollEvent(&event))
        {

            switch(event.type)
            {
                case SDL_QUIT:
                loop = false;
                break;

                case SDL_MOUSEBUTTONDOWN:
                switch(event.button.button)
                {
                    case SDL_BUTTON_LEFT:
                    turn = true;
                    current_mouse.x = event.button.x;
                    current_mouse.y = event.button.y;
                    break;
                }
                break;

                case SDL_MOUSEBUTTONUP:
                switch(event.button.button)
                {
                    case SDL_BUTTON_LEFT:
                    turn = false;
                    break;

                    case SDL_BUTTON_WHEELUP:
                    data.pos[0].z += 0.2;
                    if(data.pos[0].z > -3.0) data.pos[0].z = -3.0;
                    break;

                    case SDL_BUTTON_WHEELDOWN:
                    data.pos[0].z -= 0.2;
                    if(data.pos[0].z < -20.0) data.pos[0].z = -20.0;
                    break;
                }
                break;

                case SDL_MOUSEMOTION:
                    current_mouse.x = event.button.x;
                    current_mouse.y = event.button.y;
                    if(!turn)
                    {
                        last_mouse.x = event.button.x;
                        last_mouse.y = event.button.y;
                    }
                break;

                case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                    loop = false;
                    break;

                    case SDLK_SPACE:
                    data.angle[0] = 45;
                    data.angle[1] = 0;
                    data.pos[0].z = -5;
                    break;

                    case SDLK_l:
                    if(light)
                    {
                        light = false;
                        glDisable(GL_LIGHTING);
                    }
                    else
                    {
                        light = true;
                        glEnable(GL_LIGHTING);
                    }
                    break;

                    /*/
                    case SDLK_p:
                    if(turn)    turn = false;
                    else        turn = true;
                    break;
                    //*/
                }
                break;

            }
        }

        //Gestion des FPS
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;

        if(turn)
        {
            data.angle[0] += 0.5 * (current_mouse.x - last_mouse.x);
            data.angle[1] += 0.5 * (current_mouse.y - last_mouse.y);
            last_mouse.x = current_mouse.x;
            last_mouse.y = current_mouse.y;

        }

        /*
        x += 0.05 * ellapsed_time;
        y += 0.05 * ellapsed_time;
        z += 0.05 * ellapsed_time;
        //*/

        //affichage de la scene
        dessiner(&data);


        //mise en pause du programme
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 10)
        {
            SDL_Delay(10 - ellapsed_time);
        }

    }

    return EXIT_SUCCESS;
}

draw.cpp:

#include "header.h"

using namespace std;

void dessiner(Data* data)
{

    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();


    glTranslated(data->pos[0].x, data->pos[0].y, data->pos[0].z);
    glRotatef(data->angle[0], 0.0, 1.0, 0.0);
    glRotatef(data->angle[1], cos(data->angle[0]*PI/180.0), 0.0, sin(data->angle[0]*PI/180.0));
    glColor3ub(255, 255, 255);

    cube(data->texture[0]);


    /*

    glLoadIdentity();
    glTranslatef(-1.5, 1.5, -8.0);
    glRotatef(x, 1.0, 0.0, 0.0);
    cube(data);

    glLoadIdentity();
    glTranslatef(1.5, 1.5, -8.0);
    glRotatef(y, 0.0, 1.0, 0.0);
    cube(data);

    glLoadIdentity();
    glTranslatef(-1.5, -1.5, -8.0);
    glRotatef(z, 0.0, 0.0, 1.0);
    cube(data);
    //*/

    glFlush();
    SDL_GL_SwapBuffers();
}

void cube(GLuint texture)
{

    if(texture)
    cerr <<"ok !"<<endl;
    else
    cerr <<"zut !"<<endl;

    glBindTexture(GL_TEXTURE_2D, texture);
    glBegin(GL_QUADS);

    //face du dessus
    glNormal3d( 0, 1, 0);
        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);


    //face du dessous
    glNormal3d( 0,-1, 0);
        glTexCoord2d(0,0);  glVertex3d(-1,-1, 1);
        glTexCoord2d(0,1);  glVertex3d( 1,-1, 1);
        glTexCoord2d(1,1);  glVertex3d( 1,-1,-1);
        glTexCoord2d(1,0);  glVertex3d(-1,-1,-1);

    //face de droite
    glNormal3d( 1, 0, 0);
        glTexCoord2d(1,0);  glVertex3d( 1,-1, 1);
        glTexCoord2d(1,1);  glVertex3d( 1, 1, 1);
        glTexCoord2d(0,1);  glVertex3d( 1, 1,-1);
        glTexCoord2d(0,0);  glVertex3d( 1,-1,-1);

    //face de gauche
    glNormal3d(-1, 0, 0);
        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);

    //face avant
    glNormal3d( 0, 0,-1);
        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);


    //face arrière
    glNormal3d( 0, 0, 1);
        glTexCoord2d(0,0);  glVertex3d( 1,-1, 1);
        glTexCoord2d(1,0);  glVertex3d(-1,-1, 1);
        glTexCoord2d(1,1);  glVertex3d(-1, 1, 1);
        glTexCoord2d(0,1);  glVertex3d( 1, 1, 1);

    glEnd();
}

void pyramide()
{
    glBegin(GL_TRIANGLES);
    glColor3ub(255, 0, 0);
        glVertex3d( 0.0, 1.0, 0.0);
        glColor3ub(0, 255, 0);
        glVertex3d(-1.0,-1.0, 1.0);
        glColor3ub(0, 0, 255);
        glVertex3d( 1.0,-1.0, 1.0);

    glColor3ub(255, 0, 0);
        glVertex3d( 0.0, 1.0, 0.0);
        glColor3ub(0, 0, 255);
        glVertex3d( 1.0,-1.0, 1.0);
        glColor3ub(0, 255, 0);
        glVertex3d( 1.0,-1.0,-1.0);

    glColor3ub(255, 0, 0);
        glVertex3d( 0.0, 1.0, 0.0);
        glColor3ub(0, 255, 0);
        glVertex3d( 1.0,-1.0,-1.0);
        glColor3ub(0, 0, 255);
        glVertex3d(-1.0,-1.0,-1.0);

    glColor3ub(255, 0, 0);
        glVertex3d( 0.0, 1.0, 0.0);
        glColor3ub(0, 0, 255);
        glVertex3d(-1.0,-1.0,-1.0);
        glColor3ub(0, 255, 0);
        glVertex3d(-1.0,-1.0, 1.0);

    glEnd();
}

vectors.cpp

#include "header.h"

using namespace std;

Data creer_donnees()
{
    Data data;
    Coord init3f = {0.0, 0.0, 0.0};
    Lumiere lumiere = {{1.0, 1.0, 1.0, 1.0} , {0.0, 0.0, 0.0, 0.0}};
    //lumiere.col = {1.0, 1.0, 1.0, 1.0};
    //lumiere.pos = {0.0, 0.0, 0.0, 0.0};

    data.angle.push_back(45);
    data.angle.push_back(0);

    data.pos.push_back(init3f);
    data.pos[0].z = -5.0;

    data.texture.push_back(LoadGLTextures("crate.jpg"));
    if (data.texture[0] == 0) printf("impossible de charger les textures");


    data.lum.push_back(lumiere);    //light ambiant
    data.lum[0].col[0] = 0.5;
    data.lum[0].col[1] = 0.5;
    data.lum[0].col[2] = 0.5;

    data.lum.push_back(lumiere);    //light diffuse

    data.lum[1].pos[0] = 1.5;
    data.lum[1].pos[1] = 0.0;
    data.lum[1].pos[2] = 3.5;

    /*
    GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat LightPosition[]= { 1.5f, 0.0f, 3.5f, 1.0f };*/


    return data;   // <-- OK, c'est ignoble, mais ça patientera
}


int LoadGLTextures(char* nom_fichier)
{
    if(strlen(nom_fichier) == 0) return 0;

    SDL_Surface *TextureImage;
    GLuint texture;

    if ( ( TextureImage = IMG_Load( nom_fichier ) ) )
        {
        cerr << "succès du chargement de la texture !" << endl;

	    glGenTextures( 1, &texture);
	    glBindTexture( GL_TEXTURE_2D, texture);

	    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        }
    else
    {
        cerr << "impossible de charger la texture !" << endl;
        return 0;
    }

        glTexImage2D( GL_TEXTURE_2D, 0, 3, TextureImage->w,
			  TextureImage->h, 0, GL_RGB,
			  GL_UNSIGNED_BYTE, TextureImage->pixels );

        //gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->w, TextureImage[0]->h, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->pixels);

    if ( TextureImage )
	    SDL_FreeSurface( TextureImage );

    return texture; //ici aussi, bof, bof
}

J'ai rien regardé mais j'ai juste vu la définition de pi. Il est inutile de donner plus de 16 décimales, l'ordinateur ne saura pas les traiter.

Meme reaction de plus la precision n'est pas visible mais ton processeur et ta ram vera la difference et donc la vitesse d'execution aussi.

De plus tu dis faire du Cpp hors aucun des avantage du cpp sont utilise, tu pourrais utiliser les classes !

Sinon pour ton code je ne sais pas pas le temps de regarder enfaite.

Dsl

Laisse tomber les typedefs, les déclarations de classes, structures et énumérations s'en passe en C++.

Salut à toi !

Quand je vois ton code je me dis que il y a forcement plus simple sans s'y connaître trop, j'avais déjà fais un truc dans ce genre mais j'avais pas autant de lignes :s je te conseil de résoudre le problème de toi même, c'est le meilleur apprentissage qu'il existe ! Bon je t'ai pas trop aidé, je voulais juste mettre mon grain de sel ! a++