/*********************************************************************
*                                                                    *          
*                              FLY                                   *
*                           --E#Y#E--				     *
*                         ===MUSCLE===                               *
*                                                                    *
*********************************************************************/
/* Header Files */
#include "uniform.h"

GLuint location;

/*GLuint normalPosition;*/
/*GLuint colorPosition;*/
/*GLuint vertexPosition;*/
/*GLuint fudgeLocation;*/
/*GLuint projectionMatrix;*/
/*GLuint modelViewMatrix;*/

struct shader
{
        unsigned int id;
	FILE *sourceFile;
	const GLchar* filename;
	GLchar* source;
	
}vertShader, fragShader;

unsigned int shaderProgram;

/*------------------------------------------------------------------------*/

/* Program Size */
size_t ProgramSize(const GLchar* ShaderFile)
{
        int programFile;
        size_t size = -1;
        
        /* File Open */		
	programFile = open(ShaderFile, O_RDONLY);
	if(!programFile)
	{
	      printf(" COULD NOT LOAD SHADER! \n");
	      return -1;
	}
        
        /* Data Byte */
        size = lseek(programFile, 0, SEEK_END);
        /*printf(" GLSL DATA BYTE: %ld \n", size);*/
        
        /* File Read */ 
        char ShaderBuffer[size];
        read(programFile, ShaderBuffer, size);
        if(!programFile)
        {
              printf(" ERROR BY READ! \n");
              return -1;
        }
        
        /* File Close */
        close(programFile);
        
        return size;
}

/*------------------------------------------------------------------------*/

/* Create Shader */
void createShader(const GLchar* vert, const GLchar* frag)
{	
        size_t size1;
        size_t size2;

        /* Shader Filename */
        vertShader.filename = vert;
        fragShader.filename = frag;
        /* File Open */
        vertShader.sourceFile = fopen(vertShader.filename, "rb");
        fragShader.sourceFile = fopen(fragShader.filename, "rb");
	
	/* Version 1 / STABLE */
	size1 = ProgramSize(vertShader.filename);
	size2 = ProgramSize(fragShader.filename);
	/* Malloc */
	vertShader.source = (GLcharARB *)malloc(size1*sizeof(GLcharARB)); 
	fragShader.source = (GLcharARB *)malloc(size2*sizeof(GLcharARB)); 
	/* Read File */
	vertShader.id = fread(vertShader.source, size1, 1, vertShader.sourceFile);
	fragShader.id = fread(fragShader.source, size2, 1, fragShader.sourceFile);
	/* File Close */
	fclose(vertShader.sourceFile);
	fclose(fragShader.sourceFile);
	
	/* Create Shader */
	#if SHADER_LOG
	vertShader.id = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	fragShader.id = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	#else
	vertShader.id = glCreateShaderObjectARB(GL_ARB_vertex_shader);
	fragShader.id = glCreateShaderObjectARB(GL_ARB_fragment_shader);
	#endif
	
	/* Send to Source */
	glShaderSourceARB(vertShader.id, 1, (const GLcharARB**)&vertShader.source, NULL);
        glShaderSourceARB(fragShader.id, 1, (const GLcharARB**)&fragShader.source, NULL);	
        /* Free */
        free(vertShader.source);
        free(fragShader.source);

        /* Compile Shader */
	if(compileShader(vertShader.id) || compileShader(fragShader.id))
        {
		  printf(" COULD NOT COMPILE THE SHADERS! \n");
        }
}	

/*-------------------------------------------------------------------------*/

/* Compile Shader */
int compileShader(unsigned int shaderID)
{
	/* Compile Shader */
	glCompileShaderARB(shaderID);
        int result = 0x8200;
        
	/* Compile Status */
	glGetObjectParameterivARB(shaderID, GL_OBJECT_COMPILE_STATUS_ARB, &result);	
	if(!result)
	{
		printf(" COULD NOT COMPILE SHADER: %d \n", shaderID);
		outputLog(shaderID);
		glDeleteObjectARB(shaderID);
		return -1;
	}
	
	return shaderID;
}

/*-------------------------------------------------------------------------*/

/* Shader Log */
void outputLog(unsigned int shaderID)
{
        int infoLen = 0;
        int status = 0;
        GLcharARB *infoLog;

	/* Shader Length */
	glGetObjectParameterivARB(shaderID, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infoLen);
	infoLog = (GLcharARB *)malloc(infoLen*sizeof(GLcharARB)); 
	
	/* Shader Info Log */
	printf(" SHADER CONTAINS ERRORS! \n");	
	glGetInfoLogARB(shaderID, infoLen, &status, infoLog);
        printf("%s \n", infoLog);
        free(infoLog);
}

/*-------------------------------------------------------------------------*/

/* Create Program */
int createProgram(unsigned int shaderProgram) 	
{
        int linkStatus = 0x8200;
        int status = 0;

	/* Create Program */
	shaderProgram = glCreateProgramObjectARB();
	/* Attach the Shaders to Object */
	glAttachObjectARB(shaderProgram, vertShader.id);
	glAttachObjectARB(shaderProgram, fragShader.id);	
	/* Link the Program */	
	glLinkProgramARB(shaderProgram);
	
	/* Program Status */
	glGetObjectParameterivARB(shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &linkStatus);
	
	if(!linkStatus)
	{	
	        /* Program Info Log */
		glGetInfoLogARB(shaderProgram, linkStatus, &status, NULL);
		printf( " COULD NOT LINK PROGRAM: \n");
		glDeleteObjectARB(shaderProgram);
		return -1;
	}
	
	return shaderProgram;
}

/*-------------------------------------------------------------------------*/

