Wenas, al fin, termine mi juego, pero aun no puedo dedicarselo a nadie, ya que no funcion  :cry:  :cry:

Bueno estaba terminando el programa arreglando los fallitos (en un principio me dio 37 y 2 warning) y buen los arregle.....y ejecute. nada ser abria y se iba en un segundo sin mostrar nada. El caso es que me acorde que tenia que ponerle la carpeta de las imagenes en el fichero "debug" que es donde esta el ejecutable. pero lo he puesto y sigue igual.

Voy a poner el codigo entero, porque nose lo que pasa ni tengo idea alguna de que parte del programa puede ser. Y bueno asi los novatos como yo aprevechan  :shock:

MUCHAS GRACIAS

Código [Seleccionar] Expand

/***************
_AntiPlanes 1.0
_Make by Juan Manuel Amador Olivares &
***************/

// Librerias necesarias para poder llamar las funciones del juego
#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <time.h>

/****
Constantes
****/
#define WIDTH 400 // Anchura del mapa
#define HEIGHT 535 // Altura del mapa

#define MOVCANON 2 // Movimiento del cañon antiereo
#define CANONCICLO 3 // Numero de ciclos que tiene que pasar para que el cañon pueda moverse

#define MAXPLANES 150 // Numero maximo de aviones enemigos
#define MAXEXP 50 // Numero maximo de explosiones
#define MAXSHOT 250 // Numero maximo de disparos del cañon antiaereo

#define UPPOS 10 // Numero de ciclos que tiene que pasar para que se actualice la posicion de los aviones
#define MOVPLANE 5 // Movimiento de los aviones

#define PLANEBYCICLO 6 // Numero de aviones que son creados por ciclo
#define NEWPLANE 5 // Numero de ciclos que tiene que pasar para que se creen mas aviones enemigos

#define UPEXP 5 // Numero de ciclos que tiene que pasar para que se actualice el frame de las explosiones

#define CICLOSHOT 15 // Numero de ciclos que tiene que pasar para que se puedan crear nuevos disparos

#define UPPOSSHOT 10 // Numero de ciclos que tiene que pasar para que se actualice la posicion de los aviones
#define MOVSHOT 5 // Movimiento de los aviones

/****
Estructuras de los diferentes elementos del juego
****/
// Estructura del cañon antiaereo
struct canonstruct
{
SDL_Rect atrib;
} canon;

// Estrcutura de los aviones enemigos
struct enemyplanes
{
SDL_Rect atrib;
int estado;
} planes[MAXPLANES];

// Estructura de las explosiones
struct explosions
{
SDL_Rect atrib;
int frame;
int LastUpCiclo;
int estado;
} exp[MAXEXP];

// Estructura de los disparos
struct antishot
{
SDL_Rect atrib;
int estado;
} shot[MAXSHOT];


/****
Declaracion de superficies y variables
****/
SDL_Rect coordscreen;
SDL_Surface *screen; // Superficie de la pantalla. Con esta superficie se nicializara el modo de video y es la que se renderizara
SDL_Surface *background; // Superficie de el mapa del fondo
SDL_Surface *canonsurp; // Superficie de el cañon antiaereo
SDL_Surface *plane; // Superficie de el avion enemigo
SDL_Surface *shotsurp; // Superficie de el disparo del cañon
SDL_Surface *expsurp[5]; // Superficie de las explosiones de los enemigos
int quit = 0; // Variable usada para el controlar el bucle del juego (Game Loop)
int i = 0; // Variable usada para los bucles del juego
int v = 0; // Variable usada para los bucles del juego
int n = 0; // Variable usada para los bucles del juego
int b = 0; // Variable usada para los bucles del juego
int ciclo = 0; // Variable que contiene el numero de ciclos que ha dado el juego
int ciclouppos = 0; // Variable que guarda el numero de ciclos que llevaba el juego la ultima vez que actualizo la posicion de los aviones
int ciclocreate = 0; // Variable que guarda el numero de ciclos que lleva el juego desde la ultima vez que creo nuevos aviones
int canonppos = 0; // Variable que guarda el numero de ciclos que lleva el juego desde la ultima vez que se movio el cañon
int shotuppos = 0; // Variable que guarda el numero de ciclos que lleva el juego desde la ultima vez que se creo un disparo
int shotpos = 0; // Variable que guarda el numero de ciclos que lleva el juego desde la ultima vez que se actualizo el movimiento de los disparos
Uint8 *keyboard; // Variable utilizada para guardar el estado del teclado

