/*
  Simple Demo for GLSL
  www.lighthouse3d.com
  
  tweaked a bit by andy
*/

#include "GL/glew.h"

#ifdef __linux__
#include <GL/glut.h>
#endif

#ifdef __APPLE__
#include <glut.h>
#endif

#ifdef _WIN32
#include "glut.h"
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

// lets try Bob's obj loader
// http://www.evl.uic.edu/rlk/obj/obj.html
#ifdef _WIN32
extern "C"
{
#include "obj.h"
}
#else
#include "obj.h"
#endif

int theModel; 

// which shaders are currently being applied
int mode = 1;

int windowWidth = 320;
int windowHeight = 320;

float mouseWindowX = 0.0;
float mouseWindowY = 0.0;

char envData[800000];


////////////////////////////////////////////////////////////////////////////////

char *textFileRead(char *fn)
{
	FILE *fp;
	char *content = NULL;

	int count=0;

	if (fn != NULL) {
		fp = fopen(fn,"rt");

		if (fp != NULL) {
      
      fseek(fp, 0, SEEK_END);
      count = ftell(fp);
      rewind(fp);

			if (count > 0) {
				content = (char *)malloc(sizeof(char) * (count+1));
				count = fread(content,sizeof(char),count,fp);
				content[count] = '\0';
			}
			fclose(fp);
		}
	}
	
	if (content == NULL)
	   {
	   fprintf(stderr, "ERROR: could not load in file %s\n", fn);
	   exit(1);
	   }
	return content;
}           

////////////////////////////////////////////////////////////////////////////////

GLuint p, ptoon;

float lpos[4] = {1.0, 0.5, 1.0, 0.0};

void changeSize(int w, int h) {

	// Prevent a divide by zero, when window is too short
	if(h == 0)
		h = 1;

	float ratio = 1.0* w / h;

	// Reset the coordinate system before modifying
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	
	// Set the viewport to be the entire window
    glViewport(0, 0, w, h);
    
    windowWidth = w;
    windowHeight = h;

	// Set the correct perspective.
	gluPerspective(45, ratio, 1, 1000);
	glMatrixMode(GL_MODELVIEW);
}

////////////////////////////////////////////////////////////////////////////////

void printShaderLog(GLuint obj)
{
    GLint infoLogLength = 0;
    GLsizei charsWritten  = 0;
    GLchar *infoLog;

    glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infoLogLength);

    if (infoLogLength > 0)
    {
        infoLog = (char *) malloc(infoLogLength);
        glGetShaderInfoLog(obj, infoLogLength, &charsWritten, infoLog);
		printf("%s\n",infoLog);
        free(infoLog);
    }
}

void printProgramLog(GLuint obj)
{
    GLint infoLogLength = 0;
    GLsizei charsWritten  = 0;
    GLchar *infoLog;

    glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &infoLogLength);

    if (infoLogLength > 0)
    {
        infoLog = (char *) malloc(infoLogLength);
        glGetProgramInfoLog(obj, infoLogLength, &charsWritten, infoLog);
		printf("%s\n",infoLog);
        free(infoLog);
    }
}

////////////////////////////////////////////////////////////////////////////////

void setToonParams(GLuint p)
{
	GLint loc1,loc2,loc3,loc4;
	float specIntensity = 0.98;
	float sc[4] = {0.8,0.8,0.8,1.0};
	float threshold[2] = {0.5,0.25};
	float colors[12] = {0.4,0.4,0.8,1.0,
						0.2,0.2,0.4,1.0,
						0.1,0.1,0.1,1.0};
						
	loc1 = glGetUniformLocation(p,"specIntensity");
	glUniform1f(loc1,specIntensity);

	loc2 = glGetUniformLocation(p,"specColor");
    glUniform4fv(loc2,1,sc);
    
	loc3 = glGetUniformLocation(p,"t");
	glUniform1fv(loc3,2,threshold);

	loc4 = glGetUniformLocation(p,"colors");
	glUniform4fv(loc4,3,colors);
}

////////////////////////////////////////////////////////////////////////////////

float rotAmount = 0;

