Problème affichage des fps et vitesse d'execution avec OpenGL

Version imprimable

Bonjour,

je développe actuellement un petit moteur de jeu 2D basé sur SDL & OpenGL mais j'ai quelques petits problèmes de plantages et de vitesse d'execution.

Voici un simple programme crée avec mon moteur qui affiche une série de raquette sur toutes la hauteur de l'écran et les fps... seulement, le programme plante méchamment avec OpenGL où SDL après un premier tour de boucle et je vois pas trop pourquoi :

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
70
71
72
73
74
75
76
77
78
79
#include <ES/ES_Display/graphics.h>
#include <ES/ES_Display/ttf.h>
#include <ES/ES_Event/event.h>
#include <ES/ES_Utils/utils.h>
 
#define R_MODE ES_SDL
 
int main(int argc, char *argv[])
{
    int x_img= 0, y_img = 0, vel_x = 1;
    unsigned int check_time = 0, fps = 0;
 
    ES_Resources res;
    ES_Event event;
 
    ES_Graphics *graphics = new ES_Graphics("ES - TestApp", 640, 480, 32, false, R_MODE, true);
 
    if(R_MODE == ES_OPENGL)
    {
        graphics->opengl_init();
        graphics->set_orto_view();
    }
 
    ES_Ttf *font = new ES_Ttf();
    font->set_size(18);
    res.add_resource("global font", "arial.ttf", ES_TTF_FONT);
 
    res.add_resource("test img", "img.png", ES_IMG, true, 255, 0, 255);
 
    event.set_key_repeat(100, 2);
 
    long time = SDL_GetTicks();
 
    while(graphics->run())
    {
        check_time = SDL_GetTicks();
 
        graphics->clear_screen();
 
        while(event.poll_event())
        {
            switch(event.get_event_type())
            {
                case SDL_QUIT:
                    graphics->quit();
                break;
            }
 
        }
 
        for(int i = 0; i < graphics->get_window_height(); i+=16)
        {
            graphics->draw_image("test img", graphics->rect(0, 0, 64, 16), graphics->rect(x_img, y_img+i, 64, 16), true);
        }
 
        if(x_img > graphics->get_window_width()-64)
            vel_x = -vel_x;
        else if(x_img < 0)
            vel_x = -vel_x;
 
        x_img += vel_x;
 
        font->draw_text("global font", "FPS: "+to_string(fps), graphics->get_window_width(), 0, graphics->color(255, 255, 255, 0), ES_RIGHT);
 
        if(SDL_GetTicks()-time>=150)
        {
            fps = 1000/(SDL_GetTicks()-check_time);
            time = SDL_GetTicks();
        }
 
        graphics->flip(5);
    }
 
    res.clear_resources();
    delete font;
    delete graphics;
 
    return EXIT_SUCCESS;
}

Si je commente la ligne de l'affichage de la font le programme ne plante plus donc je pense que le problème vient de là.

Voici le code qui affiche le texte (utilise SDL_Ttf & OGLFT) :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
void ES_Ttf::draw_text(const std::string& resource_name, const std::string& text, short int x, short int y, SDL_Color color, unsigned short int justification, unsigned short int style, SDL_Color color_bg)
{
    #ifdef ES_USE_OPENGL
    if(ES_OpenGL_Mode == false)
    {
    #endif
        if(resources.get_sttf_font(resource_name) != 0)
        {
            TTF_SizeText(resources.get_sttf_font(resource_name), text.c_str(), &font_width, &font_height);
 
            switch(justification)
            {
                case ES_CENTER:
                    horizontal_justification = font_width/2;
                break;
 
                case ES_LEFT:
                    horizontal_justification = 0;
                break;
 
                case ES_RIGHT:
                    horizontal_justification = font_width;
                break;
 
                default:
                break;
            }
 
            pos.x = x-horizontal_justification;
            pos.y = y-font_height/3;
 
            switch(style)
            {
                case ES_SOLID: // rapide
                    txt = TTF_RenderText_Solid(resources.get_sttf_font(resource_name), text.c_str(), color);
                break;
 
                case ES_SHADED: // moyenement rapide, arriére plan non transparent (rendu lisse)
                    txt = TTF_RenderText_Shaded(resources.get_sttf_font(resource_name), text.c_str(), color, color_bg);
                break;
 
                case ES_BLENDED: // assez lent mais meilleur qualité (rendu lisse + colorkey)
                    txt = TTF_RenderText_Blended(resources.get_sttf_font(resource_name), text.c_str(), color);
                break;
 
                default:
                break;
            }
 
            SDL_BlitSurface(txt, NULL, SDL_GetVideoSurface(), &pos);
            SDL_FreeSurface(txt);
        }
 
    #ifdef ES_USE_OPENGL
    }
    else
    {
        if(resources.get_gl_font(resource_name) != 0)
        {
            switch(justification)
            {
                case ES_CENTER:
                    resources.get_gl_font(resource_name)->setHorizontalJustification(OGLFT::Face::CENTER);
                break;
 
                case ES_LEFT:
                    resources.get_gl_font(resource_name)->setHorizontalJustification(OGLFT::Face::LEFT);
                break;
 
                case ES_RIGHT:
                    resources.get_gl_font(resource_name)->setHorizontalJustification(OGLFT::Face::RIGHT);
                break;
 
                default:
                break;
            }
 
            resources.get_gl_font(resource_name)->setVerticalJustification(OGLFT::Face::TOP);
 
            resources.get_gl_font(resource_name)->setForegroundColor(color.r, color.g, color.b);
 
            glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
 
            glPushMatrix();
                glEnable(GL_TEXTURE_2D);
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
                glTranslatef(x, y, 0.);
                glRotatef(180., 1., 0., 0.);
 
                resources.get_gl_font(resource_name)->draw(0, 0, text.c_str());
 
                glDisable(GL_BLEND);
                glDisable(GL_TEXTURE_2D);
            glPopMatrix();
        }
    }
    #endif
}

