Me ha dado por hacer un pequeño código que me permita cargar una imagen en pantalla, pero necesito una SMC virtual para que el GeePee32 pueda buscar la imagen, además necesito convertir la imagen a .gpg.
Supuestamente esto se hace con el Dev_Util (oficial de Game Park), pero no me apaño. Le digo que me haga lo de la imagen y que me la exporte, pero no la encuentro, ¿Alguien sabe cómo se usa el programa para hacer estas dos cosas que necesito?
Bueno, aunque me temo que los programadores no han andado mucho por aquí y no me han podido responder, he conseguido una utilidad que me ha permitido pasar la imagen tanto a archivo C (con su correspondiente h) y a gpg.
Al no tener lo de la SMC virtual, lo he pasado a la GP32 (prefiero usar el emu para las pruebas porque es mucho más directo y en un programa se hacen muchísimas pruebas), pero tengo dos problemas:
1.- No me carga la imagen o al menos no me da tiempo a verla.
2.- La última parte del código, la que pone la pantalla en rojo mientras pulso el stick hacia arriba, en el emu no tiene mala velocidad, pero en la GP va muy lento, de forma que si aprietas y sueltas, la pantalla sólo se pinta de rojo parcialmente antes de volver a pintarse de negro.
Pongo aquí el código (lleno de comentarios) por si alguien me puede hechar una mano y de paso, me decís si me he equivocado en alguna de mis "conclusiones".
void GpMain( void * arg) //siempre lleva lo del parentesis, sin ello NO compila
{
unsigned char * imagen; //declara una variable con la que podremos cargar una imagen
unsigned long data_size, total_size; //define los tamaños de los datos del GpFileRead
ERR_CODE err; //Guarda el valor que devuelve GpFileOpen, este valor será SM_OK si se ha abierto correctamente
F_HANDLE h_rfile; //Es el equivalente a la variable FILE * de C
GPDRAWSURFACE gpDraw; //Es la variable de pantalla
int tecla, tecla_cam; //Almacena el valor de la tecla pulsada
GpLcdSurfaceGet(&gpDraw,0); //Toma el estado de la pantalla LCD, en este caso, el tamaño
GpSurfaceSet(&gpDraw); //Establece gpDraw como la superficie sobre la que podremos dibujar o colocar objetos
GpLcdEnable(); //Activa la pantalla LCD ¿Es realmente necesario?
GpFatInit(); //Inicializa la SMC. Lo necesitamos SIEMPRE que vayamos a leer/escribir en la SMC
err=GpFileOpen("gp:\\gpmm\\imagen.gpg",OPEN_R,&h_r file);
//Abre el fichero imagen.gpg de la ruta especificada, en modo apertura (OPEN_R) y lo abre con la variable h_rfile
if(err!=SM_OK) //Comprueba si el fichero se ha abierto correctamente. Si no es así, sale del programa
{
return;
}
imagen=(unsigned char *)gp_mem_func.malloc(data_size);
//Aloca espacio del tamaño data_size en la variable imagen (imagen es un puntero). Malloc funciona igual que en C
GpFileRead(h_rfile,(unsigned char *)imagen,data_size,&total_size);
//Lee el contenido del fichero sobre la variable imagen. A diferencia de C lleva primero el fichero del que leemos, la variable sobre la que leemos, el tamaño de lo leído y el tamaño total de todo lo leído.
GpFileClose(h_rfile); //Cierra el fichero
GpRectFill(NULL,&gpDraw,0,0,gpDraw.buf_w,gpDraw.bu f_h,0x00);
//Pinta la superficie gpDraw de negro
GpBitBlt(NULL,&gpDraw,100,80,gpDraw.buf_w,gpDraw.b uf_h,(unsigned char *)imagen,0,0,120,80);
//Coloca la imagen del puntero imagen en la pantalla
while(1) //Bucle infinito que mantiene el programa siempre en ejecución
{
GpKeyInit(); //Inicializa las teclas
tecla=GpKeyGet(); //Asigna a tecla el valor de la tecla pulsada
tecla_cam=GpKeyChanged(); //Indica cuál es la nueva tecla pulsada
tecla=tecla_cam; //Asigna a telca el valor de la tecla cambiada
if(tecla & GPC_VK_UP) //Si la tecla es el stich arriba...
{
GpRectFill(NULL,&gpDraw,0,0,gpDraw.buf_w,gpDraw.bu f_h,0xe0);
//Pinta la pantalla de rojo
}
else //Si no...
{
GpRectFill(NULL,&gpDraw,0,0,gpDraw.buf_w,gpDraw.bu f_h,0x00);
//Pinta la pantalla de negro
}
//Es muy importante tener en cuenta que la tecla se considera pulsada hasta que la soltamos.
}
}
¿Puede ser que la imagen no cargue bien por tener un tamaño ella misma y no coincidir con el tamaño que le he dicho en la función GpBitBlt? ¿Deben ser iguales ambos tamaños?
Joe, ¿nadie me puede echar un cable? ¿Se han ido todos los programadores de puente?
Pues nada, si nadie me ayuda, ya intentaré apañarme... Desde luego qué frustrante (y este era uno de los principales motivos por los que quería la GP32, para programar... v_v).
P.D: Toy de mala leche conmigo misma por no ser capaz de cargar una dichosa imagen.
Que pongo:
- con el (100,120) primero especifico la posicion en la pantalla
- con el (120,30) que sigue especifico tamaño del rectangulo q se pintara
- con el (0,0) siguiente indico el offset en la imagen. Osea, que empieza apintar en la esquina superior izquierda
- con el (240,30) indico que la imagen completa ocupa 240x30 pixels.
Que consigo:
Se dibuja la mitad izquierda de la imagen en el punto (100,120) de la pantalla.
Puede que no haya sido muy especifico anteriormente, pero lo de las imagenes lo tengo un poco olvidao. ahora estoy con cosas mas... no sabria como decirlo.
Por cierto, en el codigo anterior me llaman mucho la atencion algunas cosas. Por ejemplo:
En la primera llamada a malloc que haces, pones data_size como tamaño de memoria a reservar. Mi pregunta es: ¿cuando has iniciado el valor de sata_size???
He visto alguna cosa mas, pero no se si me resulta raro porque yo no entiendo mucho en el tema del SDK de la GP32 o porque esta mal.
Gracias por responder, básicamente lo del data_size va a ser uno de los problemas, lo malo es que no sé muy bien cómo obtener el tamaño que se debe reservar/leer y que se supone que está representado por data_size...
Supuestamente data_size podría obtenerlo haciendo una lectura del fichero sobre ella, pero no sé cuál sería el tercer parámetro, ya que no tengo muy claro si al igual que en C se refiere al número de veces que leo el dato indicado o a qué se refiere, nada lo explica.
¿Debería ser el tamaño en bytes de la imagen? (Ese tamaño se puede sacar por ejemplo con el Wind-ups). La verdad es que no he encontrado nada que lo especifique.
En el Work_en viene un ejemplo que coloca una imagen en la pantalla y permite moverla, pero usa imágenes .c y no sé porqué no se compila el ejemplo.
Resumiendo: o la documentación es mala con ganas (que lo es) o yo soy una negada (cosa que, en tema de imágenes, no me extrañaría nada...).
Siendo 19728 el tamaño en bytes de mi imagen. Este tamaño se puede obtener metiendo la imagen en la gp y comprobando con el Wind-ups el tamaño de la misma (si no recuerdo mal, las instrucciones de la GP dicen que el tamaño en el PC y el tamaño en la GP32 pueden variar un poco). La forma es bastante engorrosa, pero algo es algo, ya iré probando otras formas (leer el fichero o ver si hay alguna función que me devuelva el tamaño, sólo válido si el fichero es una imagen única).
Ahora lo que tengo es otro problema y es que la imagen sale en tonos de azul y casi no se ve porque necesito cargar la paleta de la imagen, pero tengo más o menos una idea de, al menos cómo obtener la paleta.
Cojo un prorama que me convierte las imágenes a archivos .c. Lleva dos contenidos: la imagen y la paleta de color. Supongo que si obtengo un archivo .c sólo con la paleta (un simple copy/paste en un archivo nuevo), podré cargarla posteriormente en la GP32.
Muchas gracias, mortimor, por haberme dado la pista del data_size
Mira, el tamaño de la imagen se obtiene mirando el fichero de imagen (sino tienes que saberlo a priori). Ten en cuenta el formato de los ficheros .gpg que viene al final del manual del SDK. Se trata de una cabecera y luego la imagen en el formato que tu quieras (ya sea comprimido o no, bmp, gif, png,... eso dependera de ti).
Piensa siempre que utilizar ficheros .gpg no es obligatorio, puedes cargar cualquier fichero de imagen directamente (bmp, gif, jpg,...) y sacar de el la informacion que buscas mirando en sus cabeceras. Pero tienes que conocer los formatos: si estan comprimidos, planos de color, bits por pixel, definicion, tamaño,...
Por ejemplo, si quieres cargar una imagen:
- abres el fichero
- lees la cabecera que tiene una determinada estructura, con la informacion que necesitas para cargarla y representarla lo mas fielmente posible.
- en funcion de la estructura lees el resto de fichero, que puede tener los datos de imagen y opcionalmente una paleta de colores (que estará antes de ellos)
-Una vez esta en memoria puedes representarla, modificarla, mezclarla con otra, ....
Te dejare algo de documentacion sobre formatos aqui, pero en este tema es mejor que utilices librerias para cargarlos, ya que descomprimir un jpg no es moco de pavo si no se entiende de DCTs, ventanas de convolucion y demas...
Si tengo un rato te pongo una libreria de tratamiento de imagenes en C que hice en la carrera. Aunque solo soporta BMPs (se trata de una version preliminar y la practica era de OO) se pueden añadir formatos con facilidad.
Aqui va un documento con el formato BMP, aunque esta en ingles. Te recomiendo que mires en internet o en la documentacion de microsoft sobre este formato (que es propiedad de MS)
Bueno, para que veas algo de codigo sobre manejo de imagenes te cuelgo la mencionada practica. Puede cargar imagenes BMP y permite modificarlas utilizando foltros tipo CorelDraw.
Esta en C++, contiene un manual del programador y una especificacion del diseño (aunque creo que no le interesara a mucha gente). Consta de dos partes, la parte creada en C++ estandar y una parte que se ocupa de los aspectos dependientes del sistema (como la representacion), en este caso win32.
Tiene alguna optimizacion para el compilador de C++ de Microsoft, asi que habria que hacer algun cambio (minimo) para que rulara en linux (por ejemplo).
Perdonar las erratas, es que la documentacion la hice en 2 dias. Y que conste que tiene ya algun año ehhh!!.
Lo de las cabeceras de los archivos de imagen, creo que sería meterme en mucha movida, ¿no?
Se ve que sabes un montonazo (yo sólo llevo dos años programando y aún me quedan cosas que aprender sobre C). Como compilador C/C++ yo utilizo el de Borland, ¿necesitaría algún cambio en las librerías? (de C++ no sé absolutamente nada ).
Pues en algun fichero .h cambiar directrices del compilador. Como la que sirve para que las estructuras se almacenen sin el alinemiento en memoria de 32 bits, para que carge bien las cabeceras de los fichero (sino interpreta mal los datos, es que no esta muy currada la parte de lectura de cabeceras y lee estructuras directamente).
Lo cierto es que deberia habert puesto algun ejemplo de como se usa. Si lo encuentro te pongo un prototipo de aplicacion que la usa, lo que pasa es que esta para compilarlo en win32.
No te preocupes, ya investigaré yo un poquillo cuando vuelva a tener tiempo (me temo que para Navidad ya se ha encargado el tutor de darnos material suficiente para que diseñemos datos para bases de datos.... ¬_¬).
Aún tengo que intentar usar la función GpFileGetSize para que me diga el tamaño de ese fichero y poder inicializar así la variable data_size (si el fichero contiene únicamente una imagen, el tamaño del fichero me imagino que será forzosamente el tamaño de la imagen).
Pues la verdad es que anque tenga solo una imagen el tamaño del fichero no coincidira con el de la image, ya que como hemos comentado antes tambien estan las cabeceras.
En el ejemplo de Wave ya ves que carga una serie de datos primero que son las caracteristicas de la imagen, eso es la cabecera en cuestion de los ficheros gpg. Pues bien, la memoria que hay que reservar es igual a los bytes necesarios para todos los pixel (en una imagen de 8bits hay un byte por pixel, calcula: 1 byte X numero de filas de la imagen X numero de columnas de la imagen).
Forero PRO
).
Permisos de publicación
Citar
Marcadores