#include <GL/glew.h>
#include <GL/glut.h>
#include <cmath>
 
float locx = 0.0f;
float locy = 0.0f;
float sinAdd = 0.0f;
 
float planx = 0.0f;
float plany = 0.0f;
 
void Reshape( int width, int height )
{
 
    glViewport( 0, 0, (GLsizei)width, (GLsizei)height );
    glMatrixMode( GL_PROJECTION );
 
    glLoadIdentity();
    gluPerspective( 90, (GLfloat)width / (GLfloat)height, 1.0, 100.0 );
 
    glMatrixMode( GL_MODELVIEW );
 
}
 
void lightInit( void )
{
 
    GLfloat matSpecular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat matShininess[] = { 50.0 };
    GLfloat lightPos[] = { 0.0, -2.0, -5.0, 0.0 };
 
    glShadeModel( GL_SMOOTH );
 
    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular );
    glMaterialfv( GL_FRONT_AND_BACK, GL_SHININESS, matShininess );
    glLightfv( GL_LIGHT0, GL_POSITION, lightPos );
 
    glEnable( GL_LIGHTING );
    glEnable( GL_LIGHT0 );
 
}
 
void drawPlanet( void )
{
 
    locx = ( sin( sinAdd )*3 ) + planx;
    locy = ( cos( sinAdd )*3 ) + plany;
 
    glPushMatrix();
 
    glTranslatef( locx, 0.0f, locy );
    glutSolidSphere( 0.2, 64, 64 );
 
    glPopMatrix();
 
    sinAdd+= 0.0001f;
 
}
 
void drawSun( void )
{
 
    planx = sin( sinAdd );
    plany = cos( sinAdd );
 
    glPushMatrix();
 
    glPushAttrib( GL_CURRENT_BIT );
 
    glColor3f( 0.3f, 0.0f, 0.0f );
    glTranslatef( 0.0f, 0.0f, 0.0f );
    glutSolidSphere( 0.7, 16, 16 );
 
    glPopAttrib();
 
    glPopMatrix();
 
}
 
void Display( void )
{
 
    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    glLoadIdentity();
 
    glTranslatef( 0.0f, -2.0f, -10.0f );
    drawPlanet();
    drawSun();
    //drawMoon();
 
    glutSwapBuffers();
 
}
 
int main( int argc, char **argv )
{
 
    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH );
    glEnable( GL_DEPTH );
 
    glEnable( GL_COLOR_MATERIAL );
 
    glutInitWindowSize( 1024, 900 );
    glutInitWindowPosition( 200, 100 );
 
    glutCreateWindow( "Orbital Sim" );
 
    lightInit();
 
    glutDisplayFunc( Display );
    glutIdleFunc( Display );
    glutReshapeFunc( Reshape );
 
    glutMainLoop();
 
}

const char* vertexSource =
"#version 120\n"
"in vec2 position;"
"void main() {"
"	gl_Position = vec4( position, 0.0, 1.0 );"
"}";

 
void ARContext(){
 
	resizeWindow("GL", roi.width, roi.height);
 
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	perspectiveGL( 47.0, roi.width/roi.height, 0.01, 100.0 );
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();	
	glViewport(0, 0, roi.width, roi.height);
 
	glBindTexture(GL_TEXTURE_2D, poseTexID);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, roi.width, roi.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
	glBindTexture(GL_TEXTURE_2D, 0);
 
	glBindRenderbuffer(GL_RENDERBUFFER, poseDBufferID);
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, roi.width, roi.height);
	glBindRenderbuffer(GL_RENDERBUFFER, 0);
 
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, poseFBO);
 
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, poseTexID, 0);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, poseDBufferID);
 
	errorCheck("AR Context");
}
 
void WarpContext(){
 
	resizeWindow("GL", model->getROI().width, model->getROI().height);
 
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
 
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, *warpFBOID);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0, model->getROI().width, 0, model->getROI().height, -5.0, 5.0);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glViewport(0, 0, model->getROI().width, model->getROI().height);
 
	errorCheck("Warp Context");
}

 
void AAMFitter::drawModel(){
 
	glLoadIdentity();
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glTranslatef(0.0f, 0.0f, -3.0f);
 
	glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
 
	glBegin(GL_QUADS);
		glVertex3f(-1.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, 1.0f, 0.0f);
		glVertex3f(1.0f, -1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, 0.0f);
	glEnd();
 
}
 
