#include "stdafx.h"




#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>

#include <GL/glut.h>

#ifdef GL_VERSION_1_1
#define POINTER 1
#define INTERLEAVED 2

#define DRAWARRAY 1
#define ARRAYELEMENT  2
#define DRAWELEMENTS 3

enum {
    BUTTON_LEFT = 0,
    BUTTON_RIGHT,
    BUTTON_LEFT_TRANSLATE,
};




int mButton = -1;
int mOldY, mOldX;


float eye[3] = {0.0f, 0.0f, 4.0f};
float rot[3] = {45.0f, 45.0f, 0.0f};

const int ESC = 27;

int wireframe = 0;
int test;

float diff[] = {.2,.7,.7,1};
float spec[] = {1,1,1,1};
float pos[] = {7,1,1,0};

const int GL_WIN_WIDTH = 450;
const int GL_WIN_HEIGHT = 350;
const int GL_WIN_INITIAL_X = 0;
const int GL_WIN_INITIAL_Y = 0;

	GLfloat verts[] = {0,0,0,
					1,0,0,
					1,1,0,
					0,1,0
					};
	GLfloat colors[] = {1,0,0,
						0,1,0,
						0,0,1,
						1,1,0};
	



void setupPointers(void)
{



   glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState(GL_COLOR_ARRAY);


   glVertexPointer (3, GL_FLOAT, 0, verts);
   glColorPointer(3, GL_FLOAT, 0, colors);

}



void glutResize(int width, int height)
{
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0, (float)width/(float)height, 0.1, 300.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}


void glutKeyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
		case ESC:
			exit(0);
		case 'W':
		case 'w':
		    wireframe = !wireframe;
	}
}


void clamp(float *v)
{
    int i;

    for (i = 0; i < 3; i ++)
        if (v[i] > 360 || v[i] < -360)
            v[i] = 0;
}


void glutMotion(int x, int y)
{

    if (mButton == BUTTON_LEFT)
    {

    }
	else if (mButton == BUTTON_RIGHT)
    {
          
        eye[2] -= (mOldY - y) * 0.05f;
                                      
        clamp (rot);
    } 
    else if (mButton == BUTTON_LEFT_TRANSLATE)
    {
        eye[0] += (mOldX - x) * 0.01f;
        eye[1] -= (mOldY - y) * 0.01f;
        clamp (rot);
    }

    mOldX = x;
    mOldY = y;
}


void glutMouse(int button, int state, int x, int y)
{
    if(state == GLUT_DOWN)
    {
        mOldX = x;
        mOldY = y;
		int viewport[4];
		double mvmatrix[16], projmatrix[16];
		int realy;
		double wx,wy,wz;
		bool sucess;
        switch(button)
        {
            case GLUT_LEFT_BUTTON:
                if (glutGetModifiers() == GLUT_ACTIVE_CTRL)
                {
                   mButton = BUTTON_LEFT_TRANSLATE;
                   break;
                } else
                {
                   mButton = BUTTON_LEFT;
				   		glGetIntegerv(GL_VIEWPORT, viewport);
				glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
				glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);
				realy = viewport[3] - y - 1;
				system("cls");
				printf("Test #%d\n\n\n\n",test);
				printf("Real: %d,%d\n\n",x,realy);

					for (int i = -5; i < 6; i++)
					{
						sucess = gluUnProject(x,realy,i,mvmatrix,projmatrix,viewport,&wx,&wy,&wz);
						printf("%d returned @ z=%d: %f  %f  %f \n",sucess,i,wx,wy,wz);
					}
				
				printf("\n\nModel View Matrix:\n\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
					    ,mvmatrix[0],mvmatrix[4],mvmatrix[8],mvmatrix[12]
					    ,mvmatrix[1],mvmatrix[5],mvmatrix[9],mvmatrix[13]
						,mvmatrix[2],mvmatrix[6],mvmatrix[10],mvmatrix[14]
						,mvmatrix[3],mvmatrix[7],mvmatrix[11],mvmatrix[15]);
				printf("\n\nProjection Matrix:\n\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
						"%d\t %d\t %d\t %d\n"
					    ,projmatrix[0],projmatrix[4],projmatrix[8],projmatrix[12]
					    ,projmatrix[1],projmatrix[5],projmatrix[9],projmatrix[13]
						,projmatrix[2],projmatrix[6],projmatrix[10],projmatrix[14]
						,projmatrix[3],projmatrix[7],projmatrix[11],projmatrix[15]);
				

				test++;
                   break;
                }
            case GLUT_RIGHT_BUTTON:
                mButton = BUTTON_RIGHT;
                break;
        }
    } else if (state == GLUT_UP)
      mButton = -1;
}


void glutMenu(int value)
{
	switch (value)
	{
		case 1:
			glutFullScreen();
			return;

		case 2:
			exit(0);

		case 3:

			return;

	}
}

void glutSpecial(int value, int x, int y)
{
    switch (value)
    {
        case GLUT_KEY_F1:
                glutFullScreen();
                return;
    }
}


void glutDisplay(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    if (wireframe)
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    else
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    glPushMatrix();
		glPushMatrix();
			glRotatef(rot[3],1,1,1);
			glLightfv(GL_LIGHT0, GL_POSITION, pos);
			glEnable(GL_LIGHT0);
		glPopMatrix();
		glTranslatef (-eye[0], -eye[1], -eye[2]);
		glDrawArrays(GL_POLYGON, 0, sizeof(verts));
		glColor3f(1,0,0);
		glutSolidTeapot(1);
		
    glPopMatrix();
	
	
    glFlush();
    glutSwapBuffers();
	rot[3]++;



	
}


void InitializeOGL()
{
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);
	setupPointers();
	
	
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diff);
	glLightfv(GL_LIGHT0, GL_SPECULAR, spec);

	glEnable(GL_LIGHTING);

	printf("INITILIZATION COMPLETED\n");

    return;
}


int main(int argc, char** argv)
{

    glutInitDisplayMode( GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA | GLUT_MULTISAMPLE );
    glutInitWindowPosition( GL_WIN_INITIAL_X, GL_WIN_INITIAL_Y );
    glutInitWindowSize( GL_WIN_WIDTH, GL_WIN_HEIGHT );
    glutInit( &argc, argv );

    glutCreateWindow("glutbasecode");

 
    glutReshapeFunc(glutResize);      
    glutDisplayFunc(glutDisplay);      
    glutIdleFunc(glutDisplay);        
    glutKeyboardFunc(glutKeyboard);  
    glutMouseFunc(glutMouse);       
    glutMotionFunc(glutMotion);       
    glutSpecialFunc(glutSpecial);      


    InitializeOGL();


	glutCreateMenu(glutMenu);
	glutAddMenuEntry("Full Screen", 1);
	glutAddMenuEntry("Exit", 2);
	glutAddMenuEntry("OGL Info",3);
	glutAttachMenu(GLUT_MIDDLE_BUTTON);

	glutMainLoop();

	return 0;
}
#endif