Ya hace un año sacamos un videojuego que tuvo cierto éxito, fue super-tirititran el superhéroe gaditano. Viendo el éxito que tuvimos con eso de hacer juegos localistas ahora llegamos con el segundo, pero esta ampliamos fronteras y el juego está ambientado en andalucía

El juego se llama "Nimuh en busca del tesoro andaluz" y podéis descargarlo desde la web del proyecto

http://www.nimuh.com

El juego es un juego de comerte un poco el coco y está basado en "Theseus and the Minotaur Mazes", pero con algunos toques personales y en perspectiva isométrica

Espero que os guste y que disfrutéis con él lo mismo que nosotros lo hemos hecho mientras lo hacíamos

un saludo y gracias a todos los del foro que me habéis ayudado como siempre con mis problemas a la hora de programarlo

Hola a todos:

Estoy buscando una solución desesperadamente a este tema. El problema es que estoy haciendo un juego en linux y windows. La cosa es qeu cuando captura la tecla "Ñ" en linux me dice que estoy pulsando la tecla "Ñ" (muy bien), pero si la captura en Windows me dice qeu estoy pulsando el punto y coma.

Las teclas las capturo con: event.key.keysym.sym

He estado probando con el tema del unicode así event.key.keysym.unicode (activando SDL_EnableUNICODE), pero tampoco me ha dado resultado

Parece como si windows me reconociese el teclado en ingles ¿es posible eso?

Cualquier ayuda es buena. Muchas gracias a todos

Hola a todos

Estamos en fase de terminar el juego, bueno... supongo que en dos meses estará listo, y me estoy encontrando con problemas que no se exactamente como solucionar y son bastante jodidos....

La cosa es que en el juego creado diferentes archivos XML con configuraciones y datos de los niveles y eso, y me he encontrado el problema que cuando mete una ñ o un acento en el XML luego no puedo cargarlo. Me he dado cuenta que los archivos se crean en ISO-8859-15 y cuando los paso a UTF-8 ya funcionan perfectamente

Uso "fopen" de esta manera:

f = fopen((char*)file.c_str(), "w+");

y voy haciendo los fwrite línea por línea

fwrite(tmp_val, strlen(tmp_val), 1, f);

la cuestión es ¿como podría hacer para crear directamente los archivos en UTF-8? ¿puedo hacerlo de esta forma o tendría que cambiar el código para generar los archivos de otra manera?

muchas gracias de verdad, me estáis salvando la vida estos días

Hola a todos:

Realmente no se donde poner esta pregunta, así que lo pongo en el general. En el juego que estoy haciendo tengo un problemas, que realmente es un programa general mas que particular para la creación de videojuego

Bueno que me lío. La cosa es que tengo que crear en tiempo de ejecución algunos directorios, el problema es que en windows la única forma que he encontrado es haciendo llamadas al sistema:

system('mkdir ...')

El problema es q en windows (en linux no) cuando haga una llamada al sistema se me abre y cierra una ventana en MSDOS muy rápida que es muy molesta y lo peor es que si el juego está en pantalla completa te saca de la pantalla completa y te deja en modo ventana

¿existe alguna forma de que no salgan esas ventanas cuando se hacen llamadas al sistema?

si no se puedo ¿existe otra forma de crear directorios en c++ que no sea esta?

muchas gracias

Hola a todos:

Estamos realizando un pequeño videojuego en 2D y estamos usando OpenGL. Usamos png para todas las imágenes y el problema es q en algunos ordenadores la transparencia en PNG no sale bien. Adjunto una imagen para que podáis verlo mejor:



A la derecha la que se ve mal por supuesto. Es la sombra del personaje y se ve así, como si en todas los pixel con alpha se colocaran al 50% de transparencia.

Lo raro es que pasa en algunos ordenadores. El código que uso para cargar las texturas es el siguiente:

Código [Seleccionar] Expand


glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D , texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ROW_LENGTH, surf->pitch / surf->format->BytesPerPixel);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB10_A2, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);


¿alquien me puede dar alguna idea? ¿puede ser por problemas con la tarjeta de video y opengl?

gracias

Hola:

Ya se que esto no está relacionado con videojuegos, aunque es por un videojuego por lo que tengo el problema ;-)

Estoy desesperado y no se donde preguntar

La cosa es que tengo un XML con los diferentes idiomas del juego y tengo un clase en C++ que contiene el diccionario. Con expat leo el XML y lo paso a al diccionario de la instanacia. La cosa es que uso iso-8859-1 pero no me pilla los acentos, la ñ y todo eso