void AAMFitter::ARStuff(Mat& source){
 
	ARContext();
 
	Mat ip(pIndex.size(), 1, CV_32FC2, Scalar::all(0.0));
 
	for(int i = 0; i < pIndex.size(); i++){
		ip.at<Vec2f>(i) = Vec2f(shape->at(2*pIndex[i]), shape->at(2*pIndex[i]+1));
	}
 
	solvePose(ip);
 
	drawModel();
 
	Mat image(roi.height, roi.width, CV_8UC4, Scalar::all(0));
 
	glReadPixels(0, 0, image.cols, image.rows, GL_BGRA, GL_UNSIGNED_BYTE, image.ptr());
 
	namedWindow("ARout");
	imshow("ARout", image);
	waitKey();
 
	WarpContext();
}

GLuint red=0,green=511,blue=511,alpha=3;
	GLuint val = 0;
 
	val = val | (alpha << 30);
	val = val | (blue << 20);
	val = val | (green << 10);
	val = val | (red << 0);
	GLfloat vertices[]={-0.9f, -0.9f, 0.0f,1.0f,
						 -0.9f, 0.6f, 0.0f,1.0f,
						 0.6f,0.6f,0.0f,1.0f,
						 0.6f,-0.9f,0.0f,1.0f};
 
 
	GLuint test_data[]={val,val,val,val};
	glGenBuffers(1, &BufferId);
	glBindBuffer(GL_ARRAY_BUFFER, BufferId);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
	glEnableVertexAttribArray(glGetAttribLocation(shader_data.psId,"position"));
	glVertexAttribPointer(glGetAttribLocation(shader_data.psId,"position"), 4,GL_FLOAT,GL_FALSE, 0,0);
 
 
	glGenBuffers(1, &BufferId1);
	glBindBuffer(GL_ARRAY_BUFFER, BufferId1);
	glBufferData(GL_ARRAY_BUFFER, sizeof(test_data), test_data, GL_STATIC_DRAW);
 
	glEnableVertexAttribArray(glGetAttribLocation(shader_data.psId,"color"));
//	glVertexAttribPointer(glGetAttribLocation(shader_data.psId,"color"), 4,GL_INT_2_10_10_10_REV,GL_TRUE, 0,0);
      glVertexAttribP4uiv(glGetAttribLocation(shader_data.psId,"color"),GL_UNSIGNED_INT_2_10_10_10_REV ,GL_TRUE,0);
 
 
	glDrawArrays(GL_TRIANGLE_FAN,0,4);

bool TCore::SetDCPixelFormat(HDC hDC_1) //ustawienie formatu pikseli
{
	PIXELFORMATDESCRIPTOR pfd;
 
	memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
 
	pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 24;
	pfd.cAlphaBits = 8; 
	pfd.cDepthBits = 24;
	pfd.cStencilBits = 8;
	pfd.iLayerType = PFD_MAIN_PLANE;
 
	int PixelFormat = ChoosePixelFormat(hDC_1, &pfd);
 
	if(PixelFormat == 0)
	{
		ERROR_H.Error_Log("ChoosePixelFormat failed!", false);
		return false;
	}
 
	if(SetPixelFormat(APP.hDC, OGL_WNDW.MSAAPixelFormat == 0 ? PixelFormat : OGL_WNDW.MSAAPixelFormat, &pfd) == false)
	{
		ERROR_H.Error_Log("SetPixelFormat failed!", false);
		return false;
	}
 
	return true;
}
//--------------------------------------------------------------------
 
bool TCore::InitGlew(void) //inicjacja rozszerzeń glew
{
if(glewInit() != GLEW_OK)
{
	ERROR_H.Error_Log("glewInit failed!", false);
	return false;
}
 
if (!glewIsSupported(
	"GL_VERSION_3_3 "
	"GL_ARB_vertex_program "
	"GL_ARB_fragment_program "
	)) {
 
	ERROR_H.Error_Log("Unable to load extensions\n\nExiting...\n", false);
	return false;
}
 
return true;
};
//---------------------------------------------------------------------
 
