| Inicio | Noticias | Foros PSP | Juegos | Videos | Manuales | Buscar | Contacto | Staff | Publicidad |

Retroceder   Foros PS Vita y PSP > Comunidad > Coder's Zone: Programacion PSP y PS Vita > TUTORIALES

Respuesta
 
Herramientas
Antiguo 12/10/07, 10:20:22   #1
DaRLeK
I♥BETIS
 
Avatar de DaRLeK
 
Fecha de Ingreso: ene 2006
Ubicación: Málaga Paradise
Mensajes: 2.639
Thanks: 372
Thanked 314 Times in 178 Posts
DaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundo

Medalla al merito PSPero 

Predeterminado Tutoriales C

Para cear tu primer programa:

Cita:
Aqui dejo este tuto sobre como programar una aplicacion de PSP,el tutorial esta enfocado al entorno del cygwin,pero podeis usar el Kit de programacion para torpes,el cual os facilitara mas las cosas
Empezamos
Una vez instalado el SDK y Cygwin, teniendo actualizadas todas las librerías, podremos empezar a plantearnos qué es lo que queremos hacer y cómo. Doy por supuesto que habrá gente que lea este tutorial con unos mínimos conocimientos de C o C++, y gente que no. Con él intentaré mostraros la base de cómo estructurar vuestros propios proyectos para PSP. Se intentarán dar los primeros pasos; eso si, para los no iniciados en programación, quiero comentarles que el C no es el mejor lenguaje para empezar a programar.
Organizando nuestros proyectos
Lo primero será crear una jerarquía de las carpetas para organizar nuestros proyectos. Abre una consola bash con el CYGWIN, y teclea mkdir projects y pulsa Enter. Los soportes de este comando "mkdir" parten de "MaKe DIRectory" y creará un directorio, o la carpeta, en su directorio de funcionamiento actual. Bien, ahora tenemos una carpeta nueva para todos nuestros proyectos, navegamos en ella tecleando cd projects. Ahora creamos otro directorio para un proyecto específico. Por ejemplo mkdir helloworld. Y pasamos al nuevo directorio con el comando cd helloworld.
Nota: Recordar a los no iniciados en el bash, para ver el contenido de una carpeta usamos el comando ls. Para ver los todos comandos del bash, usamos el comando help. Y el comando man (usado adecuadamente, ver help), nos dara una explicación detallada de cada comando. No es imprescindible conocerlos todos, pero el ls es basico.
Ahora deberemos hacernos con un editor de textos. Realmente no importa cual uses, puedes usar el Notepad, Wordpad, el que prefieras; yo me quedo con el UltraEdit. Es preferible usar un editor que sea capaz de identificar el código fuente de C/C++ debido a la que la sintaxis se destaca, las opciones quedan más claras (mucha gente de la scene usa Dev-C++ ). Pero lo dicho, no importa cuál uses, siempre que sepas utilizarlo.
Ahora crearemos un archivo nuevo llamado main.c en nuestro directorio helloworld. Este va a contener el código fuente de nuestro programa.
Apunte
Por si alguno no sabe qué es el código de fuente (y sé que habrá algunos), el código de fuente es lo que escribimos para crear un programa. Se escribe de una manera en que los seres humanos pueden entender. En la mayoría de los lenguajes, el código fuente necesita ser convertido a un formato que el ordenador (o en nuestro caso, la PSP) pueda entender. Éstos se llaman los lenguajes compilados, y englobaríamos C y C++ en esta categoría (la conversión se hace con el recopilador que instalamos previamente, el SDK). Hay algunos otros lenguajes de programación que utilizan lo que se llama un intérprete para leer el código fuente y compilan el código automáticamente. Éstos se llaman lenguajes scripting (un ejemplo de lenguaje scripting es PHP).
Los primeros pasos
Bien, ya tenemos el archivo que llevara nuestro código fuente. Ahora necesitamos comenzar a escribirlo. La primera parte del programa debe contener comentarios para decir a cualquier persona que lea nuestro código cuál es el objetivo del programa, cuándo fue escrito, y quién es el autor. Los comentarios son las líneas del código fuente que se omiten del binario compilado (o saltado por el intérprete en lenguajes scripting). Los comentarios son una parte muy importante del código, porque cuando tú (o algún otro) los vuelve a leer para corregir el código fuente más adelante, no recordará todas las intrincaciones del programa. Así pues, puedes dejar notas en forma de comentarios. Los comentarios se señalan con los caracteres // y /* . En cualquier momento cuando ves // sabes que el resto de la línea será un comentario. /* se usa como principio del comentario, el compilador no hará caso de su código hasta que alcanza el final, marcado con */. Un apunte interesante, cuando tenemos algun error en el codigo, al compilar podemos intentar omitirlo marcando esa linea como comentario.
Así pues, vamos a empezar nuestro programa; vamos a dejar un comentario al principio acerca de lo que hace, cuándo fue creado, y quién es su autor.
// Hola Mundo - mi primera Aplicacion para PSP
/*
Este programa fue creado por (aquí iria tu nombre) el (aquí iria la fecha)
Es una simple aplicacion "Hola Mundo".
*/
La siguiente parte del programa es donde decimos a recopilador qué archivos son principales (header) y cuáles se incluyen para utilizar en nuestro programa. Básicamente #include copia el código del archivo que indiques en el header del programa. Esto permite que crees un programa simple, mientras que usas el código avanzado que ya esta escrito. El directorio include puede incluir cualquier archivo header que viniera con el compilador (o que agregues al compilador), o los archivos header específicos para el proyecto en el cual estes trabajando. La forma de indicar cuál de éstos quieres incluir se marca con < > para incluir un archivo o si utilizamos " " comillas para hacerlo. Menorque y mayorque incluyen un archivo del recopilador include el directorio, y las comillas incluyen un archivo del mismo directorio que el archivo, incluyendo ellas. Incluiremos dos archivos en nuestro programa. El primero es pspkernel.h. Este archivo deberá incluirse en cada programa que escribas para el PSP. Contiene todo lo específico del código para PSP. Tu programa no funcionará en la PSP si no incluyes este archivo. El segundo archivo que vamos a incluir es pspdebug.h. Este archivo contiene varias funciones útiles para eliminar errores de tus programas, pero incluye específicamente la función que vamos a utilizar para escribir el texto a la pantalla. Así pues, agregamos este código a nuestro programa.
#include <pspkernel>
#include <pspdebug>
Ahora diremos a la PSP algo sobre el programa. Ésto no es realmente importante (tu programa compilaría sin él), pero es siempre una buena opción para mejorar la compatibilidad. La primera cualidad es el nombre del programa, pero no es realmente el nombre del programa que aparecerá (cambiaremos eso más adelante). Los otros valores son otras cualidades (licencia ajustada solamente), versión importante, y versión de menor importancia. Dejaremos todos los éstos a excepción del nombre como valores por defecto. Así pues, agregamos la línea siguiente al programa:
PSP_MODULE_INFO("Hola Mundo", 0, 1, 1);
Vamos a instalar la función que utilizaremos para escribir en pantalla. Este paso es opcional, pero hace que los programas basados texto sean mucho más fáciles de escribir. Una buena base en esa línea (simplificar la escritura), trata en cambiar la función en que se construye en la PSP, llamada pspDebugScreenPrintf por algo que sea mucho más fácil de teclear. Esta función se utiliza para escribir a la pantalla, y ya la veremos más adelante. Lo que vamos básicamente a hacer aquí es redefinir printf en vez de pspDebugScreenPrintf, para que cada vez que utilizamos printf el recopilador lo trate como si hubiéramos tecleado pspDebugScreenPrintf. Definimos dicho parámetro en nuestro programa:
#define printf pspDebugScreenPrintf
Bien, el bloque siguiente de código es bastante complicado. Las buenas noticias son que por ahora no necesitamos entenderlo. Dejo una breve explicación de lo que lo hace (dejaremos la sintaxis real y la explicación línea por línea para más adelante). Lo que esta parte del código contiene son básicamente las funciones que serán llamadas por nuestro programa. Las funciones instalarán el programa para funcionar en la PSP y permitirán que no nos preocupemos de si la PSP se bloquea o para salir del programa cuando lo deseemos (pulsando Home). Seguimos añadiendo lineas a nuestro programa:
/* Llamada de salida */
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
/* Llamada thread */
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
/* Configura llamada thread y vuelve a su thread id */
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
Ahora vamos a definir la función principal. Cada programa en C y C++ necesita una función principal. Aquí es desde donde se ejecuta el código. Funciones de C (y algo de C++) en el paradigma proceedural. Esto significa que el código entra en una trayectoria linear. Por ejemplo, tenemos el código siguiente.
//No pongas esto en el programa.
//Solo es un ejemplo.
int myFunction() {
//Print Out 'A'
return 0;
}
int main() {
//Print Out 'B'
myFunction();
//Print Out 'C'
return 0;
}
Los comentarios (ve al principio este turorial si no recuerdas que son los comentarios) suelen hacer lo que dicen. El programa imprimirá B entonces, imprimirá A y, para acabar, C, porque el recopilador comienza en la función principal. Imprime B, entonces ve la llamada myFunction que se define sobre él y va allí, ve que necesita imprimir A y después vuelve a donde dejó apagado e imprime C. Todos tus programas (hasta que pasemos a C++ avanzado) seguirán esta estructura linear. Así pues, la función main es vital para nuestro programa. Para definir una función, utilizamos la estructura siguiente: [tipo de retorno] [nombre]() de la función {. El tipo de retorno es lo que enviará la función de nuevo al programa. Para el main siempre debe ir precedida por int (que estará esperando para ser reinterpretado). El nombre de la función es su nombre para la función principal, y obviamente será nombrado como main. Así pues, definimos la función poniendo la línea siguiente en nuestro programa.
int main() {
Ahora necesitamos agregar dos líneas mas al sistema para limpiar la pantalla y utilizar esas funciones que pusimos anteriormente (las que dijimos que no hacia falta saber que hacian exactamente). Aunque no necesitamos conocer esas funciones de trabajo, es importante conocer los conceptos de cómo llamar funciones. Es realmente muy simple. Acabamos de poner el nombre de la función con paréntesis en el extremo (y si tomamos cualquier parámetro, los pondremos entre paréntesis, pero detallaremos eso más adelante). Cada línea en nuestro programa necesitará un punto y coma al final. La razón de esto es porque el compilador no ve ningún espacio blanco. Entre las líneas, podríamos tener 100 líneas vacías, y el compilador ni se enteraria. Esto es útil porque permite que nos ajustaremos el formato del código cómo deseemos, de una forma que podamos entender. Podemos agrupar líneas juntas, o hacer paragrafos segun bloeues de funciones de nuestro programa. Pero, alternadamente, al terminar una línea, necesitamos un punto y coma. Agregaremos estas dos líneas a nuestro programa, que poco a poco va cogiendo forma:
pspDebugScreenInit();
SetupCallbacks();
Por fin ha llegado la hora de escribir nuestro propio código, en el cual realmente podremos ver los resultados que de en nuestra PSP. ¿Recuerdas cuando definimos pspDebugScreenPrintf como printf? Bien, ahora es el momento de utilizar dicha función. La forma en que imprimiremos el texto en la pantalla será llamando la función del printf con un parámetro (ya dije que lo miraríamos más adelante). Un parámetro es una variable que podemos pasar a una función para su uso. Nos servirá de caso práctico más adelante, cuando estemos escribiendo nuestras propias funciones. Así pues, para mostrar printf en la salida a la pantalla, necesitamos pasarle una secuencia. Haremos salir Hola Mundo pasando esa secuencia a la función. Printf es una función de gran alcance porque podremos también utilizarla para hacer salir otras variables por la pantalla. Pasaríamos éstos como otros parámetros, pero como todo, vendrá a su debido tiempo. Por ahora, imprimiremos Hola Mundo en la pantalla, que ya es un avance:
printf("Hola Mundo");
Ahora necesitamos acabar algunos detalles, y entonces nuestro código de fuente estará listo para ser compilado. Necesitamos detener brevemente nuestro programa de modo que podamos ver la salida. Si no lo hiciéramos así, apenas podríamos ver el texto y volveríamos rápidamente al menú de la PSP. Nunca conseguiríamos ver nuestra hermosa frase en la pantalla porque se borraría tan rápidamente que no nos daría tiempo a leerla. Así pues, agregaremos la siguiente línea para detener brevemente el programa, hasta pulsar el botón Home y enviar al usuario de nuevo al menú principal de la PSP.
sceKernelSleepThread();
Ahora necesitamos dar a nuestra función un valor de retorno; recordad cuando definimos ("int main()"), dijimos al compilador que volviera un número entero. Le decimos que vuelva a 0 (que es un cero, no un O mayúscula') teclando la siguiente línea:
return 0;
Y finalmente, terminamos la función poniendo el símbolo de cierre:
}
¡Y eso es todo! Ahora tenemos que decirle al compilador cómo deseamos compilar este proyecto creando un makefile. Crea un archivo nuevo llamado makefile sin el extensión. Una vez creado, lo abrimos con nuestro editor, e introducimos las siguientes lineas.
TARGET = hello
OBJS = main.o
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Hola Mundo
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak
Podremos utilizar este makefile como base para todos nuestros futuros proyectos simples. Necesitaremos a veces agregar bibliotecas o el whatnot a este archivo, pero por ahora nos funcionará bien éste. Básicamente, dice al compilador que tome main.c y lo construya usando el PSPSDK en un archivo con extensión pbp que la PSP pueda leer. Sólo necesitaremos cambiar, en el caso que queramos usar el makefile en otros proyectos, la línea donde dice PSP_EBOOT_TITLE = Hola Mundo. Podemos cambiar donde dice Hola Mundo al título que queramos para futuros programas, ese será el nombre que aparecerá en el menú de juego de la PSP cuando seleccionemos el homebrew.
Una vez lo tenemos todo, abrimos un bash shell de CYGWIN en el directorio de projects/helloworld. Teclea make y en el bash debe mostrarte algo de información. Te dirá si tu código fuente tiene algún error que lo haga incompilable. Generalmente, si le da algunas advertencias, no muestra mucho texto. Los errores son para lo que se revise el código por posibles errores, las advertencias son apenas los puntos posibles que podrían causar Bugs. ¡Si no te ha mostrado ningun error, ¡¡Felicidades!! Hemos creado con éxito y compilado nuestra primera aplicación para la PSP. Seguro que estás ardiendo en deseos de probarlo en tu PSP. Así pues, copiamos C:/cygwin/home/yourUserName/projects/helloworld/EBOOT.PBP en una carpeta con el nombre que queramos en la carpeta PSP/GAME de la PSP e intentamos cargarlo como si se tratara de otro homebrew.
Nota: Recordad que para que funcione en firmware 1.50 habria que instalarle el Kxploit, con el PSP Brew es muy fácil. Para firmwares 2.0 no hace falta.
Esto lo encontré en un foro, yo no tengo ni idea, pero vaya.. a ver si os sirve xD

Aquí otro para procesar imágenes:

Cita:
A estas altura empezare el tutorial suponiendo que ya teneis instalado el Cygwin y el PSPtoolchain, entendeis como compilar un codigo fuente en un eboot ejecutable para psp y por lo menos teneis un conocimiento básico del lenguaje C de programación.Si no cumples estos requisitos leete la leccion 1,2 y 3 vuelve cuando te las sepas. Si hace mucho que has instalado el toolchain deberás actualizado debido a que necesitamos el png.h, y os teneis que asegurar de tener las librerias zlib y libpng si necesitas recordar como actualizarlo o instalar librerias ve a la leccion 1.
(Este paso es opcional) En que caso de que queramos podemos limpiar archivos que no sirven o carpetas eliminandolas simplemente.Para eliminar archivos via linux shell usamos el comando rm. Nosotros no solo queremos eliminar un archivo, sino que queremos eliminar toda la carpeta con sus contenidos, por lo que añadimos el comando -R. Basicamente estp significa que queremos borrar la carpeta yo lo que hya dentro de ella. Además añadimos el comando -f para modificar el comando y forzar la eliminacion.Pro lo que el comando quedara de la siguiente forma
rm -Rf zlib
rm -Rf libpng
Para empezar nuestro programa, necesitamos descargar Este archivo y extrais todos los archivos en una carpeta nueva en el directorio ~/ ¿Qué no sabes de que estoy habalando?. bueno excepto que tengas experiencia con nix no tienes porque saberlo, basicamente ~/ es sinonimo del directorio de usuario en un sistema nix, asi que eso aplicadico a nuestro programa es C:/cygwin/home/yourUsername, asi que crea la carpeta ahi y extrae los archivos dentro de ella.Ahora abre tu editor y crea un archivo nuevo para empezar con un nuevo codigo fuente para programacion en C.Recuerda que que se tiene que llamar main.c (leccion 2 en caso de necesitar algun repaso)y en este caso debe estar guardado en el mismo directorio que la carpeta con los archivos que habiamos extraido.Ahora vamos a poner un comentario a nuestro programa, no tiene porque ser este y recordar que es totalmente opcional.
/*
Mi programa con imagenes
Autor: Vuestro nombre
Fecha: Fecha de hoy
*/
Ahora debemos introducir las siguientes lineas, muchas ya las vimos en tutoriales anteriores y otras seran nuevas:
#include <pspdisplay>
#include <pspctrl>
#include <pspkernel>
#include <pspdebug>
#include <pspgu>
#include <png>
#include <stdio>
#include "graphics.h"
#define printf pspDebugScreenPrintf
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
PSP_MODULE_INFO("Image Display Program", 0, 1, 1);
/* Exit callback */
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
/* Callback thread */
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
¿Te resulta familiar?Bien continuemos.Una vez hecho esto vamos a continuar con la función de main()
int main() {
char buffer[200];
Image* ourImage;
Hasta el momento lo unico que hemos hecho no se diferencia mucho al de otras lecciones exceptuando que en esta hay muchas más cosas.Simpelemente hemos usado cuerdas, que mas adelante entraremos mas en profundidad en lo que es una cuerda, de momento vamos a decir que es una serie de caracteres.No existe algo tal que "Mi cuerda", realmente son solamente 8 caracteres variables situados a continuación de otros pocos en la memoria, por lo que para que podamos crear una cuerda, antes de nada debemos asignarlo en la memoria proque tan pronto como hagamos algo más (por ejemplo definir una variable) el espacio siguiente de la memoria siguiente a la cuerda se reservara por lo que nuestra cuerda no podra meterse en ese espacio, ese espacio sera llamado un buffer overflow pero no nos vamos a concentrar en eso, simplemente que sepais que generalmente es malo y es lo que hace que la psp se quede colgada.Asi que para definir una serie en lenguaje C simpelmente añade entre corchetes como de largo quieres que se la variable, esto debe ir despues del nombre de la variable.Entonces como te habaras dado cuenta cuando usamos la linea char buffer [200], estamos asignando un bloque de memoria de 200 caracteres variables, este es el maximo tamaño que puede tener la cuerda, aunque hay formas de cambiar el tamaño estan fuera de la perspectiva de este tutorial.
La segunda linea en nuestra función main() describe una nueva variable llamado ourImage, como podreis suponer es una variable de tipo imagen.Estos tipos de datos estan incluidos en graphics.h. Todo lo que vamos a hacer va a ser atraves del uso de otras funciones en el archivo graphics.h
Ahora vamos a introducir unas lineas más que nos deberian ser familiares:
pspDebugScreenInit();
SetupCallbacks();
initGraphics();
Las dos primeras lineas de este codigo son las mismas que usamos en el contador o el hello world para iniciar la pantalla, la tercera tiene la funcion de preparar a la psp para mostrar graficos.Ahora vamos a empezar a trabajar con las imagenes (.PNG)
sprintf(buffer, "ourImage.png");
ourImage = loadImage(buffer);
Donde pone ourImage.png es donde deberia ir el nombre de nuestra imagen, para hacer este turorial yo recomiendo que no cambies nada, porque el archivo que hemos descargado y extraido al principio ya venia con una imagen y tenia ese nombre, por lo cual dejarlo todo tal y como esta y una vez lo hallais hecho funcionar ya os podeis poner a investigar y cambiar cosas.
La primera linea de ese codigo es similar al comando printf(), la unica deiferencia es que en vez de escribir en la patalla escribe en la cuerda.El primer parametro que sprintf() coge es el caracter en serie que tu quieres sacar.Nosotros usamos el buffer en serie que hemos definido y el resto es como el printf(). Nosotros solo buscamos almacenar el camino de nuestras imagenes en el buffer, pero si hubiesemos querido, tambien podriamos haber usado esto para insertar variables en una cuerda uniendoles de la misma forma que con printf() (si no te acuerdas de como hacerlo deberias revisar la leccion 3).
La siguiente linea carga nuestra imagen dentro de las variables que hemos definido antes. loadImage() es otra funcion definida en graphics.h , este coge un parametro y esa es la cuerda que contiene el camino a la imagen.Ahora vamos a proceder a hacer un chequeo para ver que la imagen se ha cargado correctamente
if (!ourImage) {
//Image load failed
printf("Image load failed!\n");
} else {
Si al cargar la imagen hay algun fallo, va a poner el valor de nuestra variable en 0 (falso) y nos alertara del error. Esperemos no encontrar ningun fallo, de ser asi el siguiente codigo se ejecutara
int x = 0;
int y = 0;
sceDisplayWaitVblankStart();
Esto sirve solo para que se ejecute nuestra imagen en la pantalla, no deberia resultar extraño, solo declara unos pocos integers y despues llama a sceDisplayWaitVblankStart () explicado en lecciones anterior.Ahora vamos a dar una vuelta por toda la pantalla. La pantalla mide 480 pixels de ancho por 272 pixel de alto
while (x < 480) {
while (y < 272) {
Estos son simples while loops, deberias recordarlos de la leccion 3. La parte externa del loop continua cuando x es menor que 480 y el resto continua simpre que y sea menor que 272.Ahorra dentro de eso vamos a poner el codigo para mostrar nuestra imagen en la pantalla.
blitAlphaImageToScreen(0 ,0 ,32 , 32, ourImage, x, y);
y += 32;
}
La primera linea es tu llave. Muestra la imagen a 32bits en la pantalla. esto incluye un canal alpha. Alpha es sinonimo de transparente. La funcion blitAlphaImageToScreen coge 7 parametros. Los dos primeros estan sin poner. Si estas usando PNGs separados para cada una de tus imagenes, estos deberian ser 0.Estos parametros los puedes utilizar por ejemplo si kieres mostrar solo una parte de la imagen.El tercero y cuarto parametro es para definir el tamaño de la imagen el priemero es el ancho de imagen y el segundo es el alto. El quinto parametro es para decirle a la funcion que variable queremos usar (obviamente usaremos nuestra variable ourImage). Y finalmente los dos ultimos parametros son para definir la x y de la posicion de la imagen, para que nos enteremos todos, es para decir donde queremos que este la imagen. La x lo mueve de derecha a izquierda e y de arriba a abajo.
La siguiente linea solo incrementa nuestro counter. Nosotros lo incrementamos 32 poruqe es el alto de nuestra imagen. El "+=" incrementa la variable, esto es "x +=32" es igual que "x = x +32". El objetivo es hacer un azulejo de tu imagen en la pantalla.Por lo que ahora incrementaremos x de la siguiente forma
x += 32;
y = 0;
}
Esto mueve horizaontalmente la imagen 32 pixel, la anchura de nuestra imagen, asi que esencialmente nos estaremos moviendo sobre una columna. Entonces pondremos y = 0 otra vez por lo que podra empezar de nuevo en la parte de arriba de la columna y continuar su camino hacia abajo.
Nuestra imagen ya esta dibujo, pero todavia falta un paso mas.
flipScreen();
}
El flipScreen() esta definido en graphics.h, basicamente es lo que actualmente actualiza nuestra pantalla.Finalmente pararemos nuestro programa para poder admirar nuestra preciosa creación.
sceKernelSleepThread();
return 0;
}
Ya hemos completado nuestro programa, ahora hay que hacer un makefile como el de la leccion 2 y 3 pero con algunos añadidos y cambios. El resultado deberia ser este
TARGET = hello
OBJS = main.o graphics.o framebuffer.o
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
LIBDIR =
LIBS = -lpspgu -lpng -lz -lm
LDFLAGS =
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Image Example
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak
Ahora ya solo queda coger el cygwin y compilarlo para crear el eboot.pbp que meteremos en la psp.
IMPORTANTE
Acordaos de que la carpeta con los archivos que extraimos al principio deben estar en el mismo directorio que el main.c y el makefile que hemos creado. Y que la imagen .png que hemos usado la debeis poner juento al eboot.pbp en la psp.
Y Aquí uno para instalar el Cygwin en windows:

Cita:
Escribo esta guía por dos motivos. El primero es porque me he estado peleando un par de días para conseguir instalar el PSPSDK en mi ordenador y si no lo escribo todo, me olvidaré. El segundo es proporcionar un punto de partida a aquellas personas que quieran desarrollar para la psp y no sepan cómo empezar.
Yo soy un gurú, ni mucho menos. A decir verdad, sólo llevo 2 semanas con mi niña, pero ganas no me faltan. Nunca he estado a favor de darlo todo mascado, pues existen miles de patanes en este mundo que jamás comparten nada y se aprovechan del trabajo de unos cuantos. Esta vez haré una excepción, pues los colaboradores de este portal con sus tutoriales y aplicaciones me ayudaron a entrar en el maravilloso mundo de la psp.
1.- Instalar Cygwin.
Este paquete permite ejecutar software basado en UNIX y que es usado para la implementación de programas para la PSP.
Una vez descargado el instalador de www.cygwin.com,
debemos ejecutarlo y seguir los siguientes pasos:
Seleccionar "Install from Internet"
Elegir la ruta de instalación (recomiendo comprobar que tenéis suficiente espacio libre en esa unidad, x lo menos 2 GB, pues después se compilarán muchos binarios).
Seleccionar el directorio donde se desean guardar los paquetes descargados (donde queráis).
Configurar la conexión (ojo con los firewalls).
Seleccionar un sitio de descarga.
Seleccionar los paquetes a instalar. ¡OJO! Para que todo funcione bien, si ya le has dado a "Siguiente" vuelve atrás, hay que instalar completo el paquete Devel, así que lo buscamos en la lista y clickamos sobre la flechita hasta que en vez de "Default" ponga "Install". Ahora bajamos al paquete Web, lo abrimos pinchando en el +, buscamos el wget y pinchamos sobre la flecha del wget hasta que ponga install.
Una vez realizados estos pasos, podéis ir a echaros una cervecita con los colegas hasta que termine de instalar.
Si todo ha ido bien, ya tenéis instalado el Cygwin, ahora lo ejecutamos. Se abrirá una consola (que llamaremos shell) y se configurará vuestra cuenta. El directorio de actual de trabajo será: C:\cygwin\home\<username>, para el Administrador sería: C:\cygwin\home\Administrador.
Nota: Si no estas seguro de cual es tu directorio de trabajo la opción mas rapida y sencilla. Teclear mkdir teknopsp , por ejemplo. Aceptais con el Enter, y buscais en vuestro explorador de archivos una carpeta que se llame teknopsp (F3 comando buscar).
2.- Instalar el PSP toolchain.
El toolchain es un script hará el trabajo sucio de compilar todas las herramientas necesarias y el psp sdk. Lo podéis descargar de www.oopo.net.
Una vez descargado lo copiais en vuestro directorio de trabajo y ejecutáis los siguientes comandos desde el shell de cygwin:
$ tar xfvz psptoolchain-20060110.tgz
$ svn checkout svn://svn.pspdev.org/psp/trunk/psptoolchain
$ cd psptoolchain
$ chmod a+x ./toolchain.sh
$ ./toolchain.sh

--------------------------------------------------------------------------------
Detalle:
1. A causa de que la versión que hay actualmente en la web es 20060120 y no 20060110, el comando se ha de escribir con extensión .tar y no .tgz, así --> 'tar xvfz psptoolchain-20060120.tar'
2.Si vuestro nombre de usuario lleva acento o carácteres extraños(como me ha pasado a mi xD), el segundo comando no os funcionará, porque en UTF-8 no reconoce los acentos. Necesitáis cambiaros el nombre o utilizar una cuenta distinta.

--------------------------------------------------------------------------------
Ahora una cabezadita u otra cervecita, pues el proceso de instalación puede tardar desde 30 minutos a varias horas en función de la velocidad de vuestro PC y de la conexión a Internet.
Si todo ha ido bien, que raro es, ya tendréis instalado en vuestro PC el PSPSDK y todas las herramientas precisadas para la compilación de programas para la psp. Pero antes de seguir, deberemos añadir un par de líneas a los ficheros de configuración.
3.- Actualizando rutas.
Hay que editar (el bloc de notas vale) el fichero c:\cygwin\home\<username>\.bashrc y añadir al final estas 2 líneas:
## PSPDEV PATH SETTINGS
export PATH="/usr/local/pspdev/bin:$PATH"
También es recomendable añadir la siguiente línea al fichero c:\cygwin\cygwin.bat:
set PSPSDK=c:/cygwin/usr/local/pspdev
La pondremos antes de la línea: bash --login -i
4.- Añadiendo las últimas librerías.
Algunos de los últimos desarrollos en psp requieren tener instalada las librerías zlib, libpng y libogg.
Para instalar zlib:
$ svn checkout svn://svn.pspdev.org/psp/trunk/zlib
$ cd zlib
$ make
$ make install
$ cd ..
Para libpng:
$ svn checkout svn://svn.pspdev.org/psp/trunk/libpng
$ cd libpng
$ make
$ make install
$ cd ..
Para libogg:
$ svn checkout svn://svn.pspdev.org/psp/trunk/libogg
$ cd libogg
$ LDFLAGS="-L`psp-config --pspsdk-path`/lib -lc -lpspuser" ./autogen.sh --host psp --prefix=`psp-config --psp-prefix`
$ make
$ make install
$ cd ..
5.- Prueba del entorno.
Ejecuta el comando desde el shell:
$ psp-gcc -v
La salida debería de ser parecida a esto:
Using built-in specs.
Target: psp
Configured with: ../configure --prefix=/usr/local/pspdev --target=psp --enable-languages=c,c++ --with-newlib --enable-cxx-flags=-G0
Thread model: single
gcc version 4.0.0
Si habéis llegado hasta aquí, felicidades, ya podréis compilar fuentes y desarrollar vuestros programas.
Si no, acude al Foro PSPSDK
Y aquí uno para programar los controles:

Cita:
Para utilizar las teclas de nuestra PSP solo necesitamos 3 librerias.
ANTES DE ESTE PASO DEBES TENER DEV-PSP EN TU PC Y SABER COMPILAR. TIENES EL MANUAL DE WINDOWS EN EL FORO. NO RECOMIENDO LEER ESTE MANUAL SIN HABER LEIDO PRIMERO Y SABER LAS NOCIONES BASICAS DEL HELLO WORLD, QUE TIENES EN ESTE FORO

Para empezar, definimos las librerias:
#include <pspkernel> // Indispensal para que funcione con la PSP
#include <pspdebug> // = que el anterior
#include <pspctrl> // Controla la PSP
Despues definimos la impresion y los modulos ademas de el nivel de acceso (user o kernel):
#define pspDebugScreenPrintf printf
PSP_MODULE_INFO("TeknoBotonesPSP", 0, 1, 1);
PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU);
Y empezamos a poner todo, cuando lleguemos a los controles los explicaré:
int main(int argc, char** argc)
{
pspDebugScreenInit();
pspDebugScreenSetTextColor(0xFF);
printf(" Programacion TeknoPSP\nControlando con los botones\n");
printf(" Para salir de esta aplicacion, pulsa HOME\ www.espalpsp.com \n");

SceCtrlData data; // Con esta Call, se guardaran los botones que pulsemos.
sceCtrlSetSamplingCycle(0); // Definimos los ciclos de las pulsaciones, normalmente es 0
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
// Modo analógico
while (1) // Empezamos a definir (1)
{
sceCtrlReadBufferPositive(&data, 1); // Lectura del Buffer de los botones definido anteriormente

char* x; sprintf(x, "X: %d\n", data.Lx); // Abcisas X POSX
printf(x);
char* y; sprintf(y, "Y: %d\n", data.Ly); // Ordenadas Y POSY
printf(y);
if (data.Buttons != (int)0) // Verifica que boton estamos pulsando y si lo estamos pulsando
{
switch (data.Buttons) // En este buffer se guarda el boton que estamos pulsando
{ // Definimos los botones
case PSP_CTRL_CROSS: // CROSS -> CRUZ
printf("Has pulsado X");
break; //Vuelve hacia atrás
case PSP_CTRL_CIRCLE: // CIRCLE -> CIRCULO (Asi con todos los botones)
printf("Has pulsado O");
break;
case PSP_CTRL_SQUARE:
printf("Has pulsado [ ]");
break;
case PSP_CTRL_TRIANGLE:
printf("Has pulsado /_\");
break;
case PSP_CTRL_DOWN:
printf("ABAJO!");
break;
case PSP_CTRL_LEFT:
printf("DERECHA!");
break;
case PSP_CTRL_UP:
printf("ARRIBA!");
break;
case PSP_CTRL_RIGHT:
printf("IZKIERDA!");
break;
case PSP_CTRL_START:
printf("¿Que quieres iniciar?");
break;
case PSP_CTRL_SELECT:
printf("No hay nada que seleccionar xD");
break;
case PSP_CTRL_RTRIGGER:
printf("Para el recovery no es por aqui");
break;
case PSP_CTRL_LTRIGGER:
printf("Amorcito te quiero");
break;
case PSP_CTRL_HOME:
printf("A la mierda!");
printf("Saliendo...");
pspKernelExitGame(); //Llamada de salida del programa
break;
case PSP_CTRL_NOTE: // NOTE -> MUSICAL
printf("Musica Maestro");
break;
case PSP_CTRL_HOLD: // HOLD
printf("Locked");
break;
}
}
}
sceKernelExitGame();

Un saludo espero que os haya servido. Yo este me lo aprendi de PE A PÁ jajajaja
Saludos
CODIGO:
Código:
#include <pspkernel> // Indispensal para que funcione con la PSP
#include <pspdebug> // = que el anterior
#include <pspctrl> // Controla la PSP
#define pspDebugScreenPrintf    printf
PSP_MODULE_INFO("TeknoBotonesPSP", 0, 1, 1);
PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU);
int main(int argc, char** argc)
{
    pspDebugScreenInit();
    pspDebugScreenSetTextColor(0xFF);
    printf(" Programacion TeknoPSP\nControlando con los botones\n");
    printf(" Para salir de esta aplicacion, pulsa HOME\ www.espalpsp.com \n");
 
    SceCtrlData data; // Con esta Call, se guardaran los botones que pulsemos.
    sceCtrlSetSamplingCycle(0); // Definimos los ciclos de las pulsaciones, normalmente es 0
    sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
    // Modo analógico
    while (1) // Empezamos a definir (1)
    {
        sceCtrlReadBufferPositive(&data, 1); // Lectura del Buffer de los botones definido anteriormente
 
        char* x; sprintf(x, "X: %d\n", data.Lx); // Abcisas X POSX
        printf(x);
        char* y; sprintf(y, "Y: %d\n", data.Ly); // Ordenadas Y POSY
        printf(y);
        if (data.Buttons != (int)0) // Verifica que boton estamos pulsando y si lo estamos pulsando
        {
            switch (data.Buttons) // En este buffer se guarda el boton que estamos pulsando
            { // Definimos los botones
                case PSP_CTRL_CROSS: // CROSS -> CRUZ
                    printf("Has pulsado X");
                    break; //Vuelve hacia atrás
                case PSP_CTRL_CIRCLE: // CIRCLE -> CIRCULO (Asi con todos los botones)
                    printf("Has pulsado O");
                    break;
                case PSP_CTRL_SQUARE:
                    printf("Has pulsado [ ]");
                    break;
                case PSP_CTRL_TRIANGLE:
                    printf("Has pulsado /_\");
                    break;
                case PSP_CTRL_DOWN:
                    printf("ABAJO!");
                    break;
                case PSP_CTRL_LEFT:
                    printf("DERECHA!");
                    break;
                case PSP_CTRL_UP:
                    printf("ARRIBA!");
                    break;
                case PSP_CTRL_RIGHT:
                    printf("IZKIERDA!");
                    break;
                case PSP_CTRL_START:
                    printf("¿Que quieres iniciar?");
                    break;
                case PSP_CTRL_SELECT:
                    printf("No hay nada que seleccionar xD");
                    break;
                case PSP_CTRL_RTRIGGER:
                    printf("Para el recovery no es por aqui");
                    break;
                case PSP_CTRL_LTRIGGER:
                    printf("Amorcito te quiero");
                    break;
                case PSP_CTRL_HOME:
                    printf("A la mierda!");
                    printf("Saliendo...");
                    pspKernelExitGame(); //Llamada de salida del programa
                    break;
                case PSP_CTRL_NOTE: // NOTE -> MUSICAL
                    printf("Musica Maestro");
                    break;
                case PSP_CTRL_HOLD: // HOLD
                    printf("Locked");
                    break;
            }
        }
    }
    sceKernelExitGame();
Este ultimo es un sampled, lo único que hace esque si pulsas un botón, te sale un texto diciendo que botón has pulsado.

Yo no tengo ni idea de esto, si alguno de este foro entiende los tutos.. pues espero que les sirva de algo XD

Fuente
__________________

"Si intentas matar al rey, no falles" Omar Little

Última edición por DaRLeK fecha: 12/10/07 a las 23:57:22 Razón: Es C y no C+
DaRLeK is offline   Responder Con Cita
Antiguo 12/10/07, 12:01:32   #2
Fonsy_psp
Vacio
 
Fecha de Ingreso: jul 2007
Mensajes: 1.353
Thanks: 22
Thanked 47 Times in 31 Posts
Fonsy_psp un aura le rodeaFonsy_psp un aura le rodea
Predeterminado

Pon la fuente-->Beta.Pesepe o teknopsp k lo kojio de beta.pesepe xD

PD:Lo ultimo me a echo risa xD as pulsado x xD
[] Te kierp o algo asin xD
__________________
Vacio

Última edición por Fonsy_psp fecha: 12/10/07 a las 12:29:53
Fonsy_psp is offline   Responder Con Cita
Antiguo 12/10/07, 12:44:12   #3
DaRLeK
I♥BETIS
 
Avatar de DaRLeK
 
Fecha de Ingreso: ene 2006
Ubicación: Málaga Paradise
Mensajes: 2.639
Thanks: 372
Thanked 314 Times in 178 Posts
DaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundo

Medalla al merito PSPero 

Predeterminado

Ok, lo edito y la pongo.
__________________

"Si intentas matar al rey, no falles" Omar Little
DaRLeK is offline   Responder Con Cita
Antiguo 12/10/07, 13:00:20   #4
mellon
Gusto en conocerle...
 
Avatar de mellon
 
Fecha de Ingreso: ago 2006
Ubicación: /dev/null
Mensajes: 2.577
Thanks: 1
Thanked 10 Times in 7 Posts
mellon pronto sera famoso
Predeterminado

Y porque tutorial de C+???


Si acaso tutorial de C.....


Salu2
__________________

“Hoy en día la programación es una carrera entre los ingenieros de software, afanándose por construir mejores y más grandes programas a prueba de idiotas, y el Universo, intentando producir mejores y más grandes idiotas. Hasta ahora, el Universo va ganando…”

- Rick Cook -



- Exisisten 10 tipos de personas, los que entienden código binario y las que no.

mellon is offline   Responder Con Cita
Antiguo 12/10/07, 23:55:56   #5
DaRLeK
I♥BETIS
 
Avatar de DaRLeK
 
Fecha de Ingreso: ene 2006
Ubicación: Málaga Paradise
Mensajes: 2.639
Thanks: 372
Thanked 314 Times in 178 Posts
DaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundoDaRLeK conocido por todo el mundo

Medalla al merito PSPero 

Predeterminado

Cita:
Empezado por mellon Ver Mensaje
Y porque tutorial de C+???


Si acaso tutorial de C.....


Salu2
Ahm.. xd ni idea tio, esque como vi que gente de este foro le gustaba eso pues lo cojí, en el otro foro ponia que era C+

pero ahora lo edito.

EDITO: No se cambia.. xd
__________________

"Si intentas matar al rey, no falles" Omar Little

Última edición por DaRLeK fecha: 12/10/07 a las 23:58:28
DaRLeK is offline   Responder Con Cita
Antiguo 14/10/07, 23:24:16   #6
www.DimiPsP.com
Matando Giris
 
Avatar de www.DimiPsP.com
 
Fecha de Ingreso: jun 2007
Ubicación: Yo qué se
Mensajes: 697
Thanks: 0
Thanked 19 Times in 7 Posts
www.DimiPsP.com pronto sera famoso
Predeterminado

buf..cuto ay k leer XD
__________________
www.DimiPsP.com is offline   Responder Con Cita
Antiguo 15/10/07, 00:53:37   #7
_The One_
Necesitas un analisis? Dí
 
Avatar de _The One_
 
Fecha de Ingreso: may 2007
Mensajes: 2.534
Thanks: 6
Thanked 62 Times in 51 Posts
_The One_ un aura le rodea_The One_ un aura le rodea
Predeterminado

Cita:
Empezado por DaRLeK Ver Mensaje
Para cear tu primer programa:



Esto lo encontré en un foro, yo no tengo ni idea, pero vaya.. a ver si os sirve xD

Aquí otro para procesar imágenes:



Y Aquí uno para instalar el Cygwin en windows:



Y aquí uno para programar los controles:



Este ultimo es un sampled, lo único que hace esque si pulsas un botón, te sale un texto diciendo que botón has pulsado.

Yo no tengo ni idea de esto, si alguno de este foro entiende los tutos.. pues espero que les sirva de algo XD

Fuente
grax por la info......... a ver si me tomo un tiempito para leerlo
__________________
_The One_ is offline   Responder Con Cita
Antiguo 15/10/07, 20:36:55   #8
ignacio_13_
Banned
 
Fecha de Ingreso: jul 2007
Ubicación: Chile
Mensajes: 580
Thanks: 8
Thanked 12 Times in 12 Posts
ignacio_13_ por el buen camino
Predeterminado

Gracias por los tutoriales...a ver si os leo algun dia
ignacio_13_ is offline   Responder Con Cita
Antiguo 18/10/07, 22:47:09   #9
lrrl
4.01 m33-2 -> 5.00
 
Avatar de lrrl
 
Fecha de Ingreso: abr 2007
Ubicación: MADRID (SPAIN)
Mensajes: 622
Thanks: 0
Thanked 6 Times in 5 Posts
lrrl por el buen camino
Predeterminado

buff , un poko largo , peor haber si cuadno tenga tiempo me lo leo xq parece interesante.

salu2 y gracias x el aporte
lrrl is offline   Responder Con Cita
Antiguo 20/10/07, 16:31:33   #10
Sanxez
Loading...
 
Avatar de Sanxez
 
Fecha de Ingreso: dic 2006
Ubicación: Barcelona
Mensajes: 424
Thanks: 2
Thanked 3 Times in 3 Posts
Sanxez por el buen camino
Predeterminado

Llevo 23 minutos leyendo esto..esta noxe aver si me sale algo
__________________

Un año mas para mi negritA




Cita:
Empezado por ivanvill Ver Mensaje
Dark_Alex porque no trabajas en el downgrader de la 3.11 es que tengo 10 años y ya estoy desesperado de esperar un saludo

2.71<1.50<3.03 OE-C<3.40 OE-A<3.71 M33
Spoiler
Sanxez is offline   Responder Con Cita
Respuesta

Bookmarks

Herramientas



La franja horaria es GMT +2. Ahora son las 00:21:28.


Powered by: vBulletin, Versión 3.8.5
Derechos de Autor ©2000 - 2021, Jelsoft Enterprises Ltd.
Traducción VBulletin por vbulletinhispano.com