Me estoy volviendo loco. Llevo tres días mirando y modificando el código pero es imposible. Si le paso una string con acentos me lo hace bien, pero si le paso un string que he pillado el XML no me lo hace

Tengo el archivo XML, los archivos .cpp y .h con la codificacion iso-8859-1. El XML lo tengo con encoding="iso-8859-1" y cuando cargo en el XML_Parser de expat también le pongo iso-8859-1. Yo es que creo que no hay más

Lo he probado en linux y windows y en los dos no me funciona.

Lo más raro es que los caracteres especiales me lo pilla como si fueran dos caracteres. El texto se lo paso a una clase que me crea la palabra desde una fuente bitmap. Para ello voy leyendo cada uno de los caracteres, pero los especiales son dos números negativos

Por ejemplo, si pusiera:

"gráfico"

serías algo como:

3 (g) 10 (r) -21 -23 (á) 34 (f) 24 (i) 45 (c) 12 (o)

los números me los he inventado

Bueno, cualquier cosa a lo mejor me orienta hacer nuevas pruebas, pq ya no se me ocurre nada más

¿alguna idea?

gracias de antemano

La verdad que no se si esto facilita usar opengl, pero bueno

Lo que estoy intentando hacer es en un mapa cualquier poder poner un poco de luz para que se vea sólo una parte del mapa y la otra parte quede oscura. Pongo una imagen para que veais mas claro lo que quiero hacer



La cosa es que cuando te muevas por el mapa la luz irá cambiando. No se si tengo que iluminar la escena con OpenGL, no se si tendría que hacer una especie de máscara, la verdad que no tengo ni idea de como plantearme el problema. Además el juego va en isométrico y no se si cambia bastante de lo que he puesto.

Otra cosa es que además del mapa tengo los paneles del juego, donde estás los puntos y más datos. No se si la luz afectaría también a esta parte

La verdad que tengo muchas dudas. ¿alguien me podría orientar mas o menos para saber por donde tengo que buscar información?

gracias

Llevo mucho tiempo comiendo el coco con esto y es que no me sale. A ver si me podéis ayudar por favor. Tengo muy pocos conocimientos de OpenGL y empecé a trastearlo hace un tiempo y ahora vuelvo de nuevo.

La cosa es que estoy haciendo un juego en 2D pero usando opengl con SDL. La cuestión es que uso proyección ortogonal y quiero usar la profundidad de los elementos para poder ordenar los sprites.

La cosa es que uso glTranslatef, y cuando le paso en el último parámetro el indice Z, si no es 0, no me sale el sprite.

Estoy haciendo un montón de pruebas pero no puedo. Creo que es algo con el glEnable(GL_DEPTH_TEST), pero es que no doy con la tecla. A lo mejor no es ni eso

¿alquien me puede orientar más o menos para saber lo que hacer?

Coloco a continuación un código con el que estoy probando para ver si os orienta un poco

Se que es un poco rollo leer el código, pero os agradezco mucho vuestra ayuda

muchas gracias de antemano


#ifdef WIN32

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif

#if defined(__APPLE__) && defined(__MACH__)

#include <OpenGL/gl.h>   // Header File For The OpenGL32 Library

#include <OpenGL/glu.h>   // Header File For The GLu32 Library

#else

#include <GL/gl.h>   // Header File For The OpenGL32 Library

#include <GL/glu.h>   // Header File For The GLu32 Library

#endif

#include "SDL.h"

#include <SDL_image.h>

#include <stdlib.h>





typedef struct

{

   GLuint texture;

   int w, h;

   int w_or, h_or;

   int posx, posy;

} Textura;



Textura tex1, tex2;





SDL_Surface *LoadTex(char *filename, Textura *tex)

{

   //Uint8 *rowhi, *rowlo;

   //Uint8 *tmpbuf, tmpch;

   SDL_Surface *image, *temp;

   int i, j;



   //image = SDL_LoadBMP(filename);

   temp = IMG_Load(filename);

   if ( temp == NULL ) {

       fprintf(stderr, "Unable to load %s: %s\n", filename, SDL_GetError());

       return(NULL);

   }

   

   tex->w = 512;

   tex->h = 512;

   Uint32 saved_flags;

   Uint8  saved_alpha;

 

#if SDL_BYTEORDER == SDL_BIG_ENDIAN

     image = SDL_CreateRGBSurface(SDL_SWSURFACE, tex->w, tex->h, temp->format->BitsPerPixel,

                                 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);

#else

     image = SDL_CreateRGBSurface(SDL_SWSURFACE, tex->w, tex->h, temp->format->BitsPerPixel,

                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);

#endif



   /* Save the alpha blending attributes */

   saved_flags = temp->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);

   saved_alpha = temp->format->alpha;

   if ( (saved_flags & SDL_SRCALPHA)

      == SDL_SRCALPHA )

   {

   SDL_SetAlpha(temp, 0, 0);

   }

   

   int colorkey = SDL_MapRGB(temp->format, 255, 0, 255);

   SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey);

   SDL_FillRect(image, 0, colorkey);

   

   SDL_BlitSurface(temp, 0, image, 0);

   

   /* Restore the alpha blending attributes */

   if ( (saved_flags & SDL_SRCALPHA)

      == SDL_SRCALPHA )

   {

   SDL_SetAlpha(temp, saved_flags, saved_alpha);

   }





   tex->w_or = temp->w;

   tex->h_or = temp->h;



   SDL_FreeSurface(temp);

   return(image);

}



