// occquery.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

extern "C"
{
	#include "MathStuff.h"
	#include "DataTypes.h"
}

#include "glInterface.h"
#include "RenderTraverser.h"
#include <math.h>
#include <time.h>

double nearDist = 0.1; // eye near plane distance
int winWidth, winHeight;
int objectType = Geometry::TEAPOT;
int nextObjectType = objectType;

float visZoomFactor = 1.5f;

bool showHelp = false;
bool showStatistics = true;
bool showBoundingVolumes = false;
bool visMode = false;
bool showCreateParams = false;

// traverses and renders the hierarchy
RenderTraverser traverser;

Vector3 eyePos = {0.0, 0.0, 3.0};  // eye position 
Vector3 viewDir = {0.0, 0.0, -1.0};  // eye view dir 
Vector3 lightDir = {0.0, 0.0, 1.0};  // light dir 

Matrix4x4 eyeView; // eye view matrix
Matrix4x4 eyeProjection; // eye projection matrix
Matrix4x4 eyeProjView; //= eyeProjection*eyeView
Matrix4x4 invEyeProjView; //= eyeProjView^(-1)
Matrix4x4 visView; // visualisation view matrix

//mouse navigation state
int xEyeBegin, yEyeBegin, yMotionBegin, verticalMotionBegin, horizontalMotionBegin = 0;
int renderMode = RenderTraverser::RENDER_COHERENT;

// relative size of an object
float objectSize = 3.5f;

int numObjects = 2000;
int numNextObjects = numObjects;
float zLength = 30.0f;

// this defines the volume where objects can be drawn
Vector3 minTranslation = {-2.5f, -2.5f, -3.0f};
Vector3 maxTranslation = {2.5f, 2.5f, -3.0 - zLength};

const float minAngle = 0;
const float maxAngle = 360;

const int renderTimeSize = 100;
long renderTimes[renderTimeSize];
int renderTimesIdx = 0;
int renderTimesValid = 0;

typedef vector<Geometry *> GeometryList;
GeometryList geometry;

bool useOptimization = true;

Vector3 amb[2];
Vector3 dif[2];
Vector3 spec[2];

void begin2D(void);
void end2D(void);
void output(const int x, const int y, const char *string);
void initGLstate(void);
void keyboard(const unsigned char c, const int x, const int y);
void drawHelpMessage(void);
void drawStatistics(void);
void display(void);
void special(const int c, const int x, const int y);
void reshape(const int w, const int h);
void mouse(int button, int state, int x, int y);
void initExtensions(void);
void leftMotion(int x, int y);
//void rightMotion(int x, int y);
void middleMotion(int x, int y);
void drawEyeView(void);
void setupEyeView(void);
void setupVisView(void);
void updateEyeMtx(void);
long calcRenderTime(void);
void resetTimer(void);
void cleanUp(void);
void calcDecimalPoint(string &str, int d);

HierarchyNode* generateHierarchy(int numObjects);
Geometry *generateGeometry(Vector3 translateRatio, float xRotRatio, 
						   float yRotRatio, float zRotRatio, int materialIdx);
void displayVisualization();

void deleteGeometry();


int _tmain(int argc, _TCHAR* argv[])
{
	glutInitWindowSize(800,600);
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
	
	glutCreateWindow("Coherent Hierarchical Culling");

	glutDisplayFunc(display);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(special);
	glutReshapeFunc(reshape);
	glutMouseFunc(mouse);
	glutIdleFunc(display);
	initExtensions();
	initGLstate();

	leftMotion(0,0);
	middleMotion(0,0);
	
	HierarchyNode *hierarchy = generateHierarchy(numObjects);
	traverser.SetHierarchy(hierarchy);

	/// initialise rendertime array
	for(int i=0; i<renderTimeSize; i++)
		renderTimes[i] = 0;

	glutMainLoop();

	// clean up
	cleanUp();
	
	return 0;
}


