#include "stdafx.h"

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

// Define object names

#define SHADOW        1
#define JET           2
#define NOSE			20
#define BODY			21
#define WING			22
#define TAIL			23
#define TAILVERTICAL		231
#define TAILHORIZONTAL		232
#define LIGHT_X			1.5f
#define LIGHT_Y			1.5f
#define LIGHT_Z			1.0f
#define LIGHT_A			1.0f

#define YGROUND         -150.0f
#define CX				0.0f
#define CY				YGROUND
#define CZ				0.0f

#define BUFSIZE 512
GLuint selectBuf[BUFSIZE];

static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
static GLubyte otherImage[checkImageHeight][checkImageWidth][4];

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

static GLuint texName[2];

GLboolean	bCull = (GLboolean)true, bDepth= (GLboolean)true,	bOutline=(GLboolean)true,
            bShade= (GLboolean)true;

GLdouble pers[]={60.0, 1.0, 1.5, 700.0};

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 },

STARTbackgroundcolor[] = {0.0f, 0.0f, 1.0f, 1.0f },
STARTplanebodycolor[]  = {0.0f, 1.0f, 0.0f, 1.0f },
STARThortailcolor1[]   = {0.0f, 1.0f, 0.0f, 1.0f },
STARThortailcolor2[]   = {0.0f, 0.5f, 0.5f, 1.0f },
STARTwingcolor1[]	  = {0.0f, 1.0f, 0.0f, 1.0f },
STARTwingcolor2[]	  = {0.0f, 0.5f, 0.5f, 1.0f },
STARTshadowcolor[]	  = {0.3f, 0.3f, 0.3f, 1.0f },
STARTverttailcolor[]   = {1.0f, 0.0f, 0.0f, 1.0f },

cx=CX,  cy=CY, cz=CZ,

backgroundcolor[4], planebodycolor[4], hortailcolor1[4], hortailcolor2[4],
wingcolor1[4], wingcolor2[4], shadowcolor[4], verttailcolor[4],
// The light is positioned by this code, located in the ChangeSize function:
	wlightPos[] = {  LIGHT_X,  LIGHT_Y, LIGHT_Z,  LIGHT_A }, 
		 lightPos[] = { -75.0f, 150.0f, -50.0f, 1.0f }, //{ -30.f, 4.0f, 15.0f, 1.0f };

//jet vertices
         vdata[13][3] = {
			{0.0f, 0.0f, 25.0f},   //Pinnacle of cone is shared vertex for fan, moved up z-axis
			{5.0f, 0.0f, 0.0f}, {0.0f, 3.0f, 0.0f}, {-5.0f, 0.0f, 0.0f}, //to close the fan use {5.0f, 0.0f, 0.0f} twice
			{0.0f, 0.0f, -6.0f},  //Pinnacle of new cone with the same base verteces as above
			// horiz tail
			{-8.0f, 0.0f, 30.0}, {8.0f, 0.0f, 30.0}, {0.0f, 0.0f, 23.0}, 
			//vertical tail
			{0.0f, 0.0f, 30.0},    // far point 
			{0.0f, 8.0f, 30.0},    // up point 
			// {0.0f, 0.0f, 23.0}  // the close point is the same 
			                       // as for horiz. tail
			//wing
			{-20.0f, 1.0f, 10.0},  { 20.0f, 1.0f, 10.0}, {0.0f,  1.0f, 5.0}
			};

GLfloat ex=0.0f, ey=30.0f, ez=-30.0f,    delta= 0.01f, deltaR= 0.01f,

        trans[] = {0.0f, 0.0f, -1.0f},   ktrans = 0.0f,    deltatrans = 0.1f,
        jetrot    = 0.0f, deljetrot = 0.1f,

// Transformation matrix to project shadow
        shadowMat[16],
		vGroundPlane[4] = {0.0f, 1.0f, 0.0f, 150.0f};

void initColors()
{
	for(int i=0; i<3; i++){
		backgroundcolor[i]=STARTbackgroundcolor[i];
		planebodycolor[i]  =STARTplanebodycolor[i];
		hortailcolor1[i]   =STARThortailcolor1[i];
		hortailcolor2[i]   =STARThortailcolor2[i];
		wingcolor1[i]	   =STARTwingcolor1[i];
		wingcolor2[i]      =STARTwingcolor2[i];
		shadowcolor[i]     =STARTshadowcolor[i];
		verttailcolor[i]   =STARTverttailcolor[i];
	}
	backgroundcolor[3]=STARTbackgroundcolor[3];
}