void LoadGLTextures(void)

{   

   

   SDL_Surface *surf;

   

   surf = LoadTex("circulo.png", &tex1);

   if (!surf) {

       SDL_Quit();

   }

   

   tex1.posx = 320;

   tex1.posy = 240;



   glGenTextures(1, &tex1.texture);

   glBindTexture(GL_TEXTURE_2D, tex1.texture);



   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture

   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture



   glTexImage2D(GL_TEXTURE_2D, 0, 4, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);

   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

   

   

   surf = LoadTex("alien.png", &tex2);

   if (!surf) {

       SDL_Quit();

   }

   

   tex2.posx = 315;

   tex2.posy = 235;



   glGenTextures(1, &tex2.texture);

   glBindTexture(GL_TEXTURE_2D, tex2.texture);

   

   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture

   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture



   glTexImage2D(GL_TEXTURE_2D, 0, 4, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);

   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);    



};



void InitGL(int Width, int Height)

{

   glViewport(0, 0, Width, Height);

   LoadGLTextures();

   glEnable(GL_TEXTURE_2D);

   glClearColor(0.0f, 0.0f, 1.0f, 0.0f);

   //glClearDepth(1.0);

   //glDepthFunc(GL_LESS);

   //glEnable(GL_DEPTH_TEST);



   glShadeModel(GL_SMOOTH);

   

   glMatrixMode(GL_PROJECTION);

   glLoadIdentity();

   glOrtho(0, Width, Height, 0, 0, 1);    

   

   glMatrixMode(GL_MODELVIEW);

   

}



/* Dibujar textura */

void DrawGLTexture(Textura *tex)

{

   glPushMatrix();

   

   glEnable(GL_TEXTURE_2D);

   glEnable(GL_BLEND);

   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //GL_ONE_MINUS_SRC_ALPHA
   
   //glColor4ub(255,255,255,100);



   glBindTexture(GL_TEXTURE_2D, tex->texture);

 

   glTranslatef(tex->posx,tex->posy,0);  



   float relW = (float)tex->w_or/(float)tex->w;

   float relH = (float)tex->h_or/(float)tex->h;



 

   glBegin(GL_QUADS);

     glTexCoord2f(0.0f, relH);

     glVertex2f(-tex->w_or/2, tex->h_or/2);      

     glTexCoord2f(relW, relH);

     glVertex2f(tex->w_or/2, tex->h_or/2);

     glTexCoord2f(relW, 0.0f);

     glVertex2f(tex->w_or/2, -tex->h_or/2);

     glTexCoord2f(0.0f, 0.0f);

     glVertex2f(-tex->w_or/2,-tex->h_or/2);

   glEnd();  

   

   glDisable(GL_BLEND);

   glDisable(GL_TEXTURE_2D);

   

   glPopMatrix();

}



void DrawGLScene()

{

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);      // Clear The Screen And The Depth Buffer

   glLoadIdentity();            // Reset The View



   DrawGLTexture(&tex2);

   DrawGLTexture(&tex1);



   SDL_GL_SwapBuffers();

}



int main(int argc, char **argv)

{  

 int done;

 Uint8 *keys;



 /* Initialize SDL for video output */

 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {

   fprintf(stderr, "Unable to initialize SDL: %s\n", SDL_GetError());

   //exit(1);

 }



 /* Create a 640x480 OpenGL screen */

 if ( SDL_SetVideoMode(640, 480, 0, SDL_OPENGL) == NULL ) {

   fprintf(stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError());

   SDL_Quit();

   //exit(2);

 }



 /* Set the title bar in environments that support it */

 SDL_WM_SetCaption("Prueba OpenGL", NULL);



 /* Loop, drawing and checking events */

 InitGL(640, 480);

 done = 0;

 int speed = 1;

 while ( ! done ) {

   DrawGLScene();



   /* This could go in a separate function */

   { SDL_Event event;

     while ( SDL_PollEvent(&event) ) {

       if ( event.type == SDL_QUIT ) {

         done = 1;

       }



       if ( event.type == SDL_KEYDOWN ) {

         if ( event.key.keysym.sym == SDLK_ESCAPE ) {

           done = 1;

         }

       }

     }

       

   }

 }

 SDL_Quit();

 return 1;

}

