PDA

Ver la versión completa : Programacion de graficos y juegos



Macuy
17/09/2009, 16:11
Hola a todos... como ya les habia comentado con anterioridad, tuve que dejar de lado mi expedicion por RoR por cuestiones de tiempo... Ahora por cosas del estudio, inicio a trabajar varias cosas en ambiente full grafico... y pues creo que encontre una utileria muy interesante de la cual sinceramente no conocia... son las librerias para programar en C++ de SDL (Simple DirecMedia Layer), que contienen muchas herramientas para el manejo de multimedia e imagenes 2D....

Hasta el momento no he logrado hacer mucho por falta de tiempo, mas que hacer algunos efectos de colores, y manipular algunas imagenes de forma sencilla, pero segun logre ver, no esta complicado. Lo bonito de estas librerias, es que son multiplataformas, de modo que funcionan en Winsocks, MacOS, Linux... Obviamente estoy desarrollando sobre Linux, y pues ya les ire publicando el codigo de los distintos programitas o funciones que vaya creando...

Si alguien tiene experiencia en esta area, seria bueno poder conocer mas sobre esto...

Xaludos

Macuy
21/09/2009, 00:08
Bueno, mientras logro arreglar mi notebook (que por estar haciendo algunas cosas de la U murio) pues ire colocando informacion basica sobre estas librerias... y que me han ido ayudando a probar las cosas...


Simple DirectMedia Layer (SDL) es un conjunto de bibliotecas desarrolladas con el lenguaje C que proporcionan funciones básicas para realizar operaciones de dibujado 2D, gestión de efectos de sonido y música, y carga y gestión de imágenes.

Pese a estar programado en C, tiene wrappers a otros lenguajes de programación como C++, Ada, C#, Basic, Erlang, Lua, Java, Python, etc. También proporciona herramientas para el desarrollo de videojuegos y aplicaciones multimedia. Una de sus grandes virtudes es el tratarse de una biblioteca multiplataforma, soportando oficialmente los sistemas windows, GNU/linux, MacOS y QNX, además de otras arquitecturas/sistemas como Dreamcast, GP32, GP2X... De ahí le vienen las siglas Simple Directmedia Layer que más o menos alude a capa de abstracción multimedia. Desarrolladas inicialmente por Sam Lantinga, desarrollador de videojuegos para la plataforma GNU/linux.

La biblioteca se distribuye bajo la licencia LGPL, que es la que ha provocado el gran avance y evolución de las SDL.

Componentes adicionales

Se han desarrollado una serie de bibliotecas adicionales que complementan las funcionalidades y capacidades de la biblioteca base.

* SDL Mixer: Extiende las capacidades de SDL para la gestión y uso de sonido y música en aplicaciones y juegos. Soporta formatos de sonido como Wave, MP3 y OGG, y formatos de música como MOD, S3M, IT, y XM.
* SDL Image: Extiende notablemente las capacidades para trabajar con diferentes formatos de imagen. Los formatos soportados son los siguientes: BMP, JPEG, TIFF, PNG, PNM, PCX, XPM, LBM, GIF, y TGA,
* SDL Net: Proporciona funciones y tipos de dato multiplataforma para programar aplicaciones que trabajen con redes.
* SDL RTF: Posibilita el abrir para leer en aplicaciones SDL archivos de texto usando el formato Rich Text Format RTF.
* SDL TTF: Permite usar fuentes TrueType en aplicaciones SDL.

(wikipedia)


Ya casi termina de instalarse todo de nuevo en mi sistema, asi que ya he logrado hacer algunas cosita, por lo cual, ire publicando por aca el codigo, para que lo puedan probar... La idea es que de aca a finales de octubre, pueda tener ya un juego formal ya terminado... asi que veamos como nos va...

Xaludos

Macuy
28/09/2009, 13:02
INTRODUCCION
En los tiempos del MS-DOS la programación de videojuegos era bastante compleja, hacían falta grandes conocimientos de lenguaje ensamblador y de la estructura interna de la máquina, así como de la tarjeta de video y de sonido. Toda la programación se hacía directamente sobre el hardware. Es fácil imaginar los inconvenientes, había que preparar el juego para que funcionara con muchos modelos de tarjeta gráfica y también para los diferentes modelos de tarjetas de sonido (Adlib, Gravis Ultrasound (GUS), Sound Blaster). Es decir, hacer un juego, por simple que éste fuera, requería un esfuerzo muy alto, sin contar con que no siempre toda la información necesaria para acceder al hardware estaba al alcance de todo el mundo.

