Bonjour, il ya deux semaines, j'ai décidé de faire un (petit) jeu en 3d avec opengl ou on controlerai un peti vaisseau spatial a la souris. J'ai bien sur lu ET COMPRIS le cours de m@teo21 sur le c/c++ et le tuto de kayl mais je me heurte a beaucoup de problemes, de plus je suis passé a linux il y a une semaine donc je galere encore plus.

voila le code source (attention, c'est un peu long il n'est peut etre pas utile de tout lire):

main.cpp:

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <cstdlib>
#include <time.h>
#include "sdlglutils.h"
#include "menu.h"
#include "textures.h"
#include "jeu.h"

#define HT 800
#define LRG 1024

int main(int argc, char *argv[])
{
    double angleZ = 0;
    double angleX = 0;
    double angleY = 0;
    int moveUp =0;
    int moveDown =0;
    int moveRight =0;
    int moveLeft =0;
    int moveBack =0;
    int moveOn =0;
    int askQuit=0;
    int nbrDasteroids=10;
    bool Quit=false;

    CubeMove cubeMove;

    SDL_Event event;

    srand(time(NULL));

    //const SDL_VideoInfo *info =SDL_GetVideoInfo();
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("Tetra", NULL);

    if (SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 ) == -1)
    {
        SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 6);
    }

    SDL_Rect **mode;

    mode = SDL_ListModes(NULL, SDL_OPENGL | SDL_FULLSCREEN);

    if (mode == NULL)
    {
        exit(0);
    }
    else if (mode == (SDL_Rect **) -1)
    {
        mode[0]->w=1280;
        mode[0]->h=1024;
    }

    SDL_SetVideoMode(0,0, 32, SDL_OPENGL | SDL_FULLSCREEN);

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)mode[0]->w/mode[0]->h,1,1000);

    glEnable(GL_DEPTH_TEST);

    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;

    for (;;)
    {
        start_time = SDL_GetTicks();
        while (SDL_PollEvent(&event))
        {

            switch(event.type)
            {
                case SDL_KEYDOWN:
                exit(0);
                break;

                case SDL_MOUSEBUTTONUP:
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    cubeMove = MenuQueFaire((event.button.x)*(1280/mode[0]->w),(event.button.y)*(1024/mode[0]->h));

                    if(cubeMove.instruction==MOVE)
                    {
                        if(cubeMove.axeY==1)
                        {
                            moveRight=100;
                            cubeMove.axeY=0;
                        }

                        if(cubeMove.axeY==-1)
                        {
                            moveLeft=100;
                            cubeMove.axeY=0;
                        }

                        if(cubeMove.axeZ==1)
                        {
                            moveUp=100;
                            cubeMove.axeZ=0;
                        }
                        if(cubeMove.axeZ==-1)
                        {
                            moveDown=100;
                            cubeMove.axeZ=0;
                        }
                        if(cubeMove.axeY==1)
                        {
                            moveRight=100;
                            cubeMove.axeY=0;
                        }

                        if(cubeMove.axeY==-1)
                        {
                            moveLeft=100;
                            cubeMove.axeY=0;
                        }

                        if(cubeMove.axeZ==1)
                        {
                            moveUp=100;
                            cubeMove.axeZ=0;
                        }
                        if(cubeMove.axeZ==-1)
                        {
                            moveDown=100;
                            cubeMove.axeZ=0;
                        }
                        askQuit=-1;
                     }

                     if(cubeMove.instruction==QUIT)
                     {
                         askQuit=1;
                     }

                     if(cubeMove.instruction==NONE)
                     {
                         askQuit=-1;
                     }

                     if(cubeMove.instruction==END)
                     {
                         exit(0);
                     }
                     if(cubeMove.instruction==PLAY)
                     {
                         jouer(nbrDasteroids,event);
                     }
                 }
                 break;
             }
         }

        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;

        while(moveUp)
        {
            moveUp --;
            angleX += 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleX == 360)
        {
            angleX=0;
        }

        while(moveDown)
        {
            moveDown --;
            angleX -= 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleX == -360)
        {
            angleX=0;
        }

        while(moveLeft)
        {
            moveLeft --;
            angleZ -= 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleZ == -360)
        {
            angleZ=0;
        }

        while(moveRight)
        {
            moveRight --;
            angleZ += 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleZ == 360)
        {
            angleZ=0;
        }

        while(moveBack)
        {
            moveBack --;
            angleY += 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleY == 360)
        {
            angleY=0;
        }

        while(moveOn)
        {
            moveOn --;
            angleY -= 0.9;
            SDL_Delay(5);
            DessinMenu(angleX,angleZ,angleY);
        }
        if(angleY == -360)
        {
            angleY=0;
        }

        if(askQuit==1)
        {
            Quit=true;
        }
        if(askQuit==-1)
        {
            Quit=false;
        }

         DessinMenu(angleX,angleZ,angleY,Quit);

         ellapsed_time = SDL_GetTicks() - start_time;
         if (ellapsed_time < 10)
         {
             SDL_Delay(10 - ellapsed_time);
         }

     }

     return 0;
 }

