Discussion :

[KevinduC]

Bonjour à tous, je suis nouveau sur ce forum je programme en langage C depuis plusieurs années et je crée depuis plus d'un an un jeu en 3D grâce à la SDL et OpenGL, ce jeu est censé être un jeu de voiture de type course libre mais avec des modes comme chauffeur de bus ou ambulancier.
Je viens de passer de XP 32 bits à Windows 8 64 bits et après avoir compilé mon jeu sous Code::Blocks (J'utilisais Dev-C++ jusqu'à présent mais je n'arrive pas à compiler sous Windows 8), je l'execute et constate que celui-ci est très lent. Si je désactive l'affichage de la plupart du décor (Pour ne garder que le sol par exemple), le jeu ne rame plus et est même trop rapide, au fur et à mesure que je réactive l'affichage des éléments du décor, le jeu rame de plus en plus.
Pour info j'avais jusqu'à présent un PC fixe avec carte mère Asus, processeur Intel Pentium 4 2,8 GHz, 1Go de RAM et carte graphique NVidia GeForce ; je suis désormais sur un HP Pavilion G6 avec processeur AMD E2-1800 APU 1,7GHz, 4Go de RAM et carte graphique AMD Radeon HD 7340G, donc bien plus performant
Ce serait trop long de poster mon code mais en gros j'utilise une boucle principale qui gère les évènements SDL et appelle une fonction Dessiner(), cette fonction appelle glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT), glMatrixMode(GL_MODELVIEW) et glLoadIdentity(), place la caméra et dessine les éléments du décor grâce à des fonctions ayant chacune son rôle. Par exemple la fonction Route() va dessiner les routes en parcourant un tableau de structures de type défini contenant entre autres les coordonnées de la route, son orientation, ses dimensions, sa texture ... J'ai donc des while dans des while et c'est sans doute ce qui contribue à ralentir le jeu.
Merci de m'avoir lu et si quelqu'un a une idée pour palier à ce problème je suis preneur car j'aurais du mal à admettre que mon jeu est trop lourd pour un PC flambant neuf équipé d'un processeur double coeur et de 4 fois plus de RAM que son prédécesseur

[Neckara]

Bonjour,

Je pense qu'une partie du problème vient du système d'exploitation, en effet, je pense que Windows XP est bien moins "gourmand" que les dernières versions de Windows.
De plus un Windows sur deux étant une version non-finie du Windows suivant...

Déjà, je te conseillerais d'installer Windows XP en dual boot afin de tester ton jeu et de voir la différence même si ce ne doit pas être la seule raison de ce ralentissement.

Après, il y a d'autres facteurs comme :
- les mémoires caches des composants ;
- le disque dur pour la mémoire SWAP (vitesse de rotation, ...).
- le fait d'être en 64 bits (légèrement plus lent que du 32 bits si on utilise peu de mémoire) mais je pense que c'est presque insignifiant ;

Je suis très loin d'être un spécialiste en matériel, mais il y a plein de paramètres à regarder pour voir précisément les performances.
Par exemple, avoir un RAM de 8 Go pourrait être, dans certaines circonstances, moins "performant" qu'une RAM à 6Go mais qui aurait une fréquence bien plus élevée.


Ensuite, il y a peut-être un problème avec le driver OpenGL ? (ancienne version ou autre). Je ne sais pas s'il est possible de vérifier si les calculs sont bien fait sur la carte graphique mais ce serait intéressant de regarder ça.

[KevinduC]

- les mémoires caches des composants ;
- le disque dur pour la mémoire SWAP (vitesse de rotation, ...).
- le fait d'être en 64 bits (légèrement plus lent que du 32 bits si on utilise peu de mémoire) mais je pense que c'est presque insignifiant

Je connais pas tous ces facteurs malheureusement, sinon j'ai l'impression que le problème vient de la carte graphique car à chaque fois que la caméra se déplace, on dirait que le sol "vibre", comme un défaut d'affichage

[KevinduC]

Je viens de faire une mise à jour des pilotes graphiques et ça a rien donné

[imperio]

Il y a pleins de parametres qui rentrent en jeu, le systeme d'exploitation seul ne peut etre tout le probleme je pense.

Bonjour,

Je pense qu'une partie du problème vient du système d'exploitation, en effet, je pense que Windows XP est bien moins "gourmand" que les dernières versions de Windows.
De plus un Windows sur deux étant une version non-finie du Windows suivant...

Déjà, je te conseillerais d'installer Windows XP en dual boot afin de tester ton jeu et de voir la différence même si ce ne doit pas être la seule raison de ce ralentissement.

Je fais mes developpements 3D sous win8 et je n'ai aucune difference notable de performance en comparaison avec win XP. Apres je ne pense pas que ce soit assez pousse mais j'aurais tendance a penser que c'est sous win8 que ca s'execute le plus rapidement d'apres les tests que j'ai fait (sur le meme pc bien entendu pour ne pas trop fausser les resultats).

Il y a pas mal de pistes pour ameliorer la vitesse du rendu. Quelques-unes sont disponibles dans la FAQ a cette adresse.

Sinon si tu utilises les vieilles methodes de rendu (c'est-a-dire sans display list ni rien), saches qu'il en existe d'autres comme les VBO (vertex buffer object). A ces methodes tu peux coupler encore d'autres choses comme seulement afficher les objets "visibles", afficher tous les objets "statiques" d'un seul coup grace a un seul buffer, etc...

Comme tu peux le voir, les pistes d'amelioration sont multiples. Si tu nous montrais un peu de code nous serions plus a meme de t'aider.

[KevinduC]

Merci pour ta réponse, pour info j'ai demandé conseil à un collègue qui m'a demandé de vérifier si l'accélération matérielle était activée et il s'est avéré que c'était le cas. Sinon je me demande si le jeu n'est pas plutôt saccadé, il serait aussi rapide que sur mon ancien PC mais la fréquence d'affichage serait plus basse. Pour mon code, je poste une partie :

Le main simplifié :

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
311
312
313
314
315
316
 
int main(int argc,char *argv[])
{
 
    /*Déclaration des *SDL_Surface pour le menu principal*/
 
    double angleXrad,vitesse=0,ROTAT=MINROTAT;
    bool hautEnfonce=0,basEnfonce=0;
    bool tourneDroite=0,tourneGauche=0;
    donnees Donnees;           //La structure Donnees contient toutes les infos nécessaires à la fonction Dessiner()
    Donnees.tempsPrecedent=0;  //Initialisations
    Donnees.vue=0;
    Donnees.angleVueExt=0;
    Donnees.distVoitureCam=0;
    Donnees.htObj=0;
    Donnees.htCamExt=0
    Donnees.angleVoiture=Donnees.angleCam;
    Donnees.y=-1.5;
    Donnees.objX=Donnees.x;
    Donnees.objZ=Donnees.z-900;
 
    if(SDL_Init(SDL_INIT_VIDEO)==-1)    //En cas d'erreur on écrit dans stderr.txt
    {
        fprintf(stderr,"Erreur d'initialisation de la SDL");
        exit(EXIT_FAILURE);
    }
 
    /*Je zappe l'affichage du menu principal*/
 
    ecran=SDL_SetVideoMode(800,600,32,SDL_OPENGL);
 
    if(ecran==NULL)    //En cas d'erreur on écrit dans stderr.txt
    {
        fprintf(stderr,"Impossible d'initialiser le mode vidéo");
        exit(EXIT_FAILURE);
    }
 
    SDL_EnableKeyRepeat(10,10);                        //Execution touche maintenue enfoncée
    glLoadIdentity();                                     //Initialisation matrice
    glMatrixMode(GL_PROJECTION);
    gluPerspective(70,(double)800/600,0.3,30000);            //Perspective comme mode de projection (Angle, ratio, near, far)
 
    glEnable(GL_DEPTH_TEST);                              //Z Buffer pour afficher correctement les pixels selon la profondeur
    glEnable(GL_TEXTURE_2D);
 
    ChargeTextures(&Donnees);				//Chargement textures
    ChargeFichiers(&Donnees,Troncon);			//Chargement des données contenues dans les fichiers .txt
 
    while(1)						//Boucle principale
    {
        angleXrad=(Donnees.angleVoiture)*M_PI/180;     //Conversion en radians de l'orientation du véhicule
        SDL_PollEvent(&event);				//Gestion des évènements SDL
        if(event.type==SDL_QUIT)                     //Clic sur la croix
            break;
        if(event.type==SDL_KEYDOWN)
        {
            if(event.key.keysym.sym==SDLK_UP)        //Déplacement dans le décor
            {
                hautEnfonce=1;
                basEnfonce=0;
            }
            if(event.key.keysym.sym==SDLK_DOWN)
            {
                hautEnfonce=0;
                basEnfonce=1;
            }
            if(event.key.keysym.sym==SDLK_RIGHT)
            {
                tourneDroite=1;
                tourneGauche=0;
            }
            if(event.key.keysym.sym==SDLK_LEFT)
            {
                tourneDroite=0;
                tourneGauche=1;
            }
        }
 
        if(event.type==SDL_KEYUP)
        {
            if(event.key.keysym.sym==SDLK_UP)
            {
                hautEnfonce=0;
            }
            if(event.key.keysym.sym==SDLK_DOWN)
            {
                basEnfonce=0;
            }
            if(event.key.keysym.sym==SDLK_RIGHT)
            {
                ROTAT=MINROTAT;
                tourneDroite=0;
            }
            if(event.key.keysym.sym==SDLK_LEFT)
            {
                ROTAT=MINROTAT;
                tourneGauche=0;
            }
        }
 
        if(hautEnfonce==1&&basEnfonce==0)         //Touche du haut enfoncée
        {
            if(vitesse<Vmax[Vehicule])		//Accélération
                vitesse+=Accel[Vehicule];
            if(vitesse<0)			//Freinage en marche arroère
                vitesse+=0.005;
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==0&&basEnfonce==1)         //Touche du bas enfoncée
        {
            if(vitesse>-Vmax[Vehicule])
                vitesse-=Accel[Vehicule];
            if(vitesse>0)
                vitesse-=0.005;
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==0&&basEnfonce==0&&vitesse!=0) //Touches du haut et du bas relachées
        {
            if(vitesse>0)               //Entrain d'avancer
                vitesse-=Accel[Vehicule];
            if(vitesse<0)               //Entrain de reculer
                vitesse+=Accel[Vehicule];
            if(100*fabs(vitesse)<1)     //Vitesse ramenée à 0 si très proche de 0
                vitesse=0;
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==1&&tourneDroite==1)         //Touche du haut enfoncée et tourne à droite
        {
            Donnees.angleCam+=ROTAT;
            Donnees.angleVoiture+=ROTAT;
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT+=DECALROTAT;
 
            if(vitesse<Vmax[Vehicule])
                vitesse+=Accel[Vehicule];
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==1&&tourneGauche==1)         //Touche du haut enfoncée et tourne à gauche
        {
            Donnees.angleCam-=ROTAT;
            Donnees.angleVoiture-=ROTAT;
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT+=DECALROTAT;
 
            if(vitesse<Vmax[Vehicule])
                vitesse+=Accel[Vehicule];
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(basEnfonce==1&&tourneDroite==1)         //Touche du bas enfoncée et tourne à droite
        {
            if(vitesse>0)
            {
                Donnees.angleCam+=ROTAT;
                Donnees.angleVoiture+=ROTAT;
            }
            if(vitesse<0)
            {
                Donnees.angleCam-=ROTAT;
                Donnees.angleVoiture-=ROTAT;
            }
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT+=DECALROTAT;
 
            if(vitesse>-Vmax[Vehicule])
                vitesse-=Accel[Vehicule];
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(basEnfonce==1&&tourneGauche==1)         //Touche du bas enfoncée et tourne à gauche
        {
            if(vitesse>0)
            {
                Donnees.angleCam-=ROTAT;
                Donnees.angleVoiture-=ROTAT;
            }
            if(vitesse<0)
            {
                Donnees.angleCam+=ROTAT;
                Donnees.angleVoiture+=ROTAT;
            }
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT+=DECALROTAT;
 
            if(vitesse>-Vmax[Vehicule])
                vitesse-=Accel[Vehicule];
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==0&&basEnfonce==0&&tourneDroite==1&&vitesse!=0)         //Touches relachées, tourne à droite
        {
            if(vitesse>0)
            {
                Donnees.angleCam+=ROTAT;
                Donnees.angleVoiture+=ROTAT;
            }
            if(vitesse<0)
            {
                Donnees.angleCam-=ROTAT;
                Donnees.angleVoiture-=ROTAT;
            }
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT+=DECALROTAT;
 
            if(vitesse>0)          //Entrain d'avancer
                vitesse-=0.0001;
            if(vitesse<0)          //Entrain de reculer
                vitesse+=0.0001;
            if(100*fabs(vitesse)<1)
                vitesse=0;
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
        if(hautEnfonce==0&&basEnfonce==0&&tourneGauche==1&&vitesse!=0)         //Touches relachées, tourne à gauche
        {
            if(vitesse>0)
            {
                Donnees.angleCam+=ROTAT;
                Donnees.angleVoiture+=ROTAT;
            }
            if(vitesse<0)
            {
                Donnees.angleCam-=ROTAT;
                Donnees.angleVoiture-=ROTAT;
            }
            if(Donnees.angleCam<0)
                Donnees.angleCam+=360;
            if(Donnees.angleVoiture<0)
                Donnees.angleVoiture+=360;
            if(Donnees.angleCam>=360)
                Donnees.angleCam-=360;
            if(Donnees.angleVoiture>=360)
                Donnees.angleVoiture-=360;
            if(ROTAT<MAXROTAT)
                ROTAT-=DECALROTAT;
 
            if(vitesse>0)          //Entrain d'avancer
                vitesse-=0.0001;
            if(vitesse<0)          //Entrain de reculer
                vitesse+=0.0001;
            if(100*fabs(vitesse)<1)
                vitesse=0;
            Donnees.z-=vitesse*cos(angleXrad);
            Donnees.x-=vitesse*sin(angleXrad);
            Donnees.objZ-=vitesse*cos(angleXrad);
            Donnees.objX-=vitesse*sin(angleXrad);
        }
 
        Dessiner(&Donnees);
 
        glFlush();                             //Mise à jour
        SDL_GL_SwapBuffers();
    }
    SDL_Quit();
    return 0;
}

La fonction Dessiner() :

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
 
void Dessiner(donnees *ptr)
{
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(ptr->x,ptr->z,ptr->y,ptr->objX,ptr->objZ,ptr->y+0.5,0,0,1);
    glTranslated(ptr->x,ptr->z,ptr->y);          //L'orientation de la caméra est mal codée, c'est en fait le décor qui pivote et non la caméra
    glRotated(ptr->angleCam,0,0,1);
    glTranslated(-ptr->x,-ptr->z,-ptr->y);
 
    Surface(ptr->textures[0],0,3000,0,0,3000,0,3000,3000,30000,10000,-2,30000,-30000,-2,-25000,-30000,-2,-25000,10000,-2);  //Dessin sol
    Route(ptr->textures,ptr->Les_Routes);      //Dessin des routes
    /*ect*/
}

La fonction Routes() :

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
 
void Route(GLuint textures[MAXTEX],route Valeurs[MAXROUTE])       Valeurs[] est un tableau de structures de type route
{
    int numtex,i=0;
    double absc,ord,haut,rotate,lg,deniv,largeurdeb,largeurfin;
    while(1)
    {
        absc=Valeurs[i].x;
        ord=Valeurs[i].z;
        haut=Valeurs[i].y;
        rotate=Valeurs[i].angle;
        lg=Valeurs[i].lg;
        deniv=Valeurs[i].deniv;
        numtex=Valeurs[i].numtex;
        largeurdeb=Valeurs[i].largeur1;
        largeurfin=Valeurs[i].largeur2;
        i++;
        if(i==MAXROUTE)                      //Une fois le tableau parcouru on quitte la boucle
            break;
        glPushMatrix();
        glTranslated(absc,ord,haut);
        glRotated(rotate,0,0,1);               //Le repère est positionné et orienté
        glBindTexture(GL_TEXTURE_2D,textures[numtex]);
        glBegin(GL_QUADS);                    //Dessin de la route en fonction des dimensions et du dénivelé
        glTexCoord2i(0,0);            glVertex3d(0,0,0);
        glTexCoord2i(1,0);            glVertex3d(0,-largeurdeb,0);
        glTexCoord2i(1,(int)lg/10);   glVertex3d(lg,(-largeurfin-largeurdeb)/2,deniv);
        glTexCoord2i(0,(int)lg/10);   glVertex3d(lg,(largeurfin-largeurdeb)/2,deniv);
        glEnd();
        glPopMatrix();
    }
}

Merci beaucoup pour l'aide