Clipboard

static const char* ExtensionVertexShader = "vert";
static const char* ExtensionFragmentShader = "frag";
GLuint LoadShaderFromFile( const char* FileLocation, GLuint ShaderType )
{
	std::stringstream FileLocationWithExtension;
	const char* FileExtension = nullptr;

	FileLocationWithExtension << "shaders/" << FileLocation;

	if( ShaderType == GL_VERTEX_SHADER )
	{
		FileExtension = ExtensionVertexShader;
	}
	else if( ShaderType == GL_FRAGMENT_SHADER )
	{
		FileExtension = ExtensionFragmentShader;
	}
	else
	{
		std::cout << "Shader type not supported. Shader file won't be loaded." << std::endl;
		return 0;
	}

	if( FileExtension != nullptr )
	{
		FileLocationWithExtension << "." << FileExtension;
	}

	std::cout << "Loading shader \"" << FileLocationWithExtension.str() << "\"" << std::endl;

	GLuint ShaderHandle = 0;
	const char *ShaderData = ReadTextFile( FileLocationWithExtension.str().c_str() );

	if( ShaderData != nullptr )
	{
		ShaderHandle = glCreateShader( ShaderType );
		glShaderSource( ShaderHandle, 1, &ShaderData, NULL );
		free( (void*) ShaderData );
	}
	else
	{
		std::cout << "File not found \"" << FileLocationWithExtension.str() << "\"" << std::endl;
	}

	return ShaderHandle;
}

GLuint CreateShaderProgram( GLuint VertexShaderHandle, GLuint FragmentShaderHandle )
{
	if( VertexShaderHandle == 0 || FragmentShaderHandle == 0 )
	{
		if( VertexShaderHandle == 0 )
		{
			std::cout << "Vertex shader handle is invalid" << std::endl;
		}

		if( FragmentShaderHandle == 0 )
		{
			std::cout << "Fragment shader handle is invalid" << std::endl;
		}

		return 0;
	}

	// Compile all shaders
	glCompileShader( VertexShaderHandle );
	LogShaderCompilationErrors( VertexShaderHandle );
	glCompileShader( FragmentShaderHandle );
	LogShaderCompilationErrors( FragmentShaderHandle );

	// Create the program
	GLuint ProgramHandle = glCreateProgram();

	// Attach shaders to program
	glAttachShader( ProgramHandle, VertexShaderHandle );
	glAttachShader( ProgramHandle, FragmentShaderHandle );

	// Link and set program to use
	glLinkProgram( ProgramHandle );

	GLint LinkStatus;
	glGetProgramiv( ProgramHandle, GL_LINK_STATUS, &LinkStatus );

	glDeleteShader( VertexShaderHandle );
	glDeleteShader( FragmentShaderHandle );

	if( LinkStatus == GL_FALSE )
	{
		std::cout << "Shader program compilation failed" << std::endl;
		return 0;
	}

	return ProgramHandle;
}

GLuint LoadShaderProgram( const char* VertexFileLocation, const char* FragmentFileLocation )
{
	std::cout << "Loading shader program \"" << VertexFileLocation << "\" with fragment shader \"" << FragmentFileLocation << "\"" << std::endl;
	GLuint VertexShaderHandle, FragmentShaderHandle;

	// Read source code from files
	VertexShaderHandle = LoadShaderFromFile( VertexFileLocation, GL_VERTEX_SHADER );
	FragmentShaderHandle = LoadShaderFromFile( FragmentFileLocation, GL_FRAGMENT_SHADER );

	return CreateShaderProgram( VertexShaderHandle, FragmentShaderHandle );
}

GLuint LoadShaderProgram( const char* FileLocation )
{
	std::cout << "Loading shader program \"" << FileLocation << "\"" << std::endl;
	GLuint VertexShaderHandle, FragmentShaderHandle;

	// Read source code from files
	VertexShaderHandle = LoadShaderFromFile( FileLocation, GL_VERTEX_SHADER );
	FragmentShaderHandle = LoadShaderFromFile( FileLocation, GL_FRAGMENT_SHADER );

	return CreateShaderProgram( VertexShaderHandle, FragmentShaderHandle );
}

void LoadShaders()
{
	ShaderProgramScreenGlow = LoadShaderProgram( "screen_aligned_quad", "screen_glow_slow" );
}