à noter que si j'affiche autre chose que les fps (genre la valeur d'une autre variable) ça ne plante pas, ça viendrait peut être du calcul du fps non ? seulement j'ai testé la fonction qui calcule les fps trouvé sur un sujet du forum et ça n'as pas fonctionné.

Ensuite, j'ai un problème de vitesse d'execution entre OpenGL et SDL, j'ai l'impression qu'OpenGL tourne vraiment plus lentement que SDL, j'ai pensé au début que ça pourraît être à cause que du cast en int à l'affichage et apparement c'est bien ça, mais je sais pas très bien comment résoudre ça, j'aurait penser que appeller glVertex2i au lieu des 2f et compagnie aurait pu résoudre le problème mais ça n'est pas le cas.

Voici le code qui affiche une image avec SDL où OpenGL :

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
void ES_Graphics::draw_image(const std::string& resource_name, SDL_Rect src, SDL_Rect rect, bool blend)
{
	if(opengl_mode == false) // affiche avec sdl
		SDL_BlitSurface(resources.get_sdl_img(resource_name), &src, screen, &rect);
	#ifdef ES_USE_OPENGL
	else // affiche avec opengl
	{
		pos_x = rect.x;
		pos_y = rect.y;
		w = rect.w;
		h = rect.h;
 
		glLoadIdentity();
 
		if(blend == true)
		{
			glEnable(GL_BLEND);
			glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
		}
 
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, resources.get_opengl_img(resource_name));
 
		glBegin(GL_QUADS);
			glTexCoord2i(0,0);
			glVertex2i(pos_x,pos_y);
			glTexCoord2i(1,0);
			glVertex2i(pos_x+w,pos_y);
			glTexCoord2i(1,1);
			glVertex2i(pos_x+w,pos_y+h);
			glTexCoord2i(0,1);
			glVertex2i(pos_x,pos_y+h);
		glEnd();
 
		glDisable(GL_TEXTURE_2D);
		if(blend == true)
			glDisable(GL_BLEND);
	}
	#endif
}

Aussi, j'utilise un systéme de ressources génériques grâce au conteneur map de la stl pour charger mes images/fonts etc... mais je pense avoir un petit problème de gestion mémoires, dans ce morceau de code je charge une image avec SDL_image puis je la convertit au format de l'écran et ensuite je place la surface dans mon conteneur avec le texte (clé) associé, seulement j'ai pas l'impression que je libére correctement la surface imageo_temp à chaque fois ? si je fais un SDL_FreeSurface(imageo_temp) après img[resource_name] = imageo_temp; mes images ne peuvent plus s'afficher, comment faire pour libérer correctement cette surface après l'avoir copié dans mon conteneur ? :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				image_temp = IMG_Load(resource_filename.c_str());
				if(image_temp == 0)
					std::cerr << "_Can't load img: \"" << resource_filename.c_str() << "\" -> " << SDL_GetError() << std::endl;
				else
				{
				    imageo_temp = SDL_DisplayFormat(image_temp); // convertit la surface au format de l'écran
				    SDL_FreeSurface(image_temp);
				    if(imageo_temp!=NULL)
				    {
                        img[resource_name] = imageo_temp;
                        if(colorkey == true)
                            SDL_SetColorKey(img[resource_name], SDL_RLEACCEL | SDL_SRCCOLORKEY, SDL_MapRGB(img[resource_name]->format, r, g, b));
				    }
				    else
                        std::cerr << "_Can't convert img surface: \"" << resource_filename.c_str() << "\" -> " << SDL_GetError() << std::endl;
				}

