#include <stdlib.h>
#include <stdio.h>
#include <GL/glut.h>
#include <string.h>
#include <math.h>
#include <windows.h>

#define TEXTURE_SIZE 1024

// Light
GLfloat light_position[] = {10.0f, 10.0f, 10.0f, 1.0f};
GLfloat diffuse_light[] = {0.9f, 0.9, 0.9f, 0.0f};

GLubyte check_image[TEXTURE_SIZE][TEXTURE_SIZE][3];
GLubyte static_image[TEXTURE_SIZE][TEXTURE_SIZE][3];
GLuint check_id, static_id;
GLuint teapot_id;
float degree = 0.0f;

// TIMING_INFO
LARGE_INTEGER time;
LONGLONG freq;
long double lastFrameTime = 0;
long double currentFrameTime;
LONGLONG timer;
double fps;
char fpsString[255];


void init_check_image() {
	int c;
	for (int i = 0; i < TEXTURE_SIZE; i++) {
	   for (int j = 0; j < TEXTURE_SIZE; j++) {
		c = ((((i&0x8)==0)^((j&0x8))==0))*255;
         	check_image[i][j][0] = (GLubyte) c;
         	check_image[i][j][1] = (GLubyte) c;
         	check_image[i][j][2] = (GLubyte) c;
	   }
	}
}

void init_static_image() {
	for (int i = 0; i < TEXTURE_SIZE; i++) {
	   for (int j = 0; j < TEXTURE_SIZE; j++) {
         	static_image[i][j][0] = rand()%255;
         	static_image[i][j][1] = rand()%255;
         	static_image[i][j][2] = rand()%255;
	   }
	}
}

void drawString(char *string)
{
  int len, i;
  len = (int) strlen(string);
  for (i = 0; i < len; i++)
  {
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, string[i]);
  }
}

float counterValue()
{
		LARGE_INTEGER i;
		QueryPerformanceCounter(&i);	
		return (float)((long double)((long double)(i.QuadPart-timer)/(long double)freq));
}

void drawSphere(double resolution) {
	double steps = resolution;
	double c = 3.1415926/180.0;
	double x, y, z;
	// back slice to front slice (starting z deep)
	for (double phi = -90.0; phi<=90.0; phi+=steps) {
		glBegin(GL_QUAD_STRIP);
		// circle around z axis
		for (float theta=0.0; theta<=360.0; theta+=steps) {
			x=sin(c*theta)*cos(c*phi);
			y=cos(c*theta)*cos(c*phi);
			z=sin(c*phi);
			glNormal3d (x, y, z);
			glTexCoord2f(1-theta/360.0, (phi+90)/180);
			glVertex3d(x, y, z);
			x=sin(c*theta)*cos(c*(phi+steps));
			y=cos(c*theta)*cos(c*(phi+steps));
			z=sin(c*(phi+steps));
			glNormal3d(x, y, z);
			glTexCoord2f(1-theta/360.0, (phi+90+steps)/180);
			glVertex3d(x, y, z);
		}
		glEnd();
	}
}

void teapot () {
	teapot_id = glGenLists(1);
	glNewList(teapot_id, GL_COMPILE);
	drawSphere(1);
	glEndList();
}

void doCheckTexture() {
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, check_image);
}

void doStaticTexture() {
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, static_image);
}

void display() {
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glColor3f(1.0f, 0.0f, 0.0f);
	
	// Time mess
	float cv = counterValue();
	fps = 1.000000/(cv - lastFrameTime);
	lastFrameTime = cv;

	glPushMatrix();
		glTranslatef (0, 0, -10);
		glRasterPos2f(0.1,-5);
		sprintf(fpsString, "FPS:%f", fps);
		drawString (fpsString);
		glEnable(GL_TEXTURE_2D);	
		glPushMatrix();
			glRotatef(degree, 0.0, 1.0, 0.0);
			//glBindTexture (GL_TEXTURE_2D, check_id);
			doCheckTexture();
			//glCallList(teapot_id);
			drawSphere(1);
		glPopMatrix();
		
		glPushMatrix();
			glRotatef(degree, 0.0, 1.0, 0.0);
			glTranslatef (0, 0, -5);
			//glBindTexture (GL_TEXTURE_2D, static_id);
			doStaticTexture();
			//glCallList(teapot_id);
			drawSphere(1);
		glPopMatrix();

		glDisable(GL_TEXTURE_2D);
	glPopMatrix();

	glFlush();
	degree+= 1.0f;
	glutSwapBuffers();
	glutPostRedisplay();
}

void camera() {
	// Setup viewing
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity();
	gluPerspective (60.0f, 1.5, 0.1, 1000);
	glMatrixMode (GL_MODELVIEW);
}

void doLights() {
	glEnable (GL_LIGHTING);
	glEnable (GL_LIGHT0);
	glLightfv (GL_LIGHT0, GL_POSITION, light_position);
	glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse_light);
}

void setupTextures() {
	
	init_static_image();
	init_check_image();

	glGenTextures (1, &check_id);
	// Start binding a texture, and store on graphics card
	glBindTexture (GL_TEXTURE_2D, check_id);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, check_image);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	glGenTextures (1, &static_id);
	// Start binding a texture, and store on graphics card
	glBindTexture (GL_TEXTURE_2D, static_id);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGB, GL_UNSIGNED_BYTE, static_image);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}

int main (int argc, char** argv) {
	glutInit(&argc, argv);
	glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
	glutInitWindowSize(1024, 768);
	glutCreateWindow ("Moving Textures and Geometry");
	setupTextures();

	glEnable (GL_DEPTH_TEST);
	
	camera();
	doLights();
	teapot();

	glutDisplayFunc (display);

	// Time stuff
	lastFrameTime = 0.000000;
	fps = 0.000000;
	LARGE_INTEGER i, f;
	QueryPerformanceFrequency( &f );
	freq = f.QuadPart;
	QueryPerformanceCounter(&i);
	timer = i.QuadPart;
	glutMainLoop();
}