bool TCore::InitwGlew(void) //inicjacja rozszerzeń wglew
{
if (!wglewIsSupported(
	"WGLEW_ARB_pixel_format "
	"WGLEW_EXT_swap_control "
	"WGLEW_ARB_create_context "
	)) {
 
	//ERROR_H.Error_Log("Unable to load wglew extensions\n\nExiting...\n", false);
	//return false;
}
 
return true;
};
//---------------------------------------------------------------------
 
bool TCore::Make_Antialiasing(void)
{
if (OGL_WNDW.MSAA_On == true) { //MSAA - od 2x do 24x
	if(OGL_WNDW.MSAAPixelFormat == 0 && OGL_WNDW.MSAA_Samples > 0)
	{
		if(WGLEW_ARB_pixel_format && GLEW_ARB_multisample)
		{
			while(OGL_WNDW.MSAA_Samples > 0)
			{
				UINT NumFormats = 0;
 
				int PFAttribs[] =
				{
					WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
					WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
					WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
					WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
					WGL_COLOR_BITS_ARB, 24,
					WGL_ALPHA_BITS_ARB, 8,
					WGL_DEPTH_BITS_ARB, 24,
					WGL_STENCIL_BITS_ARB, 8,
					WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
					WGL_SAMPLE_BUFFERS_ARB, 1, //GL_TRUE,
					WGL_SAMPLES_ARB, OGL_WNDW.MSAA_Samples,
					0
				};
 
				bool result = wglChoosePixelFormatARB(APP.hDC, PFAttribs, NULL, 1, &OGL_WNDW.MSAAPixelFormat, &NumFormats);
 
				if(result == true && NumFormats > 0) {
					break;
				}
 
				OGL_WNDW.MSAA_Samples--;
			}
 
			wglDeleteContext(OGL_WNDW.hGLRC);
			DestroyWindow(APP.hWnd);
			UnregisterClass(//here forum doesn't let post code);
 
			return InitApplication();
		}
		else
		{
			OGL_WNDW.MSAA_Samples = 0;
			ERROR_H.Error_Log("Unable to load extensions: WGLEW_ARB_pixel_format or GLEW_ARB_multisample", false);
		}
	}
	else {
		//ERROR_H.Error_Log("OGL_WNDW.MSAAPixelFormat (=" + FloatToStr(OGL_WNDW.MSAAPixelFormat) + ") or OGL_WNDW.MSAA_Samples (=" + FloatToStr(OGL_WNDW.MSAA_Samples) + ") is incorrect", false);
    }
}
 
return true;
};
//---------------------------------------------------------------------
 
bool TCore::Create_OpenGL(void)
{
APP.hDC = GetDC(APP.hWnd);
 
if(APP.hDC == NULL){
	ERROR_H.Error_Log("GetDC failed!", false);
	return false;
}
 
if (SetDCPixelFormat(APP.hDC) == false) {
	return false;
}
 
OGL_WNDW.hGLRC = wglCreateContext(APP.hDC);
 
if(OGL_WNDW.hGLRC == NULL)
{
	ERROR_H.Error_Log("wglCreateContext failed!", false);
	return false;
}
 
if(wglMakeCurrent(APP.hDC, OGL_WNDW.hGLRC) == false)
{
	ERROR_H.Error_Log("wglMakeCurrent (1) failed!", false);
	return false;
}
 
if (!InitGlew()) {
	return false;
}
 
if (!InitwGlew()) {
	return false;
}
 
return true;
}
//-----------------------------------------------------------------------
 
bool TCore::Check_Folder(UnicodeString Folder)
{
if (!DirectoryExists(Folder)) {
	ERROR_H.Error_Log("Brak folderu " + Folder, false);
	return false;
}
 
return true;
}
//---------------------------------------------------------------------------
 
bool TCore::InitApplication(void)
{
	SetDoubleClickTime(DblClickTime); //ustawia czas pomiędzy dwoma kliknięciami w podwójnym kliku
 
	Load_Cursors();
 
	if (!Check_Folder(APP.MeshesPath) || !Check_Folder(APP.TexturesPath) || !Check_Folder(APP.GUITexturesPath) || !Check_Folder(APP.SoundsPath) || !Check_Folder(APP.ShadersPath)) {
		return false;
	}
 
	if (Create_Window(APP.hInstance, APP.Title, APP.Width, APP.Height) == false) {
		return false;
	}
 
	if (Create_OpenGL() == false) {
		return false;
	}
 
	if (!Make_Antialiasing()) {
		return false;
	}
 
	//tworzenie contextu w wersji OpenGL 3.3
	if(WGLEW_ARB_create_context)
	{
		wglMakeCurrent(NULL,NULL); //???
		wglDeleteContext(OGL_WNDW.hGLRC);
 
		int GL33RCAttribs[] =
		{
			WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
			WGL_CONTEXT_MINOR_VERSION_ARB, 3,
			WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
			0
		};
 
		OGL_WNDW.hGLRC = wglCreateContextAttribsARB(APP.hDC, 0, GL33RCAttribs);
 
		if(OGL_WNDW.hGLRC == NULL)
		{
			ERROR_H.Error_Log("wglCreateContextAttribsARB failed!", false);
			return false;
		}
 
		if(wglMakeCurrent(APP.hDC, OGL_WNDW.hGLRC) == false)
		{
			ERROR_H.Error_Log("wglMakeCurrent (2) failed!", false);
			return false;
		}
	}
	else
	{
		ERROR_H.Error_Log("WGL_ARB_create_context not supported!", false);
		return false;
	}
 
	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &TEX_SET.Max_Texture_Size);
    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &TEX_SET.Max_Texture_Units);
 
	if(GLEW_EXT_texture_filter_anisotropic)
	{
		glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &TEX_SET.Max_Anisotropy);
 
		if (TEX_SET.Anisotropy_Filter_Samples > TEX_SET.Max_Anisotropy) {
			TEX_SET.Anisotropy_Filter_Samples = TEX_SET.Max_Anisotropy;
		}
	}
 
	//ustawianie VSync
	if (!OGL_WNDW.VSync_On) {
		if(WGLEW_EXT_swap_control)
		{
			wglSwapIntervalEXT(0);
		}
		else {
			ERROR_H.Error_Log("WGLEW_EXT_swap_control not supported!", false);
		}
	}
	else {
		if(WGLEW_EXT_swap_control)
		{
			wglSwapIntervalEXT(1);
		}
		else {
			ERROR_H.Error_Log("WGLEW_EXT_swap_control not supported!", false);
		}
    }
 
	if (!GAME.Load_Game()) {
		return false;
	}
 
	return true;
}
//------------------------------------------------------------------------------
 