int ini_milisegundos; // Variable utilizada para el control de tiempo de renderizado
int fin_milisegundos; // Variable utilizada para el control de tiempo de renderizado
int frametime; // Variable utilizada para el control de tiempo de renderizado

/***
Funciones de control de tiempo por frame
***/
void resetTimeBase()
{
ini_milisegundos=SDL_GetTicks();
}

int CurrentTime()
{
fin_milisegundos=SDL_GetTicks();
return fin_milisegundos-ini_milisegundos;
}


/****************
Funcion principal
****************/
int main (int argc, char *argv[])
{
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 el modo de video
screen = SDL_SetVideoMode (WIDTH,HEIGHT,24, SDL_HWSURFACE);
if (screen = NULL)
{
printf ("No se puede inicializar el modo gráfico: %s\n", SDL_GetError ());
exit (1);
}

/****
Cargamos los graficos del juego en las superficies declaradas
****/
// Imagen de fondo
background = SDL_LoadBMP("background\\background.bmp");
if (background == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}

// Cañon antiaereo
canonsurp = SDL_LoadBMP("canon\\canon.bmp");
if (canonsurp == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(canonsurp,SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(canonsurp->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// Aviones enemigos
plane = SDL_LoadBMP("enemyplanes\\plane.bmp");
if (plane == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(plane,SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(plane->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// Disparo del cañon antiaereo
shotsurp = SDL_LoadBMP("canon\\shot\\shot.bmp");
if (shotsurp == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(shotsurp,SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(shotsurp->format,255,255,255)); // Determinamos la transparencia de la superficie shotsurp como 255,255,255

// 1º imagen de la explosion
expsurp[1] = SDL_LoadBMP("explosion\\exp1.bmp");
if (expsurp[1] == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(expsurp[1],SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(expsurp[1]->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// 2º imagen de la explosion
expsurp[2] = SDL_LoadBMP("explosion\\exp2.bmp");
if (expsurp[2] == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(expsurp[2],SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(expsurp[2]->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// 3º imagen de la explosion
expsurp[3] = SDL_LoadBMP("explosion\\exp3.bmp");
if (expsurp[3] == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(expsurp[3],SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(expsurp[3]->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// 4º imagen de la explosion
expsurp[4] = SDL_LoadBMP("explosion\\exp4.bmp");
if (expsurp[4] == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(expsurp[4],SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(expsurp[4]->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0

// 5º imagen de la explosion
expsurp[5] = SDL_LoadBMP("explosion\\exp5.bmp");
if (expsurp[5] == NULL)
{
printf ("No se pudo cargar el grafico: %s\n", SDL_GetError());
exit(1);
}
SDL_SetColorKey(expsurp[5],SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(expsurp[5]->format,0,0,0)); // Determinamos la transparencia de la superficie shotsurp como 0,0,0


srand (time(NULL)); // Para la semilla de rand()

/****
Inicializacion de variables del juego
****/
// Iniciamos las variables de la pantalla
coordscreen.w = screen->w;
coordscreen.h = screen->h;
coordscreen.x = 0;
coordscreen.y = 0;
// Iniciamos las varibles del cañon
canon.atrib.w = canonsurp->w;
canon.atrib.h = canonsurp->h;
canon.atrib.x = WIDTH/2-canon.atrib.w/2;
canon.atrib.y = HEIGHT-canon.atrib.h;

// Iniciamos las variables de los aviones enemigos
for (i=1; i<=MAXPLANES; i++)
{
planes[i].atrib.w = plane->w;
planes[i].atrib.h = plane->h;
planes[i].atrib.x = 0-planes[i].atrib.w;
planes[i].atrib.y = 0;
planes[i].estado = 0;
}

// Iniciamos las variables de las explosiones
for (i=1; i<=MAXEXP; i++)
{
exp[i].atrib.w = expsurp[1]->w;
exp[i].atrib.h = expsurp[1]->h;
exp[i].atrib.x = 0;
exp[i].atrib.y = 0;
exp[i].frame = 0;
exp[i].LastUpCiclo = 0;
exp[i].estado = 0;
}

// Iniciamos las variables de los disparos del cañon antiaereo
for (i=1; i<=MAXSHOT; i++)
{
shot[i].atrib.w = shotsurp->w;
shot[i].atrib.h = shotsurp->h;
shot[i].atrib.x = 0;
shot[i].atrib.y = canon.atrib.y-shot[i].atrib.h;
shot[i].estado = 0;
}



/********
Game Loop
********/

while (!quit)
{
/***************
Entrada de datos
***************/

SDL_PumpEvents(); // Obtiene mapa del estado actual del teclado
keyboard=SDL_GetKeyState(0);

if(keyboard[SDLK_LEFT]) // Flecha izquierda
{
if (ciclo == canonppos + CANONCICLO)
{
canonppos = ciclo;
canon.atrib.x -= MOVCANON;
}
}

if(keyboard[SDLK_RIGHT]) // Flecha derecha
{
if (ciclo == canonppos + CANONCICLO)
{
canonppos = ciclo;
canon.atrib.x += MOVCANON;
}
}
if(keyboard[SDLK_RCTRL]) // Tecla CTRL
{
if (ciclo == canonppos + CICLOSHOT)
{
shotuppos = ciclo;
while (v == 0)
{
v++;
if (shot[v].estado == 0)
{
shot[v].estado = 1;
shot[v].atrib.x = canon.atrib.x;

v = 1;
}
}
v = 0;
}
}
if(keyboard[SDLK_ESCAPE]) {quit=1;} // Tecla ESC


// Se actualiza la posicion de los disparos
if (ciclo == shotpos + UPPOSSHOT)
{
shotpos = ciclo;
for (i=1; i<=MAXSHOT; i++)
{
if (shot[i].estado == 1)
{
shot[i].atrib.y -= MOVSHOT;
}
}
}

// Se comprueba y elimina los disparos que han salido de la pantalla
for (i=1; i<=MAXSHOT; i++)
{
if (shot[i].estado == 1)
{
if (shot[i].atrib.y + shot[i].atrib.h == 0)
{
shot[i].estado = 0;
}
}
}




// Se actualiza la posicion de los aviones enemigos
if (ciclo == ciclouppos + UPPOS) // Si han pasado los ciclos dados por UPPOS
{
ciclouppos = ciclo;
for (i=1; i<=MAXPLANES; i++)
{
if (planes[i].estado == 1)
{
planes[i].atrib.y += MOVPLANE;
}
}
}

// Se comprueba y elimina los aviones que han salido de la pantalla
for (i=1; i<=MAXPLANES; i++)
{
if (planes[i].estado == 1)
{
if (planes[i].atrib.y + planes[i].atrib.h == HEIGHT)
{
planes[i].estado = 0;
}
}
}

// Se crean mas aviones enemigos
if (ciclo == ciclocreate + NEWPLANE)
{
ciclocreate = ciclo;
for (i=1; i<=PLANEBYCICLO; i++)
{
while (v == 0)
{
n++;
if (planes[n].estado == 0)
{
planes[n].atrib.x = 1 + rand() % WIDTH; /*numero aleatorio*/
planes[n].estado = 1;

v = 1;
}
}

v = 0; // Para que en cada ciclo se repita el bucle
}
}

// Aqui va la creacion de explosiones, el cual va dentro de deteccion de colisiones
for (i=1; 1<=MAXPLANES; i++)
{
if (planes[i].estado == 1)
{
for (n=1; n<=MAXSHOT; n++)
{
if (shot[n].estado == 1)
{
if ( ((planes[i].atrib.x + planes[i].atrib.w) > shot[n].atrib.x) && ((planes[i].atrib.y + planes[i].atrib.h) > shot[n].atrib.y) && ((shot[n].atrib.x + shot[n].atrib.w) > planes[i].atrib.x) && ((shot[n].atrib.y + shot[n].atrib.w) > planes[i].atrib.y) )
{
// Crea explosion
while (v == 0)
{
b++;
if (exp[b].estado == 0)
{
exp[b].atrib.x = shot[n].atrib.x + shot[n].atrib.w/2;
exp[b].atrib.y = shot[n].atrib.y;
exp[b].estado = 1;

v = 1;
}
v = 0;
}
}
}
}
}
}

// Se actualizan las explosiones
for (i=1; i<=MAXEXP; i++)
{
if (exp[i].estado == 1)
{
if (exp[i].LastUpCiclo == UPEXP)
{
exp[i].frame++;
exp[i].LastUpCiclo = 0;
}
else
{
exp[i].LastUpCiclo++;
}

if (exp[i].frame == 6)
{
exp[i].frame = 0;
exp[i].estado = 0;
}
}
}

/***
Pegado de superficies
***/
// Se pega la superficie de la imagen de fondo
SDL_BlitSurface(background, NULL, screen, &coordscreen);

// Se pegan los aviones
for (i = 1; i<=MAXPLANES; i++)
{
if (planes[i].estado == 1)
{
SDL_BlitSurface(plane, NULL, screen, &planes[i].atrib);
}
}

// Se pegan los disparos
for (i=1; i<=MAXSHOT; i++)
{
if (shot[i].estado == 1)
{
SDL_BlitSurface(shotsurp, NULL, screen, &shot[i].atrib);
}
}

// Se pega la imagen del cañon antiaereo
SDL_BlitSurface(canonsurp, NULL, screen, &canon.atrib);

// Se pegan las explosiones
for (i=1; i<=MAXEXP; i++)
{
if (exp[i].estado == 1)
{
switch (exp[i].frame) // Segun el frame se renderizan imagenes diferentes
{
case 1:
SDL_BlitSurface(expsurp[1], NULL, screen, &exp[i].atrib);
break;

case 2:
SDL_BlitSurface(expsurp[2], NULL, screen, &exp[i].atrib);
break;

case 3:
SDL_BlitSurface(expsurp[3], NULL, screen, &exp[i].atrib);
break;

case 4:
SDL_BlitSurface(expsurp[4], NULL, screen, &exp[i].atrib);
break;

case 5:
SDL_BlitSurface(expsurp[5], NULL, screen, &exp[i].atrib);
break;
}
}
}

SDL_Flip(screen);


ciclo++; // Se suma un ciclo

// Si NO han pasado 30 milisegundos desde la renderizacion del ultimo frame, no se sigue renderizando
do
{
frametime=CurrentTime();
} while (frametime<30);


} // Aqui termina el bucle del juego

// Se liberan las superficies
SDL_FreeSurface(background);
SDL_FreeSurface(canonsurp);
SDL_FreeSurface(plane);
SDL_FreeSurface(shotsurp);
SDL_FreeSurface(expsurp[1]);
SDL_FreeSurface(expsurp[2]);
SDL_FreeSurface(expsurp[3]);
SDL_FreeSurface(expsurp[4]);
SDL_FreeSurface(expsurp[5]);


return 0;
}

bueno, nunca habia tenido que pasar el valor de un miembro de una estructura como argumento a una funcion. Ahora, haciendo un jueguecito con SDL tengo que hacerlo, he hecho una pruba, pero para mi sorpresa me da errores. este es el codigo:

Código [Seleccionar] Expand


#include <stdio.h>

struct feo
{
int x;
int y;
int w;
int h;
}

struct olita
{
int estado;
feo atrib;
} ola[30];


void alejandro (int x)
{
x = x + 30;
}

void main()
{
ola[5].atrib.x = 8;

alejandro (ola[5].atrib.x);

printf ("%d", ola[5].atrib.x);
}

primero he puesto la estructura feo, despues la estructura olita, en la que uno de susu miembros es una estructura feo. tambien he creado un tabla (o matriz) de 30 estructuras olita.

para probar las funciones he creado una funcion llamada alejandro que accede a la estructura ola[5] y cambia le suma 30 a uno de sus miembros.

pero como ya dije antes me da errores.

GRACIAS, y perdon por ser tan novatillo, pero no lo encontraba en mi libro de C.

bueno, nunca habia tenido que pasar el valor de un miembro de una estructura como argumento a una funcion. Ahora, haciendo un jueguecito con SDL tengo que hacerlo, he hecho una pruba, pero para mi sorpresa me da errores. este es el codigo:

Código [Seleccionar] Expand


#include <stdio.h>

struct feo
{
int x;
int y;
int w;
int h;
}

struct olita
{
int estado;
feo atrib;
} ola[30];


void alejandro (int x)
{
x = x + 30;
}

void main()
{
ola[5].atrib.x = 8;

alejandro (ola[5].atrib.x);

printf ("%d", ola[5].atrib.x);
}

primero he puesto la estructura feo, despues la estructura olita, en la que uno de susu miembros es una estructura feo. tambien he creado un tabla (o matriz) de 30 estructuras olita.

para probar las funciones he creado una funcion llamada alejandro que accede a la estructura ola[5] y cambia le suma 30 a uno de sus miembros.

pero como ya dije antes me da errores.

GRACIAS, y perdon por ser tan novatillo, pero no lo encontraba en mi libro de C.

Ola, tengo 2 problemas, empiezo por el que me parece mas importante.

Estoy haciendo un jueguecito, eres un cañoncito y disparas a los aviones enemigos mediante unas teclas disparas y mueves el cañon de derecha a izquierda. como estoy empezando con SDL, pues estoy haciendo mis pruebas con graficos simples y programas muy pequeñitos.

El problema que tengo con los eventos es que cuando pulsas una tecla si, la imagen se mueve, pero si la dejas pulsada no sigue miviendose. Imaginaos un jueguecito de aviones (como el 1942) en el que tubierais que pulsar la tecla de disparo acada medio segundo para que disparara continuamente, no creo que fuera muy divertido.

aqui esta el codigo que uso para los eventos:

Código [Seleccionar] Expand

while (SDL_PollEvent (&event))
{
if (event.type == SDL_KEYDOWN)
{
if (event.key.keysym.sym == SDLK_ESCAPE)
{
done = 1;
}

if (event.key.keysym.sym == SDLK_u)
{
x = x + 5;
}
}
}

tambien he porvado esta otra forma:

Código [Seleccionar] Expand

keys=SDL_GetKeyState(NULL);

if (keys[SDLK_u] == 1)
{
x = x + 0,1;
}


El segundo problema es que me gustaria para mi juego uqe estubiera dividido en distintas carpetas para las distintas imgenes de enemigos y niveles. Pero no se como cargar la imagen desde una carpeta, sino que pongo la imagen en el mismo directorio que el ejecutable y ya esta, pero no es lo que busco.

esta es la funcion que uso para cargar imagenes:

Código [Seleccionar] Expand

image = SDL_LoadBMP("grafico.bmp");
if (image == NULL)
{
printf("No se pudo cargar la imagen: %s\n", SDL_GetError());
}

image es simplemente la varibale que contiene la superficie. COmo vereis, entre comillas he puesto grafico.bmp, he porvado poner nombrecarpeta\grafico.bmp, pero no me lo caraga ya que esa barra la coge como una secuencia de escape.

gracias por todo.
PD: al que me contesto el hilo de las tablas, gracias tambien que no he podido conectarme y ahora no encuentro el hilo.

tengo la siguiente estructura:

Código [Seleccionar] Expand

struct habitacion
{
char text[150];
int norte;
int sur;
int este;
int oeste;
} habitaciones[50];

esa tabla "habitaciones quiero ponerla entera a 0, todos sus aparatados.

¿hay alguna forma a parte de inicializarlas todas 1 a 1 o esta?:

Código [Seleccionar] Expand

for (i=1; i<=50; i++)
{
habitaciones[i].text="x";
habitaciones[i].norte=0;
habitaciones[i].sur=0;
habitaciones[i].este=0;
habitaciones[i].oeste=0;
}


la mejor que me ha parecido es la del for, pero si hay una forma mas correcta o mas facil de inicializar pues mejor saberla.

GRACIAS

Ola, quiero hacer un programa en el que hay unas etetras y tu con la letra "d" rotas sobre ti mismo para la derecha y con la s a la izquierda. Lo hago moviendo el objetivo de GluLookAt alrededor de la camara. He hecho mis calculos y eso y aunque creo que es una manera muy novata de rotar sobre si mismo, tendria que funcianar. No se que falla en el programa, si mis calculos, si el mismo programa o lo que yo creo: los vectores de GluLookAt, que no se como controlarlos. (no quiero hacerlo con rotaciones a toda la escena, sino con GluLookAt).

El programa se ejecuta, y rota al principio bien, pero de repente cuando he rotado un poco se desvia y no sigue rotando bien.

Código [Seleccionar] Expand

#include <gl/glut.h>
#include <stdio.h>
#include <stdlib.h>

int i;

short cont=1;

float rotx=1.0;
float rotz=0.0;



void display (void)
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

gluPerspective(20.0f, 1.0f, 1.0f, 10.0f);

gluLookAt(0.0, 10.0, 0.0,
rotx, 0.0, rotz,
0.0, 1.0, 0.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();


for (i=0; i<10; i++)
{
glPushMatrix();
glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);
glTranslatef(1.5f, 0.0f, 0.0f);
glutWireTeapot(0.25);
glPopMatrix();
}


glFlush();
glutSwapBuffers();
}



void teclado(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
exit(0);
return;

case 'd':
if (rotz==0.0, rotx==1.0)
{
cont=1;
}

if (rotz==1.0, rotx==0.0)
{
cont=2;
}

if (rotz==0.0, rotx==-1.0)
{
cont=3;
}

if (rotz==-1.0, rotx==0.0)
{
cont=4;
}


switch (cont)
{
case 1:
rotx=rotx-0.01;
rotz=rotz+0.01;
break;

case 2:
rotx=rotx-0.01;
rotz=rotz-0.01;
break;

case 3:
rotx=rotx+0.01;
rotz=rotz-0.01;
break;

case 4:
rotx=rotx+0.01;
rotz=rotz+0.01;
break;
}

display();

return;

case 's':
if (rotz==0.0, rotx==1.0)
{
cont=1;
}

else if (rotz==1.0, rotx==0.0)
{
cont=2;
}

else if (rotz==0.0, rotx==-1.0)
{
cont=3;
}

else if (rotz==-1.0, rotx==0.0)
{
cont=4;
}


switch (cont)
{
case 1:
rotx=rotx+0.01;
rotz=rotz-0.01;
break;

case 2:
rotx=rotx+0.01;
rotz=rotz+0.01;
break;

case 3:
rotx=rotx-0.01;
rotz=rotz+0.01;
break;

case 4:
rotx=rotx-0.01;
rotz=rotz-0.01;
break;
}
display();
return;
}
}

void rescaler(GLsizei w, GLsizei h)
{
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(90.0, (float)w/(float)h, 2.0, 7.0);
glViewport (0, 0, w, h);
glMatrixMode (GL_MODELVIEW);
}



void main(void)
{
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(800, 800);
glutInitWindowPosition(100, 100);
glutCreateWindow("Moviendo camara");
glutReshapeFunc(rescaler);
glutKeyboardFunc (teclado);

glutDisplayFunc(display);

glutMainLoop();
}