Programme lent sous Windows 8

**KevinduC** · 11/08/2013, 19h23

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** · 11/08/2013, 19h55

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** · 11/08/2013, 20h58

Envoyé par Neckara

- 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** · 11/08/2013, 23h08

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

**imperio** · 12/08/2013, 02h21

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** · 12/08/2013, 05h20

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

**Kannagi** · 12/08/2013, 09h29

Tu utilise les glbegin c'est plutôt lent utilise les vertex array ou vbo a la place comme rendu et glBindTexture sur chaque triangle c'est assez long aussi ,mais je ne pense pas que ça soit le problème vu que en fait j'ai eu le même souci avec un ami , mon jeu en 3D tourne sans probleme sur un eeepc qui possède pas de carte graphique (un chipset intel) mais qui est terriblement lent sur un windows 8 avec du bon matos a rien comprendre , mais j'ai pas pu faire plus de test pour voir ce qui ralentissait le programme.

**LittleWhite** · 12/08/2013, 11h30

Bonjour,

Il est clair que l'utilisation du pipeline fixe (une explication ici : http://alexandre-laurent.developpez....=page_1#L1-A-1 ) soit overkill pour votre application.
En effet, les fonctions OpenGL 1 ont été dépréciées et supprimées dans les dernières versions d'OpenGL (à partir de la version 3.3). D'ailleurs, avec OpenGL 3.3, GLU disparaît aussi. Vu qu'elles sont dépréciés et que l'architecture des cartes graphiques a complètement changé depuis, il est certain que les performances vont diminuer et même, que le support va disparaître.

Il faut aussi savoir, que la communication CPU -> GPU est un des goulot d'étranglement pour toute application (oui, cela a un coût de transférer les données de l'un vers l'autre) et c'est un truc ce genre d'opérations que vous faites un part un. Depuis longtemps, OpenGL tend à regrouper les transferts pour faire bloc par bloc et cela s'appelle les Vertex Buffer Object (VBO) : http://raptor.developpez.com/tutorial/opengl/vbo/

Le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
        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);

C'est huit transfert (et encore, je ne parle pas de la boucle autour). Alors qu'utiliser le VBO, c'est un transfert unique pour toute la géométrie. Même encore mieux, vous pouvez même faire en sorte de transférer votre route qu'une seule fois par carte (au chargement) et alors là, vous gagnez énormément de performances (bon, la vérité, c'est que cela ne marche que si la route ne possède pas trop de polygones).

J'avoue, passer son code en OpenGL 3/4 possède un énorme coût, mais il reste que c'est une chose nécessaire, apportant de nombreux avantages et permettant de ce mettre à niveau avec l'actualité des cartes graphiques.

De plus, il faudrait compter le nombre de glVertex* que vous faites par image, ou encore, le nombre de glBegin(), vu que votre code n'est pas du tout optimisé dans les opérations OpenGL (en effet :

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
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();
    }

On peut imaginer des améliorations en calculant qu'une seule et unique fois la position réelle du segment de la route, au lieu de la faire recalculer à OpenGL en utilisant sa matrice de modèle.

Le nombre d'appel à glVertex* doit être énorme (> 100 000 ?) dans votre programme, ce qui doit réellement causé soucis.
Même si une carte graphique peut facilement tracé plus de 100 000 sommets, l'utilisation overkill de glVertex* fait que les performances ne sont pas au rendez-vous.