void TCore::Show_Window(bool Maximized)
{
	RECT dRect, wRect, cRect;
 
	GetWindowRect(GetDesktopWindow(), &dRect);
	GetWindowRect(APP.hWnd, &wRect);
	GetClientRect(APP.hWnd, &cRect);
 
	wRect.right += APP.Width - cRect.right;
	wRect.bottom += APP.Height - cRect.bottom;
	wRect.right -= wRect.left;
	wRect.bottom -= wRect.top;
	wRect.left = dRect.right / 2 - wRect.right / 2;
	wRect.top = dRect.bottom / 2 - wRect.bottom / 2;
 
	MoveWindow(APP.hWnd, wRect.left, wRect.top, wRect.right, wRect.bottom, FALSE);
 
	ShowWindow(APP.hWnd, Maximized ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL);
	UpdateWindow(APP.hWnd);
}
//-----------------------------------------------------------------------

Generate_Texture_DDS(DDS_IMAGE_DATA *pDDSImageData1, bool Make_mipmaps, GLint Texture_Min_Filter, GLint Texture_Mag_Filter)
{
	if(pDDSImageData1 != NULL ) {
		int nHeight     = pDDSImageData1->height;
		int nWidth      = pDDSImageData1->width;
		int nNumMipMaps = pDDSImageData1->numMipMaps;
 
		int nBlockSize;
 
		if(pDDSImageData1->format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
            nBlockSize = 8;
        else
			nBlockSize = 16;
 
		glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //?
		glGenTextures(1, &TEXTURE_MANAGER.Texture_s.Texture_ID);
		glBindTexture(GL_TEXTURE_2D, TEXTURE_MANAGER.Texture_s.Texture_ID);
 
		//parametry tekstury
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Texture_Min_Filter);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, Texture_Mag_Filter); // Filtrowanie liniowe
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, CORE.TEX_SET.Anisotropy_Filter_Samples);
 
		int nSize;
        int nOffset = 0;
 
        // Load the mip-map levels
		if (Make_mipmaps == false) {
			nNumMipMaps = 1;
		}
 
        for(int i = 0; i < nNumMipMaps; ++i) {
            if(nWidth  == 0) nWidth  = 1;
            if(nHeight == 0) nHeight = 1;
 
            nSize = ((nWidth+3)/4) * ((nHeight+3)/4) * nBlockSize;
 
			glCompressedTexImage2DARB(GL_TEXTURE_2D,
                                      i,
                                      pDDSImageData1->format,
									  nWidth,
									  nHeight,
                                      0,
                                      nSize,
                                      pDDSImageData1->pixels + nOffset);
 
            nOffset += nSize;
 
			// Half the image size for the next mip-map level...
			nWidth  = (nWidth  / 2);
            nHeight = (nHeight / 2);
        }
	}
}
//-----------------------------------------------------------------------
 