Pour ceux qui veulent tester pour la vitesse d'execution entre OpenGl et SDL avec mon moteur j'ai fait un petit Pong d'exemple qui est disponible ici : http://www.garzul.tonsite.biz/ES/ES_Pong.zip

Pour passer en rendu OpenGL éditer le fichier config.xml et remplacer sdl par opengl

La page du moteur est ici : http://www.garzul.tonsite.biz/wiki/

Merci d'avance pour vos réponses :)

Code:

1 2 3 4 5 6 7 8 font->draw_text("global font", "FPS: "+to_string(fps), graphics->get_window_width(), 0, graphics->color(255, 255, 255, 0), ES_RIGHT); if(SDL_GetTicks()-time>=150) { fps = 1000/(SDL_GetTicks()-check_time); time = SDL_GetTicks(); }
Déjà je trouve cela dangereux, si ton tour de boucle fait moins d'un ms, alors tu risque le segfault sur ta division. Je ne comprends pas pourquoi tu as un check_time et un time...

Ensuite à la place de :

Code:

font->draw_text("global font", "FPS: "+to_string(fps), graphics->get_window_width(), 0, graphics->color(255, 255, 255, 0), ES_RIGHT);

fait ceci :
Code:

1 2 3 4 5 6 7 std::string str("FPS "); std::ostringstream oss; oss << fps; str += oss.str(); font->draw_text("global font", str.c_str(), graphics->get_window_width(), 0, graphics->color(255, 255, 255, 0), ES_RIGHT);
Enfin, je trouve bizarre de faire le calcul de fps APRES avoir affiché la valeur. Certes c'est une question d'une itération mais quand même...

Si cela ne change, je regarderais la fonction draw_text.

[QUOTE=Grzz-]

Citation:

Ensuite, j'ai un problème de vitesse d'execution entre OpenGL et SDL, j'ai l'impression qu'OpenGL tourne vraiment plus lentement que SDL, j'ai pensé au début que ça pourraît être à cause que du cast en int à l'affichage et apparement c'est bien ça, mais je sais pas très bien comment résoudre ça, j'aurait penser que appeller glVertex2i au lieu des 2f et compagnie aurait pu résoudre le problème mais ça n'est pas le cas.

Déjà je pense que ton calcul de FPS est bizarre, on reverra cela si ma solution fonctionne. Ensuite, il faudrait utiliser des entiers, car faire une recherche de chaîne de caractères est une mauvaise idée.

Si tu veux garder cela, tu peux mais alors il faudra implémenter une table de hachage ou une solution intelligente pour gérer le tout.

Citation:

Aussi, j'utilise un systéme de ressources génériques grâce au conteneur map de la stl pour charger mes images/fonts etc... mais je pense avoir un petit problème de gestion mémoires, dans ce morceau de code je charge une image avec SDL_image puis je la convertit au format de l'écran et ensuite je place la surface dans mon conteneur avec le texte (clé) associé, seulement j'ai pas l'impression que je libére correctement la surface imageo_temp à chaque fois ? si je fais un SDL_FreeSurface(imageo_temp) après img[resource_name] = imageo_temp; mes images ne peuvent plus s'afficher, comment faire pour libérer correctement cette surface après l'avoir copié dans mon conteneur ? :
Code:

1 2 3 imageo_temp = SDL_DisplayFormat(image_temp); // convertit la surface au format de l'écran SDL_FreeSurface(image_temp);
Il faut utiliser une autre variable :
Code:

1 2 3 imageo = SDL_DisplayFormat(image_temp); // convertit la surface au format de l'écran SDL_FreeSurface(image_temp);
et utiliser ta nouvelle variable pour le conteneur (sans faire de SDL_FreeSurface dessus bien sûr).

Jc

21/07/2007, 20h56
Grzz-
Citation:

Déjà je trouve cela dangereux, si ton tour de boucle fait moins d'un ms, alors tu risque le segfault sur ta division. Je ne comprends pas pourquoi tu as un check_time et un time... Enfin, je trouve bizarre de faire le calcul de fps APRES avoir affiché la valeur. Certes c'est une question d'une itération mais quand même...

