Discussion :

[Le Barde]

Bonjour,
Je suis toujours débutant dans les jeux vidéo, et là j'ai déjà créé une bonne petite structure (avec la SFML en l'occurrence) qui affiche deux-trois trucs dans une fenêtre.

Le problème, le voici : mon programme a une boucle infinie pour qu'à chaque étape on refasse des calculs du moteur de jeu, du moteur audio, du (futur) moteur réseau, etc. et de l'affichage de la scène. Mais pour l'instant, le programme parcourt la boucle de façon furieuse et le programme prend toutes les ressources du processeur.
J'avais déjà fait des tests avec notamment GLUT, qui gère je ne sais pas comment cette même boucle principale, mais qui en tous cas ne prend pas autant de ressources. Il y a de plus une fonction à laquelle il est fait appel chaque fois que le processeur ne sait pas quoi faire.

Auriez-vous une idée de comment faire pour pouvoir réaliser une fonction de boucle principale qui soit plus légère en utilisation processeur et qui permette de faire un appel à une certaine fonction lorsque aucun processus n'est actif (ou que le processeur n'a rien à faire) ?

Merci d'avance,
Le Barde.

[bogoss91]

Il me semble que la SFLM a une fonction comme ça : App.SetFrameLimit(50) (ou un truc du genre), qui mettrai la limite à 50 frames par secondes.

Sinon tu peux mettre un timer, qui fait que s'il n'y a pas eu 20ms entre une frame et une autre, on fait un Sleep sur le processuer pour le faire attendre.

[bob25]

salut,

pour pouvoir mieux t'aider il faudrait que tu nous dises ce qui se passe dans ta boucle

[loka]

Il faut sans doute que tu fasse une partie pour donner du temps au processeur.

Voir ta boucle principale aiderait beaucoup, car deviner le problème comme ça est assez difficile

[Le Barde]

En effet je ne libère pas du tout de temps pour le processeur ; ce que je voudrais faire c'est parvenir à libérer du temps et à faire une fonction qui s'exécute durant les "Idle Time" du processeur.
Voici ma boucle principale en l'occurrence :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "Sources/jeu.h"
 
 
int main(int argc, char** argv)
{
   jeuPtr MonJeu;
    MonJeu = jeu::jeuCreate(argc, argv);
    // Boucle principale du jeu.
    while(MonJeu->GetEtatActuel() != GAME_EXIT)
    {
      MonJeu->run();
    }
    exit(0);
}

Avec le typedef suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

typedef boost::shared_ptr<Jeu> JeuPtr;

(Tous les "MachinPtr" sont défiins de cette façon)

Et l'en-tête de la classe Jeu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class jeu : public boost::enable_shared_from_this<jeu>
{
   public:
      // Méthodes publiques
      static jeuPtr jeuCreate(int argc, char** argv);
      jeu(int argc, char** argv);
      ~jeu();
      void run();
      void Stop(int erreur=0);
      
      // Attributs publics
      //boost::mutex still_running_mutex; // Un truc comme ça ?
      game_state GetEtatActuel() {return etat_actuel;}
      jeuPtr GetSharedPtr();
   private:
      game_state etat_actuel;
      std::list<Module*> l_modules;
      graphics_enginePtr gfx;
      game_enginePtr ge;   
};

En particulier, la méthode run() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
void jeu::run()
{
   // Boucle principale du jeu
   //while(etat_actuel != GAME_EXIT) // Cette boucle est dans la fonction main() dorénavant.
   {
      // Suivant l'état du jeu
      switch (etat_actuel)
      {
         case GAME_RUN:
         {
            ge->frame();
            gfx->frame();
            //fenetre->frame();
            break;
         }
         case GAME_INIT:
         {
            gfx.reset(new graphics_engine(GetSharedPtr()));// On crée les contextes
            ge.reset(new game_engine(GetSharedPtr()));
            etat_actuel = GAME_RUN;
            break;
         }
         case GAME_MENU:
            break;
         case GAME_EXIT:
            // Le jeu est en train de quitter ;
            // rien à faire, sinon attendre, puisqu'on va sortir de la boucle.
            break;
      }
   }
}