void makeCheckImages(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][0] = (GLubyte) c;   checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;   checkImage[i][j][3] = (GLubyte) 192;
         
		 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) 192;
      }
   }

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


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 SetLightPos()
	{  lightPos[0]=wlightPos[0];  lightPos[1]=wlightPos[1]; 
	   lightPos[2]=wlightPos[2];  lightPos[3]=wlightPos[3];
	   glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
	   gltMakeShadowMatrix(vGroundPlane, lightPos, shadowMat);
	}

void Buff_Light()
	{wlightPos[0]=lightPos[0];
	 wlightPos[1]=lightPos[1];
	 wlightPos[2]=lightPos[2];
	 wlightPos[3]=lightPos[3];
	}

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 SetupRC()
    {   
	initColors();
    // Set color shading model to flat
	
    glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   makeCheckImages();
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    // Enable lighting
    glEnable(GL_LIGHTING);
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glPolygonMode(GL_BACK,GL_FILL);
   // Enable color tracking
	glEnable(GL_COLOR_MATERIAL);
	// Front material ambient and diffuse colors track glColor
	glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);

	// All materials hereafter have full specular reflectivity
	// with a high shine
	glMaterialfv(GL_FRONT, GL_SPECULAR,specref);
	glMateriali(GL_FRONT,GL_SHININESS,128);

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

   glBindTexture(GL_TEXTURE_2D, texName[1]);
   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);

   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, 
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
                otherImage);
   glEnable(GL_TEXTURE_2D);
 
    // Clockwise-wound polygons are front facing; this is reversed
    // because we are using triangle fans
    glFrontFace(GL_CCW);

   

		// the light source GL_LIGHT0 is enabled:
	
	// Set up and enable light 0
	glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
	glLightfv(GL_LIGHT0,GL_SPECULAR,specular);
	glEnable(GL_LIGHT0);
	
	SetLightPos();	//  wlightPos --> lightPos;
	                        // + glLightfv(GL_LIGHT0,GL_POSITION,lightPos); 
							//+ Calculate projection matrix to draw shadow on the ground:
                             // gltMakeShadowMatrix(vGroundPlane, lightPos, shadowMat);
	
	
	

	 // Light blue background
    glClearColor( backgroundcolor[0], backgroundcolor[1], 
					backgroundcolor[2], backgroundcolor[3] );

    // Calculate projection matrix to draw shadow on the ground
    gltMakeShadowMatrix(vGroundPlane, lightPos, shadowMat);
    }

void DrawGround(void)
{	
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glEnable(GL_TEXTURE_2D);
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glBegin(GL_QUADS);
glNormal3f(0.0f, 1.0f, 0.0f);
   glTexCoord2f(0.0, 0.0);  glVertex3f( 400.0f, -150.0f, -700.0f); //glVertex3f(-2.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0);  glVertex3f(-400.0f, -150.0f, -700.0f); //glVertex3f(-2.0, 1.0, 0.0);

   glTexCoord2f(1.0, 1.0);   glVertex3f(-400.0f, -150.0f, 200.0f); //glVertex3f(0.0, 1.0, 0.0);
   glTexCoord2f(1.0, 0.0);   glVertex3f(400.0f, -150.0f, 200.0f);//glVertex3f(0.0, -1.0, 0.0);

   glEnd();
  glutSwapBuffers();
   glDisable(GL_TEXTURE_2D);
}


void MoveJet_or_Shadow(int obj)
{	GLfloat  wtrans[3];
		// move jet or its shadow to a new position
		
	wtrans[0]= ktrans* trans[0];	wtrans[1]= ktrans* trans[1];
	wtrans[2]= ktrans* trans[2];
	if(obj==SHADOW)	// Multiply by shadow projection matrix
		glMultMatrixf((GLfloat *)shadowMat);
	
	glTranslatef(wtrans[0], wtrans[1], wtrans[2]);
	glRotatef(jetrot, 0.0f, 1.0f, 0.0f);
}


