1.0.7

- Fixed bug where shaders were creating own copies upon render and deleting compiled shader programs
- Added advanced lightning

Application.h

@@ -52,6 +52,11 @@ class Application {
 
 		glEnable(GL_MULTISAMPLE);
 
+		glEnable(GL_DEBUG_OUTPUT);
+		glDebugMessageCallback([](unsigned int src, unsigned int type, unsigned int id, unsigned int sev, int len, const char* msg, const void* param) -> void {
+			fprintf(stderr, "[GL%s] TYPE (0x%x) SEVERITY (0x%x) { \n%s }\n", (type == GL_DEBUG_TYPE_ERROR ? " ERROR" : ""), type, sev, msg);
+		}, 0);
+
 		glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
 		glfwSetKeyCallback(m_window, Input::keyboardCallback);
 		glfwSetMouseButtonCallback(m_window, Input::mouseCallback);
@@ -62,12 +67,16 @@ class Application {
 
 		Model model("resources/models/cube.obj");
 		Shader shader("resources/shaders/light.shader");
+		Shader shader2("resources/shaders/test.shader");
 		Texture texture("resources/textures/avatar.png");
 
 		shader.bind();
 		shader.setUniform1i("u_texture", 0);
-		shader.setUniform3f("u_lightCoord", 0.0f, 0.0f, 0.0f);
-		shader.setUniform3f("u_lightColor", 1.0f, 1.0f, 1.0f);
+
+		shader.setUniform3f("u_material.ambt", 1.0f, 0.5f, 0.31f);
+		shader.setUniform3f("u_material.diff", 1.0f, 0.5f, 0.31f);
+		shader.setUniform3f("u_material.spec", 0.5f, 0.5f, 0.5f);
+		shader.setUniform1f("u_material.shine", 32.0f);
 
 		Camera camera(m_window, 1200, 900);
 		glfwSetWindowUserPointer(m_window, &camera);
@@ -92,21 +101,35 @@ class Application {
 				angle = angle + 1.0f > 360.0f ? 0.0f : angle + 0.1f;
 
 				shader.bind();
+
 				glm::vec3 vp = camera.matPos();
 
-				shader.setUniform3f("u_viewCoord", vp.x, vp.y, vp.z);
+				shader.setUniform3f("u_view", vp.x, vp.y, vp.z);
 
-				glm::mat4 mod = glm::translate(glm::mat4(1.0f), glm::vec3(5.0f, 0.0f, 0.0f));
-				mod = mod * glm::rotate(glm::mat4(1.0f), glm::radians(angle), glm::vec3(0.0f, 1.0f, 0.0f));
+				glm::vec3 color;
+				color.x = sin(glfwGetTime() * 2.0f);
+				color.y = sin(glfwGetTime() * 0.7f);
+				color.z = sin(glfwGetTime() * 1.3f);
+				glm::vec3 diff = color * glm::vec3(0.5f);
+				glm::vec3 ambt = diff * glm::vec3(0.2f);
+				shader.setUniformVec3f("u_light.ambt", ambt);
+				shader.setUniformVec3f("u_light.diff", diff);
+				shader.setUniform3f("u_light.spec", 1.0f, 1.0f, 1.0f);
+				shader.setUniform3f("u_light.post", 0.0f, 0.0f, 0.0f);
+
+				glm::mat4 mod = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f, 0.0f, 4.0f));
+				mod = mod * glm::rotate(glm::mat4(1.0f), glm::radians(angle), glm::vec3(1.0f, 1.0f, 0.0f));
 
 				shader.setUniformMat4f("u_m", mod);
 				shader.setUniformMat4f("u_v", camera.matView());
 				shader.setUniformMat4f("u_p", camera.matProj());
+				model.draw(renderer, shader);				
 
-				model.draw(renderer, shader);
-
-				shader.setUniformMat4f("u_m", glm::scale(glm::mat4(1.0f), glm::vec3(0.1f, 0.1f, 0.1f)));
-				model.draw(renderer, shader);
+				shader2.bind();
+				shader2.setUniformMat4f("u_m", glm::scale(glm::mat4(1.0f), glm::vec3(0.1f, 0.1f, 0.1f)));
+				shader2.setUniformMat4f("u_v", camera.matView());
+				shader2.setUniformMat4f("u_p", camera.matProj());
+				model.draw(renderer, shader2);
 			}
 
 			Input::update();

