abstracted shaders into a class

5 files changed, 195 insertions, 78 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 82e7fa0..35e4fb6 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2,37 +2,23 @@
 #include <GLFW/glfw3.h>
 
 #include "input.h"
+#include "shader.hpp"
 
 #include <iostream>
-
-const char *vertexShaderSource = R"(
-#version 330 core
-layout (location = 0) in vec3 aPos;
-
-void main()
-{
-    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
-}
-)";
-const char *fragmentShaderSource = R"(
-#version 330 core
-out vec4 FragColor;
-
-void main()
-{
-    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
-} 
-)";
+#include <cmath>
+//#include <unistd.h> // use to print working directory
+//#include <stdio.h>
 
 float vertices[] = {
-     0.5f,  0.5f, 0.0f,  // top right
-     0.5f, -0.5f, 0.0f,  // bottom right
-    -0.5f, -0.5f, 0.0f,  // bottom left
-    -0.5f,  0.5f, 0.0f   // top left 
+	// positions		// colors
+	0.5f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  // top right
+	0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  // bottom right
+	-0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,  // bottom left
+	-0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 0.0f   // top left 
 };
 unsigned int indices[] = {  // note that we start from 0!
-    0, 1, 3,   // first triangle
-    1, 2, 3    // second triangle
+	0, 1, 3,   // first triangle
+	1, 2, 3    // second triangle
 };  
 
 void framebuffer_size_callback(GLFWwindow* window, int width, int height)
@@ -41,6 +27,7 @@ void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 }
 
 int main() {
+	//printf("Current working dir: %s\n", get_current_dir_name());
 	glfwInit();
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // 4.6 is highest
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
@@ -65,54 +52,7 @@ int main() {
 
 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
 
-	unsigned int vertexShader;
-	vertexShader = glCreateShader(GL_VERTEX_SHADER); // create a blank shader
-	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
-	glCompileShader(vertexShader);
-	{ // check if shader compiled successfully
-		int success;
-		char infoLog[512];
-		glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
-		if(!success)
-		{
-			glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
-			std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
-		}
-	}
-
-	unsigned int fragmentShader;
-	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-	glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
-	glCompileShader(fragmentShader);
-	{ // check if shader compiled successfully
-		int success;
-		char infoLog[512];
-		glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
-		if(!success)
-		{
-			glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
-			std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
-		}
-	}
-
-	unsigned int shaderProgram;
-	shaderProgram = glCreateProgram();
-	glAttachShader(shaderProgram, vertexShader);
-	glAttachShader(shaderProgram, fragmentShader);
-	glLinkProgram(shaderProgram);
-	{ // check if shader compiled successfully
-		int success;
-		char infoLog[512];
-		glGetShaderiv(shaderProgram, GL_LINK_STATUS, &success);
-		if(!success)
-		{
-			glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
-			std::cout << "ERROR::SHADER::PROGRAM::COMPILATION_FAILED\n" << infoLog << std::endl;
-		}
-	}
-
-	glDeleteShader(vertexShader); // we dont need these anymore once they are linked in the shader program
-	glDeleteShader(fragmentShader);
+	Shader shader = Shader("src/shaders/default.vert", "src/shaders/default.frag");
 
 	unsigned int VBO, VAO, EBO;
 	glGenBuffers(1, &VBO); // generate the buffer
@@ -120,17 +60,27 @@ int main() {
 
 	glGenVertexArrays(1, &VAO); // generate array
 	glBindVertexArray(VAO); // bind array to apply "settings" to it
-							
+
 	glBindBuffer(GL_ARRAY_BUFFER, VBO); // bind(activate) the buffer to the ARRAY_BUFFER
 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); // upload the data
-																			   //
+
 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
 
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); // configure how the vertex array looks
+	// position attribute
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); // configure how the vertex array looks
 	glEnableVertexAttribArray(0);
+	// color attribute
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); // configure how the vertex array looks
+	glEnableVertexAttribArray(1);
+
+	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // wireframe mode
 
-	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	//{
+	//	int nrAttributes;
+	//	glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
+	//	std::cout << "Maximum nr of vertex attributes supported: " << nrAttributes << std::endl;
+	//}
 
 	// game loop
 	while(!glfwWindowShouldClose(window))
@@ -141,7 +91,15 @@ int main() {
 		glClear(GL_COLOR_BUFFER_BIT);
 
 
-		glUseProgram(shaderProgram); // this will activate the shader and use them for all subsequent shader and render calls
+		//glUseProgram(shaderProgram); // this will activate the shader and use them for all subsequent shader and render calls
+		shader.use();
+
+		float timeValue = glfwGetTime();
+		float greenValue = (sin(timeValue) / 2.0f) + 0.5f;
+		//int vertexColorLocation = glGetUniformLocation(shaderProgram, "ourColor");
+		//glUniform4f(vertexColorLocation, 1.0f - greenValue, greenValue, (greenValue / 2.0f) + 0.25f, 1.0f);
+		shader.set4f("ourColor", 1.0f - greenValue, greenValue, (greenValue / 2.0f) + 0.25f, 1.0f);
+
 		glBindVertexArray(VAO); // activate the preconfigured settings
 		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); // :)
 		glBindVertexArray(0);