La llegada de Windows tampoco mejora demasiado el panorama, ya que no permite un acceso directo al hardware y su rendimiento gráfico es pobre. El acceso a los recursos del sistema también varía de un Sistema Operativo a otro. Se hace imprescindible, pues, crear una interfaz común para el desarrollo de videojuegos que permita el acceso estandarizado y
con una interfaz común a los recursos del sistema. Algunas de estas propuestas son OpenGL y DirectX (éste último sólo para sistemas Windows).

En el caso de OpenGL, se nos ofrece una interfaz multiplataforma, sin embargo, se limita aofrecernos una interfaz de acceso a gráficos (especializada en 3D, aunque con posibilidades de 2D) y no nos permite el acceso a otros recursos del sistema (teclado, sonido, joystick, timmers, etc...).

DirectX, sin embargo, está compuesto por varias sub-interfaces con el SO y el hardware, como DirectDraw (Gráficos 2D), Direct3D (Gráficos 3D), DirectInput (Entrada y Salida), DirectPlay (Capacidades de comunicación en redes TCP/IP), DirectSound (Acceso a hardware de sonido) y algún que otro componente más. Como vemos, DirectX tiene gran cantidad de capacidades, pero presenta dos inconvenientes. El primero es que sólo es válido para sistemas Windows, y el segundo es que por la propia naturaleza de la programación en Windows, su uso es algo engorroso y no apto para programadores con poca experiencia con las APIs de Windows y más concretamente con la interfaz COM+.

Afortunadamente, la empresa Loki Games, ante la necesidad de hacer portables los juegos de Windows a Linux y a otros sistemas operativos, crean una librería multiplataforma llamada SDL (Simple Directmedia Layer), que nos ofrece acceso a los recursos de la máquina (gráficos, sonido, entrada/salida, timming, etc...) mediante una interfaz coherente e
independiente del SO. SDL, además, nos permite utilizar la interfaz OpenGL para gráficos 3D.

LOGICA DE LOS JUEGOS

Un videojuego necesita comunicarse con el jugador a través de un dispositivo de entrada, como un Joystick o un teclado. La programación del sistema de Entrada/Salida puede parecer algo fácil de implementar, y de hecho lo es. Sin embargo, si no queremos ver como nuestro estupendo juego se hace poco “jugable” para el jugador hay que cuidar mucho este
aspecto. Una mala respuesta del juego ante una pulsación del teclado puede hacer frustrante la experiencia de juego para el jugador. Otro factor importante es el soporte de una variedad de dispositivos de entrada. Algunos jugadores preferirán usar el teclado al ratón y viceversa. Si
además queremos que nuestro juego tenga un toque profesional, hay que dar la posibilidad al jugador de que defina las teclas con las que quiere jugar, además de dar soporte a los diferentes tipos de teclados internacionales.

Macuy
28/09/2009, 13:11
VISUALIZACION
La misión de esta capa es la de convertir el estado interno del juego en una salida gráfica. Ya sea en 2D o 3D, la calidad gráfica es un factor importantísimo. Normalmente, el programador trabaja con unos gráficos creados por él mismo, y cuya calidad dependerá de las dotes artísticas de éste (Yo por ejemplo, prefiero usar imagenes ya hechas, pues soy un desastre como artista). Uno de los elementos principales de un buen juego es un buen motor gráfico, capaz de mover una gran cantidad de Sprites en un juego 2D o una gran cantidad de polígonos (triángulos) en el caso de un juego en 3D. En el diseño del motor gráfico, siempre hay que llegar a un compromiso entre la compatibilidad y el rendimiento. Hay tarjetas gráficas en el mercado con unas capacidades casi sobrenaturales, pero que no son estándar, sin embargo, tampoco podemos dar la espalda a los jugadores “profesionales” que equipan sus ordenadores con la última
aceleradora 3D del mercado.

El sonido es un aspecto al que, a veces, no se le da la importancia que merece. Tan importante como unos buenos gráficos es un buen sonido. Tanto el sonido como la banda sonora de un juego son capaces de transmitir una gran cantidad de sensaciones al jugador, y eso es, al fin y al cabo, lo que se busca. Tanto como la calidad, la buena sincronización con lo que va sucediendo en pantalla es de suma importancia. El “game loop” o bucle de juego es el encargado de “dirigir” en cada momento que tarea se está realizando.

