#include "stdafx.h"

#define BUFSIZE 512
GLuint selectBuf[BUFSIZE];

#define	checkImageWidth 256
#define	checkImageHeight 256
#define subImageWidth 64
#define subImageHeight 64
#define BRAZO 121


static GLubyte checkImage[checkImageHeight][checkImageWidth][100];

static GLubyte subImage[subImageHeight][subImageWidth][4];

static GLuint texName[1];

GLfloat ctrlpoints[4][4][3] = {
	{ { -1.5, -1.5, 1.0 },
	{ -1.5, -1.5, 1.0 },
	{ 1.5, -1.5, -1.0 },
	{ 1.5, 1.5, 1.0 } },

	{ { -1.5, -1.5, 1.5 },
	{ -1.5, -1.5, 1.5 },
	{ 1.0, -1.5, 1.0 },
	{ 1.5, -0.5, -1.0 } },

	{ { -1.5, 2.5, 2.0 },
	{ -1.5, 2.5, 2.0 },
	{ 1.5, 0.5, 0.0 },
	{ 1.5, 1.5, 1.0 } },

	{ { -1.5, 1.5, -1.0 },
	{ -1.5, 1.5, -1.0 },
	{ 1.5, 1.5, 1.0 },
	{ 1.5, 1.5, -1.0 } }
};
GLfloat texpts[2][2][2] = { {{0.0, 0.0}, {0.0, 2.0}},
{{3.0, 0.0}, {3.0, 2.0}} };

GLfloat colors[][3] = { { 0.33,0.33,0.33 },{ 1.0,0.0,0.0 },
{ 0.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 } },
col_cara3[3],
col_cara2[3],
col_cara1[3],
col_cara4[1],
shadowMat[16], 
vLuz[4] = { 2., 3.5, 0, 1. },
vPizo[4] = { 0.0f, 1.0f, 0.0f,3.5},
vCube[3] = { 0, 0, 0. }, 
vCuerpo[3] = { 2, 0, 3. };

#define GL_PI 3.1415f

GLfloat xRot = 0.45f;
GLfloat yRot = 0.35f;
GLboolean bCull = glIsEnabled(GL_CULL_FACE);
GLboolean bDepth = true;
GLboolean bOutline = (GLboolean)true; 

int angulo1 = 0.0f;
int angulo2 = 0.0f;
int angulo3 = 0.0f;

GLfloat vel;

GLenum shademode = GL_FLAT;
GLboolean bShade = (GLboolean)true;

//camera possition
GLfloat ex = 0.0f;
GLfloat ey = 0.0f;
GLfloat ez = -20.0f;

GLfloat delta = 0.01f;
GLfloat deltaR = 0.01f;
GLfloat ALFA = 0.75;
static GLfloat theta[] = { 0.0,0.0,0.0 };
static GLint axis = 2;

GLfloat  ambientLight[] = { 0.3f, 0.3f, 0.3f, 1.0f }, diffuseLight[] = { 0.7f, 0.7f, 0.7f, 1.0f },
specular[] = { 1.0f, 1.0f, 1.0f, 1.0f }, specref[] = { 1.0f, 1.0f, 1.0f, 1.0f },
mat_shininess[] = { 50.0 };

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; } // wrong input exit
    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);
}

void makeCheckImages(void)
{
    int i, j, c;

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

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

    dot = vPlaneEquation[0] * vLightPos[0] + vPlaneEquation[1] * vLightPos[1] +
        vPlaneEquation[2] * vLightPos[2] + vPlaneEquation[3] * vLightPos[3];

    // 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];
}

