WIP (Really really broken tho)

Escape-the-Dawn/Engine.h

@@ -11,53 +11,32 @@
 
 #include "World.h"
 
+
+
 class Engine
 {
 public:
 	Engine(int argc, char* argv[])
 	{
-		// Initialize GLFW
+		renderer.Initialize();
-		if (!glfwInit()) {
+		m_LastTime = glfwGetTime();
-			LOG_ERROR("GLFW: Initialization failed");
-			exit(EXIT_FAILURE);
-		}
-
-		// Create a window
-		m_Window = glfwCreateWindow(1280, 720, "OpenGL", nullptr, nullptr);
-		if (!m_Window) {
-			LOG_ERROR("GLFW: Failed to create window");
-			exit(EXIT_FAILURE);
-		}
-		glfwMakeContextCurrent(m_Window);
-
-		// GL version info
-		glGetIntegerv(GL_MAJOR_VERSION, &glVersion[0]);
-		glGetIntegerv(GL_MINOR_VERSION, &glVersion[1]);
-		glVendor = (GLchar*)glGetString(GL_VENDOR);
-		std::stringstream ss;
-		ss << glVendor << " OpenGL " << glVersion[0] << "." << glVersion[1];
-#ifdef DEBUG
-		ss << " DEBUG";
-#endif
-		LOG_INFO(ss.str().c_str());
-		glfwSetWindowTitle(m_Window, ss.str().c_str());
-
-		// Initialize GLEW
-		if (glewInit() != GLEW_OK) {
-			LOG_ERROR("GLEW: Initialization failed");
-			exit(EXIT_FAILURE);
-		}
 	}
 
-	bool Running() const { return !glfwWindowShouldClose(m_Window); }
+	bool Running() const { return !glfwWindowShouldClose(renderer.GetWindow()); }
 
 	void Tick()
 	{
+		double currentTime = glfwGetTime();
+		double dt =  currentTime - m_LastTime;
+		m_LastTime = currentTime;
+
+		//World.Update(dt);
+		renderer.Draw(dt);
+
 		glfwPollEvents();
 	}
 
 private:
-	GLFWwindow* m_Window;
+	Renderer renderer;
-	GLint glVersion[2];
+	double m_LastTime;
-	GLchar* glVendor;
 };

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

@@ -99,7 +99,8 @@
   <ItemGroup>
     <ClCompile Include="Engine.h" />
     <ClCompile Include="Model.cpp" />
-    <ClCompile Include="Renderer\Renderer.cpp" />
+    <ClCompile Include="Renderer.cpp" />
+    <ClCompile Include="ShaderProgram.cpp" />
     <ClCompile Include="Systems\CollisionSystem.cpp" />
     <ClCompile Include="World.cpp" />
     <ClCompile Include="Systems\InputSystem.cpp" />

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

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <ClCompile Include="Renderer\Renderer.cpp" />
     <ClCompile Include="World.cpp" />
     <ClCompile Include="Systems\CollisionSystem.cpp">
       <Filter>Systems</Filter>
@@ -26,6 +25,8 @@
     </ClCompile>
     <ClCompile Include="Model.cpp" />
     <ClCompile Include="Engine.h" />
+    <ClCompile Include="Renderer.cpp" />
+    <ClCompile Include="ShaderProgram.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Component.h" />

Escape-the-Dawn/Renderer.cpp

@@ -1,64 +1,77 @@
-#include "Renderer/Renderer.h"
+#include "Renderer.h"
 
 Renderer::Renderer()
 {
-
 }
 
-void Renderer::Draw()
+void Renderer::Initialize()
 {
+	// Initialize GLFW
+	if (!glfwInit()) {
+		LOG_ERROR("GLFW: Initialization failed");
+		exit(EXIT_FAILURE);
+	}
 
+	// Create a window
+	m_Window = glfwCreateWindow(1280, 720, "OpenGL", nullptr, nullptr);
+	if (!m_Window) {
+		LOG_ERROR("GLFW: Failed to create window");
+		exit(EXIT_FAILURE);
+	}
+	glfwMakeContextCurrent(m_Window);
+
+	// GL version info
+	glGetIntegerv(GL_MAJOR_VERSION, &m_glVersion[0]);
+	glGetIntegerv(GL_MINOR_VERSION, &m_glVersion[1]);
+	m_glVendor = (GLchar*)glGetString(GL_VENDOR);
+	std::stringstream ss;
+	ss << m_glVendor << " OpenGL " << m_glVersion[0] << "." << m_glVersion[1];
+#ifdef DEBUG
+	ss << " DEBUG";
+#endif
+	LOG_INFO(ss.str().c_str());
+	glfwSetWindowTitle(m_Window, ss.str().c_str());
+
+	// Initialize GLEW
+	if (glewInit() != GLEW_OK) {
+		LOG_ERROR("GLEW: Initialization failed");
+		exit(EXIT_FAILURE);
+	}
+	glEnable(GL_DEPTH_TEST);
+
+	LoadContent();
+}
+
+void Renderer::Draw(double _dt)
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
+
+	//m_ShaderProgram->Bind();
+
+	glfwSwapBuffers(m_Window);
 }
 
 void Renderer::DrawText()
 {
+	//DrawShitInTextForm
+}
 