Analicemos un ejemplo. Lo primero que hacemos es leer los dispositivos de entrada para ver si el jugador ha realizado alguna acción. Si hubo alguna acción por parte del jugador, el siguiente paso es procesarla, esto es, actualizar su posición, disparar, etc... dependiendo de que acción sea. En el siguiente paso realizamos la lógica de juego, es decir, todo aquello que
forma parte de la acción del juego y que no queda bajo control del jugador, por ejemplo, el movimiento de los enemigos, cálculo de trayectoria de sus disparos, comprobamos colisiones entre la nave enemiga y la del jugador, etc... Fuera de la lógica del juego quedan otras tareas que realizamos en la siguiente fase, como son actualizar el scroll de fondo (si lo hubiera), activar sonidos (si fuera necesario), realizar trabajos de sincronización, etc.. Ya por último nos resta volcar todo a la pantalla y mostrar el siguiente fram e. Esta fase es llamada “fase de render”.

Normalmente, el game loop tendrá un aspecto similar a lo siguiente:



int done = 0;
while (!done) {
// Leer entrada
// Procesar entrada (si se pulsó ESC, done = 1)
// Lógica de juego
// Otras tareas
// Mostrar frame
}


Antes de que entremos en el game loop, tendremos que hacer un Múltiples tareas, como inicializar el modo gráfico, inicializar todas las estructuras de datos, etc...

Macuy
28/09/2009, 13:25
Primeros pasos con SDL
"Iniciar el camino es fácil, finalizarlo también. Lo meritorio es recorrerlo"

Tanto si utilizas Windows, Linux o cualquier otro sistema operativo, SDL te va a ahorrar un montón de trabajo y de dolores de cabeza... Veamos como se instalan las librerias en Linux y WinBugs:

Windows (VC++)
Lo primero que necesitamos es tener instalado el compilador de C. Supondré que utilizan Visual C++ 6.0, ya que es el más extendido y utilizado en entornos Windows. Si tienes otro compilador, los pasos a realizar serán similares, aunque ya dependerá de cada caso. Lo mejor es consultar la documentación de tu compilador. El primer paso es descargar las librerías necesarias. Asegúrate que sean las development libraries. Si utilizas VC++ existe una versión especial de las librerías, por ejemplo, el archivo que debes descargar para VC es SDL-devel-1.x.x-VC6.zip. Una vez
descargado descomprímelo en el directorio raiz. Ahora debes tener un directorio llamado \SDL-1.x.x\. En lugar de 1.2.6, podrían ser otros valores dependiendo de la versión de la librería. Arranca VC++ y selecciona la opción new... del menú file. Podrás ver la ventana de nuevo proyecto. En la pestaña Project selecciona WIN32 Application, escribe el nombre
del proyecto en el cuadro de texto project name, y selecciona el directorio donde quieres almacenarlo en location. Seguidamente pulsa el botón OK.
En la siguiente ventana nos pregunta que tipo de aplicación queremos crear. Seleccionamos un proyecto vacío (An empty project) y pulsamos el botón finish. Ya tenemos nuestro proyecto creado. Ahora vamos a configurar el proyecto para poder utilizar las librerías de SDL.
Selecciona la opción Settings... del menú Project. Verás como aparece una ventana de configuración. Selecciona la pestaña C/C++, aparecerá un campo desplegable llamado Category. Selecciona code generation en este desplegable. En el desplegable llamado Use run-time library, selecciona Multithreaded DLL. El siguiente paso es seleccionar la opción Preprocessor en el desplegable Category. En el campo Additional include directories, incluimos la ubicación del directorio include que hay dentro del directorio de SDL. En este caso es C:\SDL-1.x.x\include.
Ahora vamos a configurar el enlazador (linker) del compilador para que pueda enlazar las librerías. Pulsamos la pestaña Link, y seleccionamos input. El el cuadro de texto Object/library modules añadimos sdlmain.lib y sdl.lib. En caso de que queramos utilizar otras librerías, como por ejemplo, SDL_mixer, hemos de añadirlas también aquí. En el campo Aditional library path, vamos a añadir la ubicación de las librerías. En este caso C:\SDL-1.x.x\lib. Una vez hecho esto, pulsamos el botón OK y ya tenemos todo listo.
Vamos a añadir código a nuestro proyecto. Selecciona la opción New... del menú file. Veremos una ventana que nos permite seleccionar el tipo de archivo. Asegúrate que está seleccionada la pestaña File. En la ventana selecciona C++ Source File. En el campo File name, introduce el nombre del archivo. En este caso lo llamaremos main.c. Seguidamente pulsamos OK. Ahora tendremos una ventana de edición lista para empezar a teclear. Prueben el siguiente código que utilizaremos para probar la librería y comenten si les funciona:


#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
int main(int argc, char *argv[]) {
SDL_Surface *screen;
SDL_Event event;
int done = 0;
atexit(SDL_Quit);
// Iniciar SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("No se pudo iniciar SDL: %s\n",SDL_GetError());
exit(1);
}
// Activamos modo de video
screen = SDL_SetVideoMode(640,480,24,SDL_HWSURFACE);
if (screen == NULL) {
printf("No se puede inicializar el modo gráfico:
\n",SDL_GetError());
exit(1);
}
// Esperamos la pulsación de una tecla para salir
while(done == 0) {
while ( SDL_PollEvent(&event) ) {
if ( event.type == SDL_KEYDOWN )
done = 1;
}
}
return 0;
}

Una vez introducido el código, pulsamos F7 para compilar el programa. Si todo va bien, VC++ nos informará que no ha habido ningún error. Si no es así repasen el código. Como por defecto VC++ está en modo debug, el compilador nos habrá creado un directorio llamado Debug en el directorio donde se encuentra el proyecto. Dentro de este directorio encontramos un ejecutable. Éste es nuestro programa ya compilado, sólo nos resta un paso. Para que los programas que utilizan SDL funcionen, hemos de copiar el archivo SDL.dll en el mismo directorio donde se encuentre el programa ejecutable (o añadirlo al directorio \windows\system32). Ya está listo para su ejecución pulsando doble click sobre él. Si todo ha ido bién, verás una ventana en negro. Pulsa cualquier tecla para cerrar el programa.

Macuy
28/09/2009, 13:39
Instalacion sobre Linux

Tal y como hicimos con Windows, lo primero que tenemos que hacer es localizar el paquete que nos conviene descargar. Si tu distribución Linux está basada en Red Hat o trabaja con paquetes en formato RPM, tendrás que bajarte los paquetes que finalizan con la extensión .rpm. La instalación de un paquete RPM se hace de la siguiente manera
(siempre como usuario root).


rpm –ivh nombre_paquete

Si tu distribución está basada en Debian (Ubuntu), podrás utilizar la utilidad apt para descargar e instalar SDL. La siguiente línea descarga e instala SDL.


apt-get install libsdl1.2-dev

Esta línea podría variar dependiendo de la última versión de SDL disponible. Es conveniente ejecutar la línea siguiente antes para asegurarte que descargas la última versión.

apt-get update
Seguidamente, para conocer que versiones y que librerías para SDL hay disponibles utliza la siguiente línea.

apt-cache search sdl
Una vez instalado SDL, las librerías deberían estar instaladas en el directorio /usr/lib, y los archivos de cabecera en /usr/include/SDL.
No vamos a entrar en detalle en el funcionamiento del compilador GCC, simplemente mostraré las líneas necesarias para realizar la compilación.
Para realizar una compilación utilizando librerías dinámicas, compila el programa de la siguiente forma.


gcc -L/usr/lib -lSDL -lpthread -I/usr/include/SDL -D_REENTRANT main.cpp otro_archivo.cpp -o ejemplo

El modificador –L permite indicar la ubicación de las librerías, y el modificador –I indica la ubicación de los archivos de cabecera. El modificador –l, nos permite indicar al compilador qué librerías queremos enlazar con nuestro programa. Si quisieramos enlazar la librería principal de SDL y también SDL_mixer utilizaríamos –lSDL –lSDL_mixer.
Por último, indica los archivos fuente que quieres compilar (main.cpp y otro_archivo.cpp) y el nombre del archivo ejecutable que quieres generar después del modificador –o. Si no entiendes el resto de modificadores no te preocupes, déjalos tal cual, ya que si no, no funcionará el archivo ejecutable. Para realizar una compilación enlazando las librerías estáticas, hazlo de la siguiente forma:


gcc -L/usr/lib -lSDL -lpthread -lm -L/usr/X11R6/lib -lX11 -lXext -ldl
-I/usr/include/SDL -D_REENTRANT main.cpp otro_archivo.cpp -o ejemplo

Para ejecutar el programa ya compilado usamos


./ejemplo