je ne vous met pas sdlglutils, ils sont sur le site et je ne les ai pas modifiés.

menu.cpp:

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "menu.h"
#include "sdlglutils.h"

void DessinMenu(double angleX, double angleZ,double angleY, bool askQuit)
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );

    gluLookAt(0,0,2.5,0,0,0,0,1,1);

    glRotated(angleZ,0,1,0);
    glRotated(angleY,0,0,1);
    glRotated(angleX,1,0,0);

    glBegin(GL_QUADS);

    DessinMenuNouvellePartie();

    DessinMenuOptionsGenerales();

    DessinMenuCredits();

    DessinMenuChargerNiveau();

    DessinMenuPartieRapide();

    DessinMenuPrincipal();

    if(askQuit)
    {
        DemanderQuitter();
    }

    glEnd();

    glFlush();
    SDL_GL_SwapBuffers();
}

CubeMove MenuQueFaire(int x, int y)
{
    CubeMove cubeMove;
    cubeMove.axeX=0;
    cubeMove.axeY=0;
    cubeMove.axeZ=0;
    cubeMove.instruction=NONE;
    static FaceDuMenu face= MENU_PRINCIPAL;

    if(face==MENU_PRINCIPAL)
    {
        if(x> 170&& x< 590)
        {
            if(y> 165 &&y< 240)
            {
                cubeMove.axeZ=1;
                face=NVL_PART;
                cubeMove.instruction=MOVE;// NVL PART
            }

            if(y> 292 &&y< 365)
            {
                cubeMove.axeY=1;
                face=CHRG_NIV;
                cubeMove.instruction=MOVE;// CHRG NIV
            }

            if(y> 417 &&y< 492)
            {
                cubeMove.axeY=-1;
                face=OPT;
                cubeMove.instruction=MOVE;// OPT
            }

            if(y> 542 &&y< 615)
            {
                cubeMove.axeZ=-1;
                face=CREDIT;
                cubeMove.instruction=MOVE;// CREDIT
            }

            if(y> 668 &&y< 743)
            {
                face=QUITTING;
                cubeMove.instruction=QUIT;// QUITTER
            }
        }
    }
    if(face==NVL_PART)
    {
        if(x>510 && x<767)
        {
            if(y>877 && y< 930)
            {
                cubeMove.axeZ=-1;
                face=MENU_PRINCIPAL;
                cubeMove.instruction=MOVE;// retour
            }

            if(y>93 && y< 146)
            {
                cubeMove.axeZ=1;
                face=PRACT;
                cubeMove.instruction=MOVE;// PRACT
            }
        }
    }
    if(face==PRACT)
    {
        if(x>510 && x<767)
        {
            if(y>877 && y< 930)
            {
                cubeMove.axeZ=-1;
                face=NVL_PART;
                cubeMove.instruction=MOVE;// retour
            }

            if(y>771 && y< 824)
            {
                cubeMove.instruction=PLAY;// jouer
            }
        }
    }
    if(face==CHRG_NIV)
    {
        if(x> 817 && x<1074)
        {
            if(y> 877&& y<930)
            {
                cubeMove.axeY=-1;
                face=MENU_PRINCIPAL;
                cubeMove.instruction=MOVE;// retour
            }
        }
    }
    if(face==OPT)
    {
        if(x> 208 && x<461)
        {
            if(y> 877&& y<930)
            {
                cubeMove.axeY=1;
                face=MENU_PRINCIPAL;
                cubeMove.instruction=MOVE;// retour
            }
        }
    }
    if(face==CREDIT)
    {
        if(x>510 && x<767)
        {
            if(y>93 && y< 146)
            {
                cubeMove.axeZ=1;
                face=MENU_PRINCIPAL;
                cubeMove.instruction=MOVE;// retour
            }
        }
    }
    if(face==QUITTING)
    {
        cubeMove.instruction=QUIT;
        if(y>511 && y< 630)
        {
            if(x> 410&& x< 611)
            {
                cubeMove.instruction=END;// oui
            }
            if(x> 667&& x< 870)
            {
                cubeMove.instruction=NONE;// non
                face=MENU_PRINCIPAL;
            }
        }
    }
    return cubeMove;
}

