Hello =)
Toujours moi avec mon p´tit programme ^^
J´aurais besoin cette fois ci d´un limiteur de frames par secondes.
En effet, sur mon zouli PC, pas de probleme, ma carte limite le nb de FPS à 60, tout marche nikel, mais sur d´autres PCs mon prog tourne à une vitesse folle :p
Donc je cherche un limiteur de FPS.
J´ai cherché sur le net, mais rien trouvé de bien util...

Merci d´avance

j´imagine que ton prog tourne en boucle. et déclenche l´affichage a un moment de ta boucle.
Dans ce cas tu te fais un petit compteur de temps (SDL_GetTicks() te renvois le temps en milisecondes par exemple) genre:
2 variables qui stockent le temps (a et b)
a = SDL_GetTicks()
debut de la boucle
{
....
b= SDL_GetTicks()
while (b-a < 16) { b= SDL_GetTicks(); }
a = b;
affichage();
...
} fin de la boucle.

en fait tu fais tourner ton jeu et avant d´afficher tu verifie qu´il y a eu 16 milisecondes depuis le dernier affichage, sinon tu le fais attendre.
(16 miliseconde => 60 fps 16*60=960)
ensuite tu déclenche l´affichage puis tu met a jour la "date" du dernier affichage et tu retourne dans ta boucle.
c´est comme ça que je fais .

Heu, disons que perso j´utiliserais SDL_Delay(), ça fais plus joli (mais peut être as tu des raisons de ne pas le conseiller guyver2, dans ce cas ça m´intéresserais de savoir pourquoi )

j´ai une excellente raison de ne pas l´utiliser : je ne la connais pas

http://www.libsdl.org/intro.fr/usingtimersfr.html
C´est tjrs un truc de su en plus

SDL_Delay() vous permet d´attendre un nombre de millisecondes.

cela ne me semble pas trop correspondre au probleme. c´est bien d´attendre un certaint delai... mais imaginons que le jeu necessite beaucoup de calcul avant de lancer l´affichage. ces calculs peuvent prendre plusieur milisecondes qui seront ajouter au delai d´attente. par exemple avec un delai de 16 miliseconde PLUS un temps de calcul de 5 miliseondes on arrive a une frame toutes les 21 miliseconde =>> le jeu rame. avec mon truc on attend au maximum 16 milisecondes.

5 miliseconde de calcul puis 11 milisecondes dans la boucle vide.
ça permet de s´adapter a la durée des calcul necessaire au jeu.

sinon on peut combiner les 2:

2 variables qui stockent le temps (a et b)
a = SDL_GetTicks()
debut de la boucle
{
....
b= SDL_GetTicks()
SDL_Delay(16-(b-a));
a = b;
affichage();
...
} fin de la boucle.

ca allait de soit
Je parlais de sdl_delay() comme un moyen de te débarasser de ta boucle while.

en fait je m´en suis rendu compte apres avoir ecris le debut de mon precedent post, et j´avais pas envis de tout effacer.

sinon autre idées:
faire un processus fils (lourd ou legers) qui ne s´occupe que de l´affichage et qui fait un truc du genre

while(1)
{
affichage();
SDL_delay(16);
}

je sais pas trop comment marchent les threads, bien que ça ne saura tarder.
Mais cela me semble néanmoins intéressant

Ce que j´ai apris à force de lire dce forum, c´est qu´on s´arrange toujours pour ne pas limiter le nombre de FPS : si on peut en faire 200, tant mieux. Par contre, tu limite la modification de ton affichage : dans le cas d´un pong, tu ne vas pas déplacer de 2 pixel ta balle toutes les frames (et donc toutes les 1/60e de seconde dans le cas idéal) mais plutot de 120*(T-t) ou T est le temps actuel en seconde et t le temps du dernier affichage. (par exemple).

Ca à l´avantage de ne pas faire de problème si tu rate une frame :
SDL_Delay(16-(b-a));
Aura un effet dévastateur si pour une raisons ou une autre, b-a>16 alors tu attendra des heures (si c´est des unsigned int et pas de int ; je ne sais pas trop comment c´est gérer).

Pareil, avec différent thread (processus léger) tu ne peut pas être sur de l´ordre dans lequel il vont s´exécuter. En gros, le PC change de thread 10 fois par seconde je crois (si il y en a suffisement qui veulent bosser), donc 1/16 de seconde c´est peu à cette échelle, et tu aura un truc pas précis du tout (SDL_delay te garentit que tu vas attendre au mois 16 milli seconde (ou centième j´en sais rien), mais tu peut aussi attendre beaucoup plus si le système décide de ne pas te rendre la main tout de suite.

Heu, moi j´ai fait comme ça à chaque fois :

while(...)
{
time_before=SDL_GetTicks();

//...

time_after=SDL_GetTicks();
if(time_after-time_before <= 10)
SDL_Delay(10-(time_after-time_before));

J´ai jamais eu de problème, vu qu´on vérifie si le temps est pas déjà dépassé...

Pfiou, que de réponses ^^
Merci les gens !
Je pense suivre la voi de dnob700...
D´une paske ça semble plu logique de modifier le deplacement plutot que d´attendre...
Et de 2 paske je ne connais et n´utilise pas la SDL ^^

En tout cas, merci

oula oui tu as raison dnob, au sujet de SDL_Delay(16-(b-a)); pour faire bien (ou mieux au moins) il faut ajouter un petit test avant. je l´ai écris vite fais et voila ce qui arrive quand on reflechis pas assez. de plus b et a sont des long donc l´attente en sera d´autant plus longue.