[debutant][c++] Problème de vitesse de déplacement

Version imprimable

Bonsoir,

Je suis sur un projet de jeu de stratégie et je m'amuse un peu en essayant de déplacer la caméra autour du plateau de jeu, mais j'ai un petit soucis dont voici le détail.
Le jeu se déroule sur un damier où figurent 20 personnages (20 modèles 3ds je précise parce que je pense que la taille que tout ça prend peut être la raison de mon problème). A un moment donné, je fais tourner le damier (la caméra en fait) pour faire jouer l'adversaire (un peu comme aux échecs : 2 "armées" à chaque bout du damier,on fait jouer un joueur puis on fait tourner le damier et on fait jouer l'autre joueur).
Mais lorsque je fais tourner mon damier, je m'aperçois que celui-ci mais un peu de temps pour tourner ( c'est un peu saccadé) alors ma question est :
Est-ce-qu'il y aurait un moyen de rendre le mouvement plus fluide ?

Pour mieux comprendre comment je m'y prend, voici la portion de code concernée :
Code:

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 //vX,vY,vZ sont les 3 premiers paramètres de gluLookAt static void deplacementCamera(void) { static int i = 1; if (i <=15){ opg->vX --; opg->vY ++; opg->vZ ++; glutPostRedisplay(); i++; } if (i>15 && i<=31){ opg->vX ++; opg->vY ++; opg->vZ --; glutPostRedisplay(); i++; } } // lorsque j'appuie sur la touche '*' , je déclenche le mouvement void clavier(unsigned char touche,int x,int y) { ... case '*': { cout << "touche *" << endl; glutIdleFunc(deplacementCamera); break; } } } ...
Idées :
- les modèles 3ds sont trop lourds pour l'application : un déplacement plus fluide n'est pas possible;
- le recours à des boucles 'for' (dans la méthode deplacementCamera) ralentit le déroulement de la méthode de déplacement de la caméra;

Merci de me faire part de vos réactions sur ce problème et d'apporter éventuellement une solution ...

Bonsoir

Avec si peu de description je dirai qu'effectivement, les modèles sont trop compliqués pour être rapidement dessinés.

Une idée serait peut être d'avoir deux modèles 3D par objet :
-Un pour le rendu en jeu
-Un pour les mouvements de caméras moins détaillé.

Il est aussi à noter que :
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 static void deplacementCamera(void) { static int i = 1; if (i <=15){ opg->vX --; opg->vY ++; opg->vZ ++; glutPostRedisplay(); i++; } if (i>15 && i<=31){ opg->vX ++; opg->vY ++; opg->vZ --; glutPostRedisplay(); i++; } }
est très maladroit dans la mesure où il n'y a aucune temporisation. Un attente de 50 ms entre deux frames serait pas une mauvaise idée.

mabu

bon alors premierement regarde du coté de frustum culling pour n'afficher que les models dont tu a besoins, c'est simple a mettre en place et ca fait gagner pas mal de vitesse dans certains cas.

deuxiemement pour tes deplacement, il faut les gerer en fonction du temps. en gros au lieu de faire un ++ sur tes variable, il faut faire un += en fonction du temps ecoulé.
en gros ca donne ca
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int previousTime; deplacementCamera { int time = glutGet(GLUT_ELAPSED_TIME); float elapsedTime = time - previousTime * 0.001; // passage de millisecondes en secondes... previousTime = time; // gestion des deplacement opg->vY += elapsedTime * facteur; opg->vZ += elapsedTime * facteur; [...] }
avec facteur le facteur de vitesse de deplacement, c'est a dire qu'avec un facteur de 1, tu de deplacera d'une unité par secondes (ca peut etre pratique d'aller plus vite :wink: )
l'avantage de cette methode c'est que ta camera se deplacera a la même vitesse quelque soit la vitesse de l'ordinateur sur lequel tourne ton programme et en plus tu n'a pas besoin de temporisation (a quoi ca sert de ralentire le rendu quand le but est d'afficher un maximum d'informations en un minimum de temps :?: )

22/02/2005, 11h38
bornibus

Bonjour,

