1

#pragma comment( lib, "glaux.lib" )	 

1

#include <GL/glaux.h>

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

// Datos de las componentes ambiente, difusa y especular
// de nuestra fuente de luz.
GLfloat ambiente[] = { 0.4, 0.4, 0.4, 1.0 };
GLfloat difusa[] = { 0.8, 0.8, 0.8, 1.0 };
GLfloat especular[] = { 0.8, 0.8, 0.8, 1.0 };
// Datos de las componentes ambiente, difusa y especular
// del material. Todo 1.0 en difusa y especular sera blanco,
// la luz ambiente es menor para aumentar la diferencia
// de sombras. 
GLfloat mat1_ambiente[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat1_difusa[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat1_especular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat1_emision[] = {   0.99, 0.99, 0.99, 1.0 };

1
2
3
4
5
6
7
8
9
10

// Para los id's de texturas que genera OpenGL para nuestro programa. 
GLuint tex_usw, tex_paleta, tex_nivel;  
GLuint tex_fondo, tex_felicidades, tex_bahh; 
GLuint tex_ladrillo[5];
 
// Variables de tipo unsigned int para guardar 
// el identificativo de las "display list"
// Solo del ladrillo. Ahora la bola la pintaremos 
// diferente.
GLuint Ladrillo; // Bola;

1
2
3
4
5
6
7
8

// Variables para las coordenadas de la bola
// Ponemos estos valores como punto flotante
// ya que viene mejor para los calculos. 
double bola_x, bola_y;
// Variables para las coordenadas de la paleta.
// La X inicial la cambiaremos luego para centrarla.
// Estos tambien en punto flotante.
double pal_x = 200, pal_y = 500;

1
2
3

// Estas variables son para en alto y el largo 
// del ladrillo en la representacion 3D.
double a_l, l_l;

1
2
3
4
5
6
7
8

// Variable que indica el tipo de vista en curso
int Vista=0;
// Indicador de si ha cumplido el tiempo
// para cambiar la vista.
bool CambiaVista=false;
// Indicador de si la vista va rotando o
// esta fija.
bool RotacionVistas=true;

1
2
3

// Habilita test de profundidad. A partir de ahora, lo que 
// esta mas cerca se pinta encima.
glEnable(GL_DEPTH_TEST);

1
2
3
4
5
6
7
8
9
10
11

// Este codigo sirve para que OpenGL pinte 
// las primitivas (punto, linea y poligono) 
// sin escalones (con antialiasing).
// Su efectividad depende mucho del 
// hardware y su diver.
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glEnable(GL_POINT_SMOOTH);
glEnable (GL_POLYGON_SMOOTH);
glEnable(GL_LINE_SMOOTH);

1
2
3
4
5
6
7

// Estas dos funciones indican a OpenGL
// que no pinte las caras traseras de los 
// objetos (vertices en orden de las manillas 
// del reloj, desde donde miramos).
// Ahorran tiempo de computo.
glCullFace(GL_BACK)	 ;
glEnable(GL_CULL_FACE);

1
2
3
4
5

// En este programa pongo de principio
// proyeccion en perspectiva.
gluPerspective(50.0f, (float)rect.right/(float)rect.bottom, 0.5f, 50.0f);
// Y coloco el punto de vista inicial.
gluLookAt(10,10,-24, 10,9,0, 0,-1,0);

1
2
3
4
5
6
7
8
9
10

// Pongo eltamaño que tendra el ladrillo en base a la medida 
// del area cliente de la ventana.
// El largo debe ser el necesario para que quepan los 
// necesarios ladrillos por fila. 
largo_ladrillo = (double)rect.right/(double)Por_fila;
 
// En esta variable guardo el largo del 
// ladrillo, convertido a las dimensiones
// del nuevo campo de juego en 3D.
l_l = (largo_ladrillo*20.0f)/(double)rect.right;

1
2
3
4
5
6
7

// El alto sera una tercera parte del largo.
alto_ladrillo = largo_ladrillo/3.0f;
 
// En esta variable guardo el alto del 
// ladrillo, convertido a las dimensiones
// del nuevo campo de juego en 3D.
a_l = l_l/3.0f;

1
2

// Posiciono la paleta en medio de la ventana
pal_x = (double)rect.right/2 - largo_ladrillo/2.0f;

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

// Modificamos la posicion de la luz 0 de OpenGL. 
// El cuarto parametro es un 1.0 para que sea una luz puntual.
GLfloat posicion[] = { 0.0, 10.0, -10.0, 1.0 };
glLightfv(GL_LIGHT0, GL_POSITION, posicion);
// Habilitamos el calculo de la iluminacion.
glEnable(GL_LIGHTING);
// Encendemos la luz 0.
glEnable(GL_LIGHT0);
// Definimos cada una de las componentes de la luz 
// que emite nuestra bombilla (la luz 0).
glLightfv(GL_LIGHT0, GL_AMBIENT, ambiente);
glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa);
glLightfv(GL_LIGHT0, GL_SPECULAR, especular);

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

// Incluimos la gestion de los mensages que vienen de los timer.
case WM_TIMER:
// Si el ID del timer es 1 (podriamos tener mas de un timer).
	if (1 == wParam) 
	{
	  // Pongo el indicador para que
	  // la funcion Pinta sepa que se ha
	  // cumplido el tiempo para cambiar 
	  // la vista y actue en consecuencia.
	  CambiaVista=true;   
	 }
	break;

1
2
3
4

// que se ejecuta cada 15 segundos. 
// Sera el que nos indique si debemos cambiar el punto
// de vista del juego.
SetTimer(IdVentana, 1, 15000, NULL);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Cambio la proyeccion a ortogonal (la 
// normal en este juego es en perspectiva)
// y deshabilito el test de profundidad para
// pintar en 2D.
 
// Cambio a matriz proyeccion
glMatrixMode(GL_PROJECTION);
// Guardo la matriz proyeccion 
// general del programa para recuperarla 
// cuando termine de pintar en ortogonal
glPushMatrix();
// Cargo matriz identidad
glLoadIdentity();
// Pongo proyeccion ortogonal
glOrtho(0,rect.right,rect.bottom,0,-1,1);
// Cambio a matriz de modelo para pintar
glMatrixMode(GL_MODELVIEW);
// Deshabilito el test de profundidad
glDisable(GL_DEPTH_TEST);
// Deshabilito la iluminacion (queremos poner
// en pantalla los dibujos con su color).
glDisable(GL_LIGHTING);

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

// Restablezco los valores anteriores
// a pintar en 2D.
 
// Cambio a matriz de proyeccion.
glMatrixMode(GL_PROJECTION);
// Recupero la que guarde con PushMatrix
// antes de cambiar.
glPopMatrix();
// Cambio a la matriz de modelo para pintar
glMatrixMode(GL_MODELVIEW);
// Habilito el test de profundidad (3D)
glEnable(GL_DEPTH_TEST);
// Habilito la iluminacion.
glEnable(GL_LIGHTING);

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

// Pintare ahora el borde 3D del campo
// de juego (ahora no coincidira con el 
// borde de la ventana) simplemente con
// lineas blancas.
 
// Variable para usar en los bucles for 
GLfloat v;
// Deshabilita texturas para pintar las lineas
// simplemente blancas.
glDisable(GL_TEXTURE_2D);
// Cargo matriz identidad.
glLoadIdentity();
// Grosor de las lineas a dibujar a 2.
glLineWidth(2);
// Pinto con lineas.
glBegin(GL_LINES);
  // A la izquierda.
  // Primera linea vertical. 
  glVertex3f( -0.1, 0,1);
  glVertex3f( -0.1, 16,1);
  // Segunda linea vertical. 
  glVertex3f( -0.1, 0,0);
  glVertex3f( -0.1, 16,0);
  // Tercera linea vertical. 
  glVertex3f( -0.1, 0,-1);
  glVertex3f( -0.1, 16,-1);
  // Lineas horizontales del borde izquierdo 
  // con un buble for.
  for(v=0;v<=16;v+=2)  { glVertex3f( -0.1, v,1);  
			 glVertex3f( -0.1, v,-1); }
 
  // Arriba.
  // Primera linea horizontal
  glVertex3f( 0, 0,1);
  glVertex3f( 20, 0,1);
  // Segunda linea horizontal
  glVertex3f( 0, 0,0);
  glVertex3f( 20, 0,0);
  // Tercera linea horizontal
  glVertex3f( 0, 0,-1);
  glVertex3f( 20, 0,-1);
  // Lineas transversales con un bucle for.
  for(v=0;v<=20;v+=2)  { glVertex3f( v, 0,1);  
			 glVertex3f( v, 0,-1); }
  // A la derecha.
  // Primera linea vertical
  glVertex3f( 20.1, 0,1);
  glVertex3f( 20.1, 16,1);
  // Segunda linea vertical
  glVertex3f( 20.1, 0,0);
  glVertex3f( 20.1, 16,0);
  // Tercera linea vertical
  glVertex3f( 20.1, 0,-1);
  glVertex3f( 20.1, 16,-1);
  // Lineas horizontales del borde derecho 
  // con un buble for.
  for(v=0;v<=16;v+=2)  { glVertex3f( 20.1, v,1);  
			 glVertex3f( 20.1, v,-1); }
 
  // Termino de pintar lineas.
glEnd();
// Habilito texturas para el resto del 
// programa.
glEnable(GL_TEXTURE_2D);

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

// Tal como hicimos con los ladrillos convertimos las 
// coordenadas a las nuevas, con la misma formula.
// El eje X lo movemos, ademas, la mitad de la paleta
// hacia la derecha (l_l/2.0f).
glTranslatef(	(l_l/2.0f)+(pal_x*20.0f)/(double)rect.right,
		(pal_y*20.0f)/(double)rect.right, 
		0);
// Indico a OpenGL la textura a usar.
glBindTexture(GL_TEXTURE_2D, tex_paleta);
// y pinto la paleta en 3D.
// Guardo la actual matriz de modelo.
glPushMatrix();
// Escalo la paleta en los ejes Y y Z.
glScalef(1,0.3333,0.5);
// Pinto la paleta (la misma lista
// que el ladrillo).
glCallList(Ladrillo);
 
// Una vez pintada la paleta 
// vamos a pintar el borde para que
// se vea mejor. Lo haremos pintando
// otra vez la paleta pero en lineas 
// solo.
// Deshabilito texturas. Solo
// queremos color normal.
glDisable(GL_TEXTURE_2D);
// Indico a OpenGL que las caras
// frontales, pinte los poligonos
// sin relleno, solo con lineas.
glPolygonMode(GL_FRONT, GL_LINE);
// Ancho de las lineas a 1 pixel.
glLineWidth(1);	
// Color gris.
glColor3f(0.5,0.5,0.5);
// Deshabilito iluminacion.
glDisable(GL_LIGHTING);
// Pinto la paleta otra vez,
// pero solo los bordes ahora.
glCallList(Ladrillo);
// Vuelvo a pintar las caras 
// frontales con relleno.
glPolygonMode(GL_FRONT, GL_FILL);
// Habilito texturas.
glEnable(GL_TEXTURE_2D);
// Habilito luces.
glEnable(GL_LIGHTING);
 
// Restablezco la matriz de modelo.
glPopMatrix();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// La pintare de color blanco.
glColor3f(1,1,1);
// Pinto la linea.
glBegin(GL_LINES);
 // Empezando en la posicion de la bola.
 // De nuevo convierto las coordenadas al nuevo 
 // sistema de coordenadas ("*20.0f)/(double)rect.right").
 glVertex2f( ((bola_x)*20.0f)/(double)rect.right,
	     ((bola_y-8)*20.0f)/(double)rect.right );
 // Hasta una coordenada que calculare en base a la
 // variable angulo usando nuestras pseudofunciones
 // trigonometricas y poniendo 2.0f como longitud de la linea.
 // De nuevo convierto las coordenadas al nuevo 
 // sistema de coordenadas ("*20.0f)/(double)rect.right").
 glVertex2f( 
	(((bola_x)*20.0f)/(double)rect.right)+(seno[angulo]*2.0f),
	(((bola_y-8)*20.0f)/(double)rect.right)-(coseno[angulo]*2.0f)
	   );
glEnd();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Convierto las coordenadas de la bola al nuevo sistema de 
// coordenadas.
glTranslatef(  	((double)(bola_x)*20.0f)/(double)rect.right,
		((double)(bola_y-8.0f)*20.0f)/(double)rect.right,
		0);
// Desabilitamos las texturas ya que
// pintaremos la bola solo con material.
glDisable(GL_TEXTURE_2D);
// Definimos el material del la bola.
// Definimos el material del objeto modificando la forma en 
// como refleja cada componente de la luz que le llega.
glMaterialfv(GL_FRONT, GL_AMBIENT, mat1_ambiente);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat1_difusa);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat1_especular);
// El brillo especular pequeño (de 0 a 255).
glMaterialf(GL_FRONT, GL_SHININESS, 20);
 