void DessinMenuPrincipal()
{
    glColor3ub(200,200,200);
    glVertex3d(1,-1,1);
    glVertex3d(1,1,1);
    glColor3ub(50,50,50);// dessin du fond
    glVertex3d(-1,1,1);
    glVertex3d(-1,-1,1);

    glVertex3d(0.05,0.9,1.1);
    glVertex3d(0.9,0.9,1.1);
    glColor3ub(200,200,200);// dessin de la barre d'info
    glVertex3d(0.9,-0.9,1.1);
    glVertex3d(0.05,-0.9,1.1);

    for(int i=0; i>-5 ;i--)
    {
        glColor3ub(20,20,20);
        glVertex3d(-0.9,0.66+(i*0.24),1.1);
        glVertex3d(-0.9,0.52+(i*0.24),1.1);// dessin des options du menu
        glColor3ub(200,200,200);
        glVertex3d(-0.1,0.52+(i*0.24),1.1);
        glVertex3d(-0.1,0.66+(i*0.24),1.1);
    }
}

void DessinMenuNouvellePartie()
{
    glColor3ub(250,250,250);
    glVertex3d(1,1,-0.5);
    glVertex3d(1,1,-1);
    glColor3ub(70,70,70);// dessin de la case "PRACT"
    glVertex3d(-1,1,-1);
    glVertex3d(-1,1,-0.5);

    glVertex3d(0,1,1);
    glVertex3d(-1,1,1);
    glColor3ub(250,250,250);// dessin de la case " nouvelle campagne"
    glVertex3d(-1,1,-0.5);
    glVertex3d(0,1,-0.5);

    glVertex3d(0,1,1);
    glVertex3d(1,1,1);
    glColor3ub(70,70,70);// dessin de la case " minis jeux"
    glVertex3d(1,1,-0.5);
    glVertex3d(0,1,-0.5);

    glColor3ub(200,200,200);
    glVertex3d(0.25,1.1,0.8);
    glVertex3d(-0.25,1.1,0.8);
    glColor3ub(100,100,100);// dessin de la case " retour"
    glVertex3d(-0.25,1.1,0.7);
    glVertex3d(0.25,1.1,0.7);

    glVertex3d(0.25,1.1,-0.7);
    glVertex3d(-0.25,1.1,-0.7);
    glColor3ub(200,200,200);// dessin de la case "PRACT"
    glVertex3d(-0.25,1.1,-0.8);
    glVertex3d(0.25,1.1,-0.8);
}

void DemanderQuitter()
{
    glColor3ub(20,20,20);
    glVertex3d(0.5,-0.3,1.2);
    glVertex3d(-0.5,-0.3,1.2);// dessin du fond
    glColor3ub(100,100,100);
    glVertex3d(-0.5,0.5,1.2);
    glVertex3d(0.5,0.5,1.2);

    glColor3ub(230,230,230);
    glVertex3d(-0.05,-0,1.25);
    glVertex3d(-0.05,-0.2,1.25);
    glColor3ub(100,100,100);// le bouton oui
    glVertex3d(-0.4,-0.2,1.25);
    glVertex3d(-0.4,-0,1.25);

    glColor3ub(230,230,230);
    glVertex3d(0.4,-0,1.25);
    glVertex3d(0.4,-0.2,1.25);
    glColor3ub(100,100,100);// le bouton non
    glVertex3d(0.05,-0.2,1.25);
    glVertex3d(0.05,0,1.25);
}

void DessinMenuChargerNiveau()
{

    glColor3ub(150,150,150);
    glVertex3d(-1,1,1);
    glVertex3d(-1,1,-1);
    glColor3ub(50,50,50); //fond
    glVertex3d(-1,-1,-1);
    glVertex3d(-1,-1,1);

    glColor3ub(100,100,100);
    glVertex3d(-1.1,-0.8,0.35);
    glVertex3d(-1.1,-0.7,0.35);// le bouton retour
    glColor3ub(200,200,200);
    glVertex3d(-1.1,-0.7,0.85);
    glVertex3d(-1.1,-0.8,0.85);
}

void DessinMenuOptionsGenerales()
{
    glColor3ub(200,200,200);
    glVertex3d(1,1,1);
    glVertex3d(1,1,-1);
    glColor3ub(70,70,70);// dessin du fond
    glVertex3d(1,-1,-1);
    glVertex3d(1,-1,1);

    glColor3ub(100,100,100);
    glVertex3d(1.1,-0.8,0.35);
    glVertex3d(1.1,-0.7,0.35);// le bouton retour
    glColor3ub(200,200,200);
    glVertex3d(1.1,-0.7,0.85);
    glVertex3d(1.1,-0.8,0.85);
}