void initGLstate(void) 
{
	glClearColor(0.6, 0.6, 0.8, 1.0);
	
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glPixelStorei(GL_PACK_ALIGNMENT,1); 
	
	glDepthRange(0.0, 1.0);
	glClearDepth(1.0);
	glDepthFunc(GL_LESS);

	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

	glShadeModel(GL_SMOOTH);
	
	GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 };
	GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
	GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 };
	GLfloat position[] = { 0.0, 3.0, 3.0, 0.0 };
    
	GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
	GLfloat local_view[] = { 0.0 };

	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
	glLightfv(GL_LIGHT0, GL_POSITION, position);
	
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
	glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

	glMaterialf(GL_FRONT, GL_SHININESS, 64);
	glEnable(GL_NORMALIZE);
			
	glFrontFace(GL_CCW);
	glCullFace(GL_BACK);
	glEnable(GL_CULL_FACE);
	
	glClearColor(0.2, 0.2, 0.8, 0.0);

	setupVisView();
}


void drawHelpMessage(void) 
{
	const char *message[] = 
	{
		"Help information",
		"",
		"'F1'           - shows/dismisses this message",
		"'F2'           - decreases number of objects (valid after scene recreation)",
		"'F3'           - increases number of objects (valid after scene recreation)",
		"'F4'           - decreases box length in z direction (valid after scene recreation)",
		"'F5'           - increases box length in z direction (valid after scene recreation)",
		"'F6'           - decreases object size (valid after scene recreation)",
		"'F7'           - increases object size (valid after scene recreation)",
		"'F8'           - cycles through object types (teapot, ...) (valid after scene recreation)",
		"",
		"'MOUSE-LEFT'   - turn left/right, move forward/backward",
		"'MOUSE-RIGHT'  - turn left/right, move forward/backward",
		"'MOUSE-MIDDLE' - move up/down, left/right",
		"'CURSOR UP'    - move forward",
		"'CURSOR BACK'  - move backward",
		"'CURSOR RIGHT' - turn right",
		"'CURSOR LEFT'  - turn left",
		"",
		"'SPACE'        - cycles through occlusion culling algorithms",
		"'-'            - decreases visibility threshold",
		"'+'            - increases visibility threshold",
		"'C'            - recreates the scene hierarchy",
		"'G'            - enables/disables optimization to take geometry as occluder",
		"",
		"'R'            - shows/hides recreation parameters",
		"'S'            - shows/hides statistics",
		"'V'            - shows/hides bounding volumes",
		"",
		"'1'            - shows/hides visualization",
		"'2'            - zooms out visualization",
		"'3'            - zooms in visualization",
		0,
	};
	
	int i;
	int x = 40, y = 42;
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	glColor4f(0.0,1.0,0.0,0.2);  // 20% green. 

	// Drawn clockwise because the flipped Y axis flips CCW and CW. 
	glRecti(winWidth - 30, 30, 30, winHeight - 30);
	
	glDisable(GL_BLEND);
	

	glColor3f(1.0,1.0,1.0);
	for(i = 0; message[i] != 0; i++) {
		if(message[i][0] == '\0') {
			y += 7;
		} else {
			output(x,y,message[i]);
			y += 14;
		}
	}

}

// generates a teapot, all parameters between zero and one
Geometry *generateGeometry(Vector3 translationRatio, float xRotRatio, 
						   float yRotRatio, float zRotRatio, int materialIdx)
{
	float xRot = minAngle + xRotRatio * (maxAngle - minAngle);
	float yRot = minAngle + yRotRatio * (maxAngle - minAngle);
	float zRot = minAngle + zRotRatio * (maxAngle - minAngle);

	Vector3 translation;
	translation[0] = minTranslation[0] + translationRatio[0] * (maxTranslation[0] - minTranslation[0]);
	translation[1] = minTranslation[1] + translationRatio[1] * (maxTranslation[1] - minTranslation[1]);
	translation[2] = minTranslation[2] + translationRatio[2] * (maxTranslation[2] - minTranslation[2]);

	Geometry *result = new Geometry(translation, xRot, yRot, zRot, objectSize, objectType);

	result->SetAmbientColor(amb[materialIdx][0], amb[materialIdx][1], amb[materialIdx][2]);
	result->SetDiffuseColor(dif[materialIdx][0], dif[materialIdx][1], dif[materialIdx][2]);
	result->SetSpecularColor(spec[materialIdx][0], spec[materialIdx][1], spec[materialIdx][2]);

	return result;
}

