/*
Repag para alejar
Avpag para acercar

Enable/Disable cull
 Enable/Disable Depth
 Enable/Disable Outline
 Enable/Disable Shademode

5 7 para rotacion de cubo en sentido de las manecillas del reloj
Tecla F6 Tecla F7 para rotacion de cubo en sentido de las manecillas del reloj
9 para subir el foco
10 para bajar el foco
11 para mover foco a la izquierda
12 para mover foco a la derecha

arriba para rotación hacia arriba
abajo para rotación hacia abajo
 izquierda para rotación hacia izquierda
 derecha para rotación hacia derecha
 Clic izquierdo sobre objeto articulado para acelerar su rotacion
Clic izquierdo fuera del mundo para regresar objeto articulado a su velocidad inicial
Clic izquierdo sobre cara de diferente color para degradar su color
Clic izquierdo fuera del mundo para regresar la cara a su color inicial

*/

#include <stdlib.h>
#include "math.h"
#include "glut.h"
#define GL_PI 3.1415f
GLfloat xRot = 0.45f;
GLfloat yRot = 0.35f;

GLfloat v[8][3];
GLfloat LUZ[4] = { 75.f, 50.f, 0.f, 1.f };

GLboolean bCull = glIsEnabled(GL_CULL_FACE);
GLboolean bDepth = glIsEnabled(GL_DEPTH_TEST);
//variables para configuracion luz Phong
GLboolean bOutline = (GLboolean)true;
GLfloat ambientLight[] = { 0.1f, 0.1f, 0.1f, 1.0f },
diffuseLight[] = { 0.9f, 0.9f, 0.9f, 1.0f },
lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 },
specular[] = { 1.0f, 1.0f, 1.0f, 1.0f },