// Y pintamos la bola de 8 (antiguas coordenadas) 
// de radio. Convertimos las coordenadas a 
// las nuevas.
auxSolidSphere((8.0f*20.0f)/(double)rect.right);
// Y habilitamos texturas.
glEnable(GL_TEXTURE_2D);

1
2
3

// Variables para almacenar las 
// coordenadas del punto de vista.
double cx,cy; 

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

// Si la vista es la numero 6 (vista desde
// la paleta) cambiamos tambien el punto de
// vista.
if(Vista==6)
{
	// Calculamos el punto medio de la paleta en 
	// coordenadas 3D (eje X).
	cx = (l_l/2.0f)+(pal_x*20.0f)/(double)rect.right;
	// Calculamos coordenada Y de la paleta en el 
	// campo de juego 3D.
	cy = (pal_y*20.0f)/(double)rect.right;
	// Ponemos matriz de proyeccion
	glMatrixMode(GL_PROJECTION);
	// Cargamos la matriz identidad para 
	// empezar de 0 con la matriz.
	glLoadIdentity();
	// Ponemos la perspectiva.
	gluPerspective(	50.0f, 
			(float)rect.right/(float)rect.bottom, 
			0.5f, 
			50.0f);
	// Colocamos el punto de vista y hacia donde mira, que
	// sera hacia arriba (4.0f mas arriba, por ejemplo).
	gluLookAt(cx,cy+2,-1.5f, cx, cy-4.0f, -1.5f, 0,0,-1);
	// Ponemos la matriz de modelo para seguir 
	// pintando.
	glMatrixMode(GL_MODELVIEW);
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// A partir de ahora, en la funcion
// Pinta, solo dibujaremos en ortogonal
// asi que lo dejamos preparado.
 
// Ponemos matriz de proyeccion
glMatrixMode(GL_PROJECTION);
// Guardamos la matriz de proyeccion 
// para restaurarla despues de pintar
// en ortogonal.
glPushMatrix();
// Cargo matriz identidad.
glLoadIdentity();
// Pongo proyeccion ortogonal.
glOrtho(0,rect.right,rect.bottom,0,-1,1);
// Cambio a matriz de modelo.
glMatrixMode(GL_MODELVIEW);
// y deshabilito iluminacion.
glDisable(GL_LIGHTING);
// y tambien test de profundidad.
glDisable(GL_DEPTH_TEST);

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

// Restablezco ahora la 
// proyeccion normal para 
// este juego.
// Cambio a matriz de proyeccion.
glMatrixMode(GL_PROJECTION);
// Restauro la matriz que guarde.
glPopMatrix();
// Cambio a matriz de modelo.
glMatrixMode(GL_MODELVIEW);
// Habilito iluminacion.
glEnable(GL_LIGHTING);
// Habilito test de profundidad.
glEnable(GL_DEPTH_TEST);

1
2
3
4
5
6
7
8

// Usamos el mismo metodo que con la tecla F, 
// pero para la tecla R.
// La usaremos para cambiar el identificador
// que deja o no la vista fija.
if(LevantaTeclaR && Teclas['R'])
  { RotacionVistas=!RotacionVistas; LevantaTeclaR=false; }
else if( !Teclas['R']) LevantaTeclaR=true;
 

1
2
3

// Si las vistas no rotan, estan fijas, lo indico 
// en pantalla.
if(!RotacionVistas) Escribe(rect.right-110,20,"Vista fija");

1
2
3
4
5
6
7
8
9

// El siguiente codigo se ejecutara en caso de 
// presionar la tecla "V" (de forma analoga a como
// lo hicimos con la "F" y la "R") o en el caso de 
// Estemos en juego, no tengamos la rotacion de 
// vistas bloqueada y se cumpla el tiempo del Timer
// que hemos creado (indicador "CambiaVista"). 
if( 	(LevantaTeclaV && Teclas['V']) 	|| 
	(CambiaVista && EnJuego && RotacionVistas)    )
{ 

1
2
3
4
5
6
7

// Aumentamos la variable que contiene el 
// numero de vista actual.
Vista++;
// Si esta variable pasa de 6 (solo
// hemos definido 7 vistas), la 
// pongo a 0 y empiezo la rotacion.
if(Vista>6) Vista=0 ;

1
2
3
4
5
6
7
8
9
10

// Pongo la matriz de proyeccion.
glMatrixMode(GL_PROJECTION);
// Cargo matriz identidad.
glLoadIdentity();
// Pongo perspectiva.
gluPerspective(	50.0f, 
		(float)rect.right/(float)rect.bottom, 
		0.5f, 
		50.0f  );
 

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

// Y selecciono la vista a poner en 
// base a la variable "Vista".
switch(Vista)
{
  case 0:
	gluLookAt(10,10,-24, 10,9,0, 0,-1,0);
	break;
  case 1:
	gluLookAt(10,0,-24, 10,9,0, 0,-1,0);				
	break;
  case 2:
	gluLookAt(10,34,-7, 10,9,0, 0,-1,0);
	break;
  case 3:
	gluLookAt(27,15,-20, 13,9,0, 0,-1,0);
	break;
  case 4:
	gluLookAt(10,-16,-7, 10,9,0, 0,-1,0);
	break;
  case 5:
	gluLookAt(20,28,-7, 8,9,0, 0,-1,0);
	break;
  case 6:
	// En este caso tengo que poner el 
	// punto de vista de acuerdo con
	// la posicion de la paleta, tal y como 
	// haciamos al presionar izquierda o 
	// derecha con vista == 6.
	cx = (l_l/2.0f)+(pal_x*20.0f)/(double)rect.right;
	cy = (pal_y*20.0f)/(double)rect.right;
	gluLookAt(cx,cy+2,-1.5f, cx, cy-4.0f, -1.5f, 0,0,-1);
	break;
}

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

	// Una vez cambida la vista
	// regreso a la matriz de modelo.
	glMatrixMode(GL_MODELVIEW);		
	// Actualizo el indicador para hacer las
	// cosas una vez por pulsacion de tecla.
	LevantaTeclaV=false; 
	// Pongo el indicador del Timer a false.
	// Cuado se cumpla el tiempo se pondra 
	// a true otra vez.
	CambiaVista=false;
}
// Me aseguro de que no se repite la accion 
// mas que una vez por pulsacion actualizando
// el indicador LevantaTecla.
else if( !Teclas['V']) LevantaTeclaV=true;