// generates a the scene hierarchy with random values
HierarchyNode* generateHierarchy(int numObjects)
{
    HierarchyNode *hierarchy = new HierarchyNode();

	// initialise materials
	copyVector3Values(amb[0], 0.0215, 0.1745, 0.0215);
	copyVector3Values(dif[0], 0.727811, 0.633, 0.6);
	copyVector3Values(spec[0], 0.633, 0.727811, 0.633);

	copyVector3Values(amb[1], 0.1745, 0.01175, 0.01175);
	copyVector3Values(dif[1], 0.61424, 0.04136, 0.04136);
	copyVector3Values(spec[1], 0.727811, 0.626959, 0.626959);

	srand (time (0));
	
	printf("generating geometry with random position and orientation ... ");

	for(int i=0; i < numObjects; i++)
	{
		float xRotRatio = rand() / (float) RAND_MAX;
		float yRotRatio = rand() / (float) RAND_MAX;
		float zRotRatio = rand() / (float) RAND_MAX;

		Vector3 translationRatio = {rand() / (float) RAND_MAX, 
									rand() / (float) RAND_MAX, 
									rand() / (float) RAND_MAX};

		int materialIdx = int(2 * rand() / (float) RAND_MAX);
			
		Geometry *geo = generateGeometry(translationRatio, xRotRatio, 
									     yRotRatio, zRotRatio, materialIdx);
		hierarchy->AddGeometry(geo);

		// put into global geometry list for later deletion
		geometry.push_back(geo);
	}

	printf("finished\n");
	printf("generating new kd-tree hierarchy ... ");
	HierarchyNode::InitKdTree(hierarchy);
	hierarchy->GenerateKdTree();
	printf("finished\n");

	return hierarchy;
}


void updateEyeMtx(void) 
{
	const Vector3 up = {0.0, 1.0, 0.0};

	look(eyeView, eyePos, viewDir, up);
	mult(eyeProjView, eyeProjection, eyeView); //eyeProjView = eyeProjection*eyeView
	invert(invEyeProjView, eyeProjView); //invert matrix
}


void setupEyeView(void)
{
	glMatrixMode(GL_PROJECTION);
	glLoadMatrixd(eyeProjection);

	glMatrixMode(GL_MODELVIEW);
	glLoadMatrixd(eyeView);
}


