Salut

on parlait il y a quelque temps de gerer la vitesse d'execution du programme, je suis tombé sur des fonctions SDL tres pratiques qui permettent de faire ca tres simplement,(sans pour autant utiliser de l'affichage sdl bien sur) tout en évitant les appels systemes pas portables

pour ceux que ca interresse j'ai trouvé mes infos ici :
http://fearyourself.developpez.com/tutoriel/sdl/pong/partie-2-base-moteur/#L2.2.b

en résumé il suffit de faire :

#include <SDL_framerate.h>
// (...)

// on cree un manager
FPSmanager manager;
SDL_initFramerate(&manager);

//on définit le nombre d'action par seconde
SDL_setFramerate(&manager,40);

// la main loop
while(1)
{
  ...
  //on dessine
  game.draw();

  // on appelle frame delay qui s'arrange pour attendre le temps qui va bien
  SDL_framerateDelay(&manager);

}

void SDL_initFramerate(FPSmanager * manager);
int SDL_setFramerate(FPSmanager * manager, int rate);
int SDL_getFramerate(FPSmanager * manager);
void SDL_framerateDelay(FPSmanager * manager);

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 @+