Macuy
28/09/2009, 13:58
Trabajando con SDL


Es hora de ponerse manos a la obra y poner a trabajar al compilador.
Antes de llamar a cualquier función de SDL, hay que inicializarla y para ello se utiliza la función SDL_Init(Uint32 flags). Veámoslo con un ejemplo.



#include <stdlib.h>


#include "SDL.h"

main(){

if (SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO)< 0) {
printf("No se puede iniciar SDL: %s\n",SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
}








En este fragmento de código hay varias cosas interesantes. Empecemos por la función SDL_Init. Como parámetro acepta un argumento de tipo Uint32. Como te dije antes, SDL es multiplataforma, por lo que tiene definidos una serie de tipos de datos que serán iguales con independencia del sistema en el que corra. La U quiere decir que el tipo de datos es sin signo (unsigned), int, como podrás adivinar es por que es un entero y 32, porque es un entero de 32 bits. Si en vez de U, usamos la S (signed) estaremos hablando de un entero con signo. Para el número de bits, los posibles valores son 8,16,32 o 64. Así, por ejemplo, Uint16, hará referencia a un entero de 16 bits. Veamos en detalle los parámetros que hemos pasado a SDL_Init(). SDL_INIT_AUDIO|SDL_INIT_VIDEO. Con este parámetro le decimos a SDL que sólo queremos inicializar el subsistema de audio y de video. Los posibles valores son

SDL_INIT_VIDEO

SDL_INIT_AUDIO
SDL_INIT_TIMER
SDL_INIT_CDROM
SDL_INIT_JOYSTICK
SDL_INIT_EVERYTHING
Los parámetros se pasan separados por la barra vertical (|). Si quisiéramos inicializar además del audio y el video el cd-rom, los parámetros serían los siguientes: SDL_INIT_AUDIO|SDL_INIT_VIDEO|SDL_INIT_CDROM
Si lo queremos activar todo, pasaremos como único parámetro SDL_INIT_EVERYTHING.
Una vez inicializado SDL, si necesitamos inicializar otro subsistema podemos hacerlo con la función SDL_InitSubSystem(Uint32 flags) de la siguiente manera.






// Inicializamos el CD-ROM


if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1) {

printf("No se puede iniciar el cdrom: %s\n",SDL_GetError());

exit(1);
}







Como habrán adivinado, la función SDL_GetError() devuelve el último error interno de SDL en formato cadena. Cuando una aplicación SDL es inicializada, se crean dos archivos, stderr.txt y stdout.txt. Durante la ejecución del programa, cualquier información que se escriba en la salida de error estándar se escribe en el archivo stderr.txt. Igualmente, cualquier información que se escriba en la salida estándar se guardará en el archivo stdout.txt. Esto nos va a ser de gran ayuda a la hora de depurar programas. Una vez finalizada la ejecución, si estos archivos están vacíos son borrados automáticamente, si no, estos permanecen intactos.

Al igual que inicializamos SDL, cuando hemos terminado el trabajo hemos de cerrarlo. La función encargada de esta tarea es SDL_Quit(). En nuestro programa de ejemplo hemos usado la siguiente la línea atexit(SDL_Quit). La función atexit() toma como parámetro a otra función a la que llama justo antes de que finalice la ejecución del programa. En nuestro caso, antes de que finelice nuestro programa (ya sea por un error o porque el usuario forzó la salida) se llamará a la función SDL_Quit(). Una de las particularidades de atexit() es que la función a la que debe llamar no tiene que tener parámetros ni devolver nada. En el caso de que queramos finalizar sólo un subsistema de SDL usaremos la función SDL_QuitSubSystem(Uint32 flags). Por ejemplo, si quisiéramos desactivar el subsistema de cdrom usaríamos la siguiente línea:






SDL_QuitSubSystem(SDL_INIT_CDROM);



La primera tarea que tenemos que acometer antes de empezar a mostrar información gráfica en la pantalla es establecer el modo de video. SDL nos lo pone fácil con la función SDL_SetVideoMode(). La función tiene la siguiente forma:




SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)


Esta función devuelve un puntero del tipo SDL_Surface. En SDL la “surface” o superficie es el elemento básico que utilizamos para construir los gráficos de nuestro juego. Imagina una superficie como un rectángulo que contiene información gráfica, por ejemplo de nuestra nave. La única superficie que es visible, es decir, que vemos en la