void Jet_or_ShadowModel(GLenum mode, int obj)
{
	if (obj==SHADOW)
	{
		if (mode == GL_SELECT)  glLoadName (SHADOW);

		// Begin a triangle fan  (far part of plane body)
		glBegin(GL_TRIANGLE_FAN);

			glVertex3fv(&vdata[0][0] /*  0.0f, 0.0f, 25.0f*/);
			  glVertex3fv(&vdata[1][0] /*5.0f, 0.0f*/);
			  glVertex3fv(&vdata[2][0] /*0.0f, 3.0f*/);
			  glVertex3fv( &vdata[3][0] /*-5.0f, 0.0f*/);
			  glVertex3fv(& vdata[1][0] /*5.0f, 0.0f*/);
		glEnd();

		glBegin(GL_TRIANGLE_FAN); // Begin a new triangle fan (close part of plane body)
			glVertex3fv(&vdata[4][0] /*  {0.0f, 0.0f, -6.0f} */);
				  glVertex3fv(&vdata[1][0] );
				  glVertex3fv(&vdata[2][0] );
				  glVertex3fv( &vdata[3][0] );
				  glVertex3fv(& vdata[1][0] );
		glEnd(); // Done drawing the fan (close part of plane body)

		glBegin(GL_TRIANGLES);
				// horiz tail
			glVertex3fv( & vdata[5][0] /*-8.0f, 0.0f, 30.0*/);            // V0
			glVertex3fv( & vdata[6][0] /*8.0f, 0.0f, 30.0*/);        // V1
			glVertex3fv( & vdata[7][0] /*0.0f, 0.0f, 23.0*/);        // V2

				// vertic tail
			glVertex3fv( & vdata[8][0] /*{0.0f, 0.0f, 30.0}*/);            // V0
			glVertex3fv( & vdata[9][0] /*{0.0f, 8.0f, 30.0}*/);        // V1
			glVertex3fv( & vdata[7][0] /*0.0f, 0.0f, 23.0*/);        // V2

				//wing
			glVertex3fv( & vdata[10][0] /*{-20.0f, 1.0f, 10.0}*/);            // V0
			glVertex3fv( & vdata[11][0] /*{ 20.0f, 1.0f, 10.0}*/);        // V1
			glVertex3fv( & vdata[12][0] /*0.0f,  1.0f, 5.0*/);        // V2

		glEnd();
	};
	if (obj==JET)
	{	GLfloat norm[3];
		if (mode == GL_SELECT)	glLoadName (JET);

		if (mode == GL_SELECT)  glPushName (BODY);

		glBegin(GL_TRIANGLE_FAN);

		// Pinnacle of cone is shared vertex for fan, moved up z-axis
		// to produce a cone instead of a circle
			glVertex3fv(&vdata[0][0] /*  0.0f, 0.0f, 25.0f*/);
			     
			  glVertex3fv(&vdata[1][0] /*5.0f, 0.0f*/);
			  
			  gltGetNormalVector( &vdata[0][0], &vdata[1][0], &vdata[2][0], norm);/* color information here */
			  glNormal3fv(norm);/* color information here */
			  glColor3f(planebodycolor[0], planebodycolor[1], planebodycolor[2]);
			  glVertex3fv(&vdata[2][0] /*0.0f, 3.0f*/);
			  
			  gltGetNormalVector( &vdata[0][0], &vdata[2][0], &vdata[3][0], norm);
			  glNormal3fv(norm);

			  glVertex3fv( &vdata[3][0] /*-5.0f, 0.0f*/);
              
			  gltGetNormalVector( &vdata[0][0], &vdata[3][0], &vdata[1][0], norm);
			  glNormal3fv(norm);

			  glVertex3fv(& vdata[1][0] /*5.0f, 0.0f*/);
		glEnd();

		if (mode == GL_SELECT)	glPopName (); //BODY

		if (mode == GL_SELECT)  glPushName (NOSE);

		glBegin(GL_TRIANGLE_FAN); // Begin a new triangle fan (close part of plane body)
			glVertex3fv(&vdata[4][0] /*  {0.0f, 0.0f, -6.0f} */);

			  glVertex3fv(&vdata[1][0] );
			  gltGetNormalVector( &vdata[1][0], &vdata[4][0], &vdata[2][0], norm);/* color information here */
			  glNormal3fv(norm);/* color information here */

			  glVertex3fv(&vdata[2][0] );
  				  gltGetNormalVector( &vdata[4][0], &vdata[3][0], &vdata[2][0], norm);
			  glNormal3fv(norm);

			  glVertex3fv( &vdata[3][0] );

				gltGetNormalVector( &vdata[4][0], &vdata[1][0], &vdata[3][0], norm);
			  glNormal3fv(norm);
			  
			  glVertex3fv(& vdata[1][0] );

		glEnd(); // Done drawing the fan (close part of plane body)

		if (mode == GL_SELECT)	    glPopName (); //NOSE
	
		if (mode == GL_SELECT)	glPushName (TAIL);

		glBegin(GL_TRIANGLES);
				// horiz tail
			if (mode == GL_SELECT)	  glPushName (TAILHORIZONTAL);
					gltGetNormalVector( &vdata[5][0], &vdata[6][0], &vdata[7][0], norm);
							  glNormal3fv(norm);
  					glColor3f(hortailcolor1[0], hortailcolor1[1], hortailcolor1[2]);
					glVertex3fv( & vdata[5][0] /*-8.0f, 0.0f, 30.0*/);            // V0
					glVertex3fv( & vdata[6][0] /*8.0f, 0.0f, 30.0*/);        // V1
					glColor3f(hortailcolor2[0], hortailcolor2[1], hortailcolor2[2]);
					glVertex3fv( & vdata[7][0] /*0.0f, 0.0f, 23.0*/);        // V2
			if (mode == GL_SELECT)  glPopName ();
				// vertic tail
			if (mode == GL_SELECT)   glPushName (TAILVERTICAL);
					gltGetNormalVector( &vdata[8][0], &vdata[9][0], &vdata[7][0], norm);
							  glNormal3fv(norm);
					glColor3f(verttailcolor[0], verttailcolor[1], verttailcolor[2]);
					glVertex3fv( & vdata[8][0] /*{0.0f, 0.0f, 30.0}*/);            // V0
					glVertex3fv( & vdata[9][0] /*{0.0f, 8.0f, 30.0}*/);        // V1
					glVertex3fv( & vdata[7][0] /*0.0f, 0.0f, 23.0*/);        // V2
			if (mode == GL_SELECT)   glPopName (); //TAILVERTICAL
			  
	    glEnd();

	    if (mode == GL_SELECT)    glPopName ();   //TAIL

		if (mode == GL_SELECT)    glPushName(WING);
				//wing
			 glEnable(GL_TEXTURE_2D);
			  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
			  glBindTexture(GL_TEXTURE_2D, texName[1]);		
				glBegin(GL_TRIANGLES);
					gltGetNormalVector( &vdata[11][0], &vdata[12][0], &vdata[10][0], norm);
					glNormal3fv(norm);
			 
	 				glColor3f(wingcolor1[0], wingcolor1[1], wingcolor1[2]);
					glTexCoord2f(0.0, 1.0);  glVertex3fv( & vdata[10][0] /*{-20.0f, 1.0f, 10.0}*/);            // V0
					glTexCoord2f(1.0, 1.0);  glVertex3fv( & vdata[11][0] /*{ 20.0f, 1.0f, 10.0}*/);        // V1
					glColor3f(wingcolor2[0], wingcolor2[1], wingcolor2[2]);
					glTexCoord2f(0.5, 0.5); glVertex3fv( & vdata[12][0] /*0.0f,  1.0f, 5.0*/);        // V2
				glEnd();   // GL_TRIANGLES
        if (mode == GL_SELECT)   glPopName();  //WING      

		glDisable(GL_TEXTURE_2D);
	
	}
}