Hola a todos:

Esta semana hemos mandado el proyecto a artfutura y hemos tenido un problema. Lo que hemos mandado da un error en algunos ordenadores, y no nos hemos dado cuenta hasta ahora que lo hemos subido a internet. Sabemos como solucionarlo, y nos gustaría reenviar el CD con el juego para no tener problemas

He leído por ahí que se pueden hacer actualizaciones, pero en la web de artfutura no lo veo. ¿se puede hacer? ¿que tengo que hacer?

gracias a todos. Es muy urgente ya que estamos a lo justo

Hola a todos:

Bueno, nosotros somos 3 gaditanos que hemos hecho un juego en 2d, llevamos ya bastante tiempo con el, y como lo hemos casi terminado en estas fechas, hemos decidido mandarlo a ArtFutura. El juego se llama Super-Tirititran y es como los juegos de naves antiguos pero ambientado en la ciudad de Cádiz. Tampoco esperéis gran cosa.

Es nuestro primer juego y no se si el último, y espero que os guste

Podéis bajarlo tanto para windows como para linux en:

http://supertirititran.sourceforge.net/

Todo el juego está hecho con software libre. Hemos usado Gimp y Blender para el tema gráfico (a lo mejor conocéis al grafista del foro de 3dpoder) y SDL como librerias para el desarrollo del juego, todo en Ubuntu y Guadalinex.

Algunos screenshot:







Y también podéis ver el video que hemos mandado a artfutura aqui

http://www.youtube.com/watch?v=Xtt-9lZWIZU

Esperamos que os guste y que lo critequéis un poco, no con mucha dureza que es la primera vez que hacemos algo de esto

saludos

 Hola:

Estoy intentando crear una versión estática para linux de mi juego, pero no puedo hacerlo. Lo estoy haciendo creando un directorio "libs" con las librerías que uso (que son SDL) e intentando exportar la variable LD_LIBRARY_PATH. La verdad que creo que no es la mejor opción, pero por ahora creo que es lo más rápido.

La cosa es que estoy usando una versión LIVECD de una distro llamada "Kanotix" y no puedo exportar la variable.

Pongo:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/directorio_libs

y cuando pongo

echo $LD_LIBRARY_LIB

no me sale nada.

Lo raro es que si pongo

export HOLA=hola

y pongo luego

echo $HOLA

si sale, y me escribe "hola". No se que puede estar pasando. A ver si alguien me puede ayudar

gracias por todo y un saludo

 Hola:

No se si lo que pido directamente no existe, pero a lo mejor sabéis de algo que me pueda orientar. Actualmente estoy portanto un juego que estaba haciendo en SDL a Opengl+SDL, en realialidad ya lo tengo todo medianamente terminado. La cosa es que me gustaría hacer esos efectos especiales tan chulos que hay en los juegos de 2d de explosiones de partículas y esas cosas. El juego es un juego tipo puzzle de bolas y eso, que tienes que ir eliminando las bolas y me gustaría que saliesen esos efectillos de como niebla que desaparece o explosiones.

He estado haciendo pruebas y aunque he conseguido algo ni por asomo algo verdaderamente de lo que me sienta orgulloso. Este fin de semana he estado viendo las demos de FunManGames y por ejemplo el juego Atlantis esta lleno de este tipo de explosiones a las que me refiero. Tampoco es q quiera llegar a algo tan profesional como eso, lo que quiero es algún sitio donde explique como hacer cosas de estas en el caso que exista, y que me oriente un poco de como hacer estos efectos.

Bueno, después de este peñazo que estoy dando, como siempre agradeceros vuestro tiempo

saludos a todos

 Estoy usando SDL + OpenGL y necesito guardar la imagen que hay en pantalla en jpg, o lo que sea, png, bmp, etc..

Existe alguna manera sencilla de hacerlo??

gracias a todos y un saludo

 He estado buscando algo, pero no lo tengo claro de que exista algo así. Estoy trabajando en un juego que espero salga la luz en un par de meses como máximo. Para este proyecto hay un músico. Aunque es un pedazo de músico, espero que lo escuchéis en breve, el ritmo de trabajo es algo bajo ya que tiene mil cosas en la cabeza. Tengo pensado otros proyectos y me gustaría saber si tenéis sitios donde se pueda bajar música para usarlo en videojuegos. Los proyectos que hago son amateur bajo Licencia Creative Commons, así que nada de comercializar nada.

