Merge remote-tracking branch 'origin/master' into Physics

Conflicts:
	include/Core/Engine.h

include/Core/Engine.h

@@ -100,7 +100,7 @@ public:
             std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
             transform->Position = glm::vec3(0.f, -3.f, -9.f);
             transform->Scale = glm::vec3(2.f, 0.5f, 1.f);
-            transform->Orientation = glm::rotate(transform->Orientation, glm::radians(45.f), glm::vec3(0, 0, -1));
+            //transform->Orientation = glm::rotate(transform->Orientation, glm::radians(45.f), glm::vec3(0, 0, -1));
 
             std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(ent);
             sprite->SpriteFile = "Textures/Core/ErrorTexture.png";

include/Core/Engine.h.orig

@@ -1,259 +0,0 @@
-/*
-	This file is part of Daydream Engine.
-	Copyright 2014 Adam Byléhn, Tobias Dahl, Simon Holmberg, Viktor Ljung
-	
-	Daydream Engine is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-	
-	Daydream Engine is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-	
-	You should have received a copy of the GNU Lesser General Public License
-	along with Daydream Engine.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <string>
-#include <sstream>
-
-#include "ResourceManager.h"
-#include "OBJ.h"
-#include "Model.h"
-#include "Texture.h"
-#include "EventBroker.h"
-#include "RenderQueue.h"
-#include "Renderer.h"
-#include "InputManager.h"
-//TODO: Remove includes that are only here for the temporary draw solution.
-#include "World.h"
-#include "CTransform.h"
-#include "Rendering/CModel.h"
-#include "Rendering/CSprite.h"
-#include "CTemplate.h"
-#include "Transform/TransformSystem.h"
-
-#include "Physics/PhysicsSystem.h"
-#include "Physics/CPhysics.h"
-
-#include "CBoxShape.h"
-
-namespace dd
-{
-
-class Engine
-{
-public:
-	Engine(int argc, char* argv[])
-	{
-		m_EventBroker = std::make_shared<EventBroker>();
-
-		m_Renderer = std::make_shared<Renderer>();
-		m_Renderer->SetFullscreen(false);
-		m_Renderer->SetResolution(Rectangle(0, 0, 1920, 1080));
-		m_Renderer->Initialize();
-
-		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
-
-		m_World = std::make_shared<World>(m_EventBroker);
-
-		//TODO: Move this out of engine.h
-		m_World->ComponentFactory.Register<Components::Transform>();
-		m_World->SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::TransformSystem>();
-<<<<<<< HEAD
-
-		m_World->ComponentFactory.Register<Components::BoxShape>();
-		m_World->ComponentFactory.Register<Components::Physics>();
-		m_World->SystemFactory.Register<Systems::PhysicsSystem>([this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::PhysicsSystem>();
-
-		m_World->ComponentFactory.Register<Components::Model>();
-		m_World->ComponentFactory.Register<Components::Template>();
-		m_World->Initialize();
-
-		auto ent = m_World->CreateEntity();
-		std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-		transform->Position = glm::vec3(0.f, 0.f, -10.f);
-		std::shared_ptr<Components::Model> model = m_World->AddComponent<Components::Model>(ent);
-		model->ModelFile = "Models/Core/UnitSphere.obj";
-
-        std::shared_ptr<Components::BoxShape> boxShape = m_World->AddComponent<Components::BoxShape>(ent);
-        boxShape->x = 5.f;
-        boxShape->y = 5.f;
-
-        std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-        physics->Static = true;
-
-        m_World->CommitEntity(ent);
-
-
-=======
-		m_World->ComponentFactory.Register<Components::Model>();
-		m_World->ComponentFactory.Register<Components::Sprite>();
-		m_World->ComponentFactory.Register<Components::Template>();
-		m_World->Initialize();
-
-//		{
-//			auto ent = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-//			transform->Position = glm::vec3(0.f, 0.f, -10.f);
-//			auto sprite = m_World->AddComponent<Components::Sprite>(ent);
-//			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-//		}
->>>>>>> origin/master
-
-		m_LastTime = glfwGetTime();
-	}
-
-	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
-
-	void Tick()
-	{
-		double currentTime = glfwGetTime();
-		double dt = currentTime - m_LastTime;
-		m_LastTime = currentTime;
-
-		ResourceManager::Update();
-
-<<<<<<< HEAD
-//		// Update input
-		m_InputManager->Update(dt);
-
-		m_World->Update(dt);
-//
-//		if (glfwGetKey(m_Renderer->Window(), GLFW_KEY_R)) {
-//			ResourceManager::Reload("Shaders/Deferred/3/Fragment.glsl");
-//		}
-
-		//TODO Fill up the renderQueue with models (Temp fix)
-//		TEMPAddToRenderQueue();
-=======
-		// Update input
-		m_InputManager->Update(dt);
-
-		m_World->Update(dt);
-
-		if (glfwGetKey(m_Renderer->Window(), GLFW_KEY_R)) {
-			ResourceManager::Reload("Shaders/Deferred/3/Fragment.glsl");
-		}
-
-		//TODO Fill up the renderQueue with models (Temp fix)
-		TEMPAddToRenderQueue();
->>>>>>> origin/master
-
-		// Render scene
-		//TODO send renderqueue to draw.
-		m_Renderer->Draw(m_RendererQueue);
-
-		// Swap event queues
-		m_EventBroker->Clear();
-
-		glfwPollEvents();
-	}
-
-	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
-
-	//TODO: Get this out of engine.h
-	void TEMPAddToRenderQueue()
-	{
-
-		if (!m_TransformSystem)
-			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
-
-		m_RendererQueue.Clear();
-
-		for (auto &pair : *m_World->GetEntities())
-		{
-			EntityID entity = pair.first;
-
-			auto templateComponent = m_World->GetComponent<Components::Template>(entity);
-			if (templateComponent)
-				continue;
-
-			auto transform = m_World->GetComponent<Components::Transform>(entity);
-			if (!transform)
-				continue;
-
-			auto modelComponent = m_World->GetComponent<Components::Model>(entity);
-			if (modelComponent)
-			{
-				Model* modelAsset = nullptr;
-				modelAsset = ResourceManager::Load<Model>(modelComponent->ModelFile);
-
-				if (modelAsset)
-				{
-					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-					glm::mat4 modelMatrix = glm::translate(glm::mat4(), absoluteTransform.Position)
-						* glm::toMat4(absoluteTransform.Orientation)
-						* glm::scale(absoluteTransform.Scale);
-					EnqueueModel(modelAsset, modelMatrix, modelComponent->Transparent, modelComponent->Color);
-				}
-			}
-
-			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
-			if (spriteComponent)
-			{
-				auto textureAsset = ResourceManager::Load<Texture>(spriteComponent->SpriteFile);
-				if (textureAsset)
-				{
-					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-					glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform.Orientation).z, glm::vec3(0, 0, -1));
-					glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
-						* glm::toMat4(orientation2D)
-						* glm::scale(absoluteTransform.Scale);
-					EnqueueSprite(textureAsset, modelMatrix, spriteComponent->Color);
-				}
-			}
-		}
-
-		m_RendererQueue.Sort();
-	}
-
-	//TODO: Get this out of engine.h
-	void EnqueueModel(Model* model, glm::mat4 modelMatrix, float transparent, glm::vec4 color)
-	{
-		for (auto texGroup : model->TextureGroups)
-		{
-			ModelJob job;
-			job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-			job.DiffuseTexture = (texGroup.Texture) ? *texGroup.Texture : 0;
-			job.NormalTexture = (texGroup.NormalMap) ? *texGroup.NormalMap : 0;
-			job.SpecularTexture = (texGroup.SpecularMap) ? *texGroup.SpecularMap : 0;
-			job.VAO = model->VAO;
-			job.ElementBuffer = model->ElementBuffer;
-			job.StartIndex = texGroup.StartIndex;
-			job.EndIndex = texGroup.EndIndex;
-			job.ModelMatrix = modelMatrix;
-			job.Color = color;
-
-			m_RendererQueue.Deferred.Add(job);
-		}
-	}
-
-	// TODO: Get this out of engine.h
-	void EnqueueSprite(Texture* texture, glm::mat4 modelMatrix, glm::vec4 color)
-	{
-		SpriteJob job;
-		job.TextureID = texture->ResourceID;
-		job.Texture = *texture;
-		job.ModelMatrix = modelMatrix;
-		job.Color = color;
-
-		m_RendererQueue.Forward.Add(job);
-	}
-
-private:
-	std::shared_ptr<ResourceManager> m_ResourceManager;
-	std::shared_ptr<EventBroker> m_EventBroker;
-	std::shared_ptr<Renderer> m_Renderer;
-	RenderQueueCollection m_RendererQueue;
-	std::shared_ptr<InputManager> m_InputManager;
-	std::shared_ptr<World> m_World;
-
-	double m_LastTime;
-};
-
-}

include/Core/Renderer.h

@@ -73,7 +73,7 @@ private:
 	ShaderProgram* m_spForward;
 	ShaderProgram* m_spScreen;
 
-	GLuint m_UnitQuad = 0;
+	GLuint m_ScreenQuad = 0;
 	Model* m_UnitSphere = nullptr;
 
 	GLuint m_rbDepthBuffer = 0;

src/game/Core/Renderer.cpp

@@ -98,21 +98,19 @@ void dd::Renderer::LoadShaders()
 	/*
 		Forward rendering
 	*/
