bool Shader::compile(const char *vertexShader, const char *fragmentShader)
{
	int status=GL_FALSE;

	// Flush errors, error reports will concern the following calls only
	FLUSH_GL_ERROR();

// Create the shader objects
	unsigned int v = glCreateShader(GL_VERTEX_SHADER);
	unsigned int f = glCreateShader(GL_FRAGMENT_SHADER);	

// Send the source code to the driver
	glShaderSource(v, 1, (const char **)&vertexShader, NULL);
	glShaderSource(f, 1, (const char **)&fragmentShader, NULL);

// Compile the Vertex Shader
	glCompileShader(v);

	CHECK_GL_ERROR();
	glGetShaderiv(v, GL_COMPILE_STATUS, &status);
	if(status == GL_FALSE)
	{
		// Failed to compile the vertex shader
		printInfoLog(v);
		ASSERT(false, "Vertex Shader failed to compile! Check the error log for details.");
		return false;
	}

// Compile the Fragment Shader
	glCompileShader(f);

	CHECK_GL_ERROR();
	glGetShaderiv(f, GL_COMPILE_STATUS, &status);
	if(status == GL_FALSE)
	{
		// Failed to compile the fragment shader
		printInfoLog(f);
		ASSERT(false, "Fragment Shader failed to compile! Check the error log for details.");
		return false;
	}

	// Create a program name
	programHandle = glCreateProgram();
	CHECK_GL_ERROR();
	ASSERT(glIsProgram(programHandle)==GL_TRUE, "Shader::compile  ->  The program handle is not a valid handle to a GLSL shader program");

	// Attach object code to the program
	glAttachShader(programHandle, v);
	glAttachShader(programHandle, f);

	// Link the object code to finish the program
	glLinkProgram(programHandle);
	printInfoLog(programHandle);

	CHECK_GL_ERROR();
	glGetProgramiv(programHandle, GL_LINK_STATUS, &status);
	if(status == GL_FALSE)
	{
		// Failed to link correctly
		THROW("Failed to link shader");
		return false;
	}
	else
	{
		// Lastly, validate the shader to determine whether it will run at all
#ifdef _DEBUG
		glValidateProgram(programHandle);
		glGetProgramiv(programHandle, GL_VALIDATE_STATUS, &status);
		ASSERT(status==GL_TRUE, "Shader::compile  ->  The GLSL shader program could not be validated, it is garaunteed to not execute.");
#endif

		// Get the locations of the uniforms samplers for each texture unit
		for(int unit=0; unit<16; ++unit)
		{
			char buffer[32]={0};
			sprintf(buffer, "tex%i", unit);

			// If a uniform could not be found, then -1 will bestored
			texLocs[unit] = getLocation(buffer);
		}
	}

	return true;
}

varying vec4 projCoord;void main(){	vec4 realPos = gl_ModelViewMatrix * gl_Vertex;  	projCoord = gl_TextureMatrix[0] * realPos;	gl_FrontColor = gl_Color;	gl_Position = ftransform();}

uniform sampler2DShadow tex1;varying vec4 projCoord;void main (){	const float kTransparency = 0.3;	vec4 color = gl_Color;	float rValue = shadow2DProj(tex1, projCoord).r + kTransparency;	rValue = clamp(rValue, 0.0, 1.0);	vec3 coordPos  = projCoord.xyz / projCoord.w;	if(coordPos.x >= 0.0 && coordPos.y >= 0.0 && coordPos.x <= 1.0 && coordPos.y <= 1.0 )   	{		gl_FragColor = color * rValue;	}	else	{		gl_FragColor = color;	}}

varying vec2 Texcoord;varying vec4 projCoord;void main(){	    // Pass down the texcoord for this vertex    Texcoord = gl_MultiTexCoord0.xy;        // Pass down the projected shadow coord    vec4 realPos = gl_ModelViewMatrix * gl_Vertex;  	projCoord = gl_TextureMatrix[1] * realPos;        // Transform vertex	gl_Position = ftransform();} 

uniform sampler2D tex0;uniform sampler2DShadow tex1;varying vec2 Texcoord;varying vec4 projCoord;void main(){		vec4 textureColor = texture2D(tex0, Texcoord);	vec4 shadowColor = shadow2DProj(tex1, projCoord);	gl_FragColor = textureColor * shadowColor;}

varying vec4 projCoord;void main(){	vec4 realPos = gl_ModelViewMatrix * gl_Vertex;  	projCoord = gl_TextureMatrix[0] * realPos;		gl_Position = ftransform();}

uniform sampler2DShadow tex1;varying vec4 projCoord;void main (){	float rValue = shadow2DProj(tex1, projCoord).r;	gl_FragColor = vec4(rValue);}

uniform sampler2D tex0;varying vec4 projCoord;void main (){	float rValue = texture2DProj(tex0, projCoord).r;	gl_FragColor = vec4(rValue);}