void DessinMenuCredits()
{
    glColor3ub(30,30,30);
    glVertex3d(1,-1,1);
    glVertex3d(-1,-1,1);
    glColor3ub(90,90,90);// dessin du fond
    glVertex3d(-1,-1,-1);
    glVertex3d(1,-1,-1);

    glVertex3d(0.25,-1.1,0.7);
    glVertex3d(-0.25,-1.1,0.7);// dessin de la case " retour"
    glColor3ub(190,190,190);
    glVertex3d(-0.25,-1.1,0.8);
    glVertex3d(0.25,-1.1,0.8);
}

void DessinMenuPartieRapide()
{
    glColor3ub(100,100,100);
    glVertex3d(1,1,-1);
    glVertex3d(1,-1,-1);
    glColor3ub(120,120,120);// dessin du fond
    glVertex3d(-1,-1,-1);
    glVertex3d(-1,1,-1);

    glColor3ub(230,230,230);
    glVertex3d(0.25,0.8,-1.1);
    glVertex3d(-0.25,0.8,-1.1);// dessin de la case " retour"
    glColor3ub(100,100,100);
    glVertex3d(-0.25,0.7,-1.1);
    glVertex3d(0.25,0.7,-1.1);

    glVertex3d(0.25,0.6,-1.1);
    glVertex3d(-0.25,0.6,-1.1);// dessin de la case commencer
    glColor3ub(230,230,230);
    glVertex3d(-0.25,0.5,-1.1);
    glVertex3d(0.25,0.5,-1.1);
}

menu.h:

void DessinMenu(double angleX, double angleZ, double angleY, bool askQuit =false);
void DessinMenuPrincipal();
void DessinMenuNouvellePartie();
void DemanderQuitter();
void DessinMenuChargerNiveau();
void DessinMenuOptionsGenerales();
void DessinMenuCredits();
void DessinMenuPartieRapide();
typedef enum Instruction
    {
        QUIT,MOVE,END,NONE,PLAY
    } Instruction;
typedef struct CubeMove
{
    double axeY;
    double axeX;
    double axeZ;
    Instruction instruction;
}CubeMove;
typedef enum FaceDuMenu
{
    MENU_PRINCIPAL, CREDIT, PRACT,NVL_PART,OPT,CHRG_NIV,QUITTING
}FaceDuMenu;
CubeMove MenuQueFaire(int x, int y);

jeu.h:

void jouer(int nbrDasteroids, SDL_Event event);
void JeuQueFaire(bool * jouer,SDL_Event event,double *vitesseXVaisseau,double *vitesseYVaisseau,double *vitesseZVaisseau);
typedef enum NomDeElement
{
    SHIP,ASTEROID,BONUS
} NomDeElement;
typedef struct ElementDuJeu
{
    double x;
    double y;
    double z;
    int pointsDeVie;
    bool alive;
    double rayon;
    NomDeElement nom;
}ElementDuJeu;
void JeuIntialiser(ElementDuJeu * elements[],int nbrDasteroids);
double Hasard(double min, double max);
void JeuDessinerLeJeu(ElementDuJeu elements[],double angleVaisseauX,double angleVaisseauY,double angleVaisseauZ);
void JeuPasserUnTour(ElementDuJeu * elements[],double vitesseXVaisseau,double vitesseYVaisseau,double vitesseZVaisseau);

jeu.cpp

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <cstdlib>
#include <time.h>
#include "jeu.h"
#include "jeuAffichage.h"

void jouer(int nbrDasteroids,SDL_Event event)
{
    SDL_ShowCursor(SDL_DISABLE);

    bool continuerAjouer=true;
    bool *pointeurSurContiuerAjouer=&continuerAjouer;
    double angleVaisseauX=0;
    double angleVaisseauY=0;
    double angleVaisseauZ=0;
    double vitesseXVaisseau=5;
    double vitesseYVaisseau=-5;
    double vitesseZVaisseau=5;
    ElementDuJeu *elementsDuJeu[1000];

    JeuIntialiser(elementsDuJeu,nbrDasteroids);
    while(continuerAjouer)
    {
        JeuDessinerLeJeu(*elementsDuJeu,angleVaisseauX,angleVaisseauY,angleVaisseauZ);
        JeuPasserUnTour(elementsDuJeu,vitesseXVaisseau,vitesseYVaisseau,vitesseZVaisseau);
        JeuQueFaire(pointeurSurContiuerAjouer, event, &vitesseXVaisseau, &vitesseYVaisseau, &vitesseZVaisseau);
    }
    SDL_ShowCursor(SDL_ENABLE);
}

