pixels ou SDL_surface 8 bits?

Version imprimable

Bonjour,

j'ai posté récemment un petit projet c++ pour afficher le mandelbrot.
Mon problème, c'est que je calcul l'image à 60 FPS, alors qu'elle s'affiche à 15FPS seulement.

Je pense que c'est parce que pour chaque pixel, je blitte une surface rgb 32 bits de taille 1x1.

J'ai cru comprendre qu'on pouvait colorer les pixels à la main, ou utiliser du rgb 8 bits pour aller plus vite.

Dans les deux cas (et plus particulièrement le deuxième), je ne sais pas comment faire.

Pourriez vous m'aider svp?

Pour l'instant ça se passe comme ça :
Code:

1 2 3 4 5 6 // allocation des surfaces SDL_Surface** surfaces = (SDL_Surface**) malloc(size*sizeof(SDL_Surface*)) ; for (int i = 0 ; i < size ; ++i) { surfaces[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0); }
Code:

1 2 3 4 5 // blit de la surface mid [qui est un indice de boucle parcourant tout l'écran] // zou est une structure contenant mes couleurs rgb SDL_FillRect(surfaces[mid], NULL, SDL_MapRGB(ecran->format, zou.red, zou.green, zou.blue)); SDL_BlitSurface(surfaces[mid], NULL, ecran, &Position) ;

25/02/2011, 09h32
flasheur

houlà un blit hardware par pixel.. argh 8O... là ta carte vidéo affiche une texture différente à chaque pixel tu m'étonnes que ça rame

je connais très mal SDL...

avec la librairie windows on fait comme ça pour afficher une soupe de pixels: on modifie les cellules d'un tableau de pixels et on le balance dans une seule image blittée (enfin, deux images, pour avoir le doublebuffer)

donc si on applique ça à SDL, tu peux modifier une texture pixel par pixel, et la blitter dans un seul rectangle

si ta texture est un rgb 8 bits alors oui ça devrait être plus rapide, au lieu de mettre à jour 24 bits par pixels, tu n'en mets à jour que 8.. ensuite la carte vidéo se charge d'appliquer la palette.. mais là je m'y connais mal aussi

mais il me semble que dans SDL il existe un truc tout fait pour gérer l'affichage pixel par pixel, mais je me souviens plus donc je suis pas sûr
25/02/2011, 09h58
LittleWhite

Bonjour,

Nous avons de la chance, la documentation décrit une méthode pour changer les pixels d'une surface: http://www.libsdl.org/docs/html/guidevideo.html#AEN97
(Cherchez un peu autour dans la doc ne fera pas de mal)

Le blit pixel par pixel est la pire chose, car j'imagine que le lock sur les surfaces va être enclenché plusieurs fois au lieu d'une et une seule fois.

Sinon, la technique de flasheur en passant par un buffer (donc surface en mémoire, temporaire, puis blit) est une bonne idée ...

Et je suis désolé de dire, mais la SDL avec les PCs, n'a aucune opération accélérée par la hardware ... :(
25/02/2011, 10h25
flasheur

??? attends tu veux dire que dans SDL, tout ce que gère la carte vidéo sur PC c'est la vsync ?

j'ai toujours lu que dans SDL le blit est accéléré par le gpu
25/02/2011, 10h34
LittleWhite

Citation:

Envoyé par flasheur

??? attends tu veux dire que dans SDL, tout ce que gère la carte vidéo sur PC c'est la vsync ?

j'ai toujours lu que dans SDL le blit est accéléré par le gpu

C'est quoi que vous appelez le vsync ? Copie du buffer software sur l'ecran ? ... alors oui ... c'est surement le minimum.

En fait, la SDL peut etre accelere par le GPU, mais le seul cas ou je suis sur que cela est fait ... c'est sur la GP2X ...

Essayez d'avoir une grande surface (1024x786) et de remplire tile par tile de 32x32 ... vous allez voir ... les performances ne sont pas vraiment convaincantes.

Vous allez peut etre me parler des flags SDL du genre SDL_HWSURFACE. Oui on doit utiliser ces flags mais non ... il ne sont pas toujours efficace. Il y a moyen de savoir si la plateforme accelere par le GPU les interactions de la SDL avec une fonction dont j'ai legerement oublier le nom -> ah ! http://code.google.com/p/openawars/s..._Window.cpp#57 SDL_GetVideoInfo()
Et sur windows on voit bien qu'il n'y a pas de hardware ....

En effet, j'ai codé ça :

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
 
void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, colors c)
{    
	Uint32 color = getcolor(c) ;
	Uint8 bpp = surface->format->BytesPerPixel;  
	Uint8 * p = ((Uint8 *)surface->pixels) + y * surface->pitch + x * bpp;     
	switch(bpp)    
	{	  
	case 1:		
		*p = (Uint8) color;		
		break;        
	case 2:            
		*(Uint16 *)p = (Uint16) color;            
		break;        
	case 3:            
		if (SDL_BYTEORDER == SDL_BIG_ENDIAN)            
		{                
			*(Uint16 *)p = ((color >> 8) & 0xff00) | ((color >> 8) & 0xff);                
			*(p + 2) = color & 0xff;            
		}            
		else           
		{                
			*(Uint16 *)p = color & 0xffff;                
			*(p + 2) = ((color >> 16) & 0xff) ;            
		}            
		break;        
	case 4:            
		*(Uint32 *)p = color;            
		break;    
	}
}

ce qui me permet de faire ça :

Code:

1
2
 
putPixel(ecran, i, j, zou) ;

ce qui m'amene à 195 FPS : nettement mieux ;)

merci beaucoup