En faît c'est bien une question de division par 0... j'aurais dû y réfléchir plus tôt, surtout que le programme ne planter pas directement au démarrage mais après quelques secondes.
Vu que c'est un programme de test j'avais directement copié coller sans trop regarder la fonction. (les résultats prècis ne m'intéresser pas)

Citation:

Ensuite, il faudrait utiliser des entiers, car faire une recherche de chaîne de caractères est une mauvaise idée.

Si tu veux garder cela, tu peux mais alors il faudra implémenter une table de hachage ou une solution intelligente pour gérer le tout.

En effet je vais peut être avoir des problèmes plus tard si je dois afficher beaucoups de choses, je vais allez voir du coté des tables de hachages et compagnies mais... est-ce que ça vaut vraiment le coup pour un moteur 2D ? (sachant que généralement il n'y à pas énormément de choses à afficher en même temps)

En faît pour le problème de vitesse j'ai conçus un exemple qui faît beaucoups plus de calculs et d'affichages de sprites que le Pong et sous OpenGL il tourne bien plus vite que SDL... alors que c'est l'inverse pour le Pong, je ne sais pas du tout ce qui peut causer ce problème mais je vais regarder du coté des polices OpenGL. (car j'ai des problème d'affichages ici et je me demande si ça ne pourraît pas en être la cause)

Citation:

Il faut utiliser une autre variable :

Je pense que tu à mal lu le code -> imageo_temp / image_temp
Mais bon c'étaît pas très simple à deviner, je vais allez corriger ça.

Si je copie la surface dans la nouvelle surface que crée le conteneur je peux libérer la surface temporaire après non ? exemple :
Code:

1 2 img[resource_name] = imageo_temp; SDL_FreeSurface(imageo_temp);
Vu qu'ensuite si je charge une autre ressource la surface imageo_temp n'est pas libéré. Mais bon si je faît ça je ne peut plus afficher mes images donc peut être que je me trompe sur le fonctionnement du conteneur map...

En tout cas merci pour l'aide.
22/07/2007, 13h52
fearyourself
Citation:

Envoyé par Grzz-

En effet je vais peut être avoir des problèmes plus tard si je dois afficher beaucoups de choses, je vais allez voir du coté des tables de hachages et compagnies mais... est-ce que ça vaut vraiment le coup pour un moteur 2D ? (sachant que généralement il n'y à pas énormément de choses à afficher en même temps)

C'est comme tu préféres, mais ca sera important un jour. Tu peux retarder la chose tant que ce n'est pas primordiale.
Citation:
Je pense que tu à mal lu le code -> imageo_temp / image_temp
Mais bon c'étaît pas très simple à deviner, je vais allez corriger ça.

Si je copie la surface dans la nouvelle surface que crée le conteneur je peux libérer la surface temporaire après non ? exemple :

Code:

1 2 img[resource_name] = imageo_temp; SDL_FreeSurface(imageo_temp);
En effet, j'ai mal vu, désolé. Non, tu ne peux pas. En faisant cela, tu copies le pointeur vers la structure, pas la structure. Et surtout pas les données pointées par la structure. SDL_DisplayFormat te fait une vraie copie c'est pour cela que tu peux faire :
Code:

1 2 img[resource_name] = SDL_DisplayFormat(imageo_temp); SDL_FreeSurface(imageo_temp);
Jc
22/07/2007, 23h32
Grzz-

J'ai trouvé ça dans une extension de la STL, est-ce que c'est sufisant ?

http://www.sgi.com/tech/stl/hash_map.html
23/07/2007, 08h51
fearyourself
Citation:

Envoyé par Grzz-

J'ai trouvé ça dans une extension de la STL, est-ce que c'est sufisant ?

http://www.sgi.com/tech/stl/hash_map.html

Cela n'a rien à voir, comme dit, il ne faut pas confondre une copie totale faite avec SDL_DisplayFormat par exemple, et une copie de pointeur.

Même ceci ne ferait pas une copie totale mais seulement une copie superficielle :
Code:

1 2 SDL_Surface tmp = *imagetmp;
Jc
23/07/2007, 15h09
Grzz-

oops en faît je disais ça à propos de la table de hachage, désolé ;) :

Citation:

Si tu veux garder cela, tu peux mais alors il faudra implémenter une table de hachage ou une solution intelligente pour gérer le tout.
23/07/2007, 15h48
fearyourself

Citation:

Envoyé par Grzz-

oops en faît je disais ça à propos de la table de hachage, désolé ;) :

Ah oui, alors je suis d'accord :wink:

Jc
23/07/2007, 19h44
Grzz-

Pour les problèmes de ralentissements au niveau d'OpenGL c'est la gestion des ressources en faît apparement... (le faît de ne copier que l'adresse) Merci pour toutes les indications !