void DrawLight()
{    glPushMatrix();
		glTranslatef(lightPos[0],lightPos[1], lightPos[2]);
		glColor3ub(255,255,0);
		glutSolidSphere(5.0f,10,10);
    glPopMatrix();
}


void RenderScene(GLenum mode)
    {   if(mode==GL_RENDER)
		{	glMatrixMode(GL_PROJECTION);
			glLoadIdentity();
		}
	    
		//glOrtho (-100.0, 100.0, -100, 100, -270.0, 270.0);
		//glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
		gluPerspective(pers[0], pers[1], pers[2], pers[3]);
		glMatrixMode (GL_MODELVIEW);
			// Reset coordinate system
		glLoadIdentity();
 		gluLookAt (ex, ey, ez, 0.0, YGROUND/*-50.0*/, 0.0, 0.0, 1.0, 0.0);

		// Clear the window and the depth buffer
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		if (mode == GL_RENDER)	
		DrawGround();
	  
		// disable lighting and save the projection state
		glDisable(GL_DEPTH_TEST);
		glDisable(GL_LIGHTING);
	
		glPushMatrix();   /* apply shadow matrix multiplication 
						  to moved Jet shadow model*/
			MoveJet_or_Shadow(SHADOW); //MoveJetShadow(); 
			glColor3f(shadowcolor[0], shadowcolor[1], shadowcolor[2]);
		
			Jet_or_ShadowModel(mode, SHADOW);
	  
		glPopMatrix();  /* end drawing jet shadow */

    // restore lighting and save the projection state
		glEnable(GL_DEPTH_TEST);	    
		glEnable(GL_LIGHTING); 
	     
		glPushMatrix(); /* draw moved Jet model*/
		MoveJet_or_Shadow(JET);//MoveJet();	
		
		Jet_or_ShadowModel(mode, JET);
    glPopMatrix(); 	 /* end jet drawing */

    // Draw the light source
	DrawLight();
    
    // Flush drawing commands
	if (mode == GL_RENDER)
     glutSwapBuffers();
    }