¿sabéis del algún sitio donde existan estas cosas?

Si no existe nada de esto, ¿sabéis si podría comprar música con bucles preparados para cosas como esta? Bucles con diferentes estilos de música

un saludo a todos y gracias de antemano

 Puedo jurar que me he estado buscando y leyendo muchas de las funciones de opengl pero no doy con la tecla. He estado leyendo código de juegos para a ver si saco conclusiones y nada.

El otro día ya me ayudasteis a crear con SDL un textura para opengl. La cosa ha funcionado. El problema es que mis texturas son con PNGs con trasparencias. La cosa es que sólo puse una textura y salió perfecto. El fondo era azul y las partes transparentes no se veían. Perfecto. Ahora me dió por hacer pruebas con dos texturas y me he dado cuenta que la parte transparente del png NO es transparente, sino q es azul (igual que el color de fondo). Podéis ver esta imagen que lo clarifica todo:



O sea, que la cosa chunga. He estado buscando y mirando el tema de blending, pero no doy con el error. Me gustaría que fuese completamente transparente. Bueno y cuando el png tiene partes con opacidad (por ejemplo al 50%) está claro que tampoco se ve.

A ver si alguien me puede ayudar por favor que es que no lo pillo

Os dejo las dos imágenes y el código del programa enterito. El código está modificado de un programa de nehe (bastante modificado vamos). Tiene una estructura llamada "Textura" donde guarda la textura opengl, tamaño original, posicion y eso, LoadGLTextures carga las dos texturas, DrawGLTexture dibuja una textura que se le pasa por el parámetro, DrawGLScene dibuja la escena.

Gracias a todos

Código [Seleccionar] Expand



#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#if defined(__APPLE__) && defined(__MACH__)
#include <OpenGL/gl.h> // Header File For The OpenGL32 Library
#include <OpenGL/glu.h> // Header File For The GLu32 Library
#else
#include <GL/gl.h> // Header File For The OpenGL32 Library
#include <GL/glu.h> // Header File For The GLu32 Library
#endif
#include "SDL.h"
#include <SDL_image.h>
#include <stdlib.h>


typedef struct
{
   GLuint texture;
   int w, h;
   int w_or, h_or;
   int posx, posy;
} Textura;

Textura tex1, tex2;


SDL_Surface *LoadTex(char *filename, Textura *tex)
{
   //Uint8 *rowhi, *rowlo;
   //Uint8 *tmpbuf, tmpch;
   SDL_Surface *image, *temp;
   int i, j;

   //image = SDL_LoadBMP(filename);
   temp = IMG_Load(filename);
   if ( temp == NULL ) {
       fprintf(stderr, "Unable to load %s: %s\n", filename, SDL_GetError());
       return(NULL);
   }
   
   tex->w = 512;
   tex->h = 512;
   Uint32 saved_flags;
   Uint8  saved_alpha;
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
     image = SDL_CreateRGBSurface(SDL_SWSURFACE, tex->w, tex->h, temp->format->BitsPerPixel,
                                 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);
#else
     image = SDL_CreateRGBSurface(SDL_SWSURFACE, tex->w, tex->h, temp->format->BitsPerPixel,
                                 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
#endif

   /* Save the alpha blending attributes */
   saved_flags = temp->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
   saved_alpha = temp->format->alpha;
   if ( (saved_flags & SDL_SRCALPHA)
      == SDL_SRCALPHA )
   {
   SDL_SetAlpha(temp, 0, 0);
   }
   
int colorkey = SDL_MapRGB(temp->format, 255, 0, 255);
SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey);
SDL_FillRect(image, 0, colorkey);
   
   SDL_BlitSurface(temp, 0, image, 0);
   
   /* Restore the alpha blending attributes */
   if ( (saved_flags & SDL_SRCALPHA)
      == SDL_SRCALPHA )
   {
   SDL_SetAlpha(temp, saved_flags, saved_alpha);
   }


   tex->w_or = temp->w;
   tex->h_or = temp->h;

   SDL_FreeSurface(temp);
   return(image);
}