+void Renderer::AddTextToDraw()
+{
+	//Add to draw shit vector
+}
+
+void Renderer::AddModelToDraw(Model* _model)
+{
+	ModelsToRender.push_back(_model);
 }
 
 //Fixa med shaders, lägga in alla verts osv.
 
-
+void Renderer::LoadContent()
-GLuint Renderer::CompileShader(GLenum shaderType, std::string fileName)
 {
-	std::string shaderFile;
+	m_ShaderProgram->AddShader(std::unique_ptr<Shader>(new VertexShader("Shaders/Vertex.glsl")));
-	std::ifstream in(fileName, std::ios::in);
+	m_ShaderProgram->AddShader(std::unique_ptr<Shader>(new FragmentShader("Shaders/Fragment.glsl")));
-
+	m_ShaderProgram->Link();
-	if(!in)
-	{
-		LOG_ERROR("Error: Failed to open shader file %s", fileName);
-		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); //GL_VERTEX_SHADER, GL_FRAGMENT_SHADER
-	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)
-	{
-		GLsizei infoLogLength;
-		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
-		GLchar* infolog = new GLchar[infoLogLength];
-		glGetShaderInfoLog(shader, infoLogLength, &infoLogLength, infolog);
-		std::cerr << infolog << std::endl;
-		delete[] infolog;
-	}
-
-	if(GLERROR("glCompileShader"))
-		return 0;
-
-	return shader;
 }

Escape-the-Dawn/Renderer.h

@@ -20,23 +20,22 @@
 
 #include "glerror.h"
 #include "ShaderProgram.h"
+#include "Model.h"
 
 class Renderer
 {
 public:
 	std::shared_ptr<ShaderProgram> m_ShaderProgram;
-	GLuint VAO;
 
-	std::vector<std::vector<float>> Vertices;
+	std::vector<Model*> ModelsToRender;
-	std::vector<std::vector<float>> Normals;
-	std::vector<std::vector<float>> TextureCoords;
 
 	Renderer();
 
-	void Draw();
+	void Initialize();
+	void Draw(double dt);
 	void DrawText();
 
-	void AddObjectToDraw();
+	void AddModelToDraw(Model*);
 	void AddTextToDraw();
 
 	void LoadContent();
@@ -45,6 +44,8 @@ public:
 
 private:
 	GLFWwindow* m_Window;
+	GLint m_glVersion[2];
+	GLchar* m_glVendor;
 };
 
 #endif // Renderer_h__

Escape-the-Dawn/Renderer/Renderer.cpp

@@ -1,38 +0,0 @@
-#include "Renderer.h"
-
-Renderer::Renderer()
-{
-	glEnable(GL_DEPTH_TEST);
-}
-
-void Renderer::Draw()
-{
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	glClearColor(1.0f, 1.0f, 0.0f, 1.0f);
-
-	m_ShaderProgram->Bind();
-}
-
-void Renderer::DrawText()
-{
-	//DrawShitInTextForm
-}
-
-void Renderer::AddTextToDraw()
-{
-	//Add to draw shit vector
-}
-
-void Renderer::AddObjectToDraw()
-{
-
-}
-
-//Fixa med shaders, lägga in alla verts osv.
-
-void Renderer::LoadContent()
-{
-	m_ShaderProgram->AddShader(std::unique_ptr<Shader>(new VertexShader("Shaders/Vertex.glsl")));
-	m_ShaderProgram->AddShader(std::unique_ptr<Shader>(new FragmentShader("Shaders/Fragment.glsl")));
-	m_ShaderProgram->Link();
-}

Escape-the-Dawn/ShaderProgram.cpp

@@ -105,7 +105,9 @@ ShaderProgram::~ShaderProgram()
 void ShaderProgram::AddShader(std::unique_ptr<Shader> shader)
 {
 	if (!shader->IsCompiled()) {
-		shader->Compile();
+		if (shader->Compile() == 0) {
+			return;
+		}
 	}
 
 	m_Shaders.push_back(std::move(shader));