Model.cpp

@@ -27,7 +27,8 @@ Model::Model(const std::string& modelPath) {
 	m_vao->addBuffer(*m_vbo, vbl);
 }
 
-void Model::draw(Renderer renderer, Shader shader) {
+/* A typo was made here. Hours were spent. It was the reference that wasn't there. */
+void Model::draw(const Renderer& renderer, const Shader& shader) {
 	renderer.draw(*m_vao, *m_ibo, shader);
 }
 

Model.h

@@ -24,7 +24,7 @@ class Model {
 	public:
 		Model(const std::string& modelPath);
 
-		void draw(Renderer renderer, Shader shader);
+		void draw(const Renderer& renderer, const Shader& shader);
 
 		static void loadModel(const std::string& filepath, std::vector<ModelVertex>& vertices, std::vector<unsigned int>& indices);
 };

Renderer.cpp

@@ -2,20 +2,6 @@
 
 #include <iostream>
 
-void glClearError() {
-	while (glGetError() != GL_NO_ERROR);
-}
-
-bool glLogCall(const char* function, const char* file, int line) {
-	while (GLenum error = glGetError()) {
-		std::cout << "[OpenGL Error] " << error << '\n' << function << '\n' << file << '\n' << line << std::endl;
-
-		return false;
-	}
-
-	return true;
-}
-
 void Renderer::draw(const VertexArray & va, const IndexBuffer & ib, const Shader & shader) const {
 	shader.bind();
 	va.bind();

Renderer.h

@@ -8,14 +8,6 @@
 #include "IndexBuffer.h"
 #include "Shader.h"
 
-#define ASSERT(x) if(!(x)) __debugbreak();
-#define glCall(x) glClearError();\
-	x;\
-	ASSERT(glLogCall(#x, __FILE__, __LINE__))
-
-void glClearError();
-bool glLogCall(const char* function, const char* file, int line);
-
 class Renderer {
 	private:
 		int m_fcnt = 0;

Shader.cpp

@@ -33,10 +33,18 @@ void Shader::setUniform3f(const std::string & name, float a, float b, float c) {
 	glUniform3f(getUniformLocation(name), a, b, c);
 }
 
+void Shader::setUniformVec3f(const std::string& name, glm::vec3 a) {
+	glUniform3fv(getUniformLocation(name), 1, &a.x);
+}
+
 void Shader::setUniform1i(const std::string& name, int a) {
 	glUniform1i(getUniformLocation(name), a);
 }
 
+void Shader::setUniform1f(const std::string& name, float a) {
+	glUniform1f(getUniformLocation(name), a);
+}
+
 void Shader::setUniformMat4f(const std::string& name, const glm::mat4& matrix) {
 	glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, &matrix[0][0]);
 }
@@ -51,7 +59,7 @@ int Shader::getUniformLocation(const std::string & name) {
 		std::cout << "[UNIFORM ERROR] " << name << std::endl;
 	}
 
-	m_uniformLocationCache[name] = location;
+	//m_uniformLocationCache[name] = location;
 	return location;
 }
 
@@ -105,7 +113,7 @@ unsigned int Shader::compileShader(unsigned int type, const std::string& source)
 		glGetShaderInfoLog(id, length, &length, message);
 		std::cout << "[Failed to compile " << (type == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT") << " shader]" << std::endl;
 		std::cout << message << std::endl;
-
+		
 		glDeleteShader(id);
 
 		return 0;

Shader.h

@@ -24,7 +24,9 @@ class Shader {
 		void setUniform4f(const std::string& name, float a, float b, float c, float d);
 		void setUniform3f(const std::string& name, float a, float b, float c);
 		void setUniform1i(const std::string& name, int a);
+		void setUniform1f(const std::string& name, float a);
 		void setUniformMat4f(const std::string& name, const glm::mat4& matrix);
+		void setUniformVec3f(const std::string& name, glm::vec3 a);
 	private:
 		int getUniformLocation(const std::string& name);
 

ZPG.vcxproj

@@ -146,6 +146,7 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="resources\shaders\light.shader" />
+    <None Include="resources\shaders\test.shader" />
   </ItemGroup>
   <ItemGroup>
     <Image Include="resources\textures\avatar.png" />

ZPG.vcxproj.filters

@@ -95,5 +95,8 @@
     <None Include="resources\shaders\light.shader">
       <Filter>Resource Files</Filter>
     </None>
+    <None Include="resources\shaders\test.shader">
+      <Filter>Resource Files</Filter>
+    </None>
   </ItemGroup>
 </Project>

resources/shaders/light.shader

@@ -25,35 +25,48 @@ void main()
 #shader fragment
 #version 330 core
 
+struct Material {
+	vec3 ambt;
+	vec3 diff;
+	vec3 spec;
+
+	float shine;
+};
+
+struct Light {
+	vec3 post;
+	vec3 ambt;
+	vec3 diff;
+	vec3 spec;
+};
+
 layout(location = 0) out vec4 color;
 
 in vec2 v_texCoord;
 in vec3 v_normal;
 in vec3 v_fragCoord;
 
-uniform vec3 u_lightColor;
-uniform vec3 u_lightCoord;
-uniform vec3 u_viewCoord;
+uniform vec3 u_view;
+uniform Material u_material;
+uniform Light u_light;
 
 uniform sampler2D u_texture;
 
 void main() 
 {
-	float ambientIntensity = 0.1;
-	vec3 cambient = ambientIntensity * u_lightColor;
+	vec3 ambt = u_light.ambt * u_material.ambt;
 
-	vec4 ctexture = texture(u_texture, v_texCoord);
-
 	vec3 norm = normalize(v_normal);
-	vec3 light = normalize(u_lightCoord - v_fragCoord);
-	float diff = max(dot(norm, light), 0.0);
-	vec3 cdiffuse = diff * u_lightColor;
+	vec3 lightVec = normalize(u_light.post - v_fragCoord);
+
+	float diff = max(dot(norm, lightVec), 0.0);
+	vec3 dffu = u_light.diff * (diff * u_material.diff);
+
+	vec3 viewVec = normalize(u_view - v_fragCoord);
+	vec3 reflVec = reflect(-lightVec, norm);
 
-	float specIntensity = 0.5;
-	vec3 view = normalize(u_viewCoord - v_fragCoord);
-	vec3 viewReflect = reflect(-light, norm);
-	float spec = pow(max(dot(view, viewReflect), 0.0), 64);
-	vec3 cspecular = specIntensity * spec * u_lightColor;
+	float spec = pow(max(dot(viewVec, reflVec), 0.0), u_material.shine);
+	vec3 spcr = u_light.spec * (spec * u_material.spec);
 
-	color = vec4(cdiffuse + cambient + cspecular, 1.0) * ctexture;
+	color = vec4(ambt + dffu + spcr, 1.0);
 }

resources/shaders/test.shader

@@ -0,0 +1,23 @@
+#shader vertex 
+#version 330 core
+
+layout(location = 0) in vec4 position;
+
+uniform mat4 u_m;
+uniform mat4 u_v;
+uniform mat4 u_p;
+
+void main()
+{
+	gl_Position = u_p * u_v * u_m * position;
+}
+
+#shader fragment
+#version 330 core
+
+layout(location = 0) out vec4 color;
+
+void main() 
+{
+	color = vec4(1.0, 1.0, 1.0, 1.0);
+}