Partage
  • Partager sur Facebook
  • Partager sur Twitter

Optimisation pour meilleur fps en SDL

Sujet résolu
z3d
    21 août 2007 à 20:45:11

    Bonjour à tous,
    voilà je suis en train de faire un jeu en SDL avec quelques potes mais j'ai un petit soucis d'optimisation: en fait, je suis à la programmation du menu principal et j'ai déjà un fps beaucoup trop faible:
    1. FPS: 1
    2. FPS: 12
    3. FPS: 14
    4. FPS: 15
    5. FPS: 15
    6. FPS: 15
    7. FPS: 14


    J'ai relus mon code des dizaines de fois et fais des tests de performances pour voir la fonction la plus gourmande et c'est le blittage de surface et c'est plutôt difficile de s'en passer.
    Est-ce que vous pouvez regarder mon code et me dire ce que vous en pensez ?
    Merci d'avance



    Variables.h
    1. #ifndef __VARIABLES_H__
    2. #define __VARIABLES_H__
    3. const int WIDTH = 1024; // Largeur de l'écran
    4. const int HEIGHT = 768; // Hauteur de l'écran
    5. const int COLOR = 32; // Type de couleur
    6. const int FPS = 31; // Fps maximum
    7. #endif


    main.cc
    1. #include <iostream>
    2. #include <SDL/SDL.h>
    3. #include "variables.h"
    4. #include "Moteur.h"
    5. using namespace std;
    6. int main(int argc, char *argv[])
    7. {
    8.     bool done = false; // Permet de savoir s'il faut quitter le programme
    9.     Moteur moteur; // variable globale permettant de faire un lien entre le jeu et la fonction main
    10.     SDL_Event event; // Permet de gérer les événements
    11.     SDL_Surface *screen; // Permet de gérer la surface principale
    12.     int frames; // Compte le nombre de frames
    13.     int last,now; // Permet de déterminer le fps
    14.     int checkTime; // Permet de réguler le fps
    15.     // Initialisation du moteur:
    16.     if(moteur.init() == false)
    17.     {
    18.         cout << "Erreur d'initialisation du moteur: " << SDL_GetError() << endl;
    19.         done = true;
    20.     }
    21.     // Initialisation de la SDL:
    22.     if(SDL_Init(SDL_INIT_VIDEO) != 0)
    23.     {
    24.         cerr << "Erreur lors de l'initialisation de la SDL: " << SDL_GetError() << endl;
    25.         return EXIT_FAILURE;
    26.     }
    27.     // Détermination du titre de la fenêtre:
    28.     SDL_WM_SetCaption("Projet 2D v1.0",NULL);
    29.     // Ouverture de la fenêtre:
    30.     screen = SDL_SetVideoMode(WIDTH,HEIGHT,COLOR,SDL_SWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF);
    31.     if(screen == NULL)
    32.     {
    33.         cerr << "Erreur lors de l'ouverture de la fenetre: " << SDL_GetError() << endl;
    34.         done = true;
    35.     }
    36.     last = SDL_GetTicks() / 1000; // Initialisation de last(en secondes)
    37.     frames = 0;
    38.     checkTime = SDL_GetTicks();
    39.     // Boucle principale:
    40.     while(!done)
    41.     {                
    42.         // Traitement des événements:
    43.         while(SDL_PollEvent(&event))
    44.         {
    45.             switch(event.type)
    46.             {
    47.                 case SDL_QUIT:
    48.                     done = true;
    49.                     break;
    50.                 case SDL_KEYDOWN:
    51.                     done = moteur.gereTouches(event);
    52.                     break;
    53.             }
    54.         }
    55.         if(SDL_GetTicks() > (checkTime + 1000/FPS))
    56.         {          
    57.             checkTime = SDL_GetTicks(); // Mise à jour de checkTime
    58.             frames++;
    59.             now = SDL_GetTicks() / 1000; // Stockage de l'heure actuelle en secondes
    60.             if(now != last)
    61.             {
    62.                 cout << "FPS: " << frames/(now-last) << endl; // Affichage du fps dans stdcout
    63.                 last = now; // Mise à jour du temps
    64.                 frames = 0;
    65.             }
    66.             cout << SDL_GetTicks() << "    ";    
    67.             moteur.gereScene(screen); // Demande au moteur de dessiner la scène
    68.             cout << SDL_GetTicks() << endl;
    69.         }
    70.         else
    71.         {
    72.             SDL_Delay(5);
    73.         }                    
    74.     }
    75.     SDL_Quit();
    76.     return EXIT_SUCCESS;
    77. }


    Moteur.h
    1. #ifndef __MOTEUR_H__
    2. #define __MOTEUR_H__
    3. #include <SDL/SDL.h>
    4. #include "Jeu.h"
    5. #include "Menu.h"
    6. class Moteur
    7. {
    8.     private:
    9.         Jeu *jeu; // Permet la création et la gestion du jeu
    10.         Menu *menu; // Permet la création et la gestion du menu      
    11.         bool dansMenu; // Sommes-nous dans le menu?
    12.         void dessineJeu(SDL_Surface *);
    13.         void dessineMenu(SDL_Surface *);
    14.     public:  
    15.         // Constructeurs et destructeur:
    16.         Moteur();
    17.         Moteur(const Moteur &);
    18.         ~Moteur();
    19.         Moteur operator = (const Moteur &);
    20.         void gereScene(SDL_Surface *); // Gestion de la scène: affichage + mise à jour
    21.         bool gereTouches(const SDL_Event &); // Gestion du clavier
    22.         bool init(); // Initialisation du moteur  
    23. };
    24. #endif


    Moteur.cc
    1. #include "variables.h"
    2. #include "Moteur.h"
    3. void Moteur::dessineJeu(SDL_Surface *screen)
    4. {
    5.     jeu->affiche(screen);
    6.     jeu->gereScene();
    7. }
    8. void Moteur::dessineMenu(SDL_Surface *screen)
    9. {
    10.     menu->affiche(screen);
    11.     menu->gereScene();      
    12. }    
    13. Moteur::Moteur()
    14. {
    15.     jeu = new Jeu();
    16.     menu = new Menu();
    17.     dansMenu = true;
    18. }
    19. Moteur::Moteur(const Moteur &M)
    20. {
    21.     if(M.jeu == NULL)
    22.         jeu = NULL;
    23.     else
    24.         jeu = new Jeu(*M.jeu);
    25.     if(M.menu == NULL)
    26.         menu = NULL;
    27.     else
    28.         menu = new Menu(*M.menu);
    29.     dansMenu = M.dansMenu;
    30. }
    31. Moteur::~Moteur()
    32. {
    33.     if(jeu != NULL)
    34.     {
    35.         delete jeu;
    36.         jeu = NULL;
    37.     }
    38.     if(menu != NULL)
    39.     {
    40.         delete menu;
    41.         menu = NULL;
    42.     }
    43. }
    44. Moteur Moteur::operator = (const Moteur &M)
    45. {
    46.     if(jeu != NULL)
    47.     {
    48.         delete jeu;
    49.         jeu = NULL;
    50.     }
    51.     if(menu != NULL)
    52.     {
    53.         delete menu;
    54.         menu = NULL;
    55.     }
    56.     if(M.jeu == NULL)
    57.         jeu = NULL;
    58.     else
    59.         jeu = new Jeu(*M.jeu);
    60.     if(M.menu == NULL)
    61.         menu = NULL;
    62.     else
    63.         menu = new Menu(*M.menu);
    64.     dansMenu = M.dansMenu;
    65.     return *(this);
    66. }      
    67. void Moteur::gereScene(SDL_Surface *screen)
    68. {    
    69.     if(dansMenu)
    70.         dessineMenu(screen);
    71.     else
    72.         dessineJeu(screen);
    73.     SDL_Flip(screen);
    74. }
    75. bool Moteur::gereTouches(const SDL_Event &event)
    76. {
    77.     if(dansMenu)
    78.     {
    79.         switch(event.key.keysym.sym)
    80.         {
    81.             case SDLK_UP:
    82.                 menu->decIndice();
    83.                 break;
    84.             case SDLK_DOWN:
    85.                 menu->incIndice();
    86.                 break;
    87.             case SDLK_ESCAPE:
    88.                 return true;
    89.                 break;                
    90.         }
    91.     }
    92.     else
    93.     {
    94.         switch(event.key.keysym.sym)
    95.         {
    96.         }        
    97.     }
    98.     return false;  
    99. }
    100. bool Moteur::init()
    101. {
    102.     return jeu->init() && menu->init();
    103. }


    Menu.h
    1. #ifndef __MENU_H__
    2. #define __MENU_H__
    3. #include <SDL/SDL.h>
    4. #include <SDL/SDL_image.h>
    5. class Menu
    6. {
    7.     private:
    8.         SDL_Surface *images[4]; // Tableau contenant l'image de fond et les différents boutons du menu
    9.         SDL_Rect pos[4]; // Tableau contenant l position et les dimensions des images
    10.         // images[0] ---> image de fond
    11.         // images[1] ---> Commencer
    12.         // images[2] ---> Configuration
    13.         // images[3] ---> Quitter
    14.         unsigned char indice; // Indice du bouton sélectionné
    15.     public:
    16.         // Constructeur et destructeur:
    17.         Menu();
    18.         Menu(const Menu &);
    19.         ~Menu();
    20.         Menu operator = (const Menu &);
    21.         void affiche(SDL_Surface *); // Affiche le menu
    22.         void gereScene(); // Mise à jour du menu
    23.         bool init(); // Initialisation du menu
    24.         void incIndice(); // Sélectionner le bouton au-dessus du sélectionné
    25.         void decIndice(); // Sélectionner le bouton en-dessous du sélectionné
    26.         int getSelection() const; // Renvoie l'indice du bouton sélectionné
    27.         void selectionne(); // Sélectionne le bouton selon la valeur de indice
    28. };
    29. #endif


    Menu.cc
    1. #include "Menu.h"
    2. Menu::Menu()
    3. {
    4.     // Allocation des images:
    5.     for(int i = 0; i < 4; i++)
    6.         images[i] = new SDL_Surface();
    7.     // Position de l'image de fond:
    8.     pos[0].x = 0;
    9.     pos[0].y = 0;
    10.     // Position de chaque bouton:
    11.     for(int i = 1; i < 4; i++)
    12.     {
    13.         pos[i].x = 50;
    14.         pos[i].y = (i+1)*100;
    15.     }
    16.     indice = 1; // Le bouton Commencer est sélectionné par défaut
    17. }
    18. Menu::Menu(const Menu &M)
    19. {
    20.     for(int i = 0; i < 4; i++)
    21.     {
    22.         if(M.images[i] == NULL)
    23.             images[i] = NULL;
    24.         else
    25.             images[i] = new SDL_Surface(*M.images[i]);
    26.     }
    27.     for(int i = 0; i < 4; i++)
    28.         pos[i] = M.pos[i];
    29. }    
    30. Menu::~Menu()
    31. {
    32.     for(int i = 0; i < 4; i++)
    33.     {
    34.         if(images[i] != NULL)
    35.         {
    36.             SDL_FreeSurface(images[i]);
    37.             images[i] = NULL;
    38.         }
    39.     }
    40. }
    41. Menu Menu::operator = (const Menu &M)
    42. {
    43.     for(int i = 0; i < 4; i++)
    44.     {
    45.         if(images[i] != NULL)
    46.         {
    47.             SDL_FreeSurface(images[i]);
    48.             images[i] = NULL;
    49.         }
    50.     }
    51.     for(int i = 0; i < 4; i++)
    52.     {
    53.         if(M.images[i] == NULL)
    54.             images[i] = NULL;
    55.         else
    56.             images[i] = new SDL_Surface(*M.images[i]);
    57.     }
    58.     return *(this);
    59. }            
    60. void Menu::affiche(SDL_Surface *screen)
    61. {
    62.     for(int i = 0; i < 4; i++)
    63.         SDL_BlitSurface(images[i],NULL,screen,&pos[i]);
    64. }
    65. void Menu::gereScene()
    66. {
    67.     selectionne();    
    68. }
    69. bool Menu::init()
    70. {
    71.     images[0] = IMG_Load("Images\\fond.png");    
    72.     images[1] = IMG_Load("Images\\commencer.png");
    73.     images[2] = IMG_Load("Images\\configuration.png");
    74.     images[3] = IMG_Load("Images\\quitter.png");
    75.     for(int i = 0; i < 4; i++)
    76.     {
    77.         pos[i].w = images[i]->w;
    78.         pos[i].h = images[i]->h;
    79.         if(images[i] == NULL)
    80.             return false;
    81.     }
    82.     return true;
    83. }  
    84. void Menu::incIndice()
    85. {
    86.     indice++;
    87.     indice = indice % 4;
    88.     if(indice == 0)
    89.         indice ++;
    90. }
    91. void Menu::decIndice()
    92. {
    93.     indice--;
    94.     indice = indice % 4;
    95.     if(indice == 0)
    96.         indice = 3;
    97. }
    98. int Menu::getSelection() const
    99. {
    100.     return indice;
    101. }
    102. void Menu::selectionne()
    103. {
    104.     if(pos[indice].x < 70)
    105.         pos[indice].x += 4;
    106.     for(int i = 1; i < 4; i++)
    107.     {
    108.         if((pos[i].x > 50) && (i != indice))
    109.             pos[i].x -= 4;
    110.     }
    111. }
    • Partager sur Facebook
    • Partager sur Twitter
    Pole
      22 août 2007 à 12:09:40

      Essaye de mettre ta surface d'écran en hadrware.
      • Partager sur Facebook
      • Partager sur Twitter
      z3d
        22 août 2007 à 12:32:10

        C'est bon j'ai grillé je te merci beaucoup rien quand changeant ce paramètre je me retrouve avec un fps doublé:

        FPS: 11
        FPS: 27
        FPS: 30
        FPS: 30
        FPS: 30
        FPS: 30
        • Partager sur Facebook
        • Partager sur Twitter

        Optimisation pour meilleur fps en SDL

        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
        × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
        • Editeur ●
        • Markdown