/* Link Program */	
void linkProgram(unsigned int shaderProgram)
{	
	/* Link the Program */	
	glLinkProgramARB(shaderProgram);
}

/*-------------------------------------------------------------------------*/

/* Location */
void Location(unsigned int shaderProgram, unsigned int location, const char* name)
{
	/* Get Location */
	/*vertexPosition = glGetAttribLocation(shaderProgram, "aVertex");*/
	/*colorPosition = glGetAttribLocation(shaderProgram, "aColor");*/
	/*normalPosition = glGetAttribLocation(shaderProgram, "aTexCoord");*/
	location = glGetAttribLocationARB(shaderProgram, name);

	/* Bind Location */
	/*glBindAttribLocation(shaderProgram, vertexPosition, name);*/
	/*glBindAttribLocation(shaderProgram, colorPosition, name);*/
	/*glBindAttribLocation(shaderProgram, normalPosition, name);*/
	glBindAttribLocationARB(shaderProgram, location, name);
}	

/*-------------------------------------------------------------------------*/

/* Uniform */
void Uniform(unsigned int shaderProgram, const char* name, const float matrix)
{
        /* Get Uniform */
        /*glUniform1f(glGetUniformLocation(shaderProgram, "aVertex"), 100.0);*/
        /*glUniform4f(glGetUniformLocation(shaderProgram, "outColor"), 0, 0, 0, 1);*/
        /*glUniform1f(glGetUniformLocation(shaderProgram, "texture0"), 0);*/

	location = glGetUniformLocationARB(shaderProgram, name);
	glUniform1fARB(location, matrix);
}

/*-------------------------------------------------------------------------*/

/* Uniform 4x4 */
void Uniform4x4(unsigned int shaderProgram, const char* name, char transpose, const float* matrix)
{
	/* Get Location */
	transpose = 0;

        /* Get Uniform 4x4 */
	/*fudgeLocation = glGetUniformLocation(shaderProgram, "uFudgeFactor");*/
	/*projectionMatrix = glGetUniformLocation(shaderProgram, "uProjectionMatrix");*/
	/*modelViewMatrix = glGetUniformLocation(shaderProgram, "uModelViewMatrix");*/
	location = glGetUniformLocationARB(shaderProgram, name);

	/* Uniform 4x4 */
        /*glUniformMatrix4fv(fudgeLocation, 1, transpose, matrix);*/
	/*glUniformMatrix4fv(projectionMatrix, 1, transpose, matrix);*/
	/*glUniformMatrix4fv(modelViewMatrix, 1, transpose, matrix);*/
	glUniformMatrix4fvARB(location, 1, transpose, matrix);
}

/*-------------------------------------------------------------------------*/

/* Uniform 3x3 */
void Uniform3x3(unsigned int shaderProgram, const char* name, char transpose, const float* matrix)
{
	/* Get Location */
	transpose = 0;

        /* Get Uniform 3x3 */
	/*fudgeLocation = glGetUniformLocation(shaderProgram, "uFudgeFactor");*/
	/*projectionMatrix = glGetUniformLocation(shaderProgram, "uProjectionMatrix");*/
	/*modelViewMatrix = glGetUniformLocation(shaderProgram, "uModelViewMatrix");*/
	location = glGetUniformLocationARB(shaderProgram, name);

	/* Uniform 3x3 */
        /*glUniformMatrix3fv(fudgeLocation, 1, transpose, matrix);*/
	/*glUniformMatrix3fv(projectionMatrix, 1, transpose, matrix);*/
	/*glUniformMatrix3fv(modelViewMatrix, 1, transpose, matrix);*/
	glUniformMatrix3fvARB(location, 1, transpose, matrix);
}

/*-------------------------------------------------------------------------*/

/* Color Uniform */
void sendUniform4f(unsigned int shaderProgram, const char* name, 
          const float red, const float green, const float blue, const float alpha)
{
        location = glGetUniformLocationARB(shaderProgram, name);
        glUniform4fARB(location, red, green, blue, alpha);
}

/*-------------------------------------------------------------------------*/

/* Uniform */
void sendUniform3f(unsigned int shaderProgram, const char* name, 
                    const float x, const float y, const float z)
{
        location = glGetUniformLocationARB(shaderProgram, name);
        glUniform3fARB(location, x, y, z);
}

/*-------------------------------------------------------------------------*/

/* Scalar Uniform */
void sendUniform(unsigned int shaderProgram, const char* name, const float scalar)
{
        location = glGetUniformLocationARB(shaderProgram, name);
        glUniform1fARB(location, scalar);
}

/*-------------------------------------------------------------------------*/

/* Create Program */	
void bindShader(unsigned int shaderProgram)
{	
	/* Bind Program */
	glUseProgramObjectARB(shaderProgram);
}

/*-------------------------------------------------------------------------*/

/* Delete Shader */
void DeleteShader(unsigned int shaderProgram)
{
        int deletStatus = 0x8200;
        int status = 0;
        
        /* Fix Pipeline */
        glUseProgramObjectARB(0);

	/* Delete the Shaders */
	glDetachObjectARB(shaderProgram, vertShader.id);	
	glDetachObjectARB(shaderProgram, fragShader.id);
	glDeleteObjectARB(vertShader.id);
	glDeleteObjectARB(fragShader.id);
	glDeleteObjectARB(shaderProgram);
	
	/* Program Status */
	glGetObjectParameterivARB(shaderProgram, GL_OBJECT_DELETE_STATUS_ARB, &deletStatus);
	
	if(!deletStatus)
	{	
	        /* Program Info Log */
		glGetInfoLogARB(shaderProgram, deletStatus, &status, NULL);
		printf( " COULD NOT DELETE SHADER: \n");
	}
}

/*-------------------------------------------------------------------------*/