void JeuPasserUnTour(ElementDuJeu * elements[1000],double vitesseXVaisseau,double vitesseYVaisseau,double vitesseZVaisseau)
{
    SDL_Delay(50);
    static double vecteurVaisseauX=-(vitesseXVaisseau);
    static double vecteurVaisseauY=-(vitesseYVaisseau);
    static double vecteurVaisseauZ=-(vitesseZVaisseau);

    elements[0]->x+=vecteurVaisseauX;
    elements[0]->y+=vecteurVaisseauY;
    elements[0]->z+=vecteurVaisseauZ;
}
void JeuQueFaire(bool * jouer,SDL_Event event,double *vitesseXVaisseau,double *vitesseYVaisseau,double *vitesseZVaisseau)
{
    while (SDL_PollEvent(&event))
    {
        switch(event.type)
        {
            case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                *jouer=false;
                break;

                case SDLK_UP:
                *vitesseXVaisseau+=5;
                break;

                default:
                break;
            }
            break;

            case SDL_MOUSEMOTION:
            {
                if(event.motion.x>100)
                {
                    *vitesseYVaisseau+=1;
                }
                else
                {
                    *vitesseYVaisseau-=1;
                }
                SDL_WarpMouse(100,100);
            }
            break;
        }
    }
}
void JeuIntialiser(ElementDuJeu * elements[1000],int nbrDasteroids)
{
    int i;
    ElementDuJeu lesElements[1000];
    elements[1000] = &lesElements[1000];

    elements[0]->nom=SHIP;
    elements[0]->alive=true;
    elements[0]->pointsDeVie=100;
    elements[0]->x=1000;
    elements[0]->y=0;
    elements[0]->z=0;
    elements[0]->rayon=0.5;
    for(i=1; i<nbrDasteroids; i++)
    {
        lesElements[i].nom=ASTEROID;
        lesElements[i].alive=true;
        lesElements[i].pointsDeVie=150;
        lesElements[i].x=Hasard(-5000.0,5000.0);
        lesElements[i].y=Hasard(-5000.0,5000.0);
        lesElements[i].z=Hasard(-5000.0,5000.0);
        lesElements[i].rayon=0.5;
    }
    i++;
    lesElements[i].nom=BONUS;
    lesElements[i].alive=true;
    lesElements[i].pointsDeVie=1;
    lesElements[i].x=Hasard(-1000.0,1000.0);
    lesElements[i].y=Hasard(-1000.0,1000.0);
    lesElements[i].z=Hasard(-1000.0,1000.0);
    lesElements[i].rayon=0.1;

    JeuAfficherEtoiles(1);
}

double Hasard(double min, double max)
{
    return (double) (min + ((double) rand() / RAND_MAX * (max - min + 1)));
}

jeuAffichage.h:

void JeuAfficherVaisseau(double x, double y, double z, double angleX, double angleY, double angleZ);
void JeuAfficherEtoiles(int init);

jeuAffichage.cpp:

#include <SDL/SDL.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include <cstdlib>
#include <time.h>
#include "jeu.h"
#include "jeuAffichage.h"

void JeuDessinerLeJeu(ElementDuJeu elements[1000],double angleVaisseauX,double angleVaisseauY ,double angleVaisseauZ)
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );

    gluLookAt(elements[0].x+4,elements[0].y-4,elements[0].z+4,elements[0].x,elements[0].y,elements[0].z-1,1,-1,1);

    glBegin(GL_TRIANGLES);

    JeuAfficherVaisseau(elements[0].x,elements[0].y,elements[0].z,angleVaisseauX,angleVaisseauY,angleVaisseauZ);

    glEnd();

    glBegin(GL_POINTS);

    JeuAfficherEtoiles(0);

    glEnd();

    glFlush();
    SDL_GL_SwapBuffers();
}

void JeuAfficherVaisseau(double x, double y, double z, double angleX, double angleY, double angleZ)
{
    glColor3ub(50,50,50);
    glVertex3d(x+0.5,y+0.5,z+0.5);
    glVertex3d(x-0.125,y-0.125,z+0.5);
    glVertex3d(x-0.125,y+0.5,z-0.125);// une de faces...

    glColor3ub(60,60,60);
    glVertex3d(x+0.5,y+0.5,z+0.5);
    glVertex3d(x-0.125,y-0.125,z+0.5);
    glVertex3d(x+0.5,y-0.125,z-0.125);// une de faces...

    glColor3ub(70,70,70);
    glVertex3d(x+0.5,y+0.5,z+0.5);
    glVertex3d(x-0.125,y+0.5,z-0.125);
    glVertex3d(x+0.5,y-0.125,z-0.125);

    glColor3ub(80,80,80);
    glVertex3d(x-0.125,y+0.5,z-0.125);
    glVertex3d(x+0.5,y-0.125,z-0.125);
    glVertex3d(x-0.125,y-0.125,z+0.5);// une de faces...
}