void renderScene(void) {
    GLint texLoc, lightLoc, fluctuationLoc;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glLoadIdentity();
	gluLookAt(0.0,3.0,6.0, 
		      0.0,0.0,-1.0,
			  0.0f,1.0f,0.0f);

	glLightfv(GL_LIGHT0, GL_POSITION, lpos);
	glRotatef(mouseWindowX*120+90,0,1,0);
	glRotatef(mouseWindowY*60,0,0,1);

    if (mode == 1) //environment map
        {
        glUseProgram(p);
            lightLoc = glGetUniformLocation(p, "LightPos");
            glUniform3f(lightLoc, 1.0, 1.0, 4.0);
    
            texLoc = glGetUniformLocation(p, "envMap");
            glUniform1i(texLoc, 0);

            fluctuationLoc = glGetUniformLocation(p, "fluctuation");
            glUniform1f(fluctuationLoc, fabs(sin(rotAmount)));
        }

   if (mode == 2) //toon shader
        {
        glUseProgram(ptoon);
        setToonParams(ptoon);
        }
    
    
    // draw obj file
    glPushMatrix();
    glScalef(4.0, 4.0, 4.0);
    obj_draw_file(theModel);
    glPopMatrix();

    rotAmount+= 0.001;

	glutSwapBuffers();
}

////////////////////////////////////////////////////////////////////////////////

void processNormalKeys(unsigned char key, int x, int y) {

	if (key == 27) 
		exit(0);
		
    if (key == '1')
        mode = 1;
    if (key == '2')
        mode = 2;
}

////////////////////////////////////////////////////////////////////////////////

GLuint setShaders(char * vert, char * frag) {
    GLuint v,f, pro;
	char *vs,*fs;

	v = glCreateShader(GL_VERTEX_SHADER);
	f = glCreateShader(GL_FRAGMENT_SHADER);

	vs = textFileRead(vert);
	fs = textFileRead(frag);

	const char * vv = vs;
	const char * ff = fs;

	glShaderSource(v, 1, &vv,NULL);
	glShaderSource(f, 1, &ff,NULL);

	free(vs);free(fs);

	glCompileShader(v);
	glCompileShader(f);

	printShaderLog(v);
	printShaderLog(f);

	pro = glCreateProgram();
	glAttachShader(pro,v);
	glAttachShader(pro,f);

	glLinkProgram(pro);
	printProgramLog(pro);
	
	return(pro);
}

////////////////////////////////////////////////////////////////////////////////

int setupTexture(char * texData)
{
    static int textureNum = 0;

    glBindTexture(GL_TEXTURE_2D, textureNum);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 512, 512, 0, GL_RGB,
        GL_UNSIGNED_BYTE, (const GLvoid *) texData);

		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	    textureNum++;

	    return(textureNum-1);
}

////////////////////////////////////////////////////////////////////////////////

void doTexStuff(char * dataPath, char * fileName, int width, int height,
		char * TheArray)
    {
    char fullPath[256];
    FILE * imageFile;

    strcpy(fullPath, dataPath);
    strcat(fullPath, fileName);
    imageFile = fopen(fullPath, "r");
	
    if (imageFile == NULL) 
	   fprintf(stderr,"Cannot find texture file in data directory");
    else
        {
        fread(TheArray, sizeof(char), height*width*3, imageFile);
        fclose(imageFile);
        }
    }

////////////////////////////////////////////////////////////////////////////////

void PassiveMouseMotion(int x, int y)
{
    if (x<0)
        mouseWindowX = -1;
    else if (x>windowWidth)
        mouseWindowX = 1;
    else
        mouseWindowX = 2* (x / (float) windowWidth) - 1.0;
           
    if (y<0)
        mouseWindowY = -1;
    else if (y>windowHeight)
        mouseWindowY = 1;
    else
        mouseWindowY = 2* (y / (float) windowHeight) - 1.0;
}

////////////////////////////////////////////////////////////////////////////////

int main(int argc, char **argv) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(windowWidth, windowHeight);
	glutCreateWindow("GLSL demo");

	glutDisplayFunc(renderScene);
	glutIdleFunc(renderScene);
	glutReshapeFunc(changeSize);
	glutKeyboardFunc(processNormalKeys);
	glutPassiveMotionFunc(PassiveMouseMotion);

	glEnable(GL_DEPTH_TEST);
	glClearColor(0.0, 0.0, 0.0, 1.0);


    // load in the obj model
    theModel = obj_add_file("aj2.obj");


    doTexStuff("./", "MarsMap.raw",  512, 512, envData);
    setupTexture(envData);

	glewInit();
	if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
		printf("Ready for GLSL\n");
	else {
		printf("No GLSL support\n");
		exit(1);
	   }

	p = setShaders("./env.vert", "./env.frag");
    ptoon = setShaders("./toon.vert", "./toon3.frag");
	
	glutMainLoop();
	return 0;
}