Hola a todos. Aqui teneis mi nuevo Tutorial sobre programacion para PSP usando SDL. En este tutorial vamos a tratar un tema muy simple. Vamos a dar nuestros primeros pinitos pintando en la pantalla de la PSP :-).

Lo primero que vamos a pintar es un cuadro morado, la pantalla al final quedara asi:

Lo primero que necesitais para poder compilar un ejecutable es el archivo MAKEFILE. Aqui teneis todas sus partes. Este archivo MAKEFILE es el que usaremos para casi todas las aplicaciones que creemos, solo tendremos que modificar unas simple cosas como os explique en el Tutorial de como compilar nuestro codigo con CYGWIN. Pero por ahora nos sirve tal cual esta dado que nuestros programas por el momento no necesitaran nada mas.

--------------------------MAKEFILE------------------------

TARGET = Prueba1
 
PSPSDK = $(shell psp-config --pspsdk-path)
 
PSPBIN = $(PSPSDK)/../bin
 
 
 
OBJS = main.o
 
 
JOY = YES
 
CFLAGS = -Wall -Wno-long-long -G0 -O2 -DJOY_$(JOY)
 
CFLAGS += $(shell $(PSPBIN)/sdl-config --cflags)
 
 
 
LIBS = -lstdc++ -lSDL $(shell $(PSPBIN)/sdl-config --libs)
 
 
 
EXTRA_TARGETS = EBOOT.PBP
 
PSP_EBOOT_TITLE = Prueba1
 
 
 
include $(PSPSDK)/lib/build.mak

Mirad aqui teneis el codigo fuente. Voy a explicar simplemente lo imprescindible por que doy por supuesto que sabeis algo de programacion en C y por que el tema de la programacion en C es muy estenso para esta serie de tutoriales. Pero todo el que haya programado alguna vez en C conocera las partes basicas de un programa en C asi que pasare a explicar estas partes muy rapidamente.

-------------------- CODIGO FUENTE----------------------

#include <pspkernel.h>
#include <sdl.h>
 
int main()
{
 
SDL_Surface *PantallaV;
SDL_Rect Cuadrado;
SDL_Event event;
 
Cuadrado.x = 0;
Cuadrado.y = 0;
Cuadrado.w = 50;
Cuadrado.h = 50;
 
SDL_Init(SDL_INIT_VIDEO);
PantallaV = SDL_SetVideoMode(480, 272, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
SDL_FillRect(PantallaV, &Cuadrado, SDL_MapRGBA(PantallaV->format,255,0,255,0));
SDL_Flip(PantallaV);
 
while (SDL_WaitEvent(&event))
{
if (event.type == SDL_QUIT) {
break;
}
}
 
}

--------------------FIN DEL CODIGO FUENTE--------------------

Empezamos a diseccionar el codigo ;-)

#include <pspkernel.h>

Estas librerias pertenecen a la programacion interna de la PSP y deberas incluirla en todos los programas que hagas para PSP o no te funcionaran. Lo que tiene por dentro se escapa ampliamente de este tutorial, solo os hace falta saber que es necesaria para cualquier
programa que hagais para PSP. Pero si alguien quiere informarse mejor pasaros por la pagina del PSPSDK hay teneis documentacion al respecto.

#include <sdl.h>

Esta libreria que cargamos es la que nos interesa es la encargada de todo el tema grafico y sonoro y poco a poco en esta serie de tutoriales explicaremos la mayoria de las funciones que la integran.

int main()

Esto no necesita presentacion aqui es donde comienza todo programa en C asi que sigo adelante :-)

SDL_Surface *PantallaV;

qui empezamos a usar SDL ;-). Lo que hacemos aqui es definir PantallaV como un tipo de puntero SDL_Surface que lo que quiere decir
en palabaras normales es que PantallaV es como un folio en Blanco que esta listo para que empezemos a pintar en el lo que queramos.

SDL_Rect Cuadrado;
 
SDL_Rect es ni mas ni menos que una estructura lo cual es la siguiente:
 
typedef struct {
Sint16 x, y;
Uint16 w, h;
}SDL_Rect;

y lo que hacemos en esta linea es definir Cuadrado como una estructura SDL_Rect. Como vamos a hacer un cuadrado usamos SDL_Rect dado que nos da los puntos de las cordenados de inicio superior izquierdo que son x e y y las cordenadas inferiores derechas que son w y h y con las siguientes lineas definimos el tamaño del cuadro dandole al programa las cuatro cordenadas.

Cuadrado.x = 0;
Cuadrado.y = 0;
Cuadrado.w = 50;
Cuadrado.h = 50;