void LoadGLTextures(void)
{
   
   SDL_Surface *surf;
   
   surf = LoadTex("prueba.png", &tex1);
   if (!surf) {
       SDL_Quit();
   }
   
   tex1.posx = 320;
   tex1.posy = 240;

   glGenTextures(1, &tex1.texture);
   glBindTexture(GL_TEXTURE_2D, tex1.texture);

   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture

   glTexImage2D(GL_TEXTURE_2D, 0, 4, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
   
   
   surf = LoadTex("alien.png", &tex2);
   if (!surf) {
       SDL_Quit();
   }
   
   tex2.posx = 320;
   tex2.posy = 200;

   glGenTextures(1, &tex2.texture);
   glBindTexture(GL_TEXTURE_2D, tex2.texture);
   
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture

   glTexImage2D(GL_TEXTURE_2D, 0, 4, surf->w, surf->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
   glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);    

};

void InitGL(int Width, int Height)
{
   glViewport(0, 0, Width, Height);
   LoadGLTextures();
   glEnable(GL_TEXTURE_2D);
   glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
   glClearDepth(1.0);
   glDepthFunc(GL_LESS);
   glEnable(GL_DEPTH_TEST);
   glShadeModel(GL_SMOOTH);
   
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0, Width, Height, 0, 0, 1);    
   
   glMatrixMode(GL_MODELVIEW);
   
}

/* Dibujar textura */
void DrawGLTexture(Textura *tex)
{
   glPushMatrix();
   
   glEnable(GL_TEXTURE_2D);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //GL_ONE_MINUS_SRC_ALPHA
   glColor4ub(255,255,255,255);

   glBindTexture(GL_TEXTURE_2D, tex->texture);
 
   glTranslatef(tex->posx,tex->posy,0);  

   float relW = (float)tex->w_or/(float)tex->w;
   float relH = (float)tex->h_or/(float)tex->h;

 
   glBegin(GL_QUADS);
     glTexCoord2f(0.0f, relH);
     glVertex2f(-tex->w_or/2, tex->h_or/2);      
     glTexCoord2f(relW, relH);
     glVertex2f(tex->w_or/2, tex->h_or/2);
     glTexCoord2f(relW, 0.0f);
     glVertex2f(tex->w_or/2, -tex->h_or/2);
     glTexCoord2f(0.0f, 0.0f);
     glVertex2f(-tex->w_or/2,-tex->h_or/2);
   glEnd();  
   
   glDisable(GL_BLEND);
   glDisable(GL_TEXTURE_2D);
   
   glPopMatrix();
}

void DrawGLScene()
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Clear The Screen And The Depth Buffer
   glLoadIdentity();    // Reset The View

   DrawGLTexture(&tex2);
   DrawGLTexture(&tex1);


   SDL_GL_SwapBuffers();
}

int main(int argc, char **argv)
{  
 int done;
 Uint8 *keys;

 /* Initialize SDL for video output */
 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
   fprintf(stderr, "Unable to initialize SDL: %s\n", SDL_GetError());
   //exit(1);
 }

 /* Create a 640x480 OpenGL screen */
 if ( SDL_SetVideoMode(640, 480, 0, SDL_OPENGL) == NULL ) {
   fprintf(stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError());
   SDL_Quit();
   //exit(2);
 }

 /* Set the title bar in environments that support it */
 SDL_WM_SetCaption("Jeff Molofee's GL Code Tutorial ... NeHe '99", NULL);

 /* Loop, drawing and checking events */
 InitGL(640, 480);
 done = 0;
 int speed = 1;
 while ( ! done ) {
   DrawGLScene();

   /* This could go in a separate function */
   { SDL_Event event;
     while ( SDL_PollEvent(&event) ) {
       if ( event.type == SDL_QUIT ) {
         done = 1;
       }

       if ( event.type == SDL_KEYDOWN ) {
         if ( event.key.keysym.sym == SDLK_ESCAPE ) {
           done = 1;
         }
       }
     }
       
   }
 }
 SDL_Quit();
 return 1;
}



 Bueno, estoy intentando cargar una textura PNG que tiene alpha. La cosa es que me salen cosas muy muy raras. Esto de las texturas de opengl me está matando, hay que acostumbrarse. Lo que haga es cargar un sdl_surface con IMG_Load de SDL_Image y luego ponerlo en la textura. Con los BMP van de escándalo pero el png salen un monton de puntos desordenados. Pongo el código:

Código [Seleccionar] Expand