void display(void) 
{
	char * msg[] = {"Frustum culling only", "Hierarchical stop and wait",
				    "Coherent hierarchical culling"};

	char msg2[200];
	char msg3[200];
	char msg4[100];
	char msg5[100];
	char msg6[100];
	char msg7[100];
	char msg8[100];

	sprintf(msg2, "Traversed: %4d, frustum culled: %4d, query culled: %4d (of %d nodes)",
			traverser.GetNumTraversedNodes(), traverser.GetNumFrustumCulledNodes(),
			traverser.GetNumQueryCulledNodes(), 
			traverser.GetHierarchy()->GetNumHierarchyNodes());
	
	char *optstr[2] = {"", ", using optimization"};
	
	float fps = 1000.0;
	long renderTime = calcRenderTime();
	if(renderTime) fps = 1000000.0f / (float)calcRenderTime();

	sprintf(msg3, "Threshold: %4d, algorithm rendering time: %ld ms (%3.3f fps)%s", 
			traverser.GetVisibilityThreshold(), renderTime / 1000, fps, optstr[useOptimization]);

	string str;
	string str2;

	calcDecimalPoint(str, Geometry::CountTriangles(objectType) * traverser.GetNumRenderedGeometry());
	calcDecimalPoint(str2, Geometry::CountTriangles(objectType) * numObjects);

	sprintf(msg4, "Rendered objects %d (of %d), rendered triangles: %s (of %s)", 
			traverser.GetNumRenderedGeometry(), numObjects, str.c_str(), str2.c_str()); 

	sprintf(msg5, "Next object num: %d", numNextObjects);
	sprintf(msg6, "Next length in z dir: %3.3f", zLength);
	
	char *objectTypeStr[3] = {"teapot", "torus", "sphere"};

	sprintf(msg7, "Next object type: %s", objectTypeStr[nextObjectType]);
	sprintf(msg8, "Next object size: %3.3f", objectSize);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	updateEyeMtx(); // bring eye modelview matrix up-to-date
	setupEyeView();

	traverser.SetViewpoint(eyePos);
	traverser.SetProjViewMatrix(eyeProjView);
	traverser.Render(renderMode);

	// cycle through rendertime array
	renderTimes[renderTimesIdx] = traverser.GetRenderTime();
	renderTimesIdx = (renderTimesIdx + 1) % renderTimeSize;

	if(renderTimesIdx  > renderTimesValid) 
		renderTimesValid = renderTimesIdx;

	if(visMode)
	{
		displayVisualization();
	}
	
	begin2D();
	if(showHelp)
		drawHelpMessage();
	else
	{
		glColor3f(1.0,1.0,1.0);
		output(10,winHeight-10, msg[renderMode]);

		if(showStatistics)
		{
			if(showCreateParams)
			{
				output(10, winHeight-150, msg8);
				output(10, winHeight-130, msg7);
				output(10, winHeight-110, msg6);
				output(10, winHeight-90,  msg5);
			}
			output(10, winHeight-70, msg3);
			output(10, winHeight-50, msg4);
			output(10, winHeight-30, msg2);
		}
	}
	end2D();

	glutSwapBuffers();
}


#pragma warning( disable : 4100 )
void keyboard(const unsigned char c, const int x, const int y) 
{
	int threshold;
	HierarchyNode *hierarchy;

	switch(c) 
	{
	case 27:
		exit(0);
		break;
	case 32: //space
		renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES;
		
		resetTimer();
		traverser.Render(renderMode);		// render once so stats are updated
		break;
	case 'h':
	case 'H':
		showHelp = !showHelp;
		break;
	case 'v':
	case 'V':
		showBoundingVolumes = !showBoundingVolumes;
		HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes);
		break;
	case 's':
	case 'S':
		showStatistics = !showStatistics;
		break;
	case '+':
		threshold = traverser.GetVisibilityThreshold() + 10;
		traverser.SetVisibilityThreshold(threshold);
		break;
	case '-':
		threshold = traverser.GetVisibilityThreshold() - 10;
		if(threshold < 0) threshold = 0;

		traverser.SetVisibilityThreshold(threshold);		
		break;
	case '1':
		visMode = !visMode;
		break;
	
	case '2':
		visZoomFactor += 0.1;	
		setupVisView();
		break;
	case '3':
		visZoomFactor -= 0.1;
		if(visZoomFactor < 0.1) visZoomFactor = 0.1;
	
		setupVisView();
		break;
	case 'r':
	case 'R':
		showCreateParams = !showCreateParams;
		break;
	case 'g':
	case 'G':
		useOptimization = !useOptimization;
		traverser.SetUseOptimization(useOptimization);
		break;
	case 'c':
	case 'C':	
		
		hierarchy = traverser.GetHierarchy();
		// delete old hierarchy
		if(hierarchy) delete hierarchy; 
		deleteGeometry();

		maxTranslation[2] = -3.0 - zLength;
		numObjects = numNextObjects;
		objectType = nextObjectType;
		
		hierarchy = generateHierarchy(numObjects);
		traverser.SetHierarchy(hierarchy);

		showCreateParams = false;

		traverser.Render(renderMode); // render once to update stats
		resetTimer();
		break;

	default:
		return;
	}

	glutPostRedisplay();
}