void anallizename( int name)
{	int i;
	if (name == SHADOW){
     for( i=0; i<3; i++)
		 shadowcolor[i]+= 0.25f*(1.0f-shadowcolor[i]);
	}
    else if (name ==  JET ){
			for( i=0; i<3; i++)
			{planebodycolor[i]+= 0.25f*(1.0f-planebodycolor[i]);
			hortailcolor1[i]+= 0.25f*(1.0f-hortailcolor1[i]);
			hortailcolor2[i]+= 0.25f*(1.0f-hortailcolor2[i]);
			wingcolor1[i]+= 0.25f*(1.0f-wingcolor1[i]);
			wingcolor2[i]+= 0.25f*(1.0f-wingcolor2[i]);
			verttailcolor[i]+= 0.25f*(1.0f-verttailcolor[i]);
			}
	}
		 else  if (name ==  NOSE ){
				 for( i=0; i<3; i++)
					{planebodycolor[i]+= 0.25f*(1.0f-planebodycolor[i]);
				 }
		 }
               else  if (name ==  BODY ){
				   for( i=0; i<3; i++)
					{planebodycolor[i]+= 0.25f*(1.0f-planebodycolor[i]);
				 }
			   }
					 else  if (name ==   WING){
						 for( i=0; i<3; i++)
						{
						wingcolor1[i]+= 0.25f*(1.0f-wingcolor1[i]);
						wingcolor2[i]+= 0.25f*(1.0f-wingcolor2[i]);
						}

					 }
						   else  if (name ==   TAIL){
								   for( i=0; i<3; i++)
										{
										hortailcolor1[i]+= 0.25f*(1.0f-hortailcolor1[i]);
										hortailcolor2[i]+= 0.25f*(1.0f-hortailcolor2[i]);
										verttailcolor[i]+= 0.25f*(1.0f-verttailcolor[i]);
										}
						   }
								 else  if (name ==   TAILVERTICAL){
										   for( i=0; i<3; i++)
												{
												verttailcolor[i]+= 0.25f*(1.0f-verttailcolor[i]);
												}
								 }
									   else  if (name ==   TAILHORIZONTAL){
												for( i=0; i<3; i++)
												{
												hortailcolor1[i]+= 0.25f*(1.0f-hortailcolor1[i]);
												hortailcolor2[i]+= 0.25f*(1.0f-hortailcolor2[i]);
												}
									   }
 glutPostRedisplay();
}


/*  processHits prints out the contents of the 
 *  selection array.
 */
void processHits (GLint hits, GLuint buffer[])
{  if (hits==0)   {/*restore all colors*/
	initColors();
	return;
   }

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

   ptr = (GLuint *) buffer;
   for (i = 0; i < hits; i++) {	/*  for each hit  */
      names = *ptr;
	  ptr+=3;
	                //  SHADOW
	 				 // JET + a plane detail
	               // JET + a plane detail + subdetail
	                      // SHADOW + JET + a plane detail 
	              // SHADOW + JET + a plane detail + subdetail
	  for (j = 0; j < names; j++)  /*  for each name */
		  anallizename( *ptr++);
   }
}

