/*
 * A viewer for patterns generated by the Reaction-Diffusion simulator for PLY objects.
 *		(rdviewer)
 *
 *		for usage info, run program without any parameters
 *
 */

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include "rply.h"

/* cell activator (colour) level array */
GLfloat *activator;

/* 3d object data arrays */
GLfloat **vertices;
GLfloat **normals;
long **faces;

/* just some vars for extracting data from PLY (could be done better) */
long vertex=0, axis=0, face=0, fvertex=0, home=0, neighb=0;
GLfloat maxv = -100;
GLfloat minv = 100;

/* angles and stuff for rotating and zooming the object */
GLfloat xangle = 0.0;
GLfloat yangle = 0.0;
GLfloat zangle = 0.0;
GLfloat zoom = 1.5;
GLfloat atX = 0.0;
GLfloat atY = 0.0;

/* global for number of vertices and faces */
long nvertices,nfaces;
e_ply_type vertex_t, face_length_t, face_value_t;

/* GLUT window identifier and viewport size (so we see whole object)*/
static int win;
GLfloat view;

/* input PLY filename */
char *filename;
char plyfilename[15];


/*
 *
 * Display usage info
 *
 */
void printUsage()
{
	printf("Results Viewer for Reaction-Diffusion Simulator\n\nusage:\trdviewer <patternfile>\n\n");
	printf("\t<patternfile>\t- File exported from R-D simulators\n\n");
	printf("\tControls:\n\t\tRotate on X axis: 'a' and 'd'\n\t\tRotate on Y axis: 's' and 'w'\n\t\tRotate on Z axis: 'z' and 'c'\n\t\tZoom in and out: '+', '-'\n\t\tMove object: Left, Right, Up and Down arrows\n\t\tReset view: 'r'\n\t\tQuit: 'q'\n\n");
}


/*
 *
 * GLUT routines, callbacks and whatnot
 *
 */
void update(void)
/*
 * update(): GLUT callback function. called every refresh. Need to call for a redisplay.
 */
{	
	glutPostRedisplay();
}

void face3(long face)
/*
 * face3(face): Render the triangular polygon indexed to in the faces array by
 * input parameter face. Colour is set according to activator[] value for the face.
 * The glMaterial and glNormal calls are required for lighting.
 */
{
	GLfloat colour[] = {activator[face], activator[face], activator[face]}; // for cheetah colours: {activator[face]/1.4, activator[face]/2.0, 0}; 
	GLfloat material[] = {activator[face], activator[face], activator[face], 1.0}; // {activator[face]/1.4, activator[face]/2.0, 0, 1.0};
	glColor3fv(colour);
	glMaterialfv(GL_FRONT, GL_SPECULAR, material);
	glMaterialfv(GL_FRONT, GL_AMBIENT, material);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, material);
	glBegin(GL_POLYGON);
		glNormal3fv(normals[faces[face][0]]);
		glVertex3fv(vertices[faces[face][0]]);
		glNormal3fv(normals[faces[face][1]]);
		glVertex3fv(vertices[faces[face][1]]);
		glNormal3fv(normals[faces[face][2]]);
		glVertex3fv(vertices[faces[face][2]]);
	glEnd();
}

void display(void)
/*
 * display(): GLUT display callback, it sets up the view, and rotation of the scene,
 * then it renders all the polygons, and swaps buffers (we're using double-buffering).
 */
{
	long i;
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	/* Set up the modelview transformation. */
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	//gluLookAt(6.0, 4.0, 14.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
	gluLookAt(0, 0, zoom * view, atX, atY, 0.0, 0.0, 1.0, 0.0);
	glRotatef(xangle, 1.0, 0.0, 0.0);
	glRotatef(yangle, 0.0, 1.0, 0.0);
	glRotatef(zangle, 0.0, 0.0, 1.0);
	
	for (i=0;i<nfaces;i++)
		face3(i);
	
	glutSwapBuffers();
}

void reshape(int w, int h)
/*
 * reshape(w, h): this is needed for when the window is resized, it keeps the
 * shape and perspective of the viewport correct.
 */
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(40.0, (GLdouble)w/(GLdouble)h, 0.01, 2000.0);
	glViewport(0, 0, (GLsizei)w, (GLsizei)h);
}

