Debug draw normals.

Escape-the-Dawn/Escape-the-Dawn.vcxproj

@@ -149,6 +149,7 @@
     <ClInclude Include="MenuFrame.h" />
     <ClInclude Include="Model.h" />
     <ClInclude Include="OBJ.h" />
+    <ClInclude Include="OpenGL.h" />
     <ClInclude Include="Renderer.h" />
     <ClInclude Include="ShaderProgram.h" />
     <ClInclude Include="Systems\InputSystem.h" />
@@ -165,6 +166,8 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="Shaders\Fragment.glsl" />
+    <None Include="Shaders\Normals.frag.glsl" />
+    <None Include="Shaders\Normals.geo.glsl" />
     <None Include="Shaders\Vertex.glsl" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

Escape-the-Dawn/Escape-the-Dawn.vcxproj.filters

@@ -146,6 +146,7 @@
     <ClInclude Include="GameWorld.h" />
     <ClInclude Include="Camera.h" />
     <ClInclude Include="OBJ.h" />
+    <ClInclude Include="OpenGL.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Shaders\Fragment.glsl">
@@ -154,6 +155,12 @@
     <None Include="Shaders\Vertex.glsl">
       <Filter>Shaders</Filter>
     </None>
+    <None Include="Shaders\Normals.geo.glsl">
+      <Filter>Shaders</Filter>
+    </None>
+    <None Include="Shaders\Normals.frag.glsl">
+      <Filter>Shaders</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Systems">

Escape-the-Dawn/Model.h

@@ -8,11 +8,7 @@
 #include <vector>
 #include <memory>
 
-#include <GL/glew.h>
+#include "OpenGL.h"
-#define GLFW_INCLUDE_GLU
-#include <GLFW/glfw3.h>
-#include <glext.h>
-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/constants.hpp>
 #include <glm/gtc/matrix_transform.hpp>

Escape-the-Dawn/OpenGL.h

@@ -0,0 +1,5 @@
+#include <GL/glew.h>
+#define GLFW_INCLUDE_GLU
+#include <GLFW/glfw3.h>
+#include <glext.h>
+#define GLM_FORCE_RADIANS

Escape-the-Dawn/Renderer.cpp

@@ -55,7 +55,20 @@ void Renderer::Draw(double dt)
 	glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
 
 	m_ShaderProgram.Bind();
+	DrawModels();
+	
+#ifdef DEBUG
+	m_ShaderProgramNormals.Bind();
+	DrawModels();
+#endif
 
+	ModelsToRender.clear();
+
+	glfwSwapBuffers(m_Window);
+}
+
+void Renderer::DrawModels()
+{
 	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix() * m_Camera->ViewMatrix();
 
 	glm::mat4 MVP;
@@ -73,7 +86,7 @@ void Renderer::Draw(double dt)
 		glUniform1f(glGetUniformLocation(m_ShaderProgram.GetHandle(), "linearAttenuation"), 0.0f);
 		glUniform1f(glGetUniformLocation(m_ShaderProgram.GetHandle(), "quadraticAttenuation"), 0.0f);
 
-		
+
 		glBindVertexArray(model->VAO);
 		for (auto texGroup : model->TextureGroups) {
 			glActiveTexture(GL_TEXTURE0);
@@ -81,9 +94,6 @@ void Renderer::Draw(double dt)
 			glDrawArrays(GL_TRIANGLES, texGroup.StartIndex, (texGroup.EndIndex - texGroup.StartIndex + 1) * abs(sin(glfwGetTime())));
 		}
 	}
-	ModelsToRender.clear();
-
-	glfwSwapBuffers(m_Window);
 }
 
 void Renderer::DrawText()
@@ -108,8 +118,20 @@ void Renderer::AddModelToDraw(std::shared_ptr<Model> _model, glm::vec3 _position
 
 void Renderer::LoadContent()
 {
-	m_ShaderProgram.AddShader(std::unique_ptr<Shader>(new VertexShader("Shaders/Vertex.glsl")));
+	auto standardVS = std::shared_ptr<Shader>(new VertexShader("Shaders/Vertex.glsl"));
-	m_ShaderProgram.AddShader(std::unique_ptr<Shader>(new FragmentShader("Shaders/Fragment.glsl")));
+	auto standardFS = std::shared_ptr<Shader>(new FragmentShader("Shaders/Fragment.glsl"));
+
+	auto normalsGS = std::shared_ptr<Shader>(new GeometryShader("Shaders/Normals.geo.glsl"));
+	auto normalsFS = std::shared_ptr<Shader>(new FragmentShader("Shaders/Normals.frag.glsl"));
+
+	m_ShaderProgram.AddShader(standardVS);
+	m_ShaderProgram.AddShader(standardFS);
 	m_ShaderProgram.Compile();
 	m_ShaderProgram.Link();
+
+	m_ShaderProgramNormals.AddShader(normalsGS);
+	m_ShaderProgramNormals.AddShader(standardVS);
+	m_ShaderProgramNormals.AddShader(normalsFS);
+	m_ShaderProgramNormals.Compile();
+	m_ShaderProgramNormals.Link();
 }

Escape-the-Dawn/Renderer.h

@@ -7,11 +7,7 @@
 #include <sstream>
 #include <vector>
 
-#include <GL/glew.h>
+#include "OpenGL.h"
-#define GLFW_INCLUDE_GLU
-#include <GLFW/glfw3.h>
-#include <glext.h>
-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/constants.hpp>
 #include <glm/gtc/matrix_transform.hpp>
@@ -27,7 +23,7 @@
 class Renderer
 {
 public:
-	ShaderProgram m_ShaderProgram;
+	
 	glm::mat4 viewMatrix;
 	glm::mat4 projectionMatrix;
 
@@ -64,7 +60,11 @@ private:
 
 	std::shared_ptr<Camera> m_Camera;
 
-	GLuint vertexArrayObject;
+	ShaderProgram m_ShaderProgram;
+	ShaderProgram m_ShaderProgramNormals;
+
+	void DrawModels();
+
 };
 
 #endif // Renderer_h__

Escape-the-Dawn/ShaderProgram.cpp

@@ -84,18 +84,13 @@ bool Shader::IsCompiled() const
 	return m_ShaderHandle != 0;
 }
 