SDL_Surface *LoadTex(char *filename)
{
   Uint8 *rowhi, *rowlo;
   Uint8 *tmpbuf, tmpch;
   SDL_Surface *image;
   int i, j;

   image = IMG_Load(filename);
   if ( image == NULL ) {
       fprintf(stderr, "Unable to load %s: %s\n", filename, SDL_GetError());
       return(NULL);
   }
   
   w = image->w;
   h = image->h;

   /* GL surfaces are upsidedown and RGB, not BGR :-) */
   tmpbuf = (Uint8 *)malloc(image->pitch);
   if ( tmpbuf == NULL ) {
       fprintf(stderr, "Out of memory\n");
       return(NULL);
   }
   
   rowhi = (Uint8 *)image->pixels;
   rowlo = rowhi + (image->h * image->pitch) - image->pitch;
   for ( i=0; i<image->h/2; ++i ) {
       for ( j=0; j<image->w; ++j ) {
           tmpch = rowhi[j*3];
           rowhi[j*3] = rowhi[j*3+2];
           rowhi[j*3+2] = tmpch;
           tmpch = rowlo[j*3];
           rowlo[j*3] = rowlo[j*3+2];
           rowlo[j*3+2] = tmpch;
       }
       memcpy(tmpbuf, rowhi, image->pitch);
       memcpy(rowhi, rowlo, image->pitch);
       memcpy(rowlo, tmpbuf, image->pitch);
       rowhi += image->pitch;
       rowlo -= image->pitch;
   }
   //free(tmpbuf);
   return(image);
}


Supongo que uno de los errores es que necesito RGBA, pero no se como usarlo. La verdad que estoy un poco muy liado.

¿alguien me puede ayudar?

muchas gracias a todos por vuestra paciencia

 Bueno, estoy intentando hacer mis primeros pinitos con opengl + sdl y quiero poner una textura en 2d. Lo he conseguido, pero tengo una duda a ver si me la podéis responder. Lo que estoy intentando es para hacer un juego en 2d con opengl, así q de principio nada de 3d. Se poco de opengl, casi nada

Tengo un código que pone una textura. La cosa es que la textura sale en el centro de la pantalla alineada a la izquierda y abajo. Para poder moverla uso "glTranslatef" para poner el origen de coordenadas el GL_QUAD que voy a crear con la textura. La cosa es que no puedo usar posiciones directamente. Es decir, mi pantalla es de 640x480 y yo quisiera poner que la textura se cargara en el pixel 100x100 y no puedo. Puedo hacerlo mediante números relativos a la pantalla.

No se si me explicado bien, la verdad que creo que me he explicado como el culo. A ver si me entendéis


El codigo del programa es este. Si os fijais es un código de la web de Nehe (www.demonews.com/hosted/nehe) que he modificado.

gracias a todos

Código [Seleccionar] Expand


#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#if defined(__APPLE__) && defined(__MACH__)
#include <OpenGL/gl.h> // Header File For The OpenGL32 Library
#include <OpenGL/glu.h> // Header File For The GLu32 Library
#else
#include <GL/gl.h> // Header File For The OpenGL32 Library
#include <GL/glu.h> // Header File For The GLu32 Library
#endif
#include "SDL.h"
#include <stdlib.h>

/* floats for x rotation, y rotation, z rotation */
float xrot, yrot, zrot;

/* storage for one texture  */
GLuint texture[1];

SDL_Surface *LoadBMP(char *filename)
{
   Uint8 *rowhi, *rowlo;
   Uint8 *tmpbuf, tmpch;
   SDL_Surface *image;
   int i, j;

   image = SDL_LoadBMP(filename);
   if ( image == NULL ) {
       fprintf(stderr, "Unable to load %s: %s\n", filename, SDL_GetError());
       return(NULL);
   }

   /* GL surfaces are upsidedown and RGB, not BGR :-) */
   tmpbuf = (Uint8 *)malloc(image->pitch);
   if ( tmpbuf == NULL ) {
       fprintf(stderr, "Out of memory\n");
       return(NULL);
   }
   rowhi = (Uint8 *)image->pixels;
   rowlo = rowhi + (image->h * image->pitch) - image->pitch;
   for ( i=0; i<image->h/2; ++i ) {
       for ( j=0; j<image->w; ++j ) {
           tmpch = rowhi[j*3];
           rowhi[j*3] = rowhi[j*3+2];
           rowhi[j*3+2] = tmpch;
           tmpch = rowlo[j*3];
           rowlo[j*3] = rowlo[j*3+2];
           rowlo[j*3+2] = tmpch;
       }
       memcpy(tmpbuf, rowhi, image->pitch);
       memcpy(rowhi, rowlo, image->pitch);
       memcpy(rowlo, tmpbuf, image->pitch);
       rowhi += image->pitch;
       rowlo -= image->pitch;
   }
   //free(tmpbuf);
   return(image);
}