specref[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat local_view[] = { 0.0 };

GLfloat mat_diffuse[] = { 0.8, 0.5, 0.1, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat high_shininess[] = { /*100.0*/ 128 };

void normalize(GLfloat v[3]) {
	GLfloat d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
	if (d == 0.0) { exit(100); return; }
	v[0] /= d; v[1] /= d; v[2] /= d;
}
void normcrossprod(GLfloat v1[3], GLfloat v2[3], GLfloat out[3])
{
	out[0] = v1[1] * v2[2] - v1[2] * v2[1]; out[1] = v1[2] * v2[0] - v1[0] * v2[2];
	out[2] = v1[0] * v2[1] - v1[1] * v2[0];	normalize(out);
}

void gltGetNormalVector(GLfloat v0[3], GLfloat //build normal 'norm'
	v1[3], GLfloat v2[3], GLfloat norm[3])	// by the triangle vrtices
{
	GLfloat d1[3], d2[3];
	for (int j = 0; j < 3; j++) {
		d1[j] = v0[j] - v1[j];
		d2[j] = v1[j] - v2[j];
	}
	normcrossprod(d1, d2, norm);
}

GLenum shademode = GL_FLAT;

GLfloat ex = 0.0f;
GLfloat ey = 50.0f;
GLfloat ez = -120.0f;
GLfloat delta = 0.01f;
GLfloat deltaR = 0.01f;
#define C1  2
#define C2  1
GLfloat VR;

static int AnguloP = 0;
static int AnguloC = 0;

GLfloat colors[][3] = { { 0.0, 0.0, 0.0 },{ 1.0, 0.0, 0.0 },
{ 1.0, 1.0, 0.0 },{ 0.0, 1.0, 0.0 },{ 0.0, 0.0, 1.0 },
{ 1.0, 0.0, 1.0 },{ 1.0, 1.0, 1.0 },{ 0.0, 1.0, 1.0 } };


static GLint caras[6][4] =
{
{0, 1, 2, 3},
{3, 2, 6, 7},
{7, 6, 5, 4},
{4, 5, 1, 0},
{5, 6, 2, 1},
{7, 4, 0, 3}
};


GLfloat puntos[2][2][2] = { {{0.0, 0.0}, {0.0, 2.0}},
{{3.0, 0.0}, {3.0, 2.0}} };


GLfloat ctrlpoints[4][4][3] = {
   { {-0.5, -2.5, -5.0},     {-0.5, -1.5, 2.0},     {0.5, -1.5, -1.0},     {1.5, -1.5, 2.0}},
   { {-1.5, -1.5, 1.0},     {-2.5, -1.5, 3.0},     {0.5, -0.5, 0.0},     {1.5, -0.5, 1.0}},
   { {-2.5, 2.5, 4.0},     {-1.5, 5.5, 1.0},     {0.5, 0.5, 3.0},     {1.5, 0.5, 4.0}},
   { {-4.5, 1.5, 5.0},     {-0.5, 1.5, -1.0},     {5.5, 1.5, 0.0},     {1.5, 1.5, -1.0},
   }
};


//-plano de piso y matriz de sombra 
GLfloat datosdePlano[] = { 0.f, 1.f/*-1.*/, 0.f, 150 /*o -150 ?*/ };
GLfloat matrizdeSombra[16];

GLfloat ALFA = 0.75f;

//-numeros para texturas
#define checkImageWidth 256
#define checkImageHeight 256
#define subImageWidth 64
#define subImageHeight 64

static GLubyte checkImage[checkImageHeight][checkImageWidth][1];
static GLubyte otherImage[checkImageHeight][checkImageWidth][4];
static GLubyte subImage[subImageHeight][subImageWidth][4];
static GLuint texName[2];


#define BUFSIZE 512
GLuint selectBuf[BUFSIZE];

#define CARA_DESTINGUIDA       111

//-Variables para la cara distinguida
GLboolean CARA_DESTINGUIDA_TOCADA;
GLfloat STARTcolor_de_cara[] = { 0.5f, 0.7f, 0.1f },
color_de_cara_DESTINGUIDA[3];

void initColors()
{
	for (int i = 0; i < 3; i++) {
		color_de_cara_DESTINGUIDA[i] = STARTcolor_de_cara[i];
	}
}



//-Textura de la curva
void Textura(void)
{
	int i, j, c;

	for (i = 0; i < checkImageHeight; i++) {
		for (j = 0; j < checkImageWidth; j++) {
			c = ((((i & 0x8) == 0) ^ ((j & 0x8)) == 0)) * 255;
			checkImage[i][j][1] = (GLubyte)c;   checkImage[i][j][1] = (GLubyte)c;
			checkImage[i][j][2] = (GLubyte)c;   checkImage[i][j][3] = (GLubyte)255;

			c = ((((i & 0x10) == 0) ^ ((j & 0x10)) == 0)) * 255;
			otherImage[i][j][0] = (GLubyte)0;   otherImage[i][j][1] = (GLubyte)0;
			otherImage[i][j][2] = (GLubyte)c;   otherImage[i][j][3] = (GLubyte)255;
		}
	}

	for (i = 0; i < subImageHeight; i++) {
		for (j = 0; j < subImageWidth; j++) {
			c = ((((i & 0x4) == 0) ^ ((j & 0x4)) == 0)) * 255;
			subImage[i][j][0] = (GLubyte)c;    subImage[i][j][1] = (GLubyte)0;
			subImage[i][j][2] = (GLubyte)0;    subImage[i][j][3] = (GLubyte)255;
		}
	}
}

void gltMakeShadowMatrix(GLfloat vPlaneEquation[], GLfloat vLightPos[], GLfloat destMat[])
{
	GLfloat dot;

	// Dot product of plane and light position
	dot = vPlaneEquation[0] * vLightPos[0] + vPlaneEquation[1] * vLightPos[1] +
		vPlaneEquation[2] * vLightPos[2] + vPlaneEquation[3] * vLightPos[3];

	// Now do the projection
	// First column
	destMat[0] = dot - vLightPos[0] * vPlaneEquation[0];
	destMat[4] = 0.0f - vLightPos[0] * vPlaneEquation[1];
	destMat[8] = 0.0f - vLightPos[0] * vPlaneEquation[2];
	destMat[12] = 0.0f - vLightPos[0] * vPlaneEquation[3];

	// Second column
	destMat[1] = 0.0f - vLightPos[1] * vPlaneEquation[0];
	destMat[5] = dot - vLightPos[1] * vPlaneEquation[1];
	destMat[9] = 0.0f - vLightPos[1] * vPlaneEquation[2];
	destMat[13] = 0.0f - vLightPos[1] * vPlaneEquation[3];

	// Third Column
	destMat[2] = 0.0f - vLightPos[2] * vPlaneEquation[0];
	destMat[6] = 0.0f - vLightPos[2] * vPlaneEquation[1];
	destMat[10] = dot - vLightPos[2] * vPlaneEquation[2];
	destMat[14] = 0.0f - vLightPos[2] * vPlaneEquation[3];

	// Fourth Column
	destMat[3] = 0.0f - vLightPos[3] * vPlaneEquation[0];
	destMat[7] = 0.0f - vLightPos[3] * vPlaneEquation[1];
	destMat[11] = 0.0f - vLightPos[3] * vPlaneEquation[2];
	destMat[15] = dot - vLightPos[3] * vPlaneEquation[3];
}


void drawBox(GLfloat size, GLenum type)
{
	v[0][0] = v[1][0] = v[2][0] = v[3][0] = -size / 2;
	v[4][0] = v[5][0] = v[6][0] = v[7][0] = size / 2;
	v[0][1] = v[1][1] = v[4][1] = v[5][1] = -size / 2;
	v[2][1] = v[3][1] = v[6][1] = v[7][1] = size / 2;
	v[0][2] = v[3][2] = v[4][2] = v[7][2] = -size / 2;
	v[1][2] = v[2][2] = v[5][2] = v[6][2] = size / 2;

	GLfloat norm[3];

	for (int i = 5; i >= 0; i--) {
		glBegin(type);

		gltGetNormalVector(&v[caras[i][1]][0], &v[caras[i][2]][0], &v[caras[i][0]][0], norm);
		glVertex3fv(&v[caras[i][0]][0]);
		glVertex3fv(&v[caras[i][1]][0]);
		glVertex3fv(&v[caras[i][2]][0]);
		glVertex3fv(&v[caras[i][3]][0]);
		glNormal3fv(norm);
		glEnd();
	}
}


void SetupRC()
{
	VR = 1;

	//-Color de fondo
	glClearColor(1.8f, 1.6f, 1.3f, 1.0f);

	glShadeModel(GL_FLAT);
	glEnable(GL_DEPTH_TEST);

	initColors();
	// Set color shading model to flat
	glShadeModel(shademode);

	Textura();
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glGenTextures(2, texName);
	glBindTexture(GL_TEXTURE_2D, texName[0]);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight,
		0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);

	glTexSubImage2D(GL_TEXTURE_2D, 0, 48, 170, subImageWidth,
		subImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, subImage);

	glTexSubImage2D(GL_TEXTURE_2D, 0, 48, 48, subImageWidth,
		subImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, subImage);

	glTexSubImage2D(GL_TEXTURE_2D, 0, 170, 48, subImageWidth,
		subImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, subImage);

	glTexSubImage2D(GL_TEXTURE_2D, 0, 170, 170, subImageWidth,
		subImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, subImage);

	glEnable(GL_TEXTURE_2D);



	// Set up and enable light 0
	glFrontFace(GL_CCW);
	glEnable(GL_LIGHTING);
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
	glEnable(GL_LIGHT0);

	// Enable color tracking
	glEnable(GL_COLOR_MATERIAL);
	// Front material ambient and diffuse colors track glColor
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
	glMateriali(GL_FRONT, GL_SHININESS, 128);


	glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 2, 3, 4, 0, 1, 4, 3, &puntos[0][0][0]);
	glEnable(GL_MAP2_TEXTURE_COORD_2);

	glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &ctrlpoints[0][0][0]);
	glEnable(GL_MAP2_VERTEX_3);

	glMapGrid2f(30, 0.0, 1.0, 20, 0.0, 1.0);

}