-ShaderProgram::ShaderProgram()
-{
-	Initialize();
-}
-
 ShaderProgram::~ShaderProgram()
 {
 	Unbind();
 	glDeleteProgram(m_ShaderProgramHandle);
 }
 
-void ShaderProgram::AddShader(std::unique_ptr<Shader> shader)
+void ShaderProgram::AddShader(std::shared_ptr<Shader> shader)
 {
 	m_Shaders.push_back(std::move(shader));
 }
@@ -111,6 +106,10 @@ void ShaderProgram::Compile()
 
 GLuint ShaderProgram::Link()
 {
+	if (m_Shaders.size() == 0) {
+		LOG_ERROR("Failed to link shader program: No shaders bound");
+	}
+
 	LOG_INFO("Linking shader program");
 	m_ShaderProgramHandle = glCreateProgram();
 	for (auto &shader : m_Shaders) {
@@ -119,10 +118,6 @@ GLuint ShaderProgram::Link()
 	glLinkProgram(m_ShaderProgramHandle);
 	if (GLERROR("glLinkProgram"))
 		return 0;
-
-	for (auto &shader : m_Shaders) {
-		shader.release();
-	}
 	m_Shaders.clear();
 
 	return m_ShaderProgramHandle;
@@ -144,9 +139,4 @@ void ShaderProgram::Bind()
 void ShaderProgram::Unbind()
 {
 	glActiveShaderProgram(0, 0);
-}
+}
-
-void ShaderProgram::Initialize()
-{
-	m_ShaderProgramHandle = 0;
-}

Escape-the-Dawn/ShaderProgram.h

@@ -6,11 +6,7 @@
 #include <fstream>
 #include <vector>
 
-#define _CRT_SECURE_NO_WARNINGS
+#include "OpenGL.h"
-#include <GL/glew.h>
-#define GLFW_INCLUDE_GLU
-#include <GLFW/glfw3.h>
-#include <glext.h>
 
 #include "glerror.h"
 
@@ -68,25 +64,20 @@ public:
 class ShaderProgram
 {
 public:
-	ShaderProgram();
+	ShaderProgram() 
+		: m_ShaderProgramHandle(0) { }
 	~ShaderProgram();
 	
-	void AddShader(std::unique_ptr<Shader> shader);
+	void AddShader(std::shared_ptr<Shader> shader);
-
 	void Compile();
 	GLuint Link();
-
 	GLuint GetHandle();
-
 	void Bind();
-
 	void Unbind();
 
 private:
 	GLuint m_ShaderProgramHandle;
-	std::vector<std::unique_ptr<Shader>> m_Shaders;
+	std::vector<std::shared_ptr<Shader>> m_Shaders;
-	
-	void Initialize();
 };
 
 #endif // ShaderProgram_h__

Escape-the-Dawn/Shaders/Normals.frag.glsl

@@ -0,0 +1,9 @@
+#version 430
+
+uniform mat4 MVP;
+
+out vec4 FragmentColor;
+
+void main() {
+	FragmentColor = vec4(1.0, 1.0, 1.0, 1.0);
+}

Escape-the-Dawn/Shaders/Normals.geo.glsl

@@ -0,0 +1,34 @@
+#version 430
+
+uniform mat4 MVP;
+
+layout(triangles) in;
+layout(line_strip, max_vertices = 6) out;
+
+in VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+} Input[3];
+
+out VertexData {
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoord;
+} Output;
+
+void main()
+{
+	for (int i = 0; i < gl_in.length(); i++)
+	{
+		gl_Position = MVP * vec4(Input[i].Position, 1.0);
+		EmitVertex();
+		gl_Position = MVP * vec4(Input[i].Position, 1.0) + MVP * vec4(Input[i].Normal, 0.0);
+		EmitVertex();
+		EndPrimitive();
+
+		Output.Position = Input[i].Position;
+		Output.Normal = Input[i].Normal;
+		Output.TextureCoord = Input[i].TextureCoord;
+	}
+}

Escape-the-Dawn/Systems/PlayerSystem.h

@@ -4,7 +4,6 @@
 #include <array>
 
 #include "System.h"
-#include "Renderer.h"
 #include "Components/Transform.h"
 #include "Components/Input.h"
 #include "logging.h"

Escape-the-Dawn/Systems/RenderSystem.h

@@ -1,6 +1,8 @@
 #ifndef RenderSystem_h__
 #define  RenderSystem_h__
 
+#include <unordered_map>
+
 #include "System.h"
 #include "Model.h"
 #include "Texture.h"
@@ -8,7 +10,6 @@
 #include "Components/Transform.h"
 #include "Components/Camera.h"
 #include "Renderer.h"
-#include <unordered_map>
 
 namespace Systems
 {

Escape-the-Dawn/Texture.h

@@ -3,10 +3,7 @@
 
 #include <string>
 
-#include <GL/glew.h>
+#include "OpenGL.h"
-#define GLFW_INCLUDE_GLU
-#include <GLFW/glfw3.h>
-#include <glext.h>
 #include <SOIL.h>
 
 class Texture

Escape-the-Dawn/World.h

@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <vector>
 #include <string>
+#include <queue>
 
 #include <boost/any.hpp>