pantalla del ordenador, es ésta que nos devuelve la función SDL_SetVideoMode().Los parámetros witdth y height son la anchura y la altura de la superficie en píxeles. Es decir, la resolución de la pantalla. En teoría aquí podemos poner cualquier cosa, pero evidentemente el hardware ha de soportar dicha resolución. Si la resolución no es soportada, SDL intentará poner una resolución válida lo más cercana a la requerida. Un poco más adelante veremos una función que nos permitirá conocer cuales son los modos válidos. Con el parámetro bpp le indicamos a SDL cuántos bits por pixels queremos establecer, es decir, la profundidad de color. Valores típicos son 8, 16, 24 y 32. Hoy en día no tiene sentido trabajar con 8, ya que sólo nos proporciona 256 colores posibles, además, habría que trabajar con paletas en vez de con color real. El último parámetro es flags, que es un campo de bits. Estos son los posibles valores y su significado.




SDL_SWSURFACE Crea la superficie de vídeo en la memoria principal
SDL_HWSURFACE Crea la superficie en la memoria de vídeo.


SDL_ASYNCBLIT Modo de blit asíncrono. Mejora el rendimiento en máquinas con más de un procesador, unque puede disminuirlo en máquinas con una sólo procesador.

SDL_ANYFORMAT Fuerza el uso de los bpp de la surface actual. Hay que usarlo cuando queramos crear la superficie en una ventana.
SDL_HWPALETTE Da a SDL acceso exclusivo a la paleta de color.

SDL_DOUBLEBUF Sólo válido con SDL_HWSURFACE. Permite el uso del doble buffer.
SDL_FULLSCREEN Intenta poner el modo a pantalla completa.

SDL_OPENGL Crea un contexto OpenGL en la superficie.

SDL_OPENGLBLIT Igual que la anterior, pero permite que SDL haga el render 2D.

SDL_RESIZABLE Crea un ventana que puede cambiar de tamaño.

SDL_NOFRAME Crea una ventana pero sin borde.


He aquí un ejemplo práctico del uso de SDL_SetVideMode().



SDL_Surface *screen;



screen = SDL_SetVideoMode(640,480,24,SDL_SWSURFACE| SDL_DOUBLEBUF);


if ( screen == NULL ){

fprintf(stderr, "No se puede establecer el modo \
de video 640x480: %s\n", SDL_GetError());
exit(1);

}

Macuy
28/09/2009, 16:17
Les dejo aca el codigo de un programa funcional, que nos mostrara una imagen bmp, para que no se me desesperen... jejeje

La imagen se llama imagen.bmp que yo en lo personal lo tengo grabado en el path donde se encuentra el archivo cpp..... Yo estoy programando sobre linux, especificamente en ubuntu. Si quieren usar otra imagen pues ademas del archivo, deben poner el path completo de la ubicacion y ser bmp



#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
int main(int argc, char *argv[]) {
SDL_Surface *image, *screen;
SDL_Rect dest;
SDL_Event event;
int done = 0;
atexit(SDL_Quit);
// Iniciar SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("No se pudo iniciar SDL: %s\n",SDL_GetError());
exit(1);
}
// Activamos modo de video
screen = SDL_SetVideoMode(640,480,24,SDL_HWSURFACE);
if (screen == NULL) {
printf("No se puede inicializar el modo gráfico: \n",SDL_GetError());
exit(1);
}
// Cargamos gráfico
image = SDL_LoadBMP("imagen.bmp");
if ( image == NULL ) {
printf("No pude cargar gráfico: %s\n", SDL_GetError());
exit(1);
}
// Definimos donde dibujaremos el gráfico
// y lo copiamos a la pantalla.
dest.x = 100;
dest.y = 100;
dest.w = image->w;
dest.h = image->h;
SDL_BlitSurface(image, NULL, screen, &dest);
// Mostramos la pantalla
SDL_Flip(screen);
// liberar superficie
SDL_FreeSurface(image);
// Esperamos la pulsación de una tecla para salir
while(done == 0) {
while ( SDL_PollEvent(&event) ) {
if ( event.type == SDL_KEYDOWN )
done = 1;
}
}
return 0;
}


Xaludos

Macuy
04/11/2009, 13:09
Bueno, perdon por dejarlos medio esperando... ya logre terminar el juego de momento funcional, y pues eso me valio la nota mayor... :mrgreen::mrgreen:

En breve les subo el fuente y especificaciones que aun estoy terminando la documentacion...

Xaludos