1
2
3
4
5
6
7
8
9
10
11

bool Teclas[256];
.
.
.
case WM_KEYDOWN: 
    Teclas[(int)wParam]=true;
.
.
.
if(Teclas[VK_DOWN]) { ...
if(Teclas['F']) { ...

1
2
3
4
5
6

// Tengo que definir esta variable a mas de 0x0400 
// para que pueda usar WM_MOUSEWHEEL y TrackMouseEvent,
// si no, no la reconoce (ver Winuser.h)
#ifndef _WIN32_WINNT 
#define _WIN32_WINNT   0x0500      
#endif 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Defino un contador para girar los cubos.
int ang=0;
// Contator para alejarnos de la escena.
GLfloat dist=0;
// Dos contadores para girar la camara, una
// para cada eje a rotar.
GLfloat ang_camaraX = 0;
GLfloat ang_camaraY = 0;
// Matriz que almacena el estado del teclado.
bool Teclas[256];
// Variable para almacenar el ultimo caracter pulsado.
unsigned char Letra;
// Indicador de si son visibles los FPS en pantalla. 
bool pintaFPS=false;
// Indicador de si hemos levantado la tecla.
bool LevantaTecla=true;
 
// Estructura para los datos del raton que vamos a usar.
// Observad como guardamos la coordenada del raton actual
// y la del frame anterior.
struct raton
{
	int prev_x;
	int prev_y;
	int rueda;
	int x;
	int	y;
	bool izquierdo;
} Raton;
 
// Estructura necesaria para controlar si el raton sale de
// nuestra ventana con la funcion TrackMouseEvent.
TRACKMOUSEEVENT tme;

1
2

// Coloco la camara y pongo hacia donde mira con la funcion gluLookAt
gluLookAt(0,0,3, 0,0,0, 0,1,0);

1
2
3
4
5
6

// Relleno los datos de la estructura TRACKMOUSEEVENT
// para poder controlar cuando sale el raton de la ventana
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = IdVentana;
tme.dwHoverTime = 1;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// En caso de presionar el boton izquierdo del raton
case WM_LBUTTONDOWN:
	// Pongo true en la variable para el boton
	// izquierdo de nuestra estructura.
	Raton.izquierdo = true;
	break;
// En caso de presionar el boton derecho del raton
case WM_RBUTTONDOWN:
 
	break;
// En caso de soltar el boton izquierdo del raton
case WM_LBUTTONUP:
	// Pongo false en la variable para el boton
	// izquierdo de nuestra estructura.
	Raton.izquierdo = false;
	break;
// En caso de soltar el boton derecho del raton
case WM_RBUTTONUP:
 
	break;
// En caso de hacer doble click con el boton izquierdo del raton
case WM_LBUTTONDBLCLK:
 
	break;
// En caso de hacer doble click con el boton derecho del raton
case WM_RBUTTONDBLCLK:
 
	break;
// En caso de que el raton salga de nuestra ventana
case WM_MOUSELEAVE:
	// Pongo false en la variable para el boton
	// izquierdo de nuestra estructura.
	// Si el raton sale de la ventana es como
	// si soltara es boton.
	Raton.izquierdo = false;
	break;
// En caso de que se mueva el raton
case WM_MOUSEMOVE:
	// Si se mueve fuera de la ventana genero el mensaje
	// WM_MOUSELEAVE con esta funcion
	TrackMouseEvent(&tme);
	// Guardo las nuevas coordenadas del raton que me
	// llegan en el parametro lParam en las variables
	// x e y de nuestra estructura.
	Raton.x=LOWORD(lParam);
	Raton.y=HIWORD(lParam);
	break;
// En caso de mover la rueda del raton.
case WM_MOUSEWHEEL:
	// Pongo el valor en la variable para la rueda
	// de nuestra estructura.
	// Hacia delante sera positivo y hacia atras 
	// sera negativo.
	Raton.rueda=(int)wParam;
	break;
// Caso de mensaje de pulsacion de una tecla
case WM_KEYDOWN: 
	// Pongo a true el estado de la tecla en el array que 
	// representa el teclado. wParam contiene el Virtual 
	// Key Code de la tecla.
	Teclas[(int)wParam]=true;	
 
	// El caso de ESC para salir lo trato especialmente.
	switch(wParam) // y segun el contenido de wParam 
	{
	case VK_ESCAPE: // ESC causa la salida del programa
		// Funcion para enviar mensaje de cerrado a la 
		// ventana y despues de la aplicacion
		PostMessage(Ventana, WM_CLOSE, 0, 0); 
		break;
	} 
	break;
// En caso de soltar una tecla
case WM_KEYUP:
	// Actualizo el estado de la tecla en el array a false.
	Teclas[(int)wParam]=false;
	// Pongo a 0 la variable para guardar el codigo ASCII
	// de la tecla pulsada.
	Letra=0;
	break;
// En caso de que se pulse una tecla con codigo ASCII.
   // Este evento nos servira para hacernos una especie de 
// getchar o gets e introducir texto. 
case WM_CHAR: 
	// Guardo el codigo ASCII generado
	Letra=(unsigned char)wParam;
	break;

1
2
3
4
5
6
7
8
9
10

// Pintamos nuestra escena.
Pinta();  
 
// Al terminar el bucle pongo a 0 nuestro
// valor para la rueda del raton
Raton.rueda=0;
// Guardo las coordenadas del raton como las anteriores 
// ahora que las he usado como actuales.
Raton.prev_x = Raton.x;
Raton.prev_y = Raton.y;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// Seleccionamos la matriz de proyeccion.
glMatrixMode(GL_PROJECTION);
// Cargo la identidad.
glLoadIdentity();
// Pongo la perspectiva.
gluPerspective(50.0f,(float)rect.right/(float)rect.bottom,0.5f,50.0f);
 
// Podria hallar los datos y usar la funcion gluLookAt pero no lo voy
// a hacer.
//gluLookAt(0,0,0+dist, 0,0,-1, 0,1,0);
 
// Si el boton izquierdo del raton esta presionado
if(Raton.izquierdo)
{
	// Si he movido el raton a la derecha
	if(Raton.prev_x > Raton.x) ang_camaraX--;
	// Si he movido el raton a la izquierda
	if(Raton.prev_x < Raton.x) ang_camaraX++;
	// Con estas dos lineas controlo que el angulo x este entre 0 y 
	// 360. No es necesario pero si me dedico a dar vueltas, el 
        // programa podria hacer cosas raras.
	if(ang_camaraX < 0) ang_camaraX+=360;
	if(ang_camaraX > 360) ang_camaraX-=360;
 
	// Si he movido el raton hacia abajo
	if(Raton.prev_y > Raton.y) ang_camaraY--;
	// Si he movido el raton hacia arriba
	if(Raton.prev_y < Raton.y) ang_camaraY++;
	// Con estas dos lineas controlo que el angulo y este entre 0 y
        // 360. No es necesario pero si me dedico a dar vueltas, el 
        // programa podria hacer cosas raras.
	if(ang_camaraY < 0) ang_camaraY+=360;
	if(ang_camaraY > 360) ang_camaraY-=360;
		// Si giro la rueda del raton hacia delante
	if(Raton.rueda>0) 
	{
		// Aumento la distancia en 0.5
		dist+=0.5; 
		// Controlo que no sea mayor de 20,
		// no sea que lo pierda de vista
		if(dist>20) dist=20;
	}
	// Si giro la rueda del raton hacia atras
	if(Raton.rueda<0) 
	{
		// Reduzco la distancia en 0.5
		dist-=0.5;
		// Controlo que no sea menor de 0, asi 
		// mantengo la escena a la vista.
		if(dist<0) dist=0;
	}
} // fin if(Raton.izquierdo)
 
// Aplico los cambios en las variables a la matriz de
// proyeccion y asi modifico la camara. Cuidado con
// el orden de las transformaciones.
 
// Giro a izquierda o derecha 
glRotatef(ang_camaraX/4,0,1,0);
// Giro arriba o abajo 
glRotatef(ang_camaraY/4,1,0,0);
// Me alejo o acerco de la escena.
glTranslatef(0,0,0-dist);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// Controlo ahora lo que hago con teclado
// Si presiono la tecla de la flecha abajo me alejo,
// igual que hice con la rueda del raton. El 
// cambio se aplicara en la roxima pasada de la
// funcion Pinta().
if(Teclas[VK_DOWN]) 
{
	dist+=0.2; 
	if(dist>20) dist=20;
}
// Controlo tambien la tecla de la flecha arriba para
// acercarme igual que hice con la rueda del raton 
if(Teclas[VK_UP]) 
{
	dist-=0.2; 
	if(dist<0) dist=0;
}
 
// Si presiono la tecla "a" o "A"
if(Teclas['A']) 
{
	// Aumento los FPS 
	FPS_que_queremos+=5; 
	// Controlo que no pase de 500 (por que me ha dado la gana)
	if(FPS_que_queremos>500) FPS_que_queremos=500;
}
// Si presiono la tecla "z" o "Z"
if(Teclas['Z']) 
{
	// Reduzco los FPS
	FPS_que_queremos-=5; 
	// Controlo que no baje de 25
	if(FPS_que_queremos<25) FPS_que_queremos=25;
}
 
// Si presiono la tecla "q" o "Q" 
if(Teclas['Q']) 
{	// Aumento el angulo de giro de los cubos 
	ang+=2; 
	// Si pasa de 360 lo hago 0
	if(ang>360) ang=0;
}
// Si presiono la tecla "w" o "W"
if(Teclas['W']) 
{	// Reduzco el angulo de giro de los cubos
	ang-=2; 
	// Si baja de 0 lo hago 360
	if(ang<0) ang=360;
}
// Aplico el giro a la matriz de modelo para que modifique
// los cubos que dibujare ahora.
glRotatef(30+ang,0,1,0);

1
2
3
4
5
6
7
8
9

// Este trozo de codigo es para visualizar o no en 
// pantalla los FPS presionando la tecla "f" o "F".
// Usamos un indicador para ver si se ha levantado 
// la tecla. De otra forma cambiaria el estado de 
// pintaFPS muchas veces en un solo pulsado de tecla
// y el resultado seria imprevisible.
if(LevantaTecla && Teclas['F'])
	{ pintaFPS=!pintaFPS; LevantaTecla=false; }
else if( !Teclas['F']) LevantaTecla=true;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Escribo los FPS reales con 4 digitos decimales si 
// pintaFPS es true.
if(pintaFPS) Escribe(480,40,"FPS: %.4f",FPS_reales );
 
// Escribo las coordenadas del raton haya donde este el raton.
Escribe(Raton.x,Raton.y,"Raton: %i - %i",Raton.x,Raton.y);
 
// Escribo la leyenda de lo que se puede hacer en nuestro 
// programa.
Escribe(370,248,"Click izquierdo presionado para mover");
Escribe(370,268,"con el raton (rueda para distancia)");
Escribe(370,288,"F - Ver FPS");
Escribe(370,308,"A Z - Modificar FPS");
Escribe(370,328,"Q W - Rotar cubos");
Escribe(370,348,"Arriba Abajo - Acercar y alejar");