Ver la versión completa : [Desarrollo] ¿Qué hacer en el desorden?
Ando un poco liado, llevo días mirando, leyendo y dando vueltas, creo que ya me he enterado de qué debo hacer para hacerme una sdk, pero a la hora de la verdad no hay manera, me he decidido por la sdk de GPH y usar las SDL de paeryn, me he bajado las fuentes, pero en el readme.gp2x, donde dice como instalarlo ... no sé qué hay que poner el --host=$HOST.
En las librerías esas que pasais para desarrollar no dais las cabeceras...
No sé, todas esas cosas así y otras que me he encontrado marean mucho. en archive.gp2x.de hay mucho material, pero para enterarse de qué hacer para empezar es muy triste.
El wiki hoy no me funciona, pero vamos cuando ha estado online (el problema de hoy parece ser puntual) tampoco he visto como hacer lo que quiero.
Quizás, y lo más seguro, sea que yo no soy capaz de situarme. Por eso necesito alguien que pueda echarme una mano.
Espero poder aportar algunas cosas pronto a la comunidad.
^MiSaTo^
16/07/2006, 20:36
Ando un poco liado, llevo días mirando, leyendo y dando vueltas, creo que ya me he enterado de qué debo hacer para hacerme una sdk, pero a la hora de la verdad no hay manera, me he decidido por la sdk de GPH y usar las SDL de paeryn, me he bajado las fuentes, pero en el readme.gp2x, donde dice como instalarlo ... no sé qué hay que poner el --host=$HOST.
En las librerías esas que pasais para desarrollar no dais las cabeceras...
No sé, todas esas cosas así y otras que me he encontrado marean mucho. en archive.gp2x.de hay mucho material, pero para enterarse de qué hacer para empezar es muy triste.
El wiki hoy no me funciona, pero vamos cuando ha estado online (el problema de hoy parece ser puntual) tampoco he visto como hacer lo que quiero.
Quizás, y lo más seguro, sea que yo no soy capaz de situarme. Por eso necesito alguien que pueda echarme una mano.
Espero poder aportar algunas cosas pronto a la comunidad.
Usas windows o linux?
Uso GNU/Linux, distribuido por Gentoo. Usar windows no es una opcion, me niego a usarlo para mis asuntos personales :D
^MiSaTo^
16/07/2006, 20:52
Uso GNU/Linux, distribuido por Gentoo. Usar windows no es una opcion, me niego a usarlo para mis asuntos personales :D
Vale yo tb xDDD
Lo que necesitas es la toolchain entera, osea el compilador cruzado y las libs.
Si quieres usar un editor como por ejemplo el kdevelop, dskywalk tiene un tutorial muy bueno en su web: http://david.dantoine.org/contenido/9/
de hecho de ahi mismo te puedes bajar una toolchain.
Sino, cuelgo mi toolchain (que me va perfecta y con las libs de paeryn) en mi web y te paso el link de descarga
PD: yo me apaño mejor con el gedit (o vi o cualquier otro editor) y makefiles
Gracias misato por ser tan rápida respondiendo.
¿En algún sitio dicen como hacerte tu propio toolchain?
Yo al igual que tú no me gusta la idea de usar kdevelop, prefiero editores de texto y la consola, y como mucho anjuta, una pena que no haya plantillas para anjuta aún.
La web que me has pasado está muy bien, pero no dice como compilar las sdl para crearme mo toolchain. Es una pena que todo este tiempo no consiga verlo en ningún sitio. :( Aquí al menos si da las cabeceras. :D
^MiSaTo^
16/07/2006, 21:19
Gracias misato por ser tan rápida respondiendo.
¿En algún sitio dicen como hacerte tu propio toolchain?
Yo al igual que tú no me gusta la idea de usar kdevelop, prefiero editores de texto y la consola, y como mucho anjuta, una pena que no haya plantillas para anjuta aún.
La web que me has pasado está muy bien, pero no dice como compilar las sdl para crearme mo toolchain. Es una pena que todo este tiempo no consiga verlo en ningún sitio. :( Aquí al menos si da las cabeceras. :D
Busca por el foro, que por algún sitio dicen cómo compilarte la toolchain
De todos modos la que uso yo, es descomprimir y listo. La compilo Puck2099 en su Gentoo (creo) y va perfecta. A mi en Ubuntu tb me va genial
Un saludo
Gracias misato por ser tan rápida respondiendo.
¿En algún sitio dicen como hacerte tu propio toolchain?
Yo al igual que tú no me gusta la idea de usar kdevelop, prefiero editores de texto y la consola, y como mucho anjuta, una pena que no haya plantillas para anjuta aún.
La web que me has pasado está muy bien, pero no dice como compilar las sdl para crearme mo toolchain. Es una pena que todo este tiempo no consiga verlo en ningún sitio. :( Aquí al menos si da las cabeceras. :D
En gentoo puedes usar el paquete crossdev, así me la hize yo. Luego con el comando crossdev te compila el gcc, binutils y glibc para linux-arm, luego con ese compilador tienes que compilar las SDL (preferentemente las de paeryn, que usan aceleracion por hardware) y ya tienes listo el toolchain.
¿Alguna sugerencia para compilar las SDL de paeryn? Es que me atasco en lo que he puesto en el primer post
^MiSaTo^
16/07/2006, 21:40
¿Alguna sugerencia para compilar las SDL de paeryn? Es que me atasco en lo que he puesto en el primer post
digo yo que en --host habrá que poner ARM o algo así (estoy hablando desde el desconocimiento, porque ya te dije que yo las uso precompiladas)
Creo que ademas del --host tienes que configurar el --prefix para que se instale en donde tengas tu toolchain
ya probé con --prefix=/gp2xsdk/Tools --host=arm y no funcionó
< - >
En gentoo puedes usar el paquete crossdev, así me la hize yo. Luego con el comando crossdev te compila el gcc, binutils y glibc para linux-arm, luego con ese compilador tienes que compilar las SDL (preferentemente las de paeryn, que usan aceleracion por hardware) y ya tienes listo el toolchain.
estoy construyendolo con
# crossdev -t arm-linux-gnu
efegea, ¿así lo hiciste tú? Cuando termine probaré a instalar las SDL, ¿como lo hiciste tú?
Si así lo hice yo. Luego las SDL con lo de ./configure --prefix=/gp2xsdk/Tools --host=arm-linux-gnu y te debería funcionar.
Una duda que tengo las SDL de paeryn, son las que se recomiendan, bien, ¿qué ocurre si instalo la últimva libsdl de la web oficial? En la web creo que piden una donación de HardWare de una GP2X para darle mejor soporte a las SDL en la GP2X.
Otra cosa que quería preguntar, a ver, si ya tengo el compilador para arm, las bin utils, y tal por qué tengo que compilar las SDL con eso? Si ya tenía en el sdk oficial de GPH instalado, ¿por qué no he compilado SDL con el compilador arm que trae ese devkit? No es un poco estupido hacerse un compilador arm, y luego hacerse otro para compilar las sdl para el primer compilado arm? Quizás no sea estúpido, quizás yo sea el ignorante. :P
Bueno mi idea es, una vez instalado entorno cross compile con crossdev, es instalar las SDL de paeryn en el /usr/arm-linux-gnu. Y ver si así funciona el invento :D Esto se haría en gentoo con el comando ROOT=/usr/arm-linux-gnu/ emerge libsdl eso en el caso de usar la última sdl estable del portage de gentoo.
Para las de paeryn creo que una vez descomprimidas sería haciendo un ./configure --prefix=/usr/arm-linux-gnu --host=arm-linux-gnu.
Si alguien cree que me equivoco en algo que me lo diga antes de que empiece a meter la pataaaa! :D
Una duda que tengo las SDL de paeryn, son las que se recomiendan, bien, ¿qué ocurre si instalo la últimva libsdl de la web oficial? En la web creo que piden una donación de HardWare de una GP2X para darle mejor soporte a las SDL en la GP2X.
Si usas las SDL oficiales no tendrás aceleración por hardware, que si tiene las de paeryn
Otra cosa que quería preguntar, a ver, si ya tengo el compilador para arm, las bin utils, y tal por qué tengo que compilar las SDL con eso? Si ya tenía en el sdk oficial de GPH instalado, ¿por qué no he compilado SDL con el compilador arm que trae ese devkit? No es un poco estupido hacerse un compilador arm, y luego hacerse otro para compilar las sdl para el primer compilado arm? Quizás no sea estúpido, quizás yo sea el ignorante. :P
Hombre si ya tenías un toolchain podias compilar las SDL con ese toolchain, no era necesario hacer el crossdev
Bueno mi idea es, una vez instalado entorno cross compile con crossdev, es instalar las SDL de paeryn en el /usr/arm-linux-gnu. Y ver si así funciona el invento :D Esto se haría en gentoo con el comando ROOT=/usr/arm-linux-gnu/ emerge libsdl eso en el caso de usar la última sdl estable del portage de gentoo.
Pero ese comando de gentoo te instalaría una versión para x86 o amd64 o lo que sea tu equipo, no la version arm que es la que necesitas.
Para las de paeryn creo que una vez descomprimidas sería haciendo un ./configure --prefix=/usr/arm-linux-gnu --host=arm-linux-gnu.
Exacto , después un make y un make install :)
Bien ya me he compilado el demo.c, pero no muestra la imagen, es un bmp que he creado yo mismo. No muestra la imagen y no hace nada, por lo que tengo que apagar la consola y volverla a encender.
os enseño mi makefile y tal
Makefile:
#
# demo make file
#
CROSS_COMPILE = /usr/arm-linux-gnu/
CXX = $(CROSS_COMPILE)gcc-bin/3.4.6/arm-linux-gnu-gcc
LD = $(CROSS_COMPILE)bin/ld
STRIP = $(CROSS_COMPILE)gcc-bin/3.4.6/arm-linux-gnu-strip
LIBS = /usr/arm-linux-gnu/lib/
INCLUDES = /usr/arm-linux-gnu/include
#CXXFLAGS = -Wall -Wshadow -Wmissing-prototypes -mcpu=arm920 -mtune=arm920t -std=c99 -Os -fstrict-aliasing -pedantic
CXXFLAGS = -O2
DEMO_TARGET = demo.gpe
DEMO_OBJS = demo.o
all : $(DEMO_TARGET)
$(DEMO_TARGET) : $(DEMO_OBJS)
$(CXX) $(DEMO_OBJS) -static -s -o $(DEMO_TARGET) -lSDL -lpthread -L$LIBS
.c.o:
$(CXX) $(CXXFLAGS) -c $*.c
.s.o:
$(CXX) $(CXXFLAGS) -c $*.s
clean:
rm -f *.o $(DEMO_TARGET)
demo.c:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <SDL/SDL.h> // SDL stands for "Simple Direct-Media Layer"
/*
convenience function, for SDL_BlitSurface.
*/
void drawSprite(SDL_Surface* imageSurface, SDL_Surface* screenSurface, int srcX, int srcY, int dstX, int dstY, int width, int height)
{
// just for annoyance later, note the SDL uses signed ints for x and y but unsigned for width and height.
// shouldn't matter until resolution gets much better
SDL_Rect srcRect;
srcRect.x = srcX;
srcRect.y = srcY;
srcRect.w = width;
srcRect.h = height;
SDL_Rect dstRect;
dstRect.x = dstX;
dstRect.y = dstY;
dstRect.w = width; // This is actually ignored by SDL_BlitSurface.
dstRect.h = height; // This is actually ignored by SDL_BlitSurface.
SDL_BlitSurface(imageSurface, &srcRect, screenSurface, &dstRect);
// fast blit from source to destination.
// ignores the -1 or -2 possible error codes.
}
/*
Main program that executes.
*/
int /// return the error code. Usually zero means execution was OK else not 0
main(int argc, /// number of arguments
char *argv[]) /// the argument strings. Argv[0] is the command name iteself.
{
SDL_Surface *screen; /// Graphical surface structure.
SDL_Joystick *joystick; /// Joystick information structure, full of info I don't use in this program.
SDL_Event event; // An event structure.
// This is a big union. Specifically, the first 8 bytes are the type. The 'union' is either
// the type (for the first 8 bytes) or some structure where the first 8 bytes
// are still the type. It is just a style, and typographic convenience, that
// it is not a structure of { unit 8 type, union data { keyboard.....} }.
int done = 0;
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0)
// initialize the video subsystem and the joystick subsystem. Using a bitwise or to send multiple flags is
// common.
{
return 1; /// oops, something failed.
}
screen = SDL_SetVideoMode(320, 240, 16, SDL_SWSURFACE);
// Setting the video mode. This SDL call can only take certain parameters.
// a 320x240 screen, so this won't look especially good on a TV which allows a higher resolution
// 16 bits per pixel.
// SDL_SWSURFACE : Create the Video Surface in System Memory.
// This works. Double buffering does not currently work, and using the SDL_HWSURFACE
// is tricky.
if (!screen) // oops. Look
{
fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError());
// Won't see the fprint on the graphical GP2X screen.
return 1;
}
joystick = SDL_JoystickOpen(0); // initialize the joystick and buttons. Number '0' is the only one.
if (!joystick) // should not happen
{
fprintf(stderr, "Couldn't open the joystick: %s\n", SDL_GetError());
return 1;
}
SDL_ShowCursor(SDL_DISABLE); // do not show cursor on the screen.
SDL_Surface* bitmap = SDL_LoadBMP("/mnt/sd/image.bmp"); // load a BMP format.
// BMP is an uncompressed simple bitmap of a specific color depth.
// The file is the sd card, which was mounted like a normal linux file system.
// Not that we don't check for errors in the demo code, and this is the only likely
// spot for an error to occur. Figuring out which errors to check for is tricky.
drawSprite(bitmap, screen, 0, 0, 0, 0, bitmap->w, bitmap->h); // draw it.
SDL_Flip(screen);
// Tell SDL to update the screen at some useful time. Note that without SDL_DOUBLEBUF,
// this will just be the same as SDL_UpdateRect.
// OK, now let's wait for a keypress. But it's complicated.
// The event queue might not be empty on start-up.
// When I launch this program from the GP2X main menus, I press down the B button.
// Depending on my speed on the button, if the SDL and the image are in cache, and,
// possibly, the phase of moon, the SDL may start up while while the B button is still down.
// If this happens, SDL immediately adds a button down event for the B button.
SDL_PollEvent(&event); // ignore any one event in the queue.
// SDL_PollEvent will return immediately, and will return 1 if there is a pending event.
// I don't care about the pending event, if any, so I can ignore the return value.
while (!done)
{
SDL_WaitEvent(&event); // wait indefinitly for events. Through away error return value (1).
// When this returns, some event happened.
switch (event.type) // look at the 'type', or a uint8 at the beginning of the event union.
{
// OK, now these are rather silly. The GP2X has no keys to hit, and has no 'quit' method.
// Instead, the GP2X has button events for the various buttons (A,B,X,Y,L,R,Start,Select,Volume), and
// the joystick positions, and the center click down.
/*
case SDL_KEYDOWN:
case SDL_QUIT:
*/
// These are the button events
case SDL_JOYBUTTONDOWN:
// and here we could see code like "if (event.jbutton.button == GP2X_BUTTON_X) ....
//but any button will do.
done = 1;
break;
}
}
SDL_Quit(); // Shut down the SDL library, freeing resources.
// This is how to quit back to the menu. Just doing a return(0) will look like the GP2X hung.
chdir("/usr/gp2x");
execl("/usr/gp2x/gp2xmenu", "/usr/gp2x/gp2xmenu", NULL);
// execl will go run the other program INSTEAD of this one.
return 0; // this line make the compiler happy, but the call to execl() above never returns
}
A ver si alguien sabe qué puede estar pasando.
Prueba a cambiar esta línea:
screen = SDL_SetVideoMode(320, 240, 16, SDL_SWSURFACE);
por esta otra:
screen = SDL_SetVideoMode(320, 240, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
Así es como me funciona a mí con las SDL de paeryn
Prueba a cambiar esta línea:
screen = SDL_SetVideoMode(320, 240, 16, SDL_SWSURFACE);
por esta otra:
screen = SDL_SetVideoMode(320, 240, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
Así es como me funciona a mí con las SDL de paeryn
efegea, nada, no me funciona, tengo que instalar las SDL de paeryn en mi GP2X?
Gracias por esas respuestas tan rápidas que das. Muchas gracias.
Pues la verdad no se lo que pasa :confused:
Las SDL no las tienes que instalar, estás compilando estáticamente.
eso me imaginaba, que no hacía falta, pero bueno, por no preguntar que no sea. jeje
Podría ser que no haya creado bien el bmp? Como debo crearlo? O sabes de donde descargar un bmp valido?
< - >
Podrías pasarme el makefile de algo que te compile bien a ti? Y ya de paso decirme qué sdk usas y tal para ver si sé qué es lo que me falla.
No creo que el problema sea el Makefile, porque si está mal no te compilaría directamente, porque..¿te compila verdad? Te adjunto mi makefile del call of dracula
El SDK que uso son las sdl de paeryn y el toolchain hecho con crossdev
Por cierto ahora que lo pienso, ¿has probado a compilarlo para pc? Así es más fácil depurarlo, si no te funciona en pc seguro que no funciona en la gp2x
Muchas gracias efegea, a ver si consigo de una vez instalar las SDL de paeryn, tengo hecho el toolchain del sdk oficial de GPH y otro hecho con crossdev, pero no sé si hago bien al compilarlas. Por que me falla, bueno, viendo que tú usas el crossdev, voy a hacer lo mismo que tú, además por que me gustaría más hacer las cosas al estilo Gentoo, :D
He creado la toolchain con crossdev -t arm-unknown-linux-gnu, ahora he de ejecutar el ./configure --prefix=$ROOT --host arm-unknown-linux-gnu --disable-shared en las fuentes de las SDL-paeryn, pero qué sería lo idoneo para $ROOT? usar /usr/local?
¿Qué has usado tú?
crossdev te instala el toolchain en /usr/arm-unknown-linux-gnu, eso es lo que tienes que usar como $ROOT
el_Salmon
13/08/2006, 21:07
Hola,
yo tambien tengo Gentoo Linux instalado y me gustaria empezar a desarrollar o depurar codigo. Me gustaria saber que es mejor para tener el toolchain de ARM, si utilizar la herramienta crossdev de Gentoo o descargar el toolchain oficial.
Añado: Leyendo en manual de D_Skywalk me ha surgido una duda: ¿se puede compilar dinamicamente un programa con las librerias SDL version comunity?
Creo que voy a optar por instalar el toolchain del oficial para evitar calentar aun más mi portatil que está que echa humo con tanto compilacion.
Con el oficial de la GP2X vas sobre seguro, es un script que se encarga de hacer todo el trabajo de construcción de la toolchain para GP2X por ti, de todas formas es una cuestión personal, yo por ejemplo tengo dos toolchains, una con GCC 4.0.2 + GLIBC 2.3.5 y otra con GCC 4.1.1 + GLIBC 2.3.6, y todas las librerías que lleva (que no son poca) estas toolchain las he compilado yo mismo (modificando el script de ooPo y añadiendo parches) y funcionan.
El toolchain oficial para GP2X será con GCC 3.4.6 + GLIBC 2.2.5 (ideal para enlazar dinámicamente tus aplicaciones, siempre que uses las libs de la GP2X que trae el toolchain) y otra con GCC 4.0.3 + GLIBC 2.3.6 que es más parecido a lo que casi todo el mundo usa (para enlazar con librerías de forma estática, así no dependes de las de la GP2X).
Si usas las librerías tipo "community" hay formas de enlazar dinámicamente con las librerías, el problema sería usarlas en la GP2X, o las instalas en la NAND en algun sitio como /lib o /usr/lib o bien incluyes las libs dinámicas (*.so) que necesites para que funcione tu aplicación junto con la misma y modificas la ruta de busqueda de las librerías dinámicas con variables de entorno como LD_LIBRARY_PATH o incluyendo y usando la librería ld-linux.so.* (el enlazador simbólico) de tu toolchain para indicar la ruta de busqueda de las librerías dinámicas para tu aplicación, aquí (http://www.codesourcery.com/gnu_toolchains/arm/faq.html#q_gnu_linux_use_glibc) tienes un ejemplo, de todas formas lo más sencillo es enlazar tus programas estáticamente.
Misato, podrias por favor colgar tu toolchain ya compilado. A mi me interesa.
el_Salmon
14/08/2006, 00:25
Con el oficial de la GP2X vas sobre seguro, es un script que se encarga de hacer todo el trabajo de construcción de la toolchain para GP2X por ti, de todas formas es una cuestión personal, yo por ejemplo tengo dos toolchains, una con GCC 4.0.2 + GLIBC 2.3.5 y otra con GCC 4.1.1 + GLIBC 2.3.6, y todas las librerías que lleva (que no son poca) estas toolchain las he compilado yo mismo (modificando el script de ooPo y añadiendo parches) y funcionan.
El toolchain oficial para GP2X será con GCC 3.4.6 + GLIBC 2.2.5 (ideal para enlazar dinámicamente tus aplicaciones, siempre que uses las libs de la GP2X que trae el toolchain) y otra con GCC 4.0.3 + GLIBC 2.3.6 que es más parecido a lo que casi todo el mundo usa (para enlazar con librerías de forma estática, así no dependes de las de la GP2X).
Si usas las librerías tipo "community" hay formas de enlazar dinámicamente con las librerías, el problema sería usarlas en la GP2X, o las instalas en la NAND en algun sitio como /lib o /usr/lib o bien incluyes las libs dinámicas (*.so) que necesites para que funcione tu aplicación junto con la misma y modificas la ruta de busqueda de las librerías dinámicas con variables de entorno como LD_LIBRARY_PATH o incluyendo y usando la librería ld-linux.so.* (el enlazador simbólico) de tu toolchain para indicar la ruta de busqueda de las librerías dinámicas para tu aplicación, aquí (http://www.codesourcery.com/gnu_toolchains/arm/faq.html#q_gnu_linux_use_glibc) tienes un ejemplo, de todas formas lo más sencillo es enlazar tus programas estáticamente.
Muchas gracias por la información. Me he descargado el toolchain oficial ya compilado del manual de D_skywalk (http://david.dantoine.org/contenido/10/) y las librerias version comunity para utilizar las librerias SDL con acelaracion. Creo que la opción de añadir las variables de entorno es lo mas sano para evitar sobreescribir librerias ¿no?
Powered by vBulletin® Version 4.2.5 Copyright © 2026 vBulletin Solutions Inc. All rights reserved.