void special(const int c, const int x, const int y) 
{
	// used to avoid vertical motion with the keys
	Vector3 hvec = {viewDir[0], 0, viewDir[2]};
	
	switch(c) 
	{
	case GLUT_KEY_F1:
		showHelp = !showHelp;
		break;
	case GLUT_KEY_F2:
		numNextObjects -= 100;
		if(numNextObjects < 100) numNextObjects = 100;
		break;
	case GLUT_KEY_F3:
        numNextObjects += 100;
		break;
	case GLUT_KEY_F4:
		zLength -= 1;
		if(zLength < 0) zLength = 0;
		break;
	case GLUT_KEY_F5:
		zLength += 1;
		break;		
	case GLUT_KEY_F6:
		objectSize -= 0.1;
		if(objectSize < 0.1) objectSize = 0.1;
		break;
	case GLUT_KEY_F7:
		objectSize += 0.1;
		break;
	case GLUT_KEY_F8:
		nextObjectType = (nextObjectType + 1) % Geometry::NUM_OBJECTS;
		break;
	case GLUT_KEY_LEFT:
		rotateVectorY(viewDir, 0.2);
		break;
	case GLUT_KEY_RIGHT:
		rotateVectorY(viewDir, -0.2);
		break;
	case GLUT_KEY_UP:
		linCombVector3(eyePos, eyePos, hvec, 0.6);
		break;
	case GLUT_KEY_DOWN:
		linCombVector3(eyePos, eyePos, hvec, -0.6);
		break;
	default:
		return;

	}

	glutPostRedisplay();
}
#pragma warning( default : 4100 )


void reshape(const int w, const int h) 
{
	double winAspectRatio = 1.0;

	glViewport(0, 0, w, h);
	
	winWidth = w;
	winHeight = h;

	if(w) winAspectRatio = (double) h / (double) w;

	perspectiveDeg(eyeProjection, 60.0, 1.0/winAspectRatio, nearDist, 150.0);

	glutPostRedisplay();
}