void cuadrado() {
	glBegin(GL_POLYGON);
	glNormal3f(0., 0., -1. /*-1.?*/);//para phong
	glVertex2f(-1., -1.);
	glVertex2f(-1., 1.);
	glVertex2f(1., 1.);
	glVertex2f(1., -1.);
	glEnd();
}

void rayas_piso() {
	glColor4f(0., 0., 0., ALFA);
	glBegin(GL_LINES);
	int i, n = 10;
	for (i = 0; i <= n; i++)
	{
		glVertex2f(-1. + i * 2. / n, -1.);
		glVertex2f(-1. + i * 2. / n, 1.);

		glVertex2f(-1., -1. + i * 2. / n);
		glVertex2f(1., -1. + i * 2. / n);
	}
	glEnd();
}



/*-Dibujar objeto curveado con color*/

void Objeto_Curveado_con_color(void) {
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_AUTO_NORMAL);

	glBindTexture(GL_TEXTURE_2D, texName[0]);
	glPushMatrix();
	glTranslatef(80, 80, 80);
	glScalef(10, 10, 10);
	glRotatef(0, 0, 1, 0);
	glRotatef(180, 1, 0, 0);
	glEvalMesh2(GL_FILL, 0, 20, 0, 20);
	glPopMatrix();
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_AUTO_NORMAL);
}

