More shader stuff.

Escape-the-Dawn/ShaderProgram.cpp

@@ -0,0 +1,149 @@
+#include "ShaderProgram.h"
+
+GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
+{
+	LOG_INFO("Compiling shader \"%s\"", fileName.c_str());
+
+	std::string shaderFile;
+	std::ifstream in(fileName, std::ios::in);
+	if(!in)
+	{
+		LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
+		return 0;
+	}
+	in.seekg(0, std::ios::end);
+	shaderFile.resize((int)in.tellg());
+	in.seekg(0, std::ios::beg);
+	in.read(&shaderFile[0], shaderFile.size());
+	in.close();
+
+	GLuint shader = glCreateShader(shaderType);
+	if(GLERROR("glCreateShader"))
+		return 0;
+
+	const GLchar* shaderFiles = shaderFile.c_str();
+	const GLint length = shaderFile.length();
+	glShaderSource(shader, 1, &shaderFiles, &length);
+	if(GLERROR("glShaderSource"))
+		return 0;
+
+	glCompileShader(shader);
+
+	GLint compileStatus;
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
+	if(compileStatus != GL_TRUE)
+	{
+		LOG_ERROR("Shader compilation failed");
+		GLsizei infoLogLength;
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+		GLchar* infolog = new GLchar[infoLogLength];
+		glGetShaderInfoLog(shader, infoLogLength, &infoLogLength, infolog);
+		LOG_ERROR(infolog);
+		delete[] infolog;
+	}
+
+	if(GLERROR("glCompileShader"))
+		return 0;
+
+	return shader;
+}
+
+Shader::Shader(GLenum shaderType, std::string fileName) : m_ShaderType(shaderType), m_FileName(fileName)
+{
+	m_ShaderHandle = 0;
+}
+
+Shader::~Shader()
+{
+	glDeleteShader(m_ShaderHandle);
+}
+
+GLuint Shader::Compile()
+{
+	m_ShaderHandle = CompileShader(m_ShaderType, m_FileName);
+	return m_ShaderHandle;
+}
+
+GLenum Shader::GetType() const
+{
+	return m_ShaderType;
+}
+
+std::string Shader::GetFileName() const
+{
+	return m_FileName;
+}
+
+GLuint Shader::GetHandle() const
+{
+	return m_ShaderHandle;
+}
+
+bool Shader::IsCompiled() const
+{
+	return m_ShaderHandle != 0;
+}
+
+ShaderProgram::ShaderProgram()
+{
+	Initialize();
+}
+
+ShaderProgram::ShaderProgram(std::string vertexShaderFile, std::string fragmentShaderFile)
+{
+	AddShader(std::unique_ptr<Shader>(new VertexShader(vertexShaderFile)));
+	AddShader(std::unique_ptr<Shader>(new VertexShader(fragmentShaderFile)));
+	Initialize();
+}
+
+ShaderProgram::~ShaderProgram()
+{
+	Unbind();
+	glDeleteProgram(m_ShaderProgramHandle);
+}
+
+void ShaderProgram::AddShader(std::unique_ptr<Shader> shader)
+{
+	if (!shader->IsCompiled()) {
+		shader->Compile();
+	}
+
+	m_Shaders.push_back(std::move(shader));
+}
+
+GLuint ShaderProgram::Link()
+{
+	LOG_INFO("Linking shader program");
+	m_ShaderProgramHandle = glCreateProgram();
+	for (auto &shader : m_Shaders) {
+		glAttachShader(m_ShaderProgramHandle, shader->GetHandle());
+	}
+	glLinkProgram(m_ShaderProgramHandle);
+	if (GLERROR("glLinkProgram"))
+		return 0;
+
+	for (auto &shader : m_Shaders) {
+		shader.release();
+	}
+	m_Shaders.clear();
+
+	return m_ShaderProgramHandle;
+}
+
+void ShaderProgram::Bind()
+{
+	if (m_ShaderProgramHandle == 0)
+		return;
+
+	glUseProgram(m_ShaderProgramHandle);
+}
+
+void ShaderProgram::Unbind()
+{
+	glActiveShaderProgram(0, 0);
+}
+
+void ShaderProgram::Initialize()
+{
+	m_ShaderProgramHandle = 0;
+}

Escape-the-Dawn/ShaderProgram.h