y asi creamos un cuadrado de 50X50. Esto lo podemos usar para cortar partes de una imagen y pegarlas en otro sitio ETC.. pero ahora lo vamos a usar para dibujar un cadrado en la pantalla de color morado seguir leyendo y vereis como.

SDL_Event event;

Esta funcion lo que hace es definir event como una estructura de eventos lo usaremos para almacenar los eventos del sistema, las pulsaciones de teclas y demas. Yo no lo suelo usar en mis proyectos, prefiero usar para controlar las teclas las funciones especificas de PSP las cuales ya veremos en sucesivos tutoriales.

SDL_Init(SDL_INIT_VIDEO);

Antes de llamar a cualquier funcion de SDL hay que inicializar la libreria y eso es lo que hacemos con esta funcion SDL_Init();, En este caso lo que hacemos es inicializar el subsistema de video para que la PSP sepa que vamos a pintar en pantalla. La funcion SDL_Init tiene otros subsistemas que puede inicializar como por ejemplo SDL_INIT_AUDIO para iniciar el audio de la PSP o SDL_INIT_TIMER o SDL_INIT_JOYSTICK que no necesita explicacion. Pero para este tutorial solo nos hace falta inicializar el video pues solo queremos mostrar un cuadro morado en pantalla si quisieramos inicializar video y audio lo tendriamos que hacer asi SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO);.

PantallaV = SDL_SetVideoMode(480, 272, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);

Esta parte del codigo es muy importante por que lo que hace es decirle al programa que PantallaV va a ser la pantalla Principal de la PSP. Por eso le damos las dimensiones de la pantalla de la PSP, osea 480X272. Tambien le decimos que vamos a usar la pantalla en modo 32 bits, osea color real. Con SDL_HWSURFACE le decimos que cree la superficie en la menoria de video. Si quisieramos crear la superficie o papel en blanco en la memoria normal usariamos esto SDL_SWSURFACE y con SDL_DOUBLEBUF le decimos que la cree con doble buffer. Con esto lo que conseguimos es eliminar ese parpadeo molesto a la hora de refrescar las imagenes por pantalla.

SDL_FillRect(PantallaV, &Cuadrado, SDL_MapRGBA(PantallaV->format,255,0,255,0));

SDL_Fillrect(); sirve para rellenar un cuadrado de un color determinado y aqui lo vamos a usar para rellenar una parte
de PantallaV de color morado. Esta parte la definimos antes con la estructura Cuadrado, osea que vamos a pintar de morado un cuadrado en pantalla de 50X50 empezando en la posicion X = 0 y Y = 0, osea en el cuadrante 0.0 lo que es la esquina superior izquierda de la pantalla y con SDL_MapRGBA(PantallaV->format,255,0,255,0) le damos la referencia de color usando el RGBA, osea el RED,GREEN,BLUE,ALPHA, los colores primarios que combinados forman todos los colores. Si hubiesemos querido pintar el cuadro de rojo pues tendriamos que haber puesto esto SDL_MapRGBA(PantallaV->format,255,0,0,0).

SDL_Flip(PantallaV);

Esto lo que hace es mostrar el segundo buffer en pantalla en el cual hemos estado puntando el cuadro para que se vea el resultado final nuestro maravilloso cuadro morado

while (SDL_WaitEvent(&event))
{
if (event.type == SDL_QUIT) {
break;
}
}

Esta parte del codigo la pongo junta dado que es un bucle. La primera funcion es la que hace el bucle while (SDL_WaitEvent(&event)). Esto hace una pregunta, que mientras SDL_WaitEvent(&event) sea cierto, osea 1 o mayor de 1 se ejecute la parte que esta dentro de las llaves del bucle, osea la siguiente funcion

if (event.type == SDL_QUIT) {
break;
}

la cual es otra pregunta, que si event.type es igual a SDL_QUIT que se ejecute la parte de codigo entre las llaves; y si no es cierto que siga adelante. En caso de que sea cierto pues se rompe el bucle con la funcion break; y asi llegamos al final del programa por lo tanto salimos de el.

Para que event.type sea igual a SDL_QUIT tenemos que haber pulsado HOME y dicho que si a la pregunta de que si queremos salir del programa.

La verdad es que es un ejemplo muy simple, espero mas adelante hacer cosas un poco mas elaboradas pero esto que teneis aqui se usara siempre. Es la panacea para mostrar cosas por pantalla con SDL.

Nos vemos en el Proximo Tutorial y espero que estos tutoriales os sirvan de ayuda. Cualquier duda que tengais postearlas en este mismo hilo, en mi WEB o mandarmelas por privado que intentare ayudaros con lo que sea.

http://www.develkop.tk/

Por cierto aqui teneis los archivos del codigo fuente asi como el ejecutable del Tutorial.

Un saludo

Kaltorak.