1
2
3
4
5
6
7
8
9
10
11

// Variable para guardar el nonbre (identificador)
// del objeto seleccionado.
int ObjetoSel = 0;
 
// Definimos el maximo numero de objetos que se
// pueden seleccionar.
#define MAX_SEL 64
 
// Identificador de si se ve la leyenda o no.
bool ImprimeLeyenda=false;
 

1
2
3
4
5
6
7
8
9
10
11

// 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);
 
// Hago que OpenGL pinte lineas 
// un poco mas anchas.
glLineWidth(2);

1
2
3
4
5
6

// En caso de presionar el boton derecho del raton
case WM_RBUTTONDOWN:
	// Pongo true en la variable para el boton
	// derecho de nuestra estructura.
	Raton.derecho = true;
	break;

1
2
3
4
5
6

// En caso de soltar el boton derecho del raton
case WM_RBUTTONUP:
	// Pongo false en la variable para el boton
	// derecho de nuestra estructura.
	Raton.derecho = false;
	break;

1
2
3

// Si el boton derecho del raton esta presionado
if(Raton.derecho)
{

1
2
3
4
5
6

// En caso de presionar el boton izquierdo del raton 
// comprobaremos si el raton esta sobre algun objeto. 
// Usaremos el metodo habitual con un indicador auxiliar
// para que solo se haga una vez por pulsacion.
if(LevantaTeclaRI && Raton.izquierdo)
{  

1
2
3
4
5
6
7
8
9
10
11

// Reservamos la suficiente memoria para almacenar
// los datos que nos retornara el sistema de seleccion
// de OpenGL. Retornara 4 unsigned int por objeto 
// seleccionado. En nuestro codigo hemos elegido un 
// numero maximo de objetos (MAX_SEL) que multiplicamos 
// por los 4 int de cada objeto seleccionado.
GLuint BufferSeleccion[4*MAX_SEL] = {0}; 
// Un array de 4 int's para guardar las dimensiones
// de nuestro viewport para luego usarlo de 
// parametro.
GLint viewport[4] = {0};

1
2
3
4

// Decimos a OpenGL que use el buffer que hemos
// definido y su tamaño. Aqui dejara OpenGL los
// objetos seleccionados.
glSelectBuffer(4*MAX_SEL, BufferSeleccion);

1
2
3

// Cargamos en el array que hemos definido el 
// viewport con la funcion de OpenGL para ello.
glGetIntegerv(GL_VIEWPORT, viewport);

1
2
3
4
5
6

// Ponemos matriz proyeccion.
glMatrixMode(GL_PROJECTION);
// Guardamos en la pila la matriz proyeccion.
glPushMatrix();	
// Cargamos la matriz identidad. 
glLoadIdentity();

1
2
3
4
5
6
7
8
9
10
11

// Usamos la funcion de la libreria glu para
// crear una matriz especial para seleccion.
// Le indicamos las coordenadas del raton (la Y
// la cambiamos para que comienzen abajo) y el tamaño 
// de una ventana, con centro en las coordenadas
// anteriores, de 2 x 2 pixels(solo la punta del raton)
// dentro de las cuales, si en modo seleccion pinta 
// algo, guardara su identificativo (glPushName o 
// glLoadName) en el array de seleccion como objeto
// seleccionado.
gluPickMatrix(Raton.x, viewport[3]-Raton.y, 2, 2, viewport);

1
2
3
4
5
6
7
8

// Pongo la perspectiva actual...
gluPerspective(50.0f, (float)rect.right/(float)rect.bottom, 0.1f, 50.0f);
// ... y coloco la camara en el mismo sitio donde esta.
// Mismos giros que antes.
glRotatef(ang_camaraX,0,1,0); 
glRotatef(ang_camaraY,1,0,0);
// Misma traslacion de antes.
glTranslatef(0,0,0-dist);

1
2
3
4
5
6
7
8

// No necesito luz ni texturas
// para seleccionar.
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
// Pongo matriz de modelo.
glMatrixMode(GL_MODELVIEW);
// Guardo la matriz de modelo.
glPushMatrix();

1
2
3
4
5
6

// Pongo a OpenGL en modo seleccion.
// En este modo OpenGL no pinta pero 
// lo que pintaria en el cuadrado definido
// por gluPickMatrix sera incluido en el 
// buffer de seleccion como objeto seleccionado.
glRenderMode(GL_SELECT); 

1
2
3
4
5
6

// Inicializa, limpia, la pila de nombres
// de seleccion.
glInitNames();	
// Guarda un primer numero en la pila de
// nombres.
glPushName(0);	

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

// Cambia el 0 que metimos antes
// en la pila por un 1 (como hacer
// glPopName y glPushName(1) ).
// El 1 sera el identificativo (nombre)
// de todo o que pinto despues si es 
// seleccionado.
glLoadName(1);
// Pito ahora el cubo con nombre 1.
glCallList(Cubo);
// Muevo el siguiente cubo.
glTranslatef(0,0,-2.0f);
// Cambio el nombre del objeto,
// ahora sera 2.
glLoadName(2);
// Pinto el cubo que tendra el nombre 2.
glCallList(Cubo);
// Muevo el siguiente cubo.
glTranslatef(2,0,2.0f);
// Cambio el nombre del objeto,
// ahora sera 3.
glLoadName(3);
// Pinto el cubo que tendra el nombre 3.
glCallList(Cubo);
// Muevo el siguiente cubo.
glTranslatef(2,0,-4.0f);
// Cambio el nombre del objeto,
// ahora sera 4.
glLoadName(4);
// Pinto el cubo que tendra el nombre 4.
glCallList(Cubo);
// Cargo matriz identidad para pintar
// donde esta la esfera.
glLoadIdentity();
// La pongo donde esta.
glTranslatef(-2.0,0,-4.0f);
// Cambio el nombre del objeto,
// ahora sera 5.
glLoadName(5);
// Pinto la esfera, que sera el objeto
// con nombre 5
auxSolidSphere(1);

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

// Dejo vacia la pila de nombres 
// al terminar.
glPopName();
// Habilito iluminacion.
glEnable(GL_LIGHTING);
// Restablezco la matriz modelo.
glPopMatrix();
// Selecciono la matriz proyeccion
glMatrixMode(GL_PROJECTION);
// La restablezco.
glPopMatrix();	
// Dejo la de matriz modelo.
glMatrixMode(GL_MODELVIEW);

1
2
3
4
5
6
7
8
9
10

// Ahora salgo del modo seleccion y 
// vuelvo al modo normal (render).
int NumSel = glRenderMode(GL_RENDER);
 
// Si el numero de objetos seleccionados supera
// el que permite nuestro buffer de seleccion,
// OpenGL retornara -1.
// Si es asi hago que el numero de objetos 
// seleccionados sea el maximo.
if(NumSel==-1) NumSel=MAX_SEL;

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

// Si ha habido algun objeto seleccionado.
if(NumSel > 0) 
{
	// Seleccionare el que esta mas cerca en caso 
	// de haber mas de 1.
	// Una variable para guardar dato de profundidad.
	GLuint z1;
	// Guardo el nombre del primer objeto seleccionado.
	ObjetoSel=BufferSeleccion[(0*4)+3];
	// Guardo en z el dato de profundidad del 
	// primer objeto seleccionado.
	GLfloat z=(float)BufferSeleccion[(0*4)+1];
	// Un bucle para recorrer todos los objetos
	// seleccionados e ir comparando sus profundidades.
	for(GLuint i=0; i<NumSel; i++)
	{
		// Obtengo la profundidad del objeto en curso...
		z1=BufferSeleccion[(i*4)+1];
		// ... y si es menos que z ...
		if(z1 < z)
		{	// ... la pongo en z...
			z=z1;
			// ... y el nombre del objeto en la 
			//variable para eso.
			ObjetoSel=BufferSeleccion[(i*4)+3];
		}
	}
}
// Si no hay ninguno seleccionado pongo 0 en la variable
// con el nombre del objeto seleccionado.
else ObjetoSel=0;
 

1
2
3
4
5

	// El resto del codigo para control de la
	// tecla Raton Izquierdo
	LevantaTeclaRI=false; 
}
else if( !Raton.izquierdo) LevantaTeclaRI=true;

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

// Si el objeto seleccionado es este (el 1)
// lo pintamos en wireframe (solo las lineas),
// sin textura y deshabilitando la iluminacion.
if(ObjetoSel==1) 
{
	glDisable(GL_LIGHTING); 
	glDisable(GL_TEXTURE_2D); 
	glPolygonMode(GL_FRONT, GL_LINE); 
}
// Pinto el objeto, normal o en wireframe.
glCallList(Cubo);
// Si lo he pintado en lineas regreso al modo
// normal.
if(ObjetoSel==1) 
{ 
	glEnable(GL_LIGHTING); 
	glEnable(GL_TEXTURE_2D); 
	glPolygonMode(GL_FRONT, GL_FILL); 
}

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

// De la misma manera que antes, controlo que
// solo se ejecuta una vez lo que hace la tecla L.
// Cambia el estado del indicador de si se ve o no la
// leyenda.
if(LevantaTeclaL && Teclas['L'])
	{ ImprimeLeyenda=!ImprimeLeyenda; LevantaTeclaL=false; }
else if( !Teclas['L']) LevantaTeclaL=true;
 
// En base al indicador InprimeLeyenda pintara o no 
// la leyenda.
if(ImprimeLeyenda)
{
	// Escribo la leyenda de lo que se puede hacer en nuestro 
	// programa. La situo segun el tamaño de la ventana, sea
	// cual sea.
	Escribe(rect.right-300,rect.bottom-180,
		"8: Cambiar a Pantalla completa y de resolución");
	Escribe(rect.right-300,rect.bottom-160,
		"U: Cambiar entre Pantalla completa y normal");
	Escribe(rect.right-300,rect.bottom-140,
		"P: Ver resoluciones de la tarjeta");
	// Ahora para mover el con el boton derecho
	// del raton
	Escribe(rect.right-300,rect.bottom-120,
		"Click derecho presionado para mover");
	Escribe(rect.right-300,rect.bottom-100,
		"con el raton (rueda para distancia)");
	Escribe(rect.right-300,rect.bottom-80,
		"F - Ver FPS");
	Escribe(rect.right-300,rect.bottom-60,
		"A Z - Modificar FPS");
	Escribe(rect.right-300,rect.bottom-40,
		"Q W - Rotar cubos");
	Escribe(rect.right-300,rect.bottom-20,
		"Arriba Abajo - Acercar y alejar");
}
// Si no pinta la Leyenda escribe como hacer que aparezca.
else 
	Escribe(rect.right-100,rect.bottom-20,"L: Leyenda");