Intéressant ! Je n'ai jamais utilisé SDL_gfx donc je suis passé à côté de cette library, ça à l'air de bien faciliter la chose tout ça.

Merci !

Bonjour,
Si je peux me permettre, je connais pas bien SDL mais je désaprouve cette technique.
Pourquoi je m'explique :
On creé un mouvement...par exemple on avance de 10 unités par boucle.
Le système que tu décris va se contenter de faire une courte pause sur le programme, se qui dans le cas ou un pc est relativement rapide va provoquer un mouvement saccadé.
La meilleurre technique reste celle du Time Elapsed.
On calcule le temps écoulé entre deux boucles et on se sert du résultat pour lisser son mouvement selon le résultat obtenu par le Time Elapsed.
Se qui donnera un calcul du style :
Déplace mon objet de 10*TimeElapsed.
Si ta machine est rapide à calculer la scene, tu aurras un résultat très petit du genre 0.02 millisecondes.
si je reprend mon calcul ça va donner 10*0.02 = 0.2 Donc nous nous déplacerons de 0.2 unités par boucle.
Si ta machine est lente, et que t'a admétons un TimeElapsed de 0.5, ça va te donner un résultat : 10*0.5 = 5 Donc nous nous déplacerons de 5 unités par boucle.
Se qui donne à l'échelle du temps un mouvement identique sur toute les machines quelqu'en soit la rapidité.
Voilou @+

ey c'est vachement interressant ca !

merci du tuyau, je connaissais pas cette méthode

La méthode de Copland est la meilleure mais elle demande que le programme soit prévu pour dès le départ.

Alors que la méthode du delay, plus approximative, peut servir de rustine.

Oui pour un jeu qui ne manipule pas ou très très peu de 3d ça peut être certainement suffisant.

Dans le cas contraire j'ai pu me rendre compte du carnage que cela pouvait faire lorsque cela tournait sur des configurations différentes de celle utilisée pour le développement/test du jeu.

Surtout si la methode fait simplement un sleep, alors tu perds completement le temps de calcul avant et apres l'image.

La seule facon de faire cela proprement serait de dire:
j'affiche une image par seconde (ce qui est totalement arbitraire) donc:

0) Je mets a zero mon timer.
1) Je fais mon precalcul.
2) j'attends pour l'affichage (temps attendu = 1000 milliseconde - timer en millisecondes)
3) je remets a zero mon timer
4) j'affiche
5) je fais mon post calcul
6) je boucle sur 1)

Juste au cas ou, si ça peut servir ... J'utilise se genre de méthode :

f32 IrrTimeElapsed(IrrlichtDevice* device)
{
	static u32 LastCycle,LoopTime;
	f32 Result=0;
	LastCycle = device->getTimer()->getRealTime() - LoopTime;
	LoopTime = device->getTimer()->getRealTime();
	Result = 27/(1000.0f/LastCycle);
	if (Result > 5.0f){Result=5.0f;}
	if (Result < 0.0001f){Result = 0.0001f;}
	return Result;
}

C'est du bricolage, mais la méthode en elle meme est interressante....! marci.

Copland Ecris:

Bonjour,
Si je peux me permettre, je connais pas bien SDL mais je désaprouve cette technique.
Pourquoi je m'explique :
On creé un mouvement...par exemple on avance de 10 unités par boucle.
Le système que tu décris va se contenter de faire une courte pause sur le programme, se qui dans le cas ou un pc est relativement rapide va provoquer un mouvement saccadé.
La meilleurre technique reste celle du Time Elapsed.
On calcule le temps écoulé entre deux boucles et on se sert du résultat pour lisser son mouvement selon le résultat obtenu par le Time Elapsed.
Se qui donnera un calcul du style :
Déplace mon objet de 10*TimeElapsed.
Si ta machine est rapide à calculer la scene, tu aurras un résultat très petit du genre 0.02 millisecondes.
si je reprend mon calcul ça va donner 10*0.02 = 0.2 Donc nous nous déplacerons de 0.2 unités par boucle.
Si ta machine est lente, et que t'a admétons un TimeElapsed de 0.5, ça va te donner un résultat : 10*0.5 = 5 Donc nous nous déplacerons de 5 unités par boucle.
Se qui donne à l'échelle du temps un mouvement identique sur toute les machines quelqu'en soit la rapidité.
Voilou @+