Voilà, si quelqu'un a des idées, qui sait comment faire en sorte que le parcours de la boucle principale ne soit pas trop furieux... Ce que je voudrais, plutôt que de faire gfx->frame() dans la boucle principale (ce qui génère le rendu), ce serait mettre cela dans une fonction du type void FonctionIdleTime();, je sais que ça se fait donc ça ne doit pas être la mer à boire

Merci déjà pour vos réponses !
Le Barde.

[Kujara]

Je connais pas SFML du tout, mais mon conseil c'est de chercher la fonction qui active le VSync .... ( vertical synchronisation, wait for vsync,dX params -> presentation_interval wait_one, etc ....) ça a plein de noms mais c'est toujours le même principe : la carte graphique va gentiment attendre que l'ecran soit pret a afficher quelque chose avant de le faire.Ca permet de limiter les fps a 60 ou 75 selon les ecrans, et ça passe ton proc de 100% a 5% si tu a de la chance ...

[loka]

Il y a bien un truc comme ça avec la SFML :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

App.UseVerticalSync(true);

Tu peux peut être utiliser la fonction sfSleep aussi pour donner du temps au processeur en faisant un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if(1 / Clock.GetElapsedTime() > FPS)
    sfSleep(1.0 / FPS - Clock.GetElapsedTime());
Clock.Reset();

[Le Barde]

Oui c'est ça, c'est pour le vertical sync. Eurêka, donc si j'utilise ça, ça va mettre en pause le programme pour que ce soit syncrone je crois, non ? Et du coup, il y a ensuite la place à une éventuelle fonction du même type que la glutIdleFunc(), mais ça je ne sais pas comment l'implémenter...

Donc je considère mon problème comme partiellement résolu (je ne peux pas essayer pour l'instant, j'ai fait une mise à jour de mon OS vers Gutsy Gibbon (la Ubuntu, là...) et j'ai des problèmes graphiques, pas d'OpenGL...)

Donc l'étape suivante consiste à voir comment implémenter une fonction Idle()...

Merci pour vos réponses
Le Barde.

[deadalnix]

Chez moi la synchro verticale a rien a voir avec l'utilisation UC. On peut avoir le meme framerate avec ou sans 100% de cpu. L'idee est d'enregistrer les temps mis pour calculer les frames et de les comparés au temps mis avec un framerate type. Si ton moteur a plus de 5ms d'avance, tu lui fait faire un sleep.

Chez moi je passe de 100% d'utilisation cpu a 30% environs sans toucher a mon framerate (puisque la synchro verticale est activée.)

[Le Barde]

Ah oui, ok. Donc mettre le vertical sync, mais aussi faire attendre si les temps de calculs sont tels que :

Si T, Période framerate (vsync) > t, Période calculée + 5 ms

Alors attendre (T - t) ms.

ok ok. (Je ne pourrai faire les essais que demain )

Personne ne sait trop pour la gestion des temps d'attente ? (Comment récupérer l'information "le CPU est inactif" et faire appel à une fonction spécifique ?)

Merci pour vos réponses, qui m'auront certainement déjà beaucoup aidé !! (Je testerai demain )

[loka]

Regarde mon message un peu plus haut, je l'avais édité en ajoutant cette partie, tu as du la rater

[Le Barde]

oups oui, au temps pour moi
Merci

[deadalnix]

Tu peux, au lieu de faire ton sleep, lancer l'execution d'une fonction.

Tu peux rendre cette fonction parametrable via un pointeur de fonction (C) ou un foncteur (C++).

Ensuite, apres sont execution, rien ne t'empeche de rester si tu est toujours large en temps et de faire un sleep.

[Le Barde]

Oui pas mal ta solution deadalnix, je vais faire comme ça
Merci beaucoup