//drawing lines
void lineas() {
   glColor3f(0.0, 1.0, 0.0);
    glBegin(GL_LINES);
    for (int i = 0; i < 10; i++)
    {
        glVertex2f(-1. + i * 2. / 9., 1.);
        glVertex2f(-1. + i * 2. / 9., -1.);

        glVertex2f(1, -1. + i * 2. / 9.);
        glVertex2f(-1., -1. + i * 2. / 9.);
    }
    glEnd();
}
//Vertex
GLfloat v1[] = { 1,1,0 }, v2[] = { 1, -1, 0 }, v3[] = { -1, -1, 0 },v4[] = { -1, 1, 0 }, norm[3];

void cuadrado() {
    glBegin(GL_POLYGON);
    gltGetNormalVector(&v1[0], &v3[0], &v2[0], norm);
    glNormal3fv(norm);
    glVertex3fv(&v1[0]);
    glVertex3fv(&v2[0]);
    glVertex3fv(&v3[0]);
    glVertex3fv(&v4[0]);
    glEnd();
}

void uncolored_cube(void)
{
    /*cara 1*/
    glPushMatrix();
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 2*/
    glPushMatrix();
    glRotatef(90., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 3*/
    glPushMatrix();
    glRotatef(180., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 4*/
    glPushMatrix();
    glRotatef(270., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 5*/
    glPushMatrix();
    glRotatef(90., 1., 0., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 6*/
    glPushMatrix();
    glRotatef(-90., 1., 0., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();
}

void colorcube(void)
{
    /*cara 1*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 2*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glRotatef(90., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 3*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glRotatef(180., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 4*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glRotatef(270., 0., 1., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 5*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glRotatef(90., 1., 0., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();

    /*cara 6*/
    glColor3fv(colors[1]);
    glPushMatrix();
    glRotatef(-90., 1., 0., 0);
    glTranslatef(0, 0, 1.);
    cuadrado();
    glPopMatrix();
}

void creaBrazo(int mode){
	glPushMatrix();
		glPushName(BRAZO);
			glTranslatef(1.0, 0.0, 0.0);
			glRotatef(angulo1, 0.0, 0.0, 1.0);
			glTranslatef(0.0, 0.0, 0.0);
			glColor3fv(col_cara4);
			glPushMatrix();
			glScalef(0.5, 2.0, 0.5);
			glutSolidCube(1.0);
			glPopMatrix();
		glPopName();

			glTranslatef(0.0, -1.0, 0.0);
			glRotatef(angulo2, 0.0, 0.0, 1.0);
			glTranslatef(0.0, -0.5, 0.0);
			glColor3fv(col_cara2);
			glPushName(BRAZO);
			glPushMatrix();
			glScalef(0.5, 1.5, 0.5);
			glutSolidCube(1.0);
			glPopMatrix();
		glPopName();
   	glPopMatrix();
}

void creaBrazoSinColor(){
	glPushMatrix();
      	glTranslatef(1.0, 0.0, 0.0);
      	glRotatef(angulo1, 0.0, 0.0, 1.0);
      	glTranslatef(0.0, 0.0, 0.0);
      	glPushMatrix();
         	glScalef(0.5, 2.0, 0.5);
         	glutSolidCube(1.0);
      	glPopMatrix();

      	glTranslatef(0.0, -1.0, 0.0);
      	glRotatef(angulo2, 0.0, 0.0, 1.0);
      	glTranslatef(0.0, -0.5, 0.0);
      	glPushMatrix();
         	glScalef(0.5, 1.5, 0.5);
         	glutSolidCube(1.0);
      	glPopMatrix();
   	glPopMatrix();
}

//shadow
void curva_SC(){
	glPushMatrix();
		glTranslatef(4, 0, 0.5);
		glScalef(1, 1, 1);
		glRotatef(180, 0, 1, 0);
		glRotatef(90.0, 1.0, 1.0, 1.0);
		glEvalMesh2(GL_FILL, 0, 20, 0, 20);
	glPopMatrix();
}

void curva_CC(){
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_AUTO_NORMAL);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	glBindTexture(GL_TEXTURE_2D, texName[0]);
	glPushMatrix();
		glTranslatef(4, 0, 0.5);
		glScalef(1, 1, 1);
		glRotatef(180, 0, 1, 0);
		glRotatef(90.0, 1.0, 1.0, 1.0);
		glEvalMesh2(GL_FILL, 0, 20, 0, 20);
	glPopMatrix();
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_AUTO_NORMAL);
}

void SombradeMiMundo(GLfloat datosdeLuz[], GLfloat datosdePlano[]) {
    glColor4f(0.33, 0.5, 0.33, ALFA);
    glPushMatrix();
    gltMakeShadowMatrix(datosdePlano, datosdeLuz, shadowMat);
    glMultMatrixf(shadowMat);

    glPushMatrix();
    glTranslatef(vCuerpo[0], vCuerpo[1], vCuerpo[2]);
    uncolored_cube();
    glPopMatrix();

    curva_SC();

    glPushMatrix();
    glTranslatef(vCube[0], vCube[1], vCube[2]);
    creaBrazoSinColor();
    glPopMatrix();

    glPopMatrix();
}


void init();

void SetupRC()
{ 
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    glColor3f(0.0f, 1.0f, 0.0f);

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

    glFrontFace(GL_CW);
    makeCheckImages();

    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);


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

     glEnable(GL_DEPTH_TEST);
    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
        0, 1, 12, 4, &ctrlpoints[0][0][0]);
    glEnable(GL_MAP2_VERTEX_3);
    glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
    init();

    glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
    glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
    glMateriali(GL_FRONT, GL_SHININESS, 128);
}

void piso() {
    glColor4f(100,200,400, ALFA);
    glPushMatrix();
    glTranslatef(0, -vPizo[3], 5);
    glRotatef(-90., 1., 0, 0);
    glScalef(10., 10, 10.);
    cuadrado();
    glDisable(GL_DEPTH_TEST);
    lineas();
    if (bDepth)  glEnable(GL_DEPTH_TEST);
    glPopMatrix();
}


void Stencil_config() {
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glDepthMask(GL_FALSE);

    glEnable(GL_STENCIL_TEST);

    glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);

    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);

    piso();

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glDepthMask(GL_TRUE);

    glStencilFunc(GL_EQUAL, 1, 0xFFFFFFFF);

    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}


