SDL depuis une classe : Réguler les FPS [Résolu]

[Froyok]

Impossible de réguler mon framerate à 60 FPS !
J'ai eu beau chercher, je vois pas du tout ou est le problème (passé ma soirée dernière et cette journée la dessus ) !

Mon code main fonctionne très bien (le cube tourne sans problèmes, mais je suis à 1800 FPS et j'utilise mon cpu à 100%, donc pas très pratique.)

Le code :

Déclarations :

Code :

1
2
3
4
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;

Dans le while principale :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
 
        angleZ += 0.05 * ellapsed_time;
        angleX += 0.05 * ellapsed_time;
 
        Dessiner();
 
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 10)
        {
            SDL_Delay(10 - ellapsed_time);
        }

Ce code fonctionne en entier (donc pas seulement avec cet extrait).
Mais il semble que dès que je passe par un objet, ça fous le merdier.
(Et encore plus bizarre, quasiment la même classe fonctionne très bien en ruby, passé au C++, cela ne fonctionne plus... )
Et j'ai essayé : déclaration de la sdl dans le main, pas par l'objet, idem avec l'ouverture de la fenêtre.
Rien ne marche.
Par contre, si je remplace mon code par celui du sdz, ça passe :\
Je comprend plus rien.

Voici mon main :

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
//Basic preprocessor
#include <iostream>
#include <string>
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <cstdlib>
 
 
//Preprocessor for the engine
//	Fonctions and class
#include "SDL_window.h"
#include "SDL_timer.h"
#include "dessiner.h"
 
 
using namespace std;
 
//Main
int main(int argc, char *argv[])
{
	float timing = 1000.0, fps = 60.0;
	int frame = 0;
 
	SDL_window window;
	window.create_window(); // Open Window
 
	float angleZ = 0;
	float angleX = 0;
 
	dessin(angleZ, angleX);
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;
 
///////////////////////////////////////////////////////
    while (true)
    {
		//=====================================
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
        //=====================================
		window.cleargl(); // Nettoyage opengl
		window.key(); // Gestion d'évènement clavier/souris/joystick
 
		//Dessin
		angleZ += 0.05;
        angleX += 0.05;
		dessin(angleZ, angleX);
		//Dessin end
 
		window.refresh(); // Actualisation de l'écran
 
		frame++; // Incrémentation du nombre de frames
		//=====================================
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < (timing/fps))
        {
            SDL_Delay((timing/fps) - ellapsed_time);
        }
        //=====================================
    }
///////////////////////////////////////////////////////
 
	window.quit(); // Termine la SDL
	return 0;
} //End Main

De même, si je recopie ma version de gestion du framerate (float timing/fps et compagnie) dans le code du tuto du sdz, cela fonctionne. En toute logique mes déclarations fonctionnent donc.

NOTE : Pour le code du main.cpp, avec ou sans ajout du #include <cstdlib>, aucuns changements. De plus le code du SDZ fonctionne si je remplace cette déclaration préprocesseur par iostream.

[EDIT] j'avoue, ma méthode de limitation des FPS n'est pas ce qu'il y a de mieux, mais actuellement je n'ai pas trouvé mieux.

[coyotte507]

Tu fais quelques erreurs:

Déjà:

Code :

1
2
3
4
5
6
7
8
9
10
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
        //=====================================
        /**
              code de dessin
        **/ 
 
        //=====================================
        ellapsed_time = SDL_GetTicks() - start_time;

Déjà ta variable start_time n'est initialisée nulle part, elle ne change pas mais SDL_GetTicks augmente, donc tu auras toujours ellapsed_time > (timing/fps).

Ensuite tu calcules deux fois ellapsed_time..

Tu devrais calculer le temps qui reste juste avant le SDL_Delay, pas avant le dessin, donc ça ferait quelque chose comme ça:

Code :

1
2
3
4
5
6
7
8
9
10
11
 
        //=====================================
        /**
              code de dessin
        **/ 
 
        //=====================================
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
        if (.....) {...}

[Froyok]

Je te remercie beaucoup, après relecture du code, je me suis rendu compte de l'erreur dont tu signale l'existence : la non initialisation de "start_time", en fait je ne l'avais pas vu car celle-ci se faisait juste avant le code de gestion des évènements !

Après, je vais être franc, je ne me suis pas plus posé de question que ça, j'ai simplement copié le code (ma priorité n'est pas sur ce point actuellement, mais vu le temps que je viens d'y passer, je crois que je vais finaliser ça afin d'être tranquille par la suite...).

Encore merci, je vais étudier tes réponses !

[Captain_JS]

Envoyé par Froyok

Mon code main fonctionne très bien (le cube tourne sans problèmes, mais je suis à 1800 FPS et j'utilise mon cpu à 100%, donc pas très pratique.)

Sauf erreur de ma part tu utiliseras toujours ton cpu à 100% à cause de la boucle principale.

[Froyok]

[Bon, problème résolu, le moteur tourne bien à 60FPS et pas plus !]
Sinon, je me permet de te contredire sur certains points Captain_JS, oui, ma boucle principale consommera surement 100% du cpu... quand je ferais de gros calculs et autres (IA, rendu, calcul physiques, etc...), mais actuellement, avec cette régulation des FPS, je ne consomme pour ainsi dire rien.

[coyotte507]

CaptainJS: En fait SDL_Delay libère le CPU pendant le temps que le programme n'est pas utilisé.