void TTextureManager::Generate_Texture_BMP(unsigned char *TextureData, bool Make_mipmaps, GLint Texture_Min_Filter, GLint Texture_Mag_Filter)
{
glGenTextures(1, &Texture_s.Texture_ID); // Utworzenie tekstury
glBindTexture(GL_TEXTURE_2D, Texture_s.Texture_ID); // ustawia teksturę jako bieżącą i w 2D
 
//parametry tekstury
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Texture_Min_Filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, Texture_Mag_Filter);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, CORE.TEX_SET.Anisotropy_Filter_Samples);
 
if (BMP_has_alpha == true) {
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, BMP_Width, BMP_Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, TextureData);
}
else {
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BMP_Width, BMP_Height, 0, GL_BGR, GL_UNSIGNED_BYTE, TextureData);
}
 
if (Make_mipmaps == true) {
	//The parameters to control the total number of mipmaps levels are given by:
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);
	glGenerateMipmap(GL_TEXTURE_2D);
}
}
//-----------------------------------------------------------------------

#version 330 core
 
// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 1) in vec4 vertexColor;
layout(location = 2) in vec2 vertexUV;
 
// Output data ; will be interpolated for each fragment.
out vec4 fragmentColor;
out vec2 UV;
 
// Values that stay constant for the whole mesh.
uniform mat4 MVP;
 
void main(){
 
	// Output position of the vertex, in clip space : MVP * position
	gl_Position =  MVP * vec4(vertexPosition_modelspace,1.0);
 
	// The color of each vertex will be interpolated
	// to produce the color of each fragment
	fragmentColor = vertexColor;
 
	// UV of the vertex. No special space for this one.
    UV = vertexUV;
}

#version 330 core
 
// Interpolated values from the vertex shaders
in vec4 fragmentColor;
in vec2 UV;
 
// Ouput data
out vec4 color;
 
// Values that stay constant for the whole mesh.
uniform int UseBaseColor;
uniform int UseTexture;
uniform int UseDiffuseMap;
uniform int UseNormalMap;
uniform int UseSpecularMap;
uniform int UseGlowMap;
uniform int UseLightMap;
uniform sampler2D DiffuseMap;
uniform sampler2D NormalMap;
uniform sampler2D SpecularMap;
uniform sampler2D GlowMap;
uniform sampler2D LightMap;
 
void main()
{
 
	if (UseTexture == 1 && UseDiffuseMap == 1) {
		// Output color = color of the texture at the specified UV
    	color = texture(DiffuseMap, UV);
 
		if (UseBaseColor == 1) {
			color = (color + fragmentColor) / 2.0;
		}
 
		if (UseNormalMap == 1) {
			//color = color;
		}
 
		if (UseSpecularMap == 1) {
			//color = color;
		}
 
		if (UseGlowMap == 1) {
			color = color + texture(GlowMap, UV);
 
			if (color.r > 1.0) {
				color.r = 1.0;
			}
			if (color.g > 1.0) {
				color.g = 1.0;
			}
			if (color.b > 1.0) {
				color.b = 1.0;
			}
 
			if (color.a > 1.0) {
				color.a = 1.0;
			}
		}
 
		if (UseLightMap == 1) {
			//color = color;
		}
	}
	else {
		// Output color = color specified in the vertex shader, 
		// interpolated between all 3 surrounding vertices
		color = fragmentColor;
	}
}