@@ -17,75 +17,18 @@
 class Shader
 {
 public:
-	static GLuint CompileShader(GLenum shaderType, std::string fileName)
+	static GLuint CompileShader(GLenum shaderType, std::string fileName);
-	{
-		LOG_INFO("Compiling shader \"%s\"", fileName.c_str());
 
-		std::string shaderFile;
+	Shader(GLenum shaderType, std::string fileName);
-		std::ifstream in(fileName, std::ios::in);
-		if(!in)
-		{
-			LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
-			return 0;
-		}
-		in.seekg(0, std::ios::end);
-		shaderFile.resize((int)in.tellg());
-		in.seekg(0, std::ios::beg);
-		in.read(&shaderFile[0], shaderFile.size());
-		in.close();
 
-		GLuint shader = glCreateShader(shaderType);
+	virtual ~Shader();
-		if(GLERROR("glCreateShader"))
-			return 0;
 
-		const GLchar* shaderFiles = shaderFile.c_str();
+	GLuint Compile();
-		const GLint length = shaderFile.length();
-		glShaderSource(shader, 1, &shaderFiles, &length);
-		if(GLERROR("glShaderSource"))
-			return 0;
 
-		glCompileShader(shader);
+	GLenum GetType() const;
-
+	std::string GetFileName() const;
-		GLint compileStatus;
+	GLuint GetHandle() const;
-		glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
+	bool IsCompiled() const;
-		if(compileStatus != GL_TRUE)
-		{
-			LOG_ERROR("Shader compilation failed");
-			GLsizei infoLogLength;
-			glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
-			GLchar* infolog = new GLchar[infoLogLength];
-			glGetShaderInfoLog(shader, infoLogLength, &infoLogLength, infolog);
-			LOG_ERROR(infolog);
-			delete[] infolog;
-		}
-
-		if(GLERROR("glCompileShader"))
-			return 0;
-
-		return shader;
-	}
-
-	Shader(GLenum shaderType, std::string fileName)
-		: m_ShaderType(shaderType), m_FileName(fileName)
-	{
-		m_ShaderHandle = 0;
-	}
-
-	virtual ~Shader()
-	{
-		glDeleteShader(m_ShaderHandle);
-	}
-
-	GLuint Compile()
-	{
-		m_ShaderHandle = CompileShader(m_ShaderType, m_FileName);
-		return m_ShaderHandle;
-	}
-
-	GLenum GetType() const { return m_ShaderType; }
-	std::string GetFileName() const { return m_FileName; }
-	GLuint GetHandle() const { return m_ShaderHandle; }
-	bool IsCompiled() const { return m_ShaderHandle != 0; }
 
 protected:
 	GLenum m_ShaderType;
@@ -125,65 +68,24 @@ public:
 class ShaderProgram
 {
 public:
-	ShaderProgram()
+	ShaderProgram();
-	{
+	~ShaderProgram();
-		Initialize();
-	}
 	
-	ShaderProgram(std::string vertexShaderFile, std::string fragmentShaderFile)
+	ShaderProgram(std::string vertexShaderFile, std::string fragmentShaderFile);
-	{
-		AddShader(std::unique_ptr<Shader>(new VertexShader(vertexShaderFile)));
-		AddShader(std::unique_ptr<Shader>(new VertexShader(fragmentShaderFile)));
-		Initialize();
-	}
 
-	void AddShader(std::unique_ptr<Shader> shader)
+	void AddShader(std::unique_ptr<Shader> shader);
-	{
-		if (!shader->IsCompiled()) {
-			shader->Compile();
-		}
 
-		m_Shaders.push_back(std::move(shader));
+	GLuint Link();
-	}
 
-	GLuint Link()
+	void Bind();
-	{
-		LOG_INFO("Linking shader program");
-		m_ShaderProgramHandle = glCreateProgram();
-		for (auto &shader : m_Shaders) {
-			glAttachShader(m_ShaderProgramHandle, shader->GetHandle());
-		}
-		glLinkProgram(m_ShaderProgramHandle);
-		if (GLERROR("glLinkProgram"))
-			return 0;
 
-		for (auto &shader : m_Shaders) {
+	void Unbind();
-			shader.release();
-		}
-		m_Shaders.clear();
-	}
-
-	void Bind()
-	{
-		if (m_ShaderProgramHandle == 0)
-			return;
-
-		glActiveShaderProgram(0, m_ShaderProgramHandle);
-	}
-
-	void Unbind()
-	{
-		glActiveShaderProgram(0, 0);
-	}
 
 private:
 	GLuint m_ShaderProgramHandle;
 	std::vector<std::unique_ptr<Shader>> m_Shaders;
 	
-	void Initialize()
+	void Initialize();
-	{
-		m_ShaderProgramHandle = 0;
-	}
 };
 
 #endif // ShaderProgram_h__