SDL con resoluciones altas

[drinor]

Hola buenas,

El problema que tengo es que cuando creo un juego con una resolución mayor de 800x600 y actualizo toda la pantalla (el fondo completo y las demás imágenes) tarda demasiado en realizar esta operación y se bajan los frames por segundo a menos de 30.

Ya he probado con varios ejemplos y siempre me ocurre lo mismo.

Espero que me digais si es que SDL no es capaz de dibujar una pantalla completa de 1024x800 o 1280x800 a una velocidad alta o que yo cometo algún error.


Muchar gracias.

[Metalero]

Mira, el desmepeño va a depender mucho de la maquina que tengas, de la complejidad de lo que estas mostrando en pantalla, y que tan optimizado esta.

Recien hice una prueba como para darte algunon numeros, y mira:

Mi PC es una AMD Phenom X4 (2.33Ghz x 4) + 2 Gb RAM + ATI Radeon HD 4300.

Probe mi proyecto (que estoy haciendo en SDL) con un rasolucion de 1280 x 1024, sacandole el limitador de FPS, y segun la "fase del juego hay muchas variaciones, que van entre los 180 y los 70 FPS (excepto una parte que realmente esta bastante "fea" en cuanto a la programacion y los FPS caen a 20)

Pero para que des una idea, la parte mas jodida, es el mapa, que dibuja por cada frame (a 1280 x 1024):

320 Tiles de 64x64 + 4 avion (aprox 100 * 200) + algunas balas (5 x 8 )

Y el mapa me anda en un rango de 100 - 70 FPS

Como veras, estando el codigo optimizado, (y contando con una PC buena) podes tener buenos FrameRates.

Si el problema es la PC, o estas dibujando algo demasiado complejo (rotaciones/escalado multiples, etc), lo mejor seria (antes que anda optimiar todo al palo) usar una resolucion mas baja (como 800 x 600, que es lo que pienso usar yo en mi juego, o 640 x 480) y usar la funcion de la SDL para hacer FULLSCREEN, con lo que cambia la resolucion del monitor a la resolucion del juego, obteniendo mayor performance, y una imagen grande.

[drinor]

Mira un ejemplo simple que tengo hecho que simplemente dibuja un fondo que se va moviendo en una ventana de 1024x800 funciona como mucho a 35 fps así que en cuanto le pongo más cosas se suben mucho los frames.

El código es:

#include <stdio>
#include <stdlib>
#include <SDL>
#include <iostream>
using namespace std;

#define An 1024
#define Al 800

Uint32 ini_milisegundos, fin_milisegundos, frametime;

void ResetTimeBase()
{
ini_milisegundos = SDL_GetTicks();
}

int CurrentTime()
{
fin_milisegundos = SDL_GetTicks();
return fin_milisegundos - ini_milisegundos;
}

int main(int argc, char **argv)
{
int i, j, cont = 0, salir = 0;

SDL_Surface *screen, *fondo;
SDL_Rect rect;
SDL_Event event;

if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0)
{
printf("No se pudo iniciar SDL: %s\n",SDL_GetError());
return 1;
}

screen = SDL_SetVideoMode(An,Al,24,SDL_HWSURFACE);

if(screen == NULL)
{
printf("No se puede inicializar el modo gráfico: \n",SDL_GetError());
return 1;
}

fondo = IMG_Load("fondo.png");
fondo = SDL_DisplayFormat(fondo);

while(!salir)
{
ResetTimeBase();

for(i=0;i<Al;i+=64)
{
for(j=0;j<An;j+=64)
{
rect.x = j;
rect.y = (i + cont) % Al ;

SDL_BlitSurface(fondo, NULL, screen, &rect);
}
}

cont++;

SDL_Flip(screen);

while(SDL_PollEvent(&event))
{
if(event.type == SDL_QUIT)
salir = 1;
}

frametime = CurrentTime();
cout<<"F:"<<1000/frametime<<endl;
}
}

La imagen que uso es (64x64):



Espero que me podais ayudar.

Muchas gracias.

[Metalero]

Mmmm... ahi veo aparentemente todo bien, con la excepcion de:

Código: Seleccionar todo

fondo = IMG_Load("fondo.png");
fondo = SDL_DisplayFormat(fondo);


que deberia ser:

Código: Seleccionar todo

SDL_Surface *tmp =  IMG_Load("fondo.png");
fondo = SDL_DisplayFormat(tmp);
SDL_FreeSurface(tmp);