J'ai bien suivi tes conseils Bafman mais le problème, c'est que les déplacements de ma caméra ne sont pas constants (et ça reste malheureusement saccadé... :() du fait que l'on s'appuie sur une horloge et sur un temps écoulé qui peut varier d'un top à un autre.
En conclusion, la (non-)fluidité reste la même mais la distance parcourue par la caméra à chaque 'frame' diffère...

Je pense pourtant que ta solution était judicieuse mais je n'arrive pas à obtenir des résultats convenables ...

Il doit surement pourtant y avoir une solution à ce 'petit' soucis de fluidité... C'est quand même triste de déplacer une caméra mais que ce soit saccadé. Venez moi en aide. :cry:

NB : Je vais regarder le principe de frustum culling mais je doute de pouvoir réduire le nombre de modèles à afficher ( et chacun des modèles ne pèse que 40 Ko...)
22/02/2005, 15h12
bornibus

Je vais peut-être reformuler ma question d'une autre manière.
Pour déplacer ma caméra, est-ce-que-je ne pourrai pas déplacer la caméra avec des instructions du genre :
glRotated(angle,0,1,0);
glTranslatef(0,0,5);
en sachant que la caméra au départ est définie comme étant :
gluLookAt(vX,vY,vZ,6,6,0,0,0,1);
avec
vX=6;
vY=-14;
vZ=10;

Merci de vos suggestions...

(Je reprécise que je désire faire tourner la caméra autour du damier.)
22/02/2005, 19h46
bornibus
Je me suis orienté vers une autre solution : le rafraichissement de l'écran !
en gros, j'ai défini une fonction refresh pour la fonction de rappel glutTimerFunc de la manière suivante :
Code:

1 2 3 4 5 6 void refresh(int value){ cout <<" refresh "<< endl; glutPostRedisplay(); glutTimerFunc(5, refresh, 0); }
J'espérais de cette manière forcer le rafraîchissement toutes les 5 ms; mais rien à faire : ça reste saccadé .... :(

J'ai pourtant l'impression (l"intuition...) que c'est là dessus qu'il faudrait s'orienter mais bon pour l'instant ça fonctionne pas.... :pleure:
22/02/2005, 19h57
Chacal_ito

yop,
la methode que decrit bafman est la bonne.
Le deplacement doit se faire en fonction du temps et non pas uniquement en fonction du nombre de boucle d'affichage.

Et ceci pour une bonne raison : Le nombre de fois que ton dessin est restitué sur ton pc en un temps X, ne sera pas le même sur une autre configuration pc si tu n'integres pas le temps.

Au sujet de l'effet saccadé, tu sais le nombre de FPS que tu as?
Si tu as un nbre de FPS tres bas.. je rejoins encore une fois bafman sur le fait d'optimiser ton affichage à l'aide d'une technique qui tu permettrais d'enlever toutes les choses dont tu n'as pas besoin pour restituer ta scene.
(frustum culling, c'est simple et efficace).

Tu chargerais pas tes models a chaque frame par hasard?? :roll:

@+
22/02/2005, 21h49
bornibus

Bon, le problème se situe bien au niveau des modèles 3ds.
En fait j'utilise des listes d'affichage pour "stocker" mes modèles.
MAIS ces listes d'affichage sont rappelées à chaque instant d'où l'impression de saccadement.
Pour l'instant j'ai résolu le problème en ne faisant pas appel à ces listes lorsqu'un mouvement (de caméra) doit être effectué. Du coup maintenant lorsque je bouge la caméra avec la souris, mes personnages disparaissent.
J'aurai préféré qu'ils ne disparaissent pas mais bon c'est le moyen le plus rapide pour que ce soit fluide.

Ce serait cool cependant (je persiste...) si vous pouviez m'indiquer comment faire pour que mes perso restent là où ils sont sans faire rappel à mes listes d'affichage....
Merci
23/02/2005, 01h06
ken_le_videur

Si tu veux les voir, il faut les .... afficher.

Citation:

Si tu veux les voir, il faut les .... afficher.

Bon je crois m'être mal expliqué.

Voici comment je m'y prend dans mon programme :
-J'ai une méthode chargerModele() qui est appelée 1 seule fois dans le main
- J'ai une méthode afficherModele(int i) qui est rappelée constamment dans le programme.

Voici ci-dessous le détail de ces deux méthodes :

Code:

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
 
 
C3DModel PersoFaibleRouge,PersoMoyenRouge,PersoFortRouge,PersoFaibleBleu,PersoMoyenBleu,PersoFortBleu,TourNeutre,TourRouge,TourBleue,Rocher;
GLuint listePersoFaibleRouge,listePersoMoyenRouge,listePersoFortRouge,listePersoFaibleBleu,listePersoMoyenBleu,listePersoFortBleu,listeTourNeutre,listeTourRouge,listeTourBleue,listeRocher;
 
void chargerModele(){
 
	//persos faibles
	CLoad3DS load_PersoFaibleRouge;							
	if (load_PersoFaibleRouge.Import3DS(&PersoFaibleRouge, MODELE_ROUGE_FAIBLE) == false )		
	{
		exit(0);
	}
 
	CLoad3DS load_PersoFaibleBleu;							
	if (load_PersoFaibleBleu.Import3DS(&PersoFaibleBleu, MODELE_BLEU_FAIBLE) == false )		
	{
		exit(0);
	}
 
	//persos moyens
	CLoad3DS load_PersoMoyenRouge;
	if (load_PersoMoyenRouge.Import3DS(&PersoMoyenRouge, MODELE_ROUGE_MOYEN) == false )	
	{
		exit(0);
	}
	CLoad3DS load_PersoMoyenBleu;
	if (load_PersoMoyenBleu.Import3DS(&PersoMoyenBleu, MODELE_BLEU_MOYEN) == false )	
	{
		exit(0);
	}
 
 
	//persos forts
	CLoad3DS load_PersoFortRouge;
	if (load_PersoFortRouge.Import3DS(&PersoFortRouge, MODELE_ROUGE_FORT) == false )
	{
		exit(0);
	}
		CLoad3DS load_PersoFortBleu;
	if (load_PersoFortBleu.Import3DS(&PersoFortBleu, MODELE_BLEU_FORT) == false )
	{
		exit(0);
	}
	//tour grise
	CLoad3DS load_TourNeutre;
	if (load_TourNeutre.Import3DS(&TourNeutre, MODELE_TOUR_NEUTRE) == false )
	{
		exit(0);
	}
 
	//tour rouge
	CLoad3DS load_TourRouge;
	if (load_TourRouge.Import3DS(&TourRouge, MODELE_TOUR_ROUGE) == false )
	{
		exit(0);
	}
 
	//tour bleue
	CLoad3DS load_TourBleue;
	if (load_TourBleue.Import3DS(&TourBleue, MODELE_TOUR_BLEUE) == false )
	{
		exit(0);
	}
 
	//Décor rocher
	CLoad3DS load_Rocher;
	if (load_Rocher.Import3DS(&Rocher, MODELE_ROCHER) == false )
	{
		exit(0);
	}
 
 
 
	//CREATION DES LISTES D'AFFICHAGE POUR TOUS LES MODELES 3ds
 
	//           POUR LE JOUEUR ROUGE
 
	//liste pour le perso faible
	listePersoFaibleRouge=glGenLists(1);	
 
	glListBase(listePersoFaibleRouge);
	glNewList(listePersoFaibleRouge,GL_COMPILE);
		PersoFaibleRouge.LoadTextures();
		PersoFaibleRouge.Draw();
	glEndList();
 
 
	//liste pour le perso moyen
	listePersoMoyenRouge=glGenLists(1);	
 
	glListBase(listePersoMoyenRouge);
	glNewList(listePersoMoyenRouge,GL_COMPILE);
		PersoMoyenRouge.LoadTextures();
		PersoMoyenRouge.Draw();
	glEndList();
 
	//liste pour le perso fort
	listePersoFortRouge=glGenLists(1);
 
	glListBase(listePersoFortRouge);
	glNewList(listePersoFortRouge,GL_COMPILE);
		PersoFortRouge.LoadTextures();
		PersoFortRouge.Draw();
	glEndList();
 
	//****************************************************
 
	//           POUR LE JOUEUR BLEU
 
	//liste pour le perso faible
	listePersoFaibleBleu=glGenLists(1);	
 
	glListBase(listePersoFaibleBleu);
	glNewList(listePersoFaibleBleu,GL_COMPILE);
		PersoFaibleBleu.LoadTextures();
		PersoFaibleBleu.Draw();
	glEndList();
 
 
	//liste pour le perso moyen
	listePersoMoyenBleu=glGenLists(1);	
 
	glListBase(listePersoMoyenBleu);
	glNewList(listePersoMoyenBleu,GL_COMPILE);
		PersoMoyenBleu.LoadTextures();
		PersoMoyenBleu.Draw();
	glEndList();
 
	//liste pour le perso fort
	listePersoFortBleu=glGenLists(1);
 
	glListBase(listePersoFortBleu);
	glNewList(listePersoFortBleu,GL_COMPILE);
		PersoFortBleu.LoadTextures();
		PersoFortBleu.Draw();
	glEndList();
 
	//****************************************************
 
	//           POUR LES TOURS
 
	//liste pour tour neutre
	listeTourNeutre=glGenLists(1);
 
	glListBase(listeTourNeutre);
	glNewList(listeTourNeutre,GL_COMPILE);
		TourNeutre.LoadTextures();
		TourNeutre.Draw();
	glEndList();
 
 
	//liste pour tour rouge
	listeTourRouge=glGenLists(1);
 
	glListBase(listeTourRouge);
	glNewList(listeTourRouge,GL_COMPILE);
		TourRouge.LoadTextures();
		TourRouge.Draw();
	glEndList();
 
	//liste pour tour bleue
	listeTourBleue=glGenLists(1);
 
	glListBase(listeTourBleue);
	glNewList(listeTourBleue,GL_COMPILE);
		TourBleue.LoadTextures();
		TourBleue.Draw();
	glEndList();
 
 
	//           POUR LE DECOR
 
	//liste pour le rocher
	listeRocher=glGenLists(1);
 
	glListBase(listeRocher);
	glNewList(listeRocher,GL_COMPILE);
		Rocher.LoadTextures();
		Rocher.Draw();
	glEndList();
 
}
 
void afficherModele(int i){
	switch(i){
 
	case 6: glCallList(listePersoFaibleBleu);
		break;
	case 5: glCallList(listePersoMoyenBleu);
		break;
	case 4: glCallList(listePersoFortBleu);
		break;
	case 3: glCallList(listePersoFaibleRouge);
		break;
	case 2: glCallList(listePersoMoyenRouge);
		break;
	case 1: glCallList(listePersoFortRouge);
		break;
	}
}
 
void afficherTour(int i){
	switch(i){
	case 2: glCallList(listeTourNeutre);
		break;
	case 1: glCallList(listeTourBleue);
		break;
	case 0: glCallList(listeTourRouge);
		break;
	}
}
 
void afficherDecor(void){
	glCallList(listeRocher);
}

[/i]

Le code est assez long mais assez redondant, c'est surtout pour montrer que j'ai pas mal de modèles 3ds à afficher.

Si une optimisation vous vient à l'idée, elle est la bienvenue...

24/02/2005, 09h40
bafman
est ce que tu voit toujours l'ensemble des pions a l'ecran ? si non alors franchement regarde le frustum culling, en gros ca permet, si un pion n'est pas visible, de ne pas faire d'appel a la fonction d'affichage, donc ca decharge la carte graphique qui va plus vite.
par contre si tu voit toujours l'ensemble des pions a l'ecran (ce qui me parrait normal pour un jeu d'echec) alors la le frustum culling est inutil.
par contre tu a pensé au back face culling ? c'est tout simple et ca peut rapporter gros...
ca se fait comme ca (tu va voir c'est tres compliqué :wink: )
Code:

1 2 3 glEnable(GL_CULL_FACE); glCullMode(GL_CCW); // ou GL_CW selon tes models mais je croit que par defaut les 3DS sont en CCW
sinon pour ton affichage, apparament tu ne fait pas une boucle d'affichage ?? en gros, a chaque fin de boucle idle() de glut tu fait appel a glutPostRedisplay(), ainsi, pas besoin de temporisation, ton programme tourne vraiment au maximum de ses capacitée.

sinon pour ton chargement de models, ca me parait correct mais 40Ko pour un model ca me parrait un peut enorme... y'a pas moyen de reduire ca ?? ca doit faire plusieurs millier de polygone par perso, ca ne m'ettone pas que ca rame...

Salut,

Bon bafman, j'ai suivi tes conseils mais ( :sad: ) malheureusement ça ne donne pas les résultats espérés :
- avec

Citation:

glEnable(GL_CULL_FACE);
glCullMode(GL_CCW);

mes personnages ont tous la tête tournée vers la caméra et sont de travers ( à moitié couchés...). Mais bon, c'est pas grave, je vais laisser tel que c'est (et puis le temps joue contre moi...).
(!! Au passage : je crois que ce n'est pas glCullMode(GL_CCW) mais glCullFace(GL_CCW) qu'il faut mettre !! )

Autrement, j'aurai une autre petite question à poser qui a toujours attrait avec le mouvement de caméra.
Cette fois-ci je voudrais changer l'axe de rotation de la caméra :
Je voudrais que ma caméra tourne autour du damier (donc l'axe de rotation serait le centre du damier). Mais pour le moment ma caméra tourne autour du coin inférieur gauche du damier.

Voici ci-dessous la fonction appelée par le callback gluDisplayFunc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void affichageDamier() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); // positionnement de la caméra gluLookAt(opg->posX,opg->posY,opg->posZ,opg->ciblX,opg->ciblY,opg->ciblZ,0,0,1); glRotatef(-angley, 0.0, 0.0, 1.0); // PROBLEME DE CENTRE DE GRAVITE MAL PLACE !!! // affichage du damier et de sesoccupants opg->affichage(deroulement->surfaceDeJeu,deroulement,mouvement); glutPostRedisplay(); glutSwapBuffers(); }
Merci de votre aide.

25/02/2005, 16h05
Bob.Killer

si tu n'utilises pas des vertexes buffer pour afficher t mesh 3DS ça peut venir de là...

par exemple avec les vertexes buffer ARB moi j affiche au moins 15 000 000 de poly à la seconde.

Dans le premier post je crois qu'il y a une grosse erreur dans ton programme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void clavier(unsigned char touche,int x,int y) { ... case '*': { cout << "touche *" << endl; glutIdleFunc(deplacementCamera); break; } } }
Si je comprends bien à chaque fois que tu appuie sur la touche étoile tu veut deplacer la caméra ? Parce que ce n'est pas ce que tu fait ici.
Quand tu fait

Code:

glutIdleFunc(deplacementCamera)

tu signale à glut que la fonction deplacementCamera devient la fonction "Idle", c'est à dire la fonction qui sera appelée lorsque glut aura le temps, quand il n'est pas en train de faire un rendu. Tu dois donc le faire en général UNE SEULE fois au début du programme. Cette fonction sert plutôt pour l'ia que pour gérer les déplacements.
Sache que dans ton programme rien ne dit que la fonction deplacementCaméra va être appelée et le déplacement ne sera effectué que quand glut aura le temps, c'est pourquoi tes mouvements sont trés saccadés.

Fait plutôt un truc comme ça :
Code:

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 int main(....) { //initialisation de glut glutInit(...); ... //fonction pour gérer les évenements glutDisplayFunc(Affichage); glutKeyboardFunc(Clavier); glutIdleFunc(Idle); ... } void Affichage() { //affichage des objets... } void Clavier() { //gestion des évenements clavier case '*': static int i = 1; if (i <=15){ opg->vX --; opg->vY ++; opg->vZ ++; glutPostRedisplay(); i++; } if (i >15 && i<=31){ opg->vX ++; opg->vY ++; opg->vZ --; glutPostRedisplay(); i++; } } void idle() { //fonction plutot utilisée pour l' "IA" que pour les déplacements }

25/02/2005, 19h01
bornibus

Merci du conseil, je prend note.
26/02/2005, 09h16
bafman

c'est pabsolument pas normale que le back face culling ne fonctionne pas... ton probleme ne paut pas venire de la car le culling ne transforme pas la geometrie... tu a essayé avec CW au lieu de CCW ?

sinon pour le fait d'utiliser des vertex buffer au lieu de display list, ca depend des cartes graphique et des drivers... parfois les display list sont plus rapide que les vertex buffer. en plus il utilise de la geometrie statique donc bref... ca depend et perso je lui conseil de rester sur le display list pour l'instant... surtout que la vitesse d'execution ne depend pas seulement du nombre de polygone mais aussi du fill rate : un quad qui occupe tout l'ecran sera plus lent a afficher que 10 quads qui ne remplissent qu'une petite partie de l'ecran...