void keyb(unsigned char key, int x, int y)
/*
 * keyb(key, x, y): GLUT keyboard callback, we use it to rotate the scene, zoom in
 * and out, perform other user functions, and finally to free all the malloced memory.
 */
{
	long i;
	
	switch(key) {
		case 'a':
			yangle -= 10;
			break;
		case 'd':
			yangle += 10;
			break;
		case 'w':
			xangle -= 10;
			break;
		case 's':
			xangle += 10;
			break;
		case 'c':
			zangle -= 10;
			break;
		case 'z':
			zangle += 10;
			break;
		case '+':
		case '=':
			zoom -= 0.2;
			break;
		case '-':
			zoom += 0.2;
			break;
		case 'r':
			xangle = yangle = zangle = atX = atY = 0.0;
			zoom = 1.5;
			break;
		case 'q':
		case 'Q':	
			printf("Freeing memory\n");
			for(i=0;i<nvertices;i++) {
				free(vertices[i]);
				free(normals[i]);
			}
			free(vertices);
			free(normals);
			for(i=0;i<nfaces;i++)
				free(faces[i]);
			free(faces);
			
			free(activator);
			
			printf("All done.\n");
			glutDestroyWindow(win);
			exit(0);
	}
}

void special(int key, int x, int y)
/*
 * special(key, x, y): GLUT special keyboard callback, used for arrow keys to move scene.
 */
{
	switch(key) {
		case GLUT_KEY_RIGHT:
			atX=atX-0.02*view;
			break;
		case GLUT_KEY_LEFT:
			atX=atX+0.02*view;
			break;
		case GLUT_KEY_UP:
			atY=atY-0.02*view;
			break;
		case GLUT_KEY_DOWN:
			atY=atY+0.02*view;
			break;
		default:
			return;
	}
}

	
/*
 *
 * All the PLY model handling routines
 *
 */
static int vertex_cb(p_ply_argument argument)
/*
 * vertex_cb(argument): RPly vertex callback. This is called everytime RPly encounters
 * a vertex as it parses the PLY file. We store the vertex coordinates and (rather crudely)
 * find the max and min coordinates, for use in setting the viewport correctly.
 */
{
	long eol;
	p_ply_property property;
	
	ply_get_argument_user_data(argument, NULL, &eol);
	ply_get_argument_property(argument, &property, NULL, NULL);
	ply_get_property_info(property, NULL, &vertex_t, NULL, NULL);
	
	vertices[vertex][axis] = (GLfloat)ply_get_argument_value(argument);

	if (vertices[vertex][axis] > maxv) maxv = vertices[vertex][axis];
	if (vertices[vertex][axis] < minv) minv = vertices[vertex][axis];
	
	axis++;
	if (eol) {
		vertex++;
		axis=0;
	}
	return 1;
}

static int normal_cb(p_ply_argument argument)
/*
 * normal_cb(argument): RPly normal callback. Store the normal for each vertex.
 */
{
	long eol;
	
	ply_get_argument_user_data(argument, NULL, &eol);
	normals[vertex-1][axis] = (GLfloat)ply_get_argument_value(argument);
	
	axis++;
	if (eol) {
		//vertex++;
		axis=0;
	}
	return 1;
}

static int face_cb(p_ply_argument argument)
/*
 * face_cb(argument): RPly face callback. Store vertex indices for each face.
 */
{
	long length, value_index;
	p_ply_property property;
	
	ply_get_argument_property(argument, &property, &length, &value_index);
	ply_get_property_info(property, NULL, NULL, &face_length_t, &face_value_t);
  
  switch (value_index) {
		case 0:
		case 1: 
			faces[face][fvertex++] = (long)ply_get_argument_value(argument);
			break;
		case 2:
			faces[face][fvertex++] = (long)ply_get_argument_value(argument);
			face++;
			fvertex=0;
			break;
		default: 
			break;
	}
	return 1;
}


/*
 *
 * Lots of initialisation stuff. Loading the object, etc.
 *
 */