Que computadora tenes?

[drinor]

Tengo este portatil:

http://www.audiotronics.es/product.aspx?imageid=1&productid=43432

Estoy programando sobre Ubuntu.

Prueba tu el código si no te importa y me dices a cuantos frames te va a ti.

Muchas gracias por tu ayuda.

[carlostex]

Hola, estuve haciendo pruebas con mi código, el mio solo dibuja un rectángulo para el fondo y luego pone tres imágenes pequeñas en un tamaño de 1280 x 800 hace 25 FPS.
Entonces le quite que dibuje el rectángulo de fondo y corrió a 40 FPS. Una de las formas de optimizar el bliting es solo copiar las partes necesarias, en mi ejemplo solo dibujo tres objetos, lo que podría hacer en ves de dibujar todo el rectángulo dibujaría un rectángulo del tamaño de la imagen en la posición donde estaba de tal forma que se borre y no deje el rastro. pero si tu juego usa un scroll continuo no hay forma de hacer eso.

[endaramiz]

Es normal que vaya lento. Si vas a hacer un scroll (en algunos casos podrías hacer optimizaciones bastante buenas), en cada frame tienes que copiar altura*anchura*BitsPerPixel bits como mínimo. En tu caso son 1024*800*24 = 19660800 bits que son algo más de 2MB (si mis cálculos rápidos no me fallan).
La fórmula tiene 3 variables, si quieres mantener la altura y la anchura, puedes cambiar los BitsPerPixel. Yo he probado con 8 y me ha pasado de 33FPS a 67FPS.
Como te comentaban antes, otra opción es bajar la altura y la anchura. Deberías plantearte seriamente si es necesaria una resolución tan grande. Porque otra opción que se me ocurre es usar otra API que tenga aceleración por hardware.

Saludos.

[drinor]

Entonces si quiero crear un juego con estas características mejor me busco otra API como por ejemplo OPENGL ya que parece que SDL no tiene tanta potencia.

Muchas grácias por vuestras respuestas.

[carlostex]

Entonces ¿SDL no tiene aceleración por hardware?,, he visto que tiene la opción de pasarle SDL_HWSURFACE entonces que hace esa función?.

de todas formas no te preocupes tanto, de lo que si estoy seguro es que no es tiempo perdido haber aprendido SDL, pues se suele usar junto con GL, de esa forma GL se usa para los gráficos dado que no tiene el soporte que tiene SDL para multimedia.

[lacabra25]

Entonces ¿SDL no tiene aceleración por hardware?,, he visto que tiene la opción de pasarle SDL_HWSURFACE entonces que hace esa función?.

de todas formas no te preocupes tanto, de lo que si estoy seguro es que no es tiempo perdido haber aprendido SDL, pues se suele usar junto con GL, de esa forma GL se usa para los gráficos dado que no tiene el soporte que tiene SDL para multimedia.

SDL_HWSURFACE lo unico que hace es indicar a SDL que una determinada superficie (ya sea la pantalla u otra superficie) se guarde en la memoria de video, la memoria que incorpora la tarjeta grafica, en lugar de en la memoria RAM normal del ordenador, esto si no recuerdo mal se hace para las superficies que vamos a usar con frecuencia para que el tiempo necesario para trabajar con ellas sea menor al estar en la memoria de video, pero el motivo de escoger entre guardar la superficie entre la memoria normal o la memoria dedicada seguramente otro pueda explicarlo mejor que yo.

Efectivamente aprender SDL no es en absoluto una perdida de tiempo, GL es mucho mas potente en cuanto a graficos, pero es un estandar que define una API unicamente para los graficos, no da soporte a el resto de multimedia y tampoco a las ventanas, necesita de SDL o de alguna API que le proporcione una ventana, una superficie en la que poder "dibujar", asi como SDL es con la que podremos detectar los diferentes eventos, GL no puede.

[drinor]

Muchas grácias por vuestras respuestas me han sido de mucha ayuda.

Entonces intentaré usar OpenGL sobre SDL.

¿ Alguien sabe donde puedo encontrar un ejemplo bien comentado sobre el uso de OpenGL sobre SDL para linux o un manual?

[Juanxo]

En este post salen algunas paginas que te pueden ayudar con estos temas

[drinor]

En este post salen algunas paginas que te pueden ayudar con estos temas

Muchas gracias por el link me ha sido de mucha ayuda.