Empezando con SDL

[migueleitorone]

Hola, soy un chico de 17 años de barcelona y estoy interesado en el desarrollo y programacion de videojuegos.
Se algo de c y he querido empezar a tocar graficos, he probado opengl pero me parece bastante complicado y hay muy poca documentacion en español. Asi que me puse con SDL, con este tutorial: http://lazyfoo.net/SDL_tutorials

Estoy en el tema 2 del tutorial y me surge una duda, que significan los parametros de estas funciones?:

Código: Seleccionar todo

SDL_Surface *load_image( std::string filename )<---------------------------------------------------
{
    //Temporary storage for the image that's loaded
    SDL_Surface* loadedImage = NULL;
    //The optimized image that will be used
    SDL_Surface* optimizedImage = NULL;
    //Load the image loadedImage = SDL_LoadBMP( filename.c_str() ); <------------------------------------
    //If nothing went wrong in loading the image
    if( loadedImage != NULL )
    {
          //Create an optimized image
          optimizedImage = SDL_DisplayFormat( loadedImage );
         //Free the old image SDL_FreeSurface( loadedImage );
     } 

http://lazyfoo.net/SDL_tutorials/lesson02/index.php

gracias por la ayuda

[Geo]

Un poco de teoría rápida .
Comentas que sabes algo de c, entonces si has manejado "cadenas de texto" ( o "cadenas de caracteres") en este lenguaje, sabrás que se usan arrays de tipo char para el efecto.
La biblioteca SDL está programada en C, y para el caso de parámetros de funciones que necesiten "cadenas de texto" espera recibir un puntero al tipo char, que indica el inicio de una serie de caracteres.
Los tutoriales que sigues usan C++, el cual puede manejar todos los tipos de datos del lenguaje C, pero también, la biblioteca estándar de este lenguaje incluye una clase o tipo llamado string, que permite manejar "cadenas de texto" de manera un tanto más práctica que en lenguaje C.

Ahora con tus preguntas

Código: Seleccionar todo

SDL_Surface *load_image( std::string filename )

Indica que el parámetro es de tipo string y que pertenece al "espacio de nombres" std, esto del espacio de nombres es como un contenedor, lo puedes equiparar a cuando en una estructura tienes diferentes variables y las refieres como estructura.miembro, aquí sería espaciodenombres::identificador, checa un poco más en la wikipedia.

Código: Seleccionar todo

//Load the image loadedImage = SDL_LoadBMP( filename.c_str() );

SDL_LoadBMP espera recibir como parámetro una "cadena de texto" al "estilo C", pero filename es de tipo string. La función c_str() "convierte" el valor de filename a una cadena "al estilo C", que es lo que espera la función SDL_LoadBMP.

[endaramiz]

La respuesta de Geo está muy bien, solo añadir que puedes incluir el "espacio de nombres std" con la línea "using namespace std;". De este modo, no hace falta usar "std::". En muchos códigos se hace esto por comodidad.

Aquí tienes una web de referencia muy buena donde puedes ver todo lo que puedes hacer con string, muchas otras estructuras de datos...

[migueleitorone]

Aver si lo he entendido, en el protitipo de la funcion, le digo al programa que el parametro va a ser un string llamado filename, es decir filename es el nombre que le doy al parametro no? Y string es el tipo de dato, que se encuentra en el namespace std?

Código: Seleccionar todo

SDL_Surface *load_image( std::string filename )

Aqui simplemente se pasa el string y se convierte a "c" para que pueda ser usado por la funcion SDL_LoadBMP?

Código: Seleccionar todo

//Load the image loadedImage = SDL_LoadBMP( filename.c_str() );

Lo que no me queda nada claro es por que usar esta funcion para cargar una imagen cuando se puede hacer simplemente con SDL_LoadBMP?

Código: Seleccionar todo

SDL_Surface *load_image( std::string filename )
{
    //Temporary storage for the image that's loaded
    SDL_Surface* loadedImage = NULL;
    //The optimized image that will be used
    SDL_Surface* optimizedImage = NULL;
    //Load the image loadedImage = SDL_LoadBMP( filename.c_str() );
    //If nothing went wrong in loading the image
    if( loadedImage != NULL )
    {
          //Create an optimized image
          optimizedImage = SDL_DisplayFormat( loadedImage );
         //Free the old image SDL_FreeSurface( loadedImage );
     } 

muchas gracias por la ayuda, seguire pasando por aqui

[Geo]

Eso es a gusto, comodidad, estilo o hasta capricho del programador .

Toma en cuenta que, dentro de load_image, además de cargar la imagen, se "convierte" al formato de la superficie que se usa para mostrar cosas en pantalla, de esta forma se consigue que el dibujar la imagen a pantalla (blit) sea más rápido (al menos eso dicta la teoría).

Según lo veo, lo que permite load_image es emplear std::string que para muchos puede ser más cómodo, además de devolver una SDL_Surface ya convertida a formato de la superficie que representa la pantalla, así no tienes que repetir este código (SDL_DisplayFormat) cada que llames a SDL_LoadBMP.

[Juanxo]

Básicamente es como te ha comentado Geo. Tu tienes un trozo de código que se repite cada vez, asi que te creas tu funcion propia para ahorrar esfuerzo y mejorar el código.
Otro punto importante es la portabilidad. Ahora lógicamente no le darás demasiada importancia, pero imaginate que decides pasar tu código a SFML (una biblioteca muy similar a SDL). Con tu funcion propia simplemente tendrías que cambiar una vez lo de load_BMP. De la otra manera tendrías que cambiar cada linea que utilice load_BMP.

[migueleitorone]

Para que sirve convertirla al mismo formato? el formato es .bmp, .jpg, etc?

[carlostex]

No ese formato, cuando cargas una imagen en SDL, ya no existe eso del formato de la imagen, todas las imagenes se representan con la misma estructura, la cual es el de una superficie y lo que contiene es el array de valores, sobre las estructuras hay libros en esta web que contiene información de las estrcuturas internas de SDL, quizas no te sirva saber como trabaja SDL, pero lo que te digo lo aprendí de ese libro.
AL hablar del formato dentro de SDL, se refiere a como se representan los valores de la imagen, es decir cada pixel esta dado por un numero de bits, 24 bits es una imagen de color real. Existen de 16, 8, 4, y 32 bpp(bits por pixel), generalmente para las computadoras modernas se usan 32 bits, que admite la tranparencia de imagenes, asi ya no tienes que hacer el colorkey, yo uso imagenes de 32 bits con el formato PNG, y de hecho es mas rapido que usar imagenes de 24.
De cualquier forma si trabajas con menores bpp se debe hacer la converción al formato de la superficie, por ejemplo si tu superficie es de 32 bits, y cargas una imagen de 24 bits, deberias convertir la imagen a 32 bits. Este proceso se hace antes de copiar cada imagen a la superficie, pues la converción entre formatos requiere un tiempo considerable de computo.

[migueleitorone]

entonces si tengo una pantalla como esta:

Código: Seleccionar todo

  screen = SDL_SetVideoMode( 640, 480, 32, SDL_SWSURFACE );

y una imagen, uso SDL_DisplayFormat() para convertir la imagen a 32 bits?
Que pasa si no la convierto? Y si la imagen ya es de 32 bits?

Se usaria asi no?

Código: Seleccionar todo

screen = SDL_DisplayFormat( imagen );

muchas gracias

[RafaG]

Es mejor convertir las imágenes con SDL_DisplayFormat porque así solo se tendrá que hacer una vez la conversión, si no lo haces, cada vez que se haga SDL_BlitSurface(imagen,...) SDL lo tendrá convertir y la aplicación se hará más lenta. Y si la imagen es de 32 bits y la conviertes, supongo que no pasará nada.

Saludos.

[migueleitorone]

entiendo. gracias por aclararme la duda

[migueleitorone]

hola, iba a avanzar en el tutorial pero acabo de ver que no me ha quedado del todo claro el asunto,

Código: Seleccionar todo

//If nothing went wrong in loading the image
if( loadedImage != NULL )
{
     //Create an optimized image
     optimizedImage = SDL_DisplayFormat( loadedImage );
     //Free the old image
     SDL_FreeSurface( loadedImage );
}

SDL_DisplayFormat convierte loadedImage al formato de optimized image, pero en ningun momento se indica cual es el formato de optimizedImage, si su formato fuera de 24 bits, no serviria de nada suponiendo que tuviera que insertar optimizedImage a

Código: Seleccionar todo

screen = SDL_SetVideoMode( 640, 480, 32, SDL_SWSURFACE );

la conversion se tendria que volver a hacer? o el formato por defecto es de 32 bits?
Igual me estoy haciendo un lio, pero me da que faltan datos.

[Juanxo]

Los comienzos siempre son duros xD

SDL_DisplayFormat no convierte la imagen que le pasas como parámetro, sino que internamente crea una nueva y te la devuelve con el formato de la pantalla, de ahi lo de optimizedImage (imagen optimizada)

[migueleitorone]

es decir, si yo tengo

Código: Seleccionar todo

screen = SDL_SetVideoMode( 640, 480, 32, SDL_SWSURFACE );

SDL_DiplayFormat me convierte la imagen que le pase a 32 bits, si tengo esto otro

Código: Seleccionar todo

screen = SDL_SetVideoMode( 640, 480, 24, SDL_SWSURFACE );

me convertira la imagen a 24 bits no?

[Juanxo]

si, de hecho, en la sección de libros de LosersJuegos tienes un manual de referencia completísimo de SDL, escrito por Antonio García Alba que te explicará en detalle todos estos temas y te servirá de guía

[migueleitorone]

a perfecto, voy a hecharle un ojo aver si sigo con ese, que me esta costando bastante estudiar en ingles.
gracias de nuevo

[adrigm77]

http://softwarelibre.uca.es/wikijuegos/

[migueleitorone]

gracias por el link, aunque ya me habia bajado la version en pdf.
Muy buen manual, extenso y muy ameno de leer.

[yasser_001200]

Hola. Mi nombre es Yasser y soy de Cuba. Me encanta la programación de videojuegos. Quisiera que me digan cómo hago para mover una imagen por la pantalla con las flechas de direccion, pero que detecte cuando las dejo presionadas por ejemplo: mientras tenga LEFT presionado que vaya a laizquierda y si lo suelto y presiono RIGHT que vaya a la derecha, sin detenerse. Tengo una idea de cómo hacerlo pero tendría que usar una macro de windows para detectar teclas y no una funcion de SDL... creo que SDL usa algo de SDL_GetKeyState