// Load Bitmaps And Convert To Textures
void LoadGLTextures(void)
{
   // Load Texture
   SDL_Surface *image1;
   
   image1 = LoadBMP("imagen.bmp");
   if (!image1) {
       SDL_Quit();
       //exit(1);
   }

   // Create Texture
   glGenTextures(1, &texture[0]);
   glBindTexture(GL_TEXTURE_2D, texture[0]);   // 2d texture (x and y size)

   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // scale linearly when image smalled than texture

   // 2d texture, level of detail 0 (normal), 3 components (red, green, blue), x size from image, y size from image,
   // border 0 (normal), rgb color data, unsigned byte data, and finally the data itself.
   glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->w, image1->h, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->pixels);
};

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
void InitGL(int Width, int Height)         // We call this right after our OpenGL window is created.
{
   glViewport(0, 0, Width, Height);
   LoadGLTextures();    // Load The Texture(s)
   glEnable(GL_TEXTURE_2D);   // Enable Texture Mapping
   glClearColor(0.0f, 0.0f, 1.0f, 0.0f); // Clear The Background Color To Blue
   glClearDepth(1.0);    // Enables Clearing Of The Depth Buffer
   glDepthFunc(GL_LESS);   // The Type Of Depth Test To Do
   glEnable(GL_DEPTH_TEST);   // Enables Depth Testing
   glShadeModel(GL_SMOOTH);   // Enables Smooth Color Shading
   
   glMatrixMode(GL_PROJECTION);
   
   glMatrixMode(GL_MODELVIEW);
}

/* The main drawing function. */
void DrawGLScene()
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Clear The Screen And The Depth Buffer
   glLoadIdentity();    // Reset The View

   glTranslatef(-0.3f,-0.3f,0.0f);

   glEnable(GL_TEXTURE_2D);
   glEnable(GL_BLEND);
   glBindTexture(GL_TEXTURE_2D, texture[0]);   // choose the texture to use.
   
   int x = 0, y = 0, w = 256, h = 256;
   
   glBegin(GL_QUADS);
     glTexCoord2f(0.0f, 1.0f);
     glVertex2f(0.0f, 1.0f);
     glTexCoord2f(1.0f, 1.0f);
     glVertex2f(1.0f, 1.0f);
     glTexCoord2f(1.0f, 0.0f);
     glVertex2f(1.0f, 0.0f);
     glTexCoord2f(0.0f, 0.0f);
     glVertex2f(0.0f, 0.0f);
   glEnd();
   
   glDisable(GL_TEXTURE_2D);
   glDisable(GL_BLEND);

   // swap buffers to display, since we're double buffered.
   SDL_GL_SwapBuffers();
}

int main(int argc, char **argv)
{  
 int done;

 /* Initialize SDL for video output */
 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
   fprintf(stderr, "Unable to initialize SDL: %s\n", SDL_GetError());
   //exit(1);
 }

 /* Create a 640x480 OpenGL screen */
 if ( SDL_SetVideoMode(640, 480, 0, SDL_OPENGL) == NULL ) {
   fprintf(stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError());
   SDL_Quit();
   //exit(2);
 }

 /* Set the title bar in environments that support it */
 SDL_WM_SetCaption("Jeff Molofee's GL Code Tutorial ... NeHe '99", NULL);

 /* Loop, drawing and checking events */
 InitGL(640, 480);
 done = 0;
 while ( ! done ) {
   DrawGLScene();

   /* This could go in a separate function */
   { SDL_Event event;
     while ( SDL_PollEvent(&event) ) {
       if ( event.type == SDL_QUIT ) {
         done = 1;
       }
       if ( event.type == SDL_KEYDOWN ) {
         if ( event.key.keysym.sym == SDLK_ESCAPE ) {
           done = 1;
         }
       }
     }
   }
 }
 SDL_Quit();
 return 1;
}


 Bueno, a ver si me explico bien. Estoy haciendo un juego en SDL, y en la versión de linux me gustaría hacer un compilación en la que no hiciese falta tener las librerías SDL instaladas en la distribución, sino que directamente  estuviesen con el juego. Como en windows cuando se dejan las DLL junto al ejecutable.

La verdad que no tengo ni idea de como hacerlo. ¿alguna idea para esto?

muchas gracias a todos

 Hola:

Estoy haciendo un juego en 2D con SDL, y me gustaría simular los temblores de pantallas estos típicos que salen cuando se pega un bombazo.  La verdad que no tengo ni idea que como poder hacerlo de una manera mas o menos sencilla

¿alguien me puede orientar mas o menos de como poder hacerlo?

un saludo y gracias por vuestro tiempo de antemano

 Hola a todos:

Necesito unas librerías de descompresión (de zip por ejemplo) pero que funcionen en linux y windows. Creo que de las mas conocidas es:

http://www.gzip.org/zlib/

He estado mirando pero no me entero muy bien como funciona. ¿sabéis de algún ejemplo sencillo de utilizar para comprimir y descomprimir en c++?

A lo mejor hay otra libreria mas sencilla

Gracias y un saludo