void luz() {
    glColor3f(0.3, 0.3, 0.7);
    glPushMatrix();
    glTranslatef(vLuz[0], vLuz[1], vLuz[2]);
    glutSolidSphere(1.0, 20., 20.);
    glPopMatrix();

}

void display(int mode)
{
     glMatrixMode(GL_PROJECTION);
    if (mode == GL_RENDER)
        glLoadIdentity();
        gluPerspective(60.0, 1.0, 1.5, 1500.0);
    glMatrixMode(GL_MODELVIEW);

    // Reset coordinate system
    glLoadIdentity();
    gluLookAt(ex, ey, ez, 0.0, 0.0, 0.0, 0.0, 10.0, 0.0);


   // GLfloat x, y, angle;         // Storage for coordinates and angles
    int iPivot = 1;            // Used to flag alternating colors
    // Clear the window and the depth buffer
    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);

    //reflejo---------------------
    Stencil_config();
    glFrontFace(GL_CCW);
    glPushMatrix();
    glTranslatef(0, -vPizo[3], 0);
    glScalef(1, -1, 1);
    glTranslatef(0, vPizo[3], 0);
     luz();

    curva_CC();

    glEnable(GL_LIGHTING);
    glPushMatrix();
    //glTranslatef(2, 0, 3);
    glTranslatef(vCuerpo[0], vCuerpo[1], vCuerpo[2]);
    colorcube();
    glPopMatrix();
    glDisable(GL_LIGHTING);

    glPushMatrix();
    //glTranslatef(vCube[0], vCube[1], vCube[2]);
    creaBrazo(mode);
    glPopMatrix();
    glPopMatrix();
    glDisable(GL_STENCIL_TEST);
    glFrontFace(GL_CW);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_DEPTH_TEST);
    piso();

    if (bDepth)  glEnable(GL_DEPTH_TEST);


    Stencil_config();
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glLightfv(GL_LIGHT0, GL_POSITION, vLuz);
    SombradeMiMundo(vLuz, vPizo);
    glDisable(GL_STENCIL_TEST);
    glDisable(GL_BLEND);
    if (bDepth)  glEnable(GL_DEPTH_TEST);

    luz();
    curva_CC();
    glEnable(GL_LIGHTING);
    glPushMatrix();
    //glTranslatef(2, 0, 3);
    glTranslatef(vCuerpo[0], vCuerpo[1], vCuerpo[2]);
    colorcube();
    glPopMatrix();
    glDisable(GL_LIGHTING);
    glPushMatrix();
    glTranslatef(vCube[0], vCube[1], vCube[2]);
    creaBrazo(mode);
    glPopMatrix();

    glFlush();// glutSwapBuffers();
}