void init(void)
{
	long i,j;
	FILE *fp;
	p_ply ply;
	GLfloat mat_specular[] = { 0.8, 0.8, 0.8, 1.0 };
	GLfloat mat_shininess[] = { 10.0 };
	GLfloat light_ambient[] = {0.1, 0.1, 0.1, 0.5};
  GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
	float concA, concI;
	 
	/* some GL initialisation */
	glClearColor(0.0, 0.0, 0.5, 1.0);
	glEnable(GL_DEPTH_TEST);
	
	/* load PLY file */
	ply = ply_open(plyfilename, NULL);
	if ((!ply) || (!ply_read_header(ply))) {
		printf("Error opening PLY file or reading header.\n");
   	exit;
	}
  
	/* set callbacks for PLY reading and get number of vertices and faces */
  nvertices = ply_set_read_cb(ply, "vertex", "x", vertex_cb, NULL, 0);
  ply_set_read_cb(ply, "vertex", "y", vertex_cb, NULL, 0);
  ply_set_read_cb(ply, "vertex", "z", vertex_cb, NULL, 1);
	ply_set_read_cb(ply, "vertex", "xnorm", normal_cb, NULL, 0);
	ply_set_read_cb(ply, "vertex", "ynorm", normal_cb, NULL, 0);
	ply_set_read_cb(ply, "vertex", "znorm", normal_cb, NULL, 1);
  nfaces = ply_set_read_cb(ply, "face", "vertex_indices", face_cb, NULL, 0);
  if (nfaces == 0) nfaces = ply_set_read_cb(ply, "face", "vertex_index", face_cb, NULL, 0);
	printf("Vertices: %ld\nFaces: %ld\n", nvertices, nfaces);
   
  /* mallocate memory for arrays */
  /* 3d structure data */
  vertices = malloc(nvertices * sizeof(GLfloat *));
	normals = malloc(nvertices * sizeof(GLfloat *));
  for(i=0;i<nvertices;i++) {
  	vertices[i] = malloc(3 * sizeof(GLfloat));
		normals[i] = malloc(3 * sizeof(GLfloat));
	}
  faces = malloc(nfaces * sizeof(long *));
  for(i=0;i<nfaces;i++)
		faces[i] = malloc(3 * sizeof(long));
   
  /* r-d arrays */
  activator = malloc(nfaces * sizeof(GLfloat));
  
  printf("Done mallocating memory.\n");
  
	/* a little bit of error checking */
  if (!ply_read(ply)) printf("Error extracting vertices.\n");
  ply_close(ply);
	
	/* open up pattern file and load conc. data into memory */
	fp = fopen(filename,"r");
	fscanf(fp, "%s\n", plyfilename);
	for (i=0;i<nfaces;i++) {
		fscanf(fp, "%f\n", &concA);
		activator[i] = (GLfloat)concA;
		//printf("%.3f\n", cA[i]);
	}
	fclose(fp);
  
  /* making sure we get everything in view (very basic may need to be improved) */
  view = maxv - minv; 
  //printf("max: %.2f %.2f\nView: %.2f\n",maxv,minv,view);
	
	/* setup for lighting */
	glShadeModel (GL_SMOOTH);
	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
	light_position[0] = light_position[1] = light_position[2] = -view;
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
	
	printf("Initialisation done.\n");
	printf("Controls:\n\tRotate on X axis: 'a' and 'd'\n\tRotate on Y axis: 's' and 'w'\n\tRotate on Z axis: 'z' and 'c'\n\tZoom in and out: '+', '-'\n\tMove object: Left, Right, Up and Down arrows\n\tReset view: 'r'\n\tQuit: 'q'\n");
}


int main(int argc, char** argv)
{
	FILE *fp;
	
	/* print out usage information */
	if ((argc == 1) || (argv[1][0] == '-')) {
		printUsage();
		return 0;
	}
	
	/* get pattern file filename from command-line */
	filename = argv[1];
	printf("%s\n",filename);
	
	/* open our pattern file and retrieve plyfilename */
	if (fp = fopen(filename,"r")) {
		fscanf(fp,"%s\n",plyfilename);
		fclose(fp);
		printf("plyfilename: %s\n",plyfilename);
	} else {
		printf("Error!!!. Cannot open %s\n", filename);
		exit(0);
	}
	
	/* intialise GLUT and register callbacks, then enter main loop */
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
	glutInitWindowSize(250,250);
	glutInitWindowPosition(300,200);
	win = glutCreateWindow("R-D Viewer");
	init();
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutIdleFunc(update);
	glutKeyboardFunc(keyb);
	glutSpecialFunc(special);
	glutMainLoop();
	
	return 0;
}