void JeuAfficherEtoiles(int init)
{
    int i=0;
    static ElementDuJeu etoiles[100000];
    if(init)
    {
        for (i=0; i<100000 ;i++)
        {
            etoiles[i].x=Hasard(-5000.0,5000.0);
            etoiles[i].y=Hasard(-5000.0,5000.0);
            etoiles[i].z=Hasard(-5000.0,5000.0);
        }
        glPointSize(2);
    }
    else
    {
        glColor3ub(255,255,255);

        for (i=0; i<100000;i++)
        {
            glVertex3d(etoiles[i].x,etoiles[i].y,etoiles[i].z);
        }
    }
}

voila alors tout d'abord, bravo a ceux qui ont tout lus.

les problemes:
-quand je compile et que je vai dans la fonction JeuDessinerLeJeu(); le programme se ferme brutalement et code blocks me dit :"Process terminated with status -1 (0 minutes, 6 seconds)"

quand j'execute le code pour charger une texture donné par kayl, j'ai la meme erreur.

si vous avez lu mon code, vous avez vu que j'ai éssayé du faire que bouger la souris a gauche ou a droite décale le vaisseau. ça ne marche pas, le vaisseau reste immobile.

je pense qu'une mauvaise utilisation des pointeurs sur tableau de structure de ma part cause un dépassement de mémoire.

Si vous avez des idée pour le fonctionnement du control du vaisseau a la souris, dite le moi.

Merci de m'avoir lu.

Gaspar

que dit ton debuggueur ?

mon débugger ne dit rien, il compile sans probleme, je crois que c'est linux qui tue mon programme quand il fait un dépassement de mémoire, j'ai éssayé de mettre en commentaire certaine lignes de la fonction JeuDessinerLeJeu(); mais ça ne marche touours pas...

debuggueur != compilateur

oui je sais mais si le débuggeur dit quelque chose, la compilation est arretée. La il compile sans broncher.

Ben non, tu ne sais pas !

Le compilateur, ça compile, et si il y a un warning, il te le dit, si il y a une erreur, il s'arrete. Ensuite, il link et pond l'executable, que tu peux lancer.

Le debuggueur est un outil qui permet - PENDANT L'EXECUTION - d'arreter l'execution si l'utilisateur le demande, et de dire ou ça s'est arrété, et de te dire quelle est la valeur de chaque variable au moment ou ça a planté.

Tu n'utilises pas le debuggueur, alors ne me dis pas "je sais", puisque visiblement tu sais pas ce que c'est.

Ca ne sera pas facile de trouver l'erreur; essaye de commenter le contenu de JeuDessinerLeJeu(); pour voir si ca marche (et de décommenter petit à petit).

Ceci dit, le fonctionnement de ta méthode est fondamentalement faux... Tu as lu les tuto de Kayl ? Tu as zapé le cours sur les matrices ou quoi ?

Tu calculs les positions du sommets du vaisseau à chaque fois que tu veux le dessiner... t'es pas malade ? Tu te rends compte si on devait faire des opérations sur TOUT les sommets quand on a plusieurs millier de façes ?
Alors oui, le calcul doit être fait... mais si il est dans ton code, c'est le CPU qui s'en charge.

Si tu utilise les matrices, et donc OpenGL, se sera le GPU qui fera les calculs (faut bien que la carte graphique serve à quelque chose).

Pour faire déplacer ton vaisseau de 5 unités vers X.
Au lieu de faire des glVertex(5+x, y, z); ...

Il faut faire:
glTranslate(5, 0, 0); // tous les points suivants seront décalés de 5 unité sur l'axe 5
glvertex(x, y, z);
...


Pour ce qui est de la boucle principale... c'est une horreur aussi !!