void RenderScene(void)
{
   display(GL_RENDER);
    glFlush();
}

void ChangeSize(GLsizei w, GLsizei h)
{    // Set Viewport to window dimensions
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);

}
//Teclas Especiales
void SpecialKeys(int key, int x, int y)
{
    GLfloat dx, dz;
    if (key == GLUT_KEY_DOWN)
    {//increase distance from camera to origin
        ex *= (1.0f + deltaR);  ey *= (1.0f + deltaR); ez *= (1.0f + deltaR);
    }
    if (key == GLUT_KEY_UP)
    {//reduce distance from camera to origin (close up)
        ex *= (1.0f - deltaR); ey *= (1.0f - deltaR); ez *= (1.0f - deltaR);
    }
    if (key == GLUT_KEY_LEFT)
        //Rotate camera around origin in Oxz plane
    {
        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)
        //Rotate camera around origin in Oxz plane
    {
        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_F6) {
        vLuz[1] += 0.25;
    }
    if (key == GLUT_KEY_F5) {
        vLuz[1] -= 0.25;
    }

    if (key == GLUT_KEY_F7) {
        vCube[0] += 0.25;
        vCuerpo[0] += 0.25;
    }
    if (key == GLUT_KEY_F8) {
        vCube[0] -= 0.25;
        vCuerpo[0] -= 0.25;
    }
    if (key == GLUT_KEY_F10) {
        vCube[1] += 0.25;
        vCuerpo[1] += 0.25;

    }
    if (key == GLUT_KEY_F9) {
        vCube[1] -= 0.25;
        vCuerpo[1] -= 0.25;

    }
    if (key == GLUT_KEY_F11) {
        vCube[2] += 0.25;
        vCuerpo[2] += 0.25;

    }
    if (key == GLUT_KEY_F12) {
        vCube[2] -= 0.25;
        vCuerpo[2] -= 0.25;

    }
    // Refresh the Window
    glutPostRedisplay();
}