diff --git a/src/shader.cpp b/src/shader.cpp
new file mode 100644
index 0000000..25b2fdc
--- /dev/null
+++ b/src/shader.cpp
@@ -0,0 +1,110 @@
+#include "shader.hpp"
+
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+#include <glad/glad.h>
+
+Shader::Shader(const char* vertexPath, const char* fragmentPath)
+{
+	// 1. retrieve the vertex/fragment source code from filePath
+	std::string vertexCode;
+	std::string fragmentCode;
+	std::ifstream vShaderFile;
+	std::ifstream fShaderFile;
+	// ensure ifstream objects can throw exceptions:
+	vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+	fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+	try 
+	{
+		// open files
+		vShaderFile.open(vertexPath);
+		fShaderFile.open(fragmentPath);
+		std::stringstream vShaderStream, fShaderStream;
+		// read file's buffer contents into streams
+		vShaderStream << vShaderFile.rdbuf();
+		fShaderStream << fShaderFile.rdbuf();		
+		// close file handlers
+		vShaderFile.close();
+		fShaderFile.close();
+		// convert stream into string
+		vertexCode   = vShaderStream.str();
+		fragmentCode = fShaderStream.str();
+	}
+	catch(std::ifstream::failure e)
+	{
+		std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ" << std::endl;
+	}
+	const char* vShaderCode = vertexCode.c_str();
+	const char* fShaderCode = fragmentCode.c_str();
+
+	// 2. compile shaders
+	unsigned int vertex, fragment;
+	int success;
+	char infoLog[512];
+
+	// vertex Shader
+	vertex = glCreateShader(GL_VERTEX_SHADER);
+	glShaderSource(vertex, 1, &vShaderCode, NULL);
+	glCompileShader(vertex);
+	// print compile errors if any
+	glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
+	if(!success)
+	{
+		glGetShaderInfoLog(vertex, 512, NULL, infoLog);
+		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
+	};
+
+	// fragment Shader
+	fragment = glCreateShader(GL_FRAGMENT_SHADER);
+	glShaderSource(fragment, 1, &fShaderCode, NULL);
+	glCompileShader(fragment);
+	// print compile errors if any
+	glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
+	if(!success)
+	{
+		glGetShaderInfoLog(fragment, 512, NULL, infoLog);
+		std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
+	};
+	this->ID = glCreateProgram();
+	glAttachShader(ID, vertex);
+	glAttachShader(ID, fragment);
+	glLinkProgram(ID);
+	// print linking errors if any
+	glGetProgramiv(ID, GL_LINK_STATUS, &success);
+	if(!success)
+	{
+		glGetProgramInfoLog(ID, 512, NULL, infoLog);
+		std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+	}
+
+	glDeleteShader(vertex);
+	glDeleteShader(fragment);
+}
+
+void Shader::use()
+{
+	glUseProgram(ID);
+}
+
+void Shader::setBool(const std::string &name, bool value) const
+{
+	glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
+}
+
+void Shader::setInt(const std::string &name, int value) const
+{
+	glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
+}
+
+void Shader::set1f(const std::string &name, float value) const
+{
+	glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
+}
+
+void Shader::set4f(const std::string &name, float value0, float value1, float value2, float value3) const
+{
+	glUniform4f(glGetUniformLocation(ID, name.c_str()), value0, value1, value2, value3);
+}
diff --git a/src/shader.hpp b/src/shader.hpp
new file mode 100644
index 0000000..8fba3df
--- /dev/null
+++ b/src/shader.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+
+#include <glad/glad.h>
+
+class Shader
+{
+	public:
+		// id of the shader program
+		unsigned int ID;
+
+		Shader(const char* vertexPath, const char* fragmentPath);
+
+		// activate the shader
+		void use();
+
+		// utility functions for uniforms
+		void setBool(const std::string &name, bool value) const;
+		void setInt(const std::string &name, int value) const;
+		void set1f(const std::string &name, float value) const;
+		void set4f(
+				const std::string &name,
+				float value0,
+				float value1,
+				float value2,
+				float value3
+				) const;
+};
diff --git a/src/shaders/default.frag b/src/shaders/default.frag
new file mode 100644
index 0000000..36ed030
--- /dev/null
+++ b/src/shaders/default.frag
@@ -0,0 +1,9 @@
+#version 330 core
+out vec4 FragColor;
+in vec3 ourColor;
+
+void main()
+{
+    FragColor = vec4(ourColor, 1.0);
+} 
+
diff --git a/src/shaders/default.vert b/src/shaders/default.vert
new file mode 100644
index 0000000..2e9b994
--- /dev/null
+++ b/src/shaders/default.vert
@@ -0,0 +1,11 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+out vec3 ourColor;
+
+void main()
+{
+    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
+	ourColor = aColor;
+}