/*-Dibujar objeto curveado sin color*/
void objeto_cuveado_sin_color(void) {

	glTranslatef(80, 80, 80);
	glScalef(10, 10, 10);
	glRotatef(0, 0, 1, 0);
	glRotatef(180, 1, 0, 0);
	glEvalMesh2(GL_FILL, 0, 20, 0, 20);
	glPopMatrix();
	glDisable(GL_TEXTURE_2D);

}

/*-Dibuja cubo sin color*/
void cubo_sin_color(void)
{
	glShadeModel(GL_FLAT);

	glPushMatrix();
	glScalef(30., 30., 30.);

	glPushMatrix();
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	glRotatef(90., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	glRotatef(180., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	glRotatef(270., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	glRotatef(90., 1., 0., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	glRotatef(-90., 1., 0., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPopMatrix();
}


/*-Dibuja cubo con color*/
void cubo_con_color(GLenum mode)
{
	glShadeModel(GL_FLAT);

	glPushMatrix();
	glScalef(30., 30., 30.);
	glPushMatrix();
	glTranslatef(0., 0., 1.);
	/*glColor3fv(colors[2]); <-------- sería la cara sin textura
	cuadrado();*/

	/*-Genera cara con textura*/
	glEnable(GL_TEXTURE_2D);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	glBindTexture(GL_TEXTURE_2D, texName[0]);
	glBegin(GL_QUADS);
	glTexCoord2f(0.0, 0.0);  glVertex2f(-1., -1.);
	glTexCoord2f(0.0, 1.0);  glVertex2f(-1., 1.);
	glTexCoord2f(1.0, 1.0);   glVertex2f(1., 1.);
	glTexCoord2f(1.0, 0.0);   glVertex2f(1., -1.);
	glEnd();

	glDisable(GL_TEXTURE_2D);
	/*fin cara con textura*/
	glPopMatrix();

	// INICIO de construccion de CARA_DESTINGUIDA para seleccion
	glPushMatrix();
	if (mode == GL_SELECT)
		glLoadName(CARA_DESTINGUIDA);//= glPopNAme(); + glPushName(CARA_DESTINGUIDA);

	glColor3fv(color_de_cara_DESTINGUIDA);
	glRotatef(90., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();

	if (mode == GL_SELECT)
		glLoadName(0);  //= glPopNAme(); + glPushName(0);
	glPopMatrix();
	// FIN de construccion de CARA_DESTINGUIDA

	glPushMatrix();
	//glColor3fv(colors[3]);
	glColor4f(colors[3][3], colors[1][1], colors[2][2], ALFA);
	glRotatef(180., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	//glColor3fv(colors[3]);
	glColor4f(colors[3][3], colors[1][1], colors[2][2], ALFA);
	glRotatef(270., 0., 1., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	//glColor3fv(colors[3]);
	glColor4f(colors[3][3], colors[1][1], colors[2][2], ALFA);
	glRotatef(90., 1., 0., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPushMatrix();
	//glColor3fv(colors[3]);
	glColor4f(colors[3][3], colors[1][1], colors[2][2], ALFA);
	glRotatef(-90., 1., 0., 0.);
	glTranslatef(0., 0., 1.);
	cuadrado();
	glPopMatrix();

	glPopMatrix();
}






/*-Funci n que Dibuja el Objeto Articulado sin Color*/
void articulado_sin_color(int mode) {

	glPushName(C1);
	glPushMatrix();
	glNormal3f(0., 0., -1. /*-1.?*/);//para phong
	glTranslatef(1.0, 0.0, 0.0);
	glRotatef((GLfloat)AnguloC, 0.0, 0.0, 1.0);
	glTranslatef(1.0, 0.0, 0.0);
	glPushMatrix();
	cubo_sin_color();
	glPopMatrix();
	glPopName();

	glPopMatrix();

	glPushName(C2);
	glPushMatrix();
	glTranslatef(1.0, 0.0, -32.0);
	glRotatef((GLfloat)AnguloP, 0.0, 0.0, 1.0);
	glTranslatef(1.0, 0.0, 0.0);
	glPushMatrix();
	glScalef(40.0, 0.4, 1.0);
	drawBox(3.0, GL_QUADS);
	glPopMatrix();
	glPopName();

	glPopMatrix();
}

/*-Funcion que dibuja el objeto articulado con color*/
void articulado_con_color(int mode) {

	glPushName(C1);
	glPushMatrix();
	glNormal3f(0., 0., -1. /*-1.?*/);//para phong
	glTranslatef(1.0, 0.0, 0.0);
	glRotatef((GLfloat)AnguloC, 0.0, 0.0, 1.0);
	glTranslatef(1.0, 0.0, 0.0);
	glPushMatrix();
	glColor3f(5, 0.3, 5.0);
	cubo_con_color(mode);
	glPopMatrix();
	glPopName();

	glPopMatrix();

	glPushName(C2);
	glPushMatrix();
	glTranslatef(1.0, 0.0, -32.0);
	glRotatef((GLfloat)AnguloP, 0.0, 0.0, 1.0);
	glTranslatef(1.0, 0.0, 0.0);
	glPushMatrix();
	glScalef(40.0, 0.4, 1.0);
	glColor3f(5, 0.3, 5.0);
	drawBox(3.0, GL_QUADS);
	glPopMatrix();
	glPopName();

	glPopMatrix();
}





void Sombra_objetos(int mode)
{

	glColor4f(0.2f, 0.2f, 0.2f, ALFA);
	glPushMatrix();
	gltMakeShadowMatrix(datosdePlano, LUZ, matrizdeSombra);
	glMultMatrixf(matrizdeSombra);
	//cubo_sin_color();
	articulado_sin_color(mode);
	objeto_cuveado_sin_color();
	glPopMatrix();
}



void piso() {

	glPushMatrix();
	glTranslatef(0.f, -datosdePlano[3], 50.f);
	glRotatef(270.f, 1.f, 0.f, 0.f);

	glScalef(400.f, 400.f, 400.f); //tamaño del piso
	glColor4f(.3f, .3f, .3f, ALFA);
	cuadrado();//sin color
	glDisable(GL_DEPTH_TEST);
	rayas_piso();
	if (bDepth)glEnable(GL_DEPTH_TEST);
	glPopMatrix();
}

void StencilConfig()
{// step 1
 // turning off writing to the color buffer and depth buffer so we only
 // write to stencil buffer
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDepthMask(GL_FALSE);

	// enable stencil buffer
	glEnable(GL_STENCIL_TEST);
	// write a one to the stencil buffer everywhere we are about to draw
	glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
	// this is to always pass a one to the stencil buffer where we draw
	glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);

	// render the plane which the shadow will be on
	// color and depth buffer are disabled, only the stencil buffer
	// will be modified
	piso();//DrawGround();

		   // turn the color and depth buffers back on
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	glDepthMask(GL_TRUE);

	// until stencil test is diabled, only write to areas where the
	// stencil buffer has a one. This is to draw the shadow only on
	// the floor.
	glStencilFunc(GL_EQUAL, 1, 0xFFFFFFFF);

	// don't modify the contents of the stencil buffer
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	// end step 1
}

void luz() {
	/*-Funcion para la posicion de la luz*/
	glColor4f(1.f, 1.f, 0.f, 1.f - ALFA);
	glLightfv(GL_LIGHT0, GL_POSITION, LUZ/*lightPos*/);
	glPushMatrix();
	glTranslatef(LUZ[0], LUZ[1], LUZ[2]);
	glScalef(10., 10., 10.);
	glutSolidSphere(1., 20., 20.);
	glPopMatrix();
}


void Velocidad(int name)
{
	int i;
	if (name == C2) {
		for (i = 0; i < 3; i++) {
			VR += 1;
		}
	}
	glutPostRedisplay();
}


void RenderScene(GLenum mode)
{
	glMatrixMode(GL_PROJECTION);
	if (mode == GL_RENDER) //para no seleccion	
		glLoadIdentity();
	gluPerspective(60.0, 1.0, 1.5, 1500.0);
	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity();
	gluLookAt(ex, ey, ez, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

	// Turn culling on if flag is set
	if (bCull)   glEnable(GL_CULL_FACE);
	else        glDisable(GL_CULL_FACE);

	// Enable depth testing if flag is set
	if (bDepth)  glEnable(GL_DEPTH_TEST);
	else        glDisable(GL_DEPTH_TEST);

	// Draw the back side as a wireframe only, if flag is set
	if (bOutline) glPolygonMode(GL_BACK, GL_LINE);
	else        glPolygonMode(GL_BACK, GL_FILL);

	// Save matrix state and do the rotation
	glPushMatrix();
	glRotatef(xRot, 1.0f, 0.0f, 0.0f);
	glRotatef(yRot, 0.0f, 1.0f, 0.0f);


	/////////////////////-Reflejo
	StencilConfig();
	glFrontFace(GL_CCW);
	glPushMatrix();
	glTranslatef(0.0f, -datosdePlano[3], 0.0f);
	glScalef(1.0f, -1.0f, 1.0f);  // geometry is mirrored by ground    
	glTranslatef(0.0f, datosdePlano[3], 0.0f);
	glEnable(GL_LIGHTING);
	articulado_con_color(mode);
	//cubo_con_color(mode);  
	Objeto_Curveado_con_color();
	glDisable(GL_LIGHTING);
	luz();

	glPopMatrix();
	glFrontFace(GL_CW);
	glDisable(GL_STENCIL_TEST);
	/////////////////////-fin Reflejo

	//luz();
	//dar transparencia con blending (mezclar) al piso y la sombra
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glDisable(GL_DEPTH_TEST); // para evitar errores de redondeo y no se vean puntitos

	piso();

	StencilConfig();
	glDisable(GL_DEPTH_TEST);
	Sombra_objetos(mode);

	glDisable(GL_STENCIL_TEST);
	glDisable(GL_BLEND); //fin de blending

	if (bDepth)  glEnable(GL_DEPTH_TEST);

	luz();
	glEnable(GL_LIGHTING);
	//cubo_con_color(mode);
	articulado_con_color(mode);
	Objeto_Curveado_con_color();
	glDisable(GL_LIGHTING);



	glPopMatrix();

	glFlush();
}

//-Funcion para degradar cara distinguida
void anallizename(int name)
{
	int i;
	if (name == CARA_DESTINGUIDA) {
		CARA_DESTINGUIDA_TOCADA = true;
		for (i = 0; i < 3; i++)
			color_de_cara_DESTINGUIDA[i] += 0.25f * (1.0f - color_de_cara_DESTINGUIDA[i]);
	}
	glutPostRedisplay();
}


void SpecialKeys(int key, int x, int y)
{
	GLfloat dx, dy, dz;


	if (key == GLUT_KEY_UP)
	{
		dy = -ez;
		dz = ey;
		GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
		ey += delta * dy;
		ez += delta * dz;
		GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
		ex /= s1;
		ey /= s1;
		ey /= s1;
	}

	if (key == GLUT_KEY_DOWN)
	{
		dy = -ez;
		dz = ey;
		GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
		ey -= delta * dy;
		ez -= delta * dz;
		GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
		ex /= s1;
		ex /= s1;
		ey /= s1;
	}


	if (key == GLUT_KEY_LEFT)
		//-Rotar camara
	{
		dx = -ez;     dz = ex;
		GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
		ex += delta * dx;       ez += delta * dz;
		GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
		ex /= s1;    ey /= s1;    ey /= s1;
	}

	if (key == GLUT_KEY_RIGHT)
		//Rotar camara
	{
		dx = -ez;     dz = ex;
		GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
		ex -= delta * dx;          ez -= delta * dz;
		GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
		ex /= s1;    ey /= s1;    ey /= s1;
	}

	if (key == GLUT_KEY_F1) bCull = !bCull;
	if (key == GLUT_KEY_F2)bDepth = !bDepth;
	if (key == GLUT_KEY_F3)bOutline = !bOutline;
	if (key == GLUT_KEY_F4)
	{
		if (shademode == GL_FLAT) { shademode = GL_SMOOTH; }
		else { if (shademode == GL_SMOOTH) { shademode = GL_FLAT; } };
		glShadeModel(shademode);
	}


	if (key == GLUT_KEY_F5)
	{
		AnguloC = (AnguloC + (int)VR) % 360;
		AnguloP = (AnguloP + (int)VR) % 360;
	}

	if (key == GLUT_KEY_F6)
	{
		AnguloC = (AnguloC - (int)VR) % 360;
		AnguloP = (AnguloP - (int)VR) % 360;
	}


	if (key == GLUT_KEY_F7) {
		AnguloP = (AnguloP + (int)VR) % 360;
	}

	if (key == GLUT_KEY_F8) {
		AnguloP = (AnguloP - (int)VR) % 360;
	}

	if (key == GLUT_KEY_F9) {
		LUZ[1] += 5.0;
	}
	if (key == GLUT_KEY_F10) {
		LUZ[1] -= 5.0;
	}
	if (key == GLUT_KEY_F11)
	{
		LUZ[0] = LUZ[0] + 5.0;
	}
	if (key == GLUT_KEY_F12)
	{
		LUZ[0] = LUZ[0] - 5.0;
	}

	if (key == GLUT_KEY_PAGE_DOWN)
	{
		ex *= (1.0f + deltaR);  ey *= (1.0f + deltaR);    ez *= (1.0f + deltaR);
	}

	if (key == GLUT_KEY_PAGE_UP)
	{
		ex *= (1.0f - deltaR); ey *= (1.0f - deltaR);    ez *= (1.0f - deltaR);
	}

	// Refresh the Window
	glutPostRedisplay();
}


/*  procesar toques (seleccion)*/
void processHits(GLint hits, GLuint buffer[])
{
	if (hits == 0) {/*restaura los colores y la velocidad de rotacion*/
		VR = 1;
		initColors();
		return;
	}
	CARA_DESTINGUIDA_TOCADA = false;
	unsigned int i, j, k, l;
	GLuint names1, *ptr1, names2, *ptr2;

	//para degradado de cara
	ptr1 = (GLuint*)buffer;
	for (i = 0; i < hits; i++) {    /*  for each hit  */
		names1 = *ptr1;
		ptr1 += 3;
		for (j = 0; j < names1; j++)  /*  for each name */
			anallizename(*ptr1++);

	}
	//para aumentar velocidad de rotacion
	ptr2 = (GLuint*)buffer;
	for (k = 0; k < hits; k++) {    /*  for each hit  */
		names2 = *ptr2;
		ptr2 += 3;
		for (l = 0; l < names2; l++)  /*  for each name */
			Velocidad(*ptr2++);

	}

	if (!CARA_DESTINGUIDA_TOCADA) /*restore all colors*/
		initColors();

}




/*-Para la seleccion de la cara del cubo*/
void pickCara_del_Cubo(int button, int state, int x, int y)
{
	GLint hits;
	GLint viewport[4];

	if (button != GLUT_LEFT_BUTTON || state != GLUT_DOWN)
		return;

	glGetIntegerv(GL_VIEWPORT, viewport);

	glSelectBuffer(BUFSIZE, selectBuf);
	(void)glRenderMode(GL_SELECT);

	glInitNames();
	glPushName(0);

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	/*  create 5x5 pixel picking region near cursor location    */
	gluPickMatrix((GLdouble)x, (GLdouble)(viewport[3] - y),
		5.0, 5.0, viewport);

	/*inicio: restaurar la matrix de proyeccion*/
	RenderScene(GL_SELECT);
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	/*FIN restaurar la matrix de proyeccion*/

	glMatrixMode(GL_MODELVIEW);

	hits = glRenderMode(GL_RENDER);
	processHits(hits, selectBuf);
	glutPostRedisplay();
}


void display() //<- envoltura a RenderScene() para seleccion
{
	RenderScene(GL_RENDER);
}

// Called by GLUT library when the window has changed size
void ChangeSize(GLsizei w, GLsizei h)
{    // Set Viewport to window dimensions
	glViewport(0, 0, (GLsizei)w, (GLsizei)h);

}



int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE/*GLUT_DOUBLE*/ | GLUT_RGB | GLUT_STENCIL);
	glutInitWindowSize(600, 600);
	glutInitWindowPosition(100, 100);
	glutCreateWindow(argv[0]);
	glutDisplayFunc(display);
	glutReshapeFunc(ChangeSize);
	glutSpecialFunc(SpecialKeys);
	glutMouseFunc(pickCara_del_Cubo);
	SetupRC();
	glutMainLoop();
	return 0;
}