Lunes, 21/Ago/2017, 1:46 PM
                          Inicio

Registrarse

Entrada
Le saludo Huésped | RSS
[ Mensajes nuevos · Participantes · Reglas del foro · Búsqueda · RSS ]
Página 1 de 11
Foro » Programacion » Tutoriales Programacion C » Mostrando Imagen [graphics.h] (sting18)
Mostrando Imagen [graphics.h]
sting18Fecha: Viernes, 09/Sep/2011, 7:20 PM | Mensaje # 1
Generalísimo
Grupo: Administradores
Mensajes: 26
Reputación: 32767
Estatus: Offline
Ahora veremos como mostrar una imagen png hay que tener en cuanta que las medidas de nuestro psp son 480x272 pixeles para asi tener la imagen en pantalla completa y ya saben comensamos con las librerias necesarias.

Code
#include <pspkernel.h>
#include <pspdebug.h>
#include "graphics.h"


Se preguntaran porque la libreia graphics.h esta entre comillas? esto es porque la libreria no viene en el kid de programacion y la tenemos que descargar y ponerla junto nuestro main.c y makefile porque le pusimos "graphics.h" podemos metrala a una carpeta y cambiar la dideccion ejemplo "librerias/graphics.h" esto depende de cada programador el caso aqui es que encuentre la libreria el compilador.

Descargar archivos nesesarios: http://www.megaupload.com/?d=TWCX0KJ0 meter todos los archivos junto al main.c y makefile.

continuamos con esto ya visto en tutos pasados informacion y boton home.

Code
PSP_MODULE_INFO("Imprimir imagen", 0, 1, 0);
PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);


Code
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 toda imagen tiene que ser asignada primero si lo la asignas no la podras usar y la asignamos asi.

Code
Image* imagen;


Ya teniendo asignada la imagen comensamos con nuestro main que es lo primero que lee el codigo y la funcion principal de nuestro programa.

Code
int main()
{


y ahora iniciamos el modo grafico de nuestra psp asi.

Code
initGraphics();


He iniciamos la salida del HOME.

Code
SetupCallbacks();


y ahora cargamos la imagen que se encontrara a lado de nuestro EBOOT.PBP y la cargamos en una variable.

Code
imagen = loadImage("imagen.png");


Recuerden que dentro de el parentecis tiene que ir la direccion donde se encuentra la imagen si junto al EBOOT.PBP creamos una carpeta que se llame "imagenes" y dentro de esa carpeta metemos nuestra imagen entonces seria cargarla imagen = loadImage("imagenes/imagen.png"); todo dependiendo de donde se encuentre la imagen a partir del EBOOT.PBP que vamos a crear.

Ahora a llegado el momento de mostrar nuestra imagen y lo aremos con esto.

Code
blitAlphaImageToScreen(0 ,0 ,480 , 272, imagen, 0, 0);


Ahora veremos como trabajan estos parametros de mostrar imagen.
El primer 0 indica donde empieza la imagen respecto al eje X, el segundo 0 lo mismo pero respecto al Eje Y
el 480 indica el ancho de la imagen y el 272 el alto.
imagen es la variable de la imagen, donde hemos guardado toda la informació y que vamos a imprimir en pantalla, la hemos definido antes en el loadImage
los dos últimos numeros indican la coordenada de la imagen, donde queremos que se imprima, es decir,
en este caso por ejemplo se imprimiría a partir de la esquina superior izquierda de la pantalla,
si ponemos 240 y 136, la imagen empezara a imprimirse justo en el centro de la pantalla recordemos que las medidas de nuestro PSP son de 480x272 si imprimimos a mas de estas cordenadas la imagen quedara fuera de la pantalla del psp

Y ahora vamos con lo esencial para que se muestre la pantalla y esto es..

Code
flipScreen();


esto hace que se le de vuelta a la pantalla y muestre la imagen que hemos puesto en blitAlphaImageToScreen , si queremos mostrar mas imagenes tenemos que cargarlas igual pero poner solo un flipScreen.

Esta funcion es importante ya que borra la imagen de la ram si no cargarias la ram y se te quedaria trabado el psp.

Code
freeImage(imagen);


NOTA: La ram es de 32MB en caso de psp fat en slim sube a 64MB.

cerramos nuestro main y listo.

Code
return 0;
}


Ya solo creamos nuestro Makefile.

Code
TARGET = imagenes
OBJS = main.o graphics.o framebuffer.o
   
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
   
LIBDIR =
#Aqui incluiremos libs necesarias
LIBS = -lpspgu -lpng -lz -lm
LDFLAGS =
   
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Iniciandome en graficos
   
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak


Se dan cuenta que a nuestro Makefile le agregamos en la parte de "OBJS:" este pedaso de code "graphics.o framebuffer.o" se preguntaran porque? esto es porque al agregar mas librerias tememos que agregarlas tambien al makefile para que aga su trabajo, es importante sabes que algunas librerias si no es que casi todas trabajan bajo otro archivo ejemplo esta libreria trabaja tambien con "framebuffer" que aunque no lo pongamos en nuestro main la libreria lo ocupa para ser funcinal tambien hay que agregar -lpspgu -lpng -lz -lm es para las librerias ya entenderan porque despues.

Ademas de estas acciones la libreria graphics.h tiene muchas funciones mas tales como.

<graphics.h>

initGraphics();
Activa graficos, para poder mostrar imágenes en pantalla.
disableGraphics();
Desactiva gráficos.
loadImage();
Carga una imagen (en la RAM) para después ser mostrada. (Ej: loadImage("foto.png");) -> Carga imagen foto.png.
blitAlphaImageToScreen();
Muestra imagen en pantalla. (Ej: blitAlphaImageToScreen(0 ,0 ,480 , 272, imagen, 0, 0);) -> Muestra la imagen foto de 480*272 pixeles en las coordenadas x=0, y=0.
flipScreen();
"Se le da la vuelta a la pantalla" para que muestre las imágenes.
freeImage(imagen);
Alrevés que loadImage();, borra la imagen de la RAM. Importante para que nuestra PSP no se trabe por falta de RAM.
createImage(int Ancho, int Alto);
Crea una imagen en blanco (transparente) con las dimenciones dadas en Alto y Ancho. (Ej: imagenNueva = createImage(480, 272);) -> Crea una imagen de 480px X 272px.
clearScreen(Color color);
"Limpia" la pantalla con el color indicado. (Ej: clearScreen(0xFFFFFF);) -> Limpia la pantalla con el color blanco.
saveImage(Char *Nombre, Color* data, int Ancho, int Alto, int lineSize, int saveAlfa);
Toma un screenshot de la pantalla en formato PNG. (Ej: saveImage("ms0:/captura.png", getVramDisplayBuffer(), 480, 272, 480, 1);) -> Guarda "captura.png" en la raíz de la Memory Stick con las dimenciones de la PSP y con canal alfa (transparencia) activada

esto ya es uso de cada quien cualquier duda y sugerencia para mejorar este post por favor aganla saber.
 
Foro » Programacion » Tutoriales Programacion C » Mostrando Imagen [graphics.h] (sting18)
Página 1 de 11
Búscar:

Copyright MyCorp © 2017 Hacer un sitio web gratis con uCoz