void keyboardDown(unsigned char key, int x, int y) {

	 GLfloat dx, dz, dy;
    //mover articulacion
    if (key == 'a') {
        angulo1 += vel;
    }
        if (key == 'd') {
        angulo1 -= vel;
    }


    if (key == 'w') {
        if (angulo2 < 100.0f)
            angulo2 += vel;
    }

    if (key == 's') {
        if (angulo2 > -100.f)
            angulo2 -= vel;
    }

    //mover luz
    if (key == '-') {
        vLuz[2] += 0.25;
    }
    if (key == '+') {
        vLuz[2] -= 0.25;
    }

    if (key == '/') {
        vLuz[0] += 0.25;
    }
    if (key == '*') {
        vLuz[0] -= 0.25;
    }
    //Mover Camara
    //camara-verticalmente
    if (key == '8') {
                dx = -ez;     dz = ey;
        GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
        ey += delta * dx;       ez += delta * dz;
        GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
        ex /= s1;	ey /= s1;	ey /= s1;
    }

    if (key == '2') {
        dx = -ez;     dz = ey;
        GLfloat s = sqrtf(ex * ex + ey * ey + ez * ez);
        ey -= delta * dx;      	ez -= delta * dz;
        GLfloat s1 = sqrtf(ex * ex + ey * ey + ez * ez) / s;
        ex /= s1;	ey /= s1;	ey /= s1;
    }
    //camara-horizontal
    if (key == 'k')
    {
        ex *= (1.0f); ey -= (1.0f + deltaR); ez *= (1.0f);
    }

    if (key == 'i')
    {
        ex *= (1.0f); ey += (1.0f + deltaR);;	ez *= (1.0f);
    }
    //movimiento-horizontal

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

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

/*accion al tocar en medio de la cola*/
void init_color_brazo() {


    col_cara3[0] = colors[2][0];
    col_cara3[1] = colors[2][1];
    col_cara3[2] = colors[2][2];

    col_cara2[0] = colors[2][0];
    col_cara2[1] = colors[2][1];
    col_cara2[2] = colors[2][2];

    col_cara1[0] = colors[2][0];
    col_cara1[1] = colors[2][1];
    col_cara1[2] = colors[2][2];
    vel = 5.0f;
}


void init(void)
{
    init_color_brazo();
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glShadeModel(GL_FLAT);
}

void anallizename(int name)
{
    int i;
    if (name != BRAZO)return;
    for (i = 0; i < 3; i++)
        col_cara3[i] *= 0.9;
		col_cara1[i] *= 0.9;
		col_cara2[i] *= 0.9;
    vel++;
    glutPostRedisplay();
}


void processHits(GLint hits, GLuint buffer[])
{
    if (hits == 0) {
        init();
        return;
    }

    unsigned int i, j;
    GLuint names, * ptr;

    ptr = (GLuint*)buffer;
    for (i = 0; i<hits; i++) {
        names = *ptr;
        ptr += 3;
        for (j = 0; j < names; j++) 
            anallizename(*ptr++);
    }
}


void pickBrazo(int button, int state, int x, int y)
{
    GLuint selectBuf[BUFSIZE];
    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);

    display(GL_SELECT);

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    hits = glRenderMode(GL_RENDER);
    processHits(hits, selectBuf);
    glutPostRedisplay();
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_STENCIL);
    glutInitWindowSize(1000,650);
    glutInitWindowPosition(100, 100);
	glutCreateWindow("Proyecto Final Oscar Parra");
    glutDisplayFunc(RenderScene);
    glutReshapeFunc(ChangeSize);
    glutSpecialFunc(SpecialKeys);
    glutKeyboardFunc(keyboardDown);
    glutMouseFunc(pickBrazo);
    SetupRC();
    glutMainLoop();
    return 0;
}

/*
			***Proyecto Final***
	***Parra Cárdenas Oscar Amaury***
			***2182000766***


    Teclas...
	F1	b
	F2  profundidad
	F3	quitar lineas
	F4	shade mode
	F5	bajar luz
	F6	subir luz
	F7  trasladar izquierda
	F8	trasladar derecha
	F9	trasladar abajo
	F10 trasladar arriba
	F11 atrás
	F12 adelante

	a	girar brazo izquierda
	d	girar brazo derecha
	w	articular arriba
	s	articular abajo

	-	alejar luz
	+	acercar luz
	/	mover luz a la izquierda
	*	mover luz a la derecha

	8	acercar cámara
	2	alejar cámara

	k	rotar plano abajo
	i	rotar plano arriba
	l	rotar plano derecha
	j	rotar plano izquierda

	flecha arriba	 acercar
	flecha abajo	 alejar
	flecha derecha	 derecha
	flecha izquierda izquierda

*/