void pickPlaneDetails(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);
   /*gluOrtho2D (0.0, 3.0, 0.0, 3.0);
  */
   RenderScene (GL_SELECT);

   glMatrixMode (GL_PROJECTION);
   glPopMatrix ();
   //glFlush ();

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


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

		
    }

void SpecialKeys(int key, int x, int y)
    {GLfloat dx, dy, dz;
    
	if(key == GLUT_KEY_UP)
	{//increase distance from camera to origin
		ex*=(1.0f+deltaR);  ey*=(1.0f+deltaR);	ez*=(1.0f+deltaR);

    glutPostRedisplay();
		return;
	}

    if(key == GLUT_KEY_DOWN)
	{//reduce distance from camera to origin (close up)
		ex*=(1.0f-deltaR); ey*=(1.0f-deltaR);	ez*=(1.0f-deltaR);

    glutPostRedisplay();
	return;}

    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; 

    glutPostRedisplay();return;
	}

    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;
	
    glutPostRedisplay();return;}
 
	if(key ==  GLUT_KEY_F5)//Rotate camera around origin in Oyz plane
         {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;
	
    glutPostRedisplay();return;}

	if(key ==  GLUT_KEY_F6)//Rotate camera around origin in Oyz plane
         {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; 

	glutPostRedisplay();return;}

	if(key ==  GLUT_KEY_F7)//Move jet forward 
        {	 ktrans += deltatrans;
             glutPostRedisplay();return;
		}

	if(key ==  GLUT_KEY_F8)//Rote jet  around origin in Oyz plane
        {	 ktrans += deltatrans;
			jetrot    += deljetrot; 
			
			glutPostRedisplay();return;
		}

	if(key ==  GLUT_KEY_F9)//Rote jet  around origin in Oyz plane
        {	ktrans += deltatrans;
			jetrot   -= deljetrot; 
   
			glutPostRedisplay();return;
		}
if(key ==  GLUT_KEY_F10)//Move light toward the center of ground 
        {	Buff_Light(); 
			dx=cx-wlightPos[0]; dy=cy-wlightPos[1];    dz=cz-wlightPos[2];
			dx*=(1.0-deltatrans); dy*=(1.0-deltatrans);
			dz*=(1.0-deltatrans);
			wlightPos[0]=cx-dx;  wlightPos[1]=cy-dy; wlightPos[2]=cz-dz;
			
			SetLightPos();
			 // Calculate new projection matrix to draw shadow on the ground
			
			glutPostRedisplay();return;
		}
	if(key ==  GLUT_KEY_F11)//Move light outward the center of ground 
        {	Buff_Light();
			dx=cx-wlightPos[0]; dy=cy-wlightPos[1];    dz=cz-wlightPos[2];
			
			dx/=(1.0-deltatrans); dy/=(1.0-deltatrans);
			dz/=(1.0-deltatrans);
			wlightPos[0]=cx-dx;  wlightPos[1]=cy-dy; wlightPos[2]=cz-dz;
			
			SetLightPos();
			 // Calculate new projection matrix to draw shadow on the ground
			
			glutPostRedisplay();return;
		}
	if(key ==  GLUT_KEY_F1){ bCull=!bCull;
	  // Turn on/off culling on if flag is set
		if(bCull)   glEnable(GL_CULL_FACE);
		else        glDisable(GL_CULL_FACE);

		glutPostRedisplay();return;
		}
	if(key ==  GLUT_KEY_F2){bDepth=!bDepth;
	if(bDepth)  {glEnable(GL_DEPTH_TEST);
				glClear(GL_DEPTH_BUFFER_BIT);}
		 else        glDisable(GL_DEPTH_TEST);
		
         glutPostRedisplay();return;
		}

	if(key ==  GLUT_KEY_F3){bOutline=!bOutline;

    // 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);
  
    glutPostRedisplay();
	return;
	}
	if(key ==  GLUT_KEY_F4)
		{bShade=!bShade;
		if(bShade){glShadeModel(GL_FLAT);}
	    else {glShadeModel(GL_SMOOTH);} 

    glutPostRedisplay();
		   return;
		}
    }

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT);
   RenderScene(GL_RENDER);
   
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
 glutCreateWindow (argv[0]);
 glutDisplayFunc(display);
    glutReshapeFunc(ChangeSize);
	 glutSpecialFunc (SpecialKeys);

	 glutMouseFunc (pickPlaneDetails);
    SetupRC();
    glutMainLoop();
return 0;
}