Finalement, l'utilisation d'un frustrum culling (technique pour ne pas chercher à afficher les choses qui ne sont pas à l'écran), sera dans tous les cas, bénéfiques.

J'ai donc des while dans des while et c'est sans doute ce qui contribue à ralentir le jeu.

J'ose croire qu'il faudra nettoyer votre code, il en a clairement besoin. Mais si vous voulez une vraie analyse des performances coté CPU, utilisez un profileur.

le jeu ne rame plus et est même trop rapide

Dans votre réorganisation, il faudra réfléchir à ce problème là, aussi, qui est de garder un nombre d'image par seconde stable, peut importe les performances du système.

Un peu de lecture s'impose :

**Kannagi** · 12/08/2013, 12h20

@LittleWhite plutôt accord mais répond t on réellement a la question ?
Il dit que son code marchait sans souci sur son ancien ordi (moins puissant) malgré qu'il faisait un rendu avec la pipeline fixe , il possède un ordi plus puissant et les performance sont super réduite.

D’après ce que tu dis , les carte graphiques récentes supporte mal opengl 1.x ? , mais bon pas sur que ici c'est un souci de sa carte graphique et non de OS enfaite s'il avait un dual boot (avec XP ou linux ) la on serait fixer je pense.

Après argument de opengl 4 est de mon point de vue médiocre très peu ordi le supporte , et niveau mobile aucun a ma connaissance , pareil pour les consoles portable (vue qu'en est dans la partie jeux vidéo autant en parlé), en faite opengl 1.x tourne sur plus ordi que opengl 4.

Après conseiller de passe direct de opengl 1.x a 3 ou 4 , c'est plutot un conseil suicidaire ? , ça se voit que tu fais pas de jeu en 3D

, je pense que remplacer petit a petit les fonction et le meilleur conseil , opengl 2 pour s'initier au shader effectivement ne plus utiliser glbegin mais c'est pas compliqué de s'en passer =P, puis quand il a compris , il remplace les fonction de glu en shader et la il sera en opengl 3.

**LittleWhite** · 12/08/2013, 12h33

Je n'ai pas conseillé de faire de l'OpenGL 4, mais de l'OpenGL 3 minimum, et surtout, ce que je conseille, c'est de supprimer le pipeline fixe.

Oui, le programme passait bien sur une NVIDIA GeForce (on ne donne ici, pas la référence, donc on ne sait pas), mais on parle de cette série : http://www.amd.com/us/products/noteb...n-7300m.aspx#2 (et encore, je trouve pas la carte précisément). Un support de OpenGL 4.1 ! Et cette page, c'est une carte pour PC portable.
Donc, il faut arrêter d'avoir peur d'OpenGL 3 (et même de OpenGL 4). Mais bon, je ne suis pas fou, je ne conseille pourtant pas la version 4, mais la version 3.

Et encore, je me cite :

J'avoue, passer son code en OpenGL 3/4 possède un énorme coût, mais il reste que c'est une chose nécessaire, apportant de nombreux avantages et permettant de ce mettre à niveau avec l'actualité des cartes graphiques.

Je connais donc la contrainte. J'ai parlé des VBO qui sont utilisable dès OpenGL 2.

Maintenant, une carte graphique OpenGL 1.x, ça n'existe plus. Tout le monde est en pipeline dynamique et maintenant, il est optimisé à mort.
Les consoles portables ne rentrent pas dans le même champ. Prenons une PS3 juste pour l'exemple. Elle a une version d'OpenGL 1 ultra modifié avec des extensions de partout, ce qui fait qu'elle n'est pas comparable.
La Nintendo DS utilise son propre système graphique. Les téléphones portables utilisent OpenGL ES 2.X (le 1 tend aussi à disparaitre). La version 2 est tout en pipeline dynamique. Et pire, si je me rappelle bien, OpenGL ES n'a jamais eu de fonctions glVertex*, c'est pour dire qu'il y a un moment, faut passer le cap.

Ce qui est plus suicidaire actuellement, c'est de continuer à faire de l'OpenGL 1.X en 2013, mais je ne suis pas fou, la transition doit se faire progressivement, mais ça, c'est du soucis du programmeur.

**Kannagi** · 12/08/2013, 12h45

Ben disons surtout que je voulais pas être Hors sujet , je le dis et je le répète le but c'est juste de savoir si c'est windows 8 ou la carte graphique qui ralentit son programme pour le moment on ne peut que supposé.

Inutile de partir sur un débat , mais juste pas partir en HS , après opengl 4 on doit le conseillé déjà si l'auteur de ce topic supporte opengl 4 avant c'est juste je que j'essayai de dire et surtout si les autres peuvent y jouer , je me rappelle que pour le dev jeux video en un week end , finalement a mon souvenir personne pouvait tester une démo en opengl 4.
Opengl 2 ou 3 no soucis pour moi.

Maintenant, une carte graphique OpenGL 1.x, ça n'existe plus.
[...]
Ce qui est plus suicidaire actuellement, c'est de continuer à faire de l'OpenGL 1.X en 2013.

Quand t'aura un ordi avec un chipset intel on en reparle

**LittleWhite** · 12/08/2013, 12h49

Sinon, en cherchant un peu sur Google, l'autre possibilité, c'est que le pilote actif est un pilote logiciel (donc tout sur le CPU).
Pour le vérifier, vous pouvez utiliser glGetString(GL_VENDOR) et si celui-ci retourne Microsoft Corporation, alors, c'est que le rendu est purement logiciel (il faudrait que ce soit AMD, dans votre cas pour que tout aille bien).
La raison de cela est que l'initialisation d'OpenGL est mal effectuée. Comme c'est la SDL qui gère, vous pouvez utiliser SDL_GL_SetAttribute pour forcer le contexte a être OpenGL > 1 afin de ne pas retomber sur le driver Microsoft (mais il faut passer à la SDL 2.0, je crois, pour cela), ou alors, ne plus ouvrir la fenêtre avec la SDL.

EDIT :

Le chipset Intel est compatible OpenGL 3 depuis peu (et OpenGL 2 depuis longtemps), miraculeusement, avec la mise à jour de Mesa en version 9 qui implémente OpenGL 3.

**dragonjoker59** · 12/08/2013, 14h57

Envoyé par Kannagi

Quand t'aura un ordi avec un chipset intel on en reparle

Les chipsets Intel supportent OpenGL 2.x donc les shaders (vertex et fragment) et il est donc possible sans soucis de se passer du pipeline fixe, de même pour les VBO.

Je suis de l'avis de Little White, les glVertex*, glBegin et glEnd c'est bien joli mais il est possible que ce ne soit pas du tout optimisé côté driver avec les cartes récentes, je pense qu'il y a de toute façon un problème de performance à cet endroit. C'est pour moi la première chose à faire : passer aux VBO (pour le pipeline fixe c'est une autre paire de manches).

Une autre chose qui me choque, c'est que dans ton main() tu calcules X fois cos(angleXrad) et sin(angleXrad). Ce sont de petites opérations qui ont malgré tout un coût pas anodin et je te conseille de stocker ces valeurs dans des variables (qui évolueront à chaque changement de angleXrad, évidemment).

Enfin, tu parles aussi d'un jeu trop rapide lorsque tu as enlevé un maximum de choses, c'est parce que tu ne fixes pas un frame rate. Tu as pour cela au moins 2 méthodes (que je connais, après il doit y en avoir d'autres) :

Dessiner sur le déclenchement d'un timer fixe
Déterminer un temps par frame (par exemple 40ms), dessiner ta frame en regardant le temps que ça prend, faire un sleep du temps restant (40 - <temps frame>)

Ca règlera au moins le problème de jeu trop rapide.

**KevinduC** · 12/08/2013, 18h46

Si j'ai bien compris vos arguments la version 1.x d'OpenGL tourne mal sur les cartes graphiques récentes (Et je dois me passer des glBegin() et tout le reste ..), pourtant j'ai testé mon programme sur le PC de mon père qui est très récent aussi et il n'y a pas de problème.

On peut imaginer des améliorations en calculant qu'une seule et unique fois la position réelle du segment de la route, au lieu de la faire recalculer à OpenGL en utilisant sa matrice de modèle

Tu veux dire avant la boucle principale ? J'y ai pensé mais vu que le décor est redessiné à chaque tour de boucle si je fais ça les routes n'apparaitront plus (J'ai testé de toute façon)

Enfin, tu parles aussi d'un jeu trop rapide lorsque tu as enlevé un maximum de choses, c'est parce que tu ne fixes pas un frame rate

Ce n'est absolument pas un problème, bien au contraire.

ce que je conseille, c'est de supprimer le pipeline fixe

Petite question : Qu'est-ce que le pipeline fixe ?

Pour finir je dirais que je trouve choquant qu'on supprime une ancienne version d'OpenGL pour ceux qui ont appris à programmer dessus, vous êtes absolument sûr que passer en version 3 résoudrait le problème ? C'est une lourde opération mais ça peut être intéressant, les shader je sais pas ce que c'est mais rien que le nom me donne envie d'en savoir plus ^^

**LittleWhite** · 12/08/2013, 18h59

Envoyé par KevinduC

Petite question : Qu'est-ce que le pipeline fixe ?

Lire un seul message sur six, c'est choquant. J'ai donné des liens dans mon message, dont ce lien là : http://alexandre-laurent.developpez....=page_1#L1-A-1

Envoyé par KevinduC

Pour finir je dirais que je trouve choquant qu'on supprime une ancienne version d'OpenGL pour ceux qui ont appris à programmer dessus, vous êtes absolument sûr que passer en version 3 résoudrait le problème ? C'est une lourde opération mais ça peut être intéressant, les shader je sais pas ce que c'est mais rien que le nom me donne envie d'en savoir plus ^^

OpenGL 1, ça date des années 90. Depuis, les cartes graphiques ont radicalement changées. La bibliothèque a reflété ces changements pour nous proposer des fonctionnalités que tout le monde apprécie. C'est pas une suppression totale, vu qu'une certaine couche de compatibilité reste, c'est plutôt une évolution logique.
Maintenant, si vraiment vous voulez apprendre OpenGL, sincèrement, c'est la version 3 qu'il faut apprendre. Oui, les changements sont conséquents par rapport à un programme en OpenGL 1, mais j'ose croire que cela vaille le coup et que les choses auquel on a accès sont extraordinaires.

Après, comme je l'ai écrit dans un autre message (que vous ne semblez pas avoir lu), il se peut que cela soit à cause du pilote Microsoft.

**KevinduC** · 12/08/2013, 19h21

Lire un seul message sur six, c'est choquant

Pour ton information j'ai lu tous les messages (Ma dernière connexion date d'hier soir) mais je n'ai pas eu de suite le réflexe de jeter un oeil à ton lien, après j'ignore comment tu perçois les choses mais de mon côté je pense qu'il est intéressant de profiter d'être en contact avec des membres du forum pour satisfaire sa curiosité, ou alors ne communiquons plus directement, échangeons des liens.
Je suis d'ailleurs entrain de me renseigner sur OpenGL 3, j'aurai sans doute la réponse à ma question puisque tu as refusé de me donner la définition du pipeline

**KevinduC** · 13/08/2013, 01h19

Quelqu'un connaîtrait-il un lien pour télécharger les lib de OpenGL 3 ?

**LittleWhite** · 13/08/2013, 01h54

Je vais me faire taper sur les doigts, mais bon, voici un lien, qui explique la raison des fonctions OpenGL > 1 sous Windows : http://alexandre-laurent.developpez....GL-Extensions/
Car, sous Windows, les fonctions OpenGL > 1 ne sont pas visibles (à cause de l'implémentation Microsoft) alors qu'elles sont disponibles à travers les pilotes graphiques. Du coup, il faut les charger à la main (en récupérant les pointeurs de fonctions), ou le faire faire par une bibliothèque (GLEW). Mais tout est expliquer en suivant le lien que j'ai donné.
Aussi, pour avoir un contexte OpenGL 3, il faut utiliser SDL 2, ou autre.

**KevinduC** · 13/08/2013, 03h00

Il paraît qu'il faut créer sa propre matrice de projection, ça a l'air intéressant

Il est vraiment garanti que mon problème (La lenteur/saccade de mon jeu sous Windows 8) vient de l'ancienneté de la version d'OpenGL ? Je m'apprête à recoder presque toutes mes fonctions (Dès que j'aurai réussi à tout installer) et je veux m'assurer que ça en vaut la peine.

Du coup, il faut les charger à la main (en récupérant les pointeurs de fonctions), ou le faire faire par une bibliothèque (GLEW)

C'est pas plus pratique de télécharger ?

**LittleWhite** · 13/08/2013, 08h59

GLEW se télécharge, c'est une bibliothèque.

Pour ce qui est de la vitesse d'OpenGL, vous n'avez pas suivi une des réponses que j'ai donné précédemment (oui, je sais, vous n'allez pas cliquer sur le lien, sauf que celui-ci vous renvoie à une des réponses ci-dessus), qui est de faire le test du : glGetString(). Donc, il y a toujours une part d'incertitude. Après, je pense que oui, qu'utiliser OpenGL 3 sera plus rapide que le pipeline fixe et j'avais expliqué pourquoi.

Programme lent sous Windows 8

OpenGL

Discussions similaires

Partager

Partager