Déjà la boucle for(;;)
replace là par un while(booléen) (et tu passes le bouléen à false quand on ferme le programme, plutôt qu'un exit(0);

En effet, quand tu aurra chargé des textures, modèles 3D etc... il faudra penser à les supprimer quand on fermera le programme (donc apres la boucle "infinie"), ce que ne fera pas un exit(0);



Ensuite cette boucle "infinie"... chaque itération doit correspondre à une image (et une seule).
Si je dis ça, c'est en pensant aux "DessinMenu(angleX,angleZ,angleY)" etc...

En effet, avec cette méthode (avec des sleep :s ) il va se passer quelques secondes où seulement une seule animation sera produite...
Et si on veux afficher deux animations en même temps ? Et si on a besoin d'afficher le monde 3D en même temps ? et en temps réel ?

Pour faire des animations il faut:
- savoir quelles animations doivent être jouées
- connaitre le temps sur laquelle l'animation doit être jouée (1 secondes, 2 secondes ?)
- connaitre le temps écoulé entre 2 images pour pouvoir divisé le mouvement en plusieurs étapes (assez d'étapes pour que l'animation se déroule pendant x secondes )

On évite ainsi:
- les sleep
- un affichage limité à une seule chose

On gagne:
- en fluidité (l'animation est découpée en de nombreuses images)

Exemple:

void AfficherMenu(float elapsed_time);

void main()
{
     float last_time = SDL_GetTicks();
     float current_time, elapsed_time;

     bool run = true;
     while(run)
     { 
          // On récupère le temps écoulés entre 2 images dans la variable ellapsed_time;
          current_time = SDL_GetTicks();
          elapsed_time = current_time - last_time;
          last_time = current_time;

          // Mise à jour des évènements
          SDL_Event event;
          while(SDL_PollEvent(&event)
          {
                // traitements...
                // Exemple: si on veux jouer une animation quand on appuis sur la touche A:
                case SDLK_a:
                    MenuJouerAnimationA(); // on va indiquer qu'une animation doit être jouée
                    break;
           
          }

          // Affichage
          InitialisationImage();
          AfficherLaScene3D(elapsed_time);
          ResetDuZBuffer();
          AfficherMenu(elapsed_time);    // on fera un blendin au cas où so l'interface doit être tansparante pour voire la scène

          SDL_GL_SwapBuffers(); // on basule notre image UNE SEULE FOIS
     }
}

void AfficherMenu(float elapsed_time)
{
     float temps_animationA = 2000; // 2000 millisecondes = 2 secondes
     float temps_animationA_en_cours = 0; // pour savoir où en est l'animation
     float angle; // l'angle pour nos menu

     if(JouerAnimationA() ) // si on doit jouer l'animation A
     {

          // Si l'animation a finis de se jouer, il faut la couper
          if ( temps_animationA_en_cours >= temps_animationA) {
               TerminerAnimationA();
          }

          // on calcul le pourcentage de l'animation effectué pour trouver l'angle à utilser (angle variant de 200 à 0)

          float pourcentage = temps_animationA_en_cours * 100 / temps_animationA;
          angle = 200-(pourcentage * 200 / 100);

          DessinMenu(angle);

          temps_animationA_en_cours += elapsed_time; // on met à jours le temps d'animation écoulé
     }

     ...
}

désolé fvirtman je me suis trompé . L'onglet débugger est vide, mais l'onglet build log contient ça :
""
Checking for existence: /home/gaspar/Prog/Tetra/bin/Debug/Tetra
Executing: /home/gaspar/Prog/Tetra/bin/Debug/Tetra (in /home/gaspar/Prog/Tetra/bin/Debug)
Process terminated with status -1 (0 minutes, 7 seconds)
""
"7 seconds" c'est le temps que j'ai mit avant de demander (depuis mon menu) a jouer et c'est la que le programme s'arrete.
"status -1" sa veut dire quelque chose de précis ??(a part qu'il y a eu un probleme)

Merci sebajuste de m'avoir lu, pour le sleep, j'ai pas encore remplacé par ta technique(que j'ai déja mise dans le menu) mais je compte le faire, pour les matrices, je vais remplacer tout ça, merci

Par contre, mon menu est en fait un gros cube et sur chaque face, on trouve des options, et les animations sont des rotations pour passer d'une face a l'autre. on ne fait jamais plus d'une animation a la fois et l'utilisateur n'est pas sensé cliquer sur des bouton pendant que le cube tourne.

pour le exit(0); sa simplifie quand même le code, je veu bien quitter de maniere plus conventionnelle, mais sa changera quoi?

Sinon, j'ai déjà essayer de commenter et décommenter les lignes de JeuDessinerLeJeu(); mais ça ne marche que quand tout est en commentaire, je crois que je m'embrouille un peu sur les tableaux de pointeur sur structure, surtout quand en relisant le cours j'ai vu que les tableaux était des pointeurs. j'ai meme éssayer de faire un int qui contiendrai une adresse(celle du début de mon tableau), une sorte de pointeur mais pas déclaré comme un pointeur mais il voulait pas aller a l'adresse contenue dans cet int parce que c'est pas un vrai pointeur.

Pour lancer le debugger, sur Code::Blocks, c'est la touche F8 par défaut.


Sinon, je ne comprends pas... Pourquoi utilise tu un tableau[1000] alors que tu n'utilise que l'index [0] ??
Pourquoi un tableau ?


Pour le exit(0), il faut bien comprendre que ca va killer ton programme... que vont devenir les pointeurs où la mémoire a été allouée ?
Que vont devenir les textures chargées dans la carte graphique ?

Ça va être au système d'exploitation de faire le ménage, car tu ne l'aura pas fait toi même.
Et si pour X raison, ce ménage ne se fait pas (ou mal... par exemple au mauvais vidage automatique des VBO chargés sur la carte graphique, ou des textures, ou quoique ce soit d'autre) tu risques un plantage complet de ta machine.

en fait, j'avai prévu de faire un tableau[1000] pour stocker tout les éléments du jeu( le vaisseau, les astéroides, les bonus a atraper, peut etre les méchants) mais pour l'instant, j'éssaye déja d'y stocker le vaisseau spatial(ou pluto sa vie, sa position et tout le reste)
Quand tout ça marchera, je ferai une allocation dynamique pour prendre seulement ce dont j'ai besoin.

édit :J'ai lancé le débugger, quand je demande a jouer,le programme c'est bloqué et comme je suis en fullscreen et que je connais pas le raccourcis qui revient au bureau sous linux, je sui forcé d'éteindre l'ordi puis de le redémarer ...
je vai tester sans le fullscreen

edit :quand je lance le débuggeur, (j'ai mis le programe sans fullscreen, dans une fenetre de 200 px sur 200px),
une boite de dialogue me dit "Program received signal SIGSEGV, Segmentation fault.
Do you want to view the backtrace?"
quand je demande a voir le "backtrace", il me dit qu'il a recçu le signal a la ligne 55 de main.cpp

Do you want to view the backtrace?"

Là tu fais "oui", et avec un peu de chance, il va t'indiquer les différents appel de fonctions, jusqu'à celle qui fait planter.

Segmentation fault => ton programme essaye d'accéder à une zone mémoire qui n'a pas été allouée.
Donc oui, ton problème vient de tes pointeurs.

Si c'est pour stocker tes objets, je te conseil de passer plutôt par un std::vector pour plusieurs raisons:
- Pas de tableau, moins de pointeurs (tu peux toujours faire un vector de pointeur, mais tu évite grandement les erreurs de toute façon)
- le vector s'adapte a tes besoins: il s'agrandi (par liste chainée) quand tu as besoin d'ajouter des éléments (pas d'allocation à faire)

Des infos ici:
http://cpp.developpez.com/faq/cpp/?page=STL

Ça devrait corriger ton problème.


Edit: pour le debugger, il faut arrêter le programme (avec l'icône en forme stop rouge, avec une croix blanche à l'intérieur). Car même après avoir planté, le programme est toujours en route.

merci pour ton aide. Mon programme est en fullscreen donc quand il se bloque, il faut retourner au bureau et je sais pas comment faire sous linux. j'ai un peu regardé dans l'aide de KDE mais j'ai pas trouver l'équivalent du bon vieu "ctrl+alt+suppr" de windows.quand je regarde le backtrace, il me dit qu'il y a un probleme quand je veux voir la meilleur résolution pour mon jeu.(cette ligne n'a jammai posé probleme avant)

Je suis en train de regarder ton lien, j'ai du boulot ! je m'y met et je revien quand j'ai lu tout ça.
encore merci

Évites le fullscreen quand tu prog. C'est plus qu'un conseil

j'ai mis mon prog dans une petite fenetre et j'ai lancé le débugger, quand j'arrive a la fonction jouer(), comme prévu, sa bug et il me dit"Program received signal SIGSEGV, Segmentation fault.
In ?? () (/usr/lib/libGLcore.so.1)"

mais "libGLcore.so.1" c'est la librairie de OpenGL non? le coeur de opengl, d'après le nom meme. Si C'est opengl qui beug, je suis coincé non?

(a moin de reprogrammé opengl )

edit: je suis pas sur d'avoir bien compris, vector c'est une sorte de super-tableau amélioré?

si une fonction d'OpenGL foire, c'est que tu lui as envoyé un parametre pourri
OpenGL a fait ses preuves, ça vient forcément de toi

Oui, le type de paramètre est valide, donc OpenGL le prend... mais le contenu est erroné, et OpenGL plante son calcul.
Le problème vient don bien de ton programme

daccord mais comment trouver quel parametre pourri je lui enoie? si le débuggeur peut pas, il va falloir que je teste toute les fonction utilisant opengl de mon programme?? je peux réduire le champ de recherche a la fonction jeuDessinerLeJeu() mais j'ai déja fait tout pleins de test sur cette fonction. Je pense que mes pointeurs sur la premiere case du tableau de structure est pourri mais la question est Pourquoi?

Salut,

bah, tu plantes un point d'arret au debut de la fonction ou tu penses que ca plante, et tu step in au fur et à mesure en regardant tes variables (locals et globales si necessaires).