void mouse(int button, int state, int x, int y) 
{
	if(((button == GLUT_LEFT_BUTTON) || (button == GLUT_RIGHT_BUTTON)) && state == GLUT_DOWN) 
	{
		xEyeBegin = x;
		yMotionBegin = y;

		glutMotionFunc(leftMotion);
	}
	else if(button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
	{
		horizontalMotionBegin = x;
		verticalMotionBegin = y;
		glutMotionFunc(middleMotion);
	}

	glutPostRedisplay();
}

/**
	rotation for left/right mouse drag
	motion for up/down mouse drag
*/
void leftMotion(int x, int y) 
{
	static double eyeXAngle = 0.0;
	// not move in the vertical direction
	Vector3 horView = {viewDir[0], 0, viewDir[2]};
	
	eyeXAngle = 0.6 *  PI * (xEyeBegin - x) / 180.0;
	linCombVector3(eyePos, eyePos, horView, (yMotionBegin - y) * 0.1);
	
	rotateVectorY(viewDir, eyeXAngle);
	
	xEyeBegin = x;
	yMotionBegin = y;

	glutPostRedisplay();
}

// strafe
void middleMotion(int x, int y) 
{
	// the 90 degree rotated view vector 
	// y zero so we don't move in the vertical
	Vector3 rVec = {viewDir[0], 0, viewDir[2]};
	
	rotateVectorY(rVec, PI / 2.0);
	linCombVector3(eyePos, eyePos, rVec, (horizontalMotionBegin - x) * 0.1);
	
	eyePos[1] += (verticalMotionBegin - y) * 0.1;

	horizontalMotionBegin = x;
	verticalMotionBegin = y;

	glutPostRedisplay();
}


void initExtensions(void) 
{
	GLenum err = glewInit();
	if(GLEW_OK != err) {
		// problem: glewInit failed, something is seriously wrong
		fprintf(stderr,"Error: %s\n",glewGetErrorString(err));
		exit(1);
	}

	if(!GLEW_ARB_occlusion_query) {
		printf("I require the GL_ARB_occlusion_query OpenGL extension to work.\n");
		exit(1);
	}
}


void begin2D(void) 
{
	glDisable(GL_LIGHTING);
	glDisable(GL_DEPTH_TEST);

	glPushMatrix();
	glLoadIdentity();

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	gluOrtho2D(0, winWidth, winHeight, 0);
}


void end2D(void) 
{
	glPopMatrix();
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

	glEnable(GL_LIGHTING);
	glEnable(GL_DEPTH_TEST);
}


void output(const int x, const int y, const char *string) 
{
	if(string != 0) 
	{
		int len, i;
		glRasterPos2f(x,y);
		len = (int) strlen(string);
		
		for (i = 0; i < len; i++) 
		{
			glutBitmapCharacter(GLUT_BITMAP_8_BY_13,string[i]);
		}
	}
}

// explicitly deletes geometry generated for hierarchy 
// (deleting the hierarchy does not delete the geometry)
void deleteGeometry()
{
	for (GeometryList::iterator it = geometry.begin(); it != geometry.end(); it++)
		if(*it)	delete (*it);
	
	geometry.clear();
}

// displays the visualisation of the kd tree node culling
void displayVisualization()
{
	begin2D();
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	glColor4f(0.0,0.0,0.0,0.5); 

	glRecti(winWidth, 0, winWidth / 2, winHeight / 2);
	glDisable(GL_BLEND);
	end2D();

	glViewport(winWidth / 2, winHeight / 2, winWidth, winHeight);
	glPushMatrix();
	glLoadMatrixd(visView);
	
	glClear(GL_DEPTH_BUFFER_BIT);

	// --- visualization of the occlusion culling
	HierarchyNode::SetRenderBoundingVolume(true);
	traverser.RenderVisualization();
	HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes);

	glPopMatrix();
	glViewport(0, 0, winWidth, winHeight);
}

/**
	sets up view matrix in order to get a good position 
	for viewing the kd tree node culling
*/
void setupVisView()
{
	const Vector3 up = {0.0, 1.0, 0.0};
	
	Vector3 visPos = {24, 23, -6};
	
	visPos[0] *= visZoomFactor; 
	visPos[1] *= visZoomFactor; 
	visPos[2] *= visZoomFactor;

	Vector3 visDir = {-1.3,-1,-1};
	
	normalize(visDir);
	look(visView, visPos, visDir, up);
}

// we take a couple of measurements and compute the average
long calcRenderTime()
{
	long result = 0;

	for(int i=0; i<renderTimesValid; i++)
		result += renderTimes[i];
    
	if(renderTimesValid)
		result /= renderTimesValid;

	return result;
}


// reset the timer array for a new traversal method
void resetTimer()
{
	renderTimesValid = 0;
	renderTimesIdx = 0;
}

// cleanup routine after the main loop
void cleanUp()
{
	if(traverser.GetHierarchy()) 
		delete traverser.GetHierarchy();

	deleteGeometry();

	Geometry::CleanUp();
}

// this function inserts a dezimal point after each 1000
void calcDecimalPoint(string &str, int d)
{
	vector<int> numbers;
	char hstr[100];

	while(d != 0)
	{
		numbers.push_back(d % 1000);
		d /= 1000;
	}

	// first element without leading zeros
	if(numbers.size() > 0)
	{
		sprintf(hstr, "%d", numbers.back());
		str.append(hstr);
	}
	
	for(int i=numbers.size()-2; i >= 0; i--)
	{
		sprintf(hstr, ",%03d", numbers[i]);
		str.append(hstr);
	}
}