-
 	m_spForward = ResourceManager::Load<ShaderProgram>("Shaders/Forward/");
 	m_spForward->Link();
 
 	/*
 		Screen draw
 	*/
-
 	m_spScreen = ResourceManager::Load<ShaderProgram>("Shaders/Screen/");
 	m_spScreen->Link();
 }
 
 void dd::Renderer::CreateBuffers()
 {
-	m_UnitQuad = CreateQuad();
+	m_ScreenQuad = CreateQuad();
 	m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
 
 	glGenRenderbuffers(1, &m_rbDepthBuffer);
@@ -222,7 +220,7 @@ void dd::Renderer::Draw(RenderQueueCollection& rq)
 	m_spScreen->Bind();
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_CurrentScreenBuffer);
-	glBindVertexArray(m_UnitQuad);
+	glBindVertexArray(m_ScreenQuad);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
 
 	glfwSwapBuffers(m_Window);
@@ -271,7 +269,7 @@ void dd::Renderer::DrawDeferred(RenderQueue &objects, RenderQueue &lights)
 	glBindTexture(GL_TEXTURE_2D, m_GDiffuse);
 	glActiveTexture(GL_TEXTURE1);
 	glBindTexture(GL_TEXTURE_2D, m_tLighting);
-	glBindVertexArray(m_UnitQuad);
+	glBindVertexArray(m_ScreenQuad);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
 }
 
@@ -329,7 +327,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 		auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
 		if (spriteJob)
 		{
-			glm::mat4 modelMatrix = spriteJob->ModelMatrix;
+			glm::mat4 modelMatrix = glm::scale(glm::vec3(0.5f)) * spriteJob->ModelMatrix;
 			MVP = PV * modelMatrix;
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
@@ -338,7 +336,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, spriteJob->Texture);
 
-			glBindVertexArray(m_UnitQuad);
+			glBindVertexArray(m_ScreenQuad);
 			glDrawArrays(GL_TRIANGLES, 0, 6);
 
 			continue;