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

Conflicts:
	include/Core/Engine.h
	src/game/Game/PadSystem.cpp
	src/game/Physics/PhysicsSystem.cpp

src/game/CMakeLists.txt

@@ -75,8 +75,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Rendering}
     ${SOURCE_FILES_Transform}
     ${SOURCE_FILES_Physics}
-    ${SOURCE_FILES_Game}
-)
+    ${SOURCE_FILES_Game})
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")

src/game/Core/Camera.cpp

@@ -77,20 +77,20 @@ void dd::Camera::SetOrientation(glm::quat val)
 
 void dd::Camera::UpdateProjectionMatrix()
 {
-	m_ProjectionMatrix = glm::ortho(
-		-16.f,
-		16.f,
-		-9.f,
-		9.f,
-		m_NearClip,
-		m_FarClip
-		);
-//	m_ProjectionMatrix = glm::perspective(
-//		m_FOV,
-//		m_AspectRatio,
+//	m_ProjectionMatrix = glm::ortho(
+//		-16.f,
+//		16.f,
+//		-9.f,
+//		9.f,
 //		m_NearClip,
 //		m_FarClip
 //		);
+	m_ProjectionMatrix = glm::perspective(
+		m_FOV,
+		m_AspectRatio,
+		m_NearClip,
+		m_FarClip
+		);
 }
 
 void dd::Camera::UpdateViewMatrix()

src/game/Core/EventBroker.cpp

@@ -40,6 +40,7 @@ void dd::EventBroker::Unsubscribe(BaseEventRelay &relay) // ?
 	{
 		if (it->second == &relay)
 		{
+			relay.m_Broker = nullptr;
 			eventRelays.erase(it);
 			break;
 		}

src/game/Core/Renderer.cpp

@@ -113,6 +113,8 @@ void dd::Renderer::CreateBuffers()
 	m_ScreenQuad = CreateQuad();
 	m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
 	m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
+	m_StandardNormal = ResourceManager::Load<Texture>("Textures/Core/NeutralNormalMap.png");
+	m_StandardSpecular = ResourceManager::Load<Texture>("Textures/Core/NeutralSpecularMap.png");
 
 	glGenRenderbuffers(1, &m_rbDepthBuffer);
 	glBindRenderbuffer(GL_RENDERBUFFER, m_rbDepthBuffer);
@@ -207,7 +209,9 @@ void dd::Renderer::CreateBuffers()
 
 void dd::Renderer::Draw(RenderQueueCollection& rq)
 {
+
 	DrawDeferred(rq.Deferred, rq.Lights);
+	rq.Forward.Jobs.sort(dd::Renderer::DepthSort);
 	DrawForward(rq.Forward, rq.Lights);
 
 	// Finally: Draw the deferred+forward combined texture to the screen
@@ -276,14 +280,20 @@ void dd::Renderer::DrawDeferred(RenderQueue &objects, RenderQueue &lights)
 
 void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 {
+
 	// Forward-render semi-transparent objects on top of the current framebuffer
 	glDisable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
 	glDepthMask(GL_TRUE);
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_BLEND);
+	//glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
 	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
 
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred3);
+//	glClearColor(1, 0.9, 0.8f, 1);
+//	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
 	m_spForward->Bind();
 	DrawScene(objects, *m_spForward);
 }
@@ -304,21 +314,32 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
+			glUniform3fv(glGetUniformLocation(shaderProgramHandle, "LightPosition"), 1, glm::value_ptr(glm::vec3(0.f,0.f,-9.f)));
+			glUniform3fv(glGetUniformLocation(shaderProgramHandle, "LightSpecular"), 1, glm::value_ptr(glm::vec3(1.f)));
+			glUniform3fv(glGetUniformLocation(shaderProgramHandle, "LightDiffuse"), 1, glm::value_ptr(glm::vec3(1.f)));
+			glUniform1f(glGetUniformLocation(shaderProgramHandle, "LightRadius"), 40.0f);
 
 			glUniform1f(glGetUniformLocation(shaderProgramHandle, "MaterialShininess"), modelJob->Shininess);
 
-			//TODO: Make sure that a normal/specular is loaded in.
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture);
 			if (modelJob->NormalTexture != 0) {
 				glActiveTexture(GL_TEXTURE1);
 				glBindTexture(GL_TEXTURE_2D, modelJob->NormalTexture);
+			} else {
+				glActiveTexture(GL_TEXTURE1);
+				glBindTexture(GL_TEXTURE_2D, *m_StandardNormal);
 			}
+
 			if (modelJob->SpecularTexture != 0) {
 				glActiveTexture(GL_TEXTURE2);
 				glBindTexture(GL_TEXTURE_2D, modelJob->SpecularTexture);
+			} else {
+				glActiveTexture(GL_TEXTURE2);
+				glBindTexture(GL_TEXTURE_2D, *m_StandardSpecular);
 			}
 
+
 			glBindVertexArray(modelJob->VAO);
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->ElementBuffer);
 			glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);

src/game/Core/Shaders/Deferred/3/Fragment.glsl

@@ -38,7 +38,8 @@ void main()
 
 	//frag_Diffuse = DiffuseTexel * (vec4(La, 0.0) * (vec4(LightingTexel.rgb, 0.0) + vec4(LightingTexel.a, LightingTexel.a, LightingTexel.a, 0.0)));
 	//frag_Diffuse = DiffuseTexel * (vec4(La, 0.0) + LightingTexel);
-	frag_Diffuse = DiffuseTexel * (vec4(1.f, 1.f, 1.f, 0.0) + LightingTexel);
+	//frag_Diffuse = DiffuseTexel * (vec4(1.f, 1.f, 1.f, 0.0) + LightingTexel);
+	frag_Diffuse = DiffuseTexel + LightingTexel;
 	//frag_Diffuse = DiffuseTexel;
 	//frag_Diffuse = vec4(LightingTexel.r, LightingTexel.g, LightingTexel.b, 1.0);
 }

src/game/Core/Shaders/Forward/Fragment.glsl

@@ -46,7 +46,7 @@ in VertexData
 	vec4 BoneWeights2;
 } Input;
 
-out vec4 FragmentColor;
+out vec4 frag_Diffuse;
 
 vec4 phong(vec3 position, vec3 normal, vec3 specular, float specularExponent)
 {
@@ -83,7 +83,8 @@ void main()
 	vec4 specularTexel = texture(SpecularMap, Input.TextureCoord);
 
 	vec4 diffuseTexel = texture(DiffuseTexture, Input.TextureCoord);
-
-	FragmentColor = phong(Input.Position, normalize(normal), specularTexel.rgb, specularTexel.a);
-	//FragmentColor = diffuseTexel;
+	vec4 La = vec4(0.3, 0.3, 0.3, 1.0);
+	vec4 light = phong(Input.Position, normalize(normal), specularTexel.rgb, specularTexel.a);
+	//frag_Diffuse = light;
+	frag_Diffuse = diffuseTexel;
 }

src/game/Core/Shaders/PureForward/Fragment.glsl

@@ -0,0 +1,89 @@
+/*
+	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/>.
+*/
+
+#version 440
+
+layout (binding=0) uniform sampler2D DiffuseTexture;
+layout (binding=1) uniform sampler2D NormalMap;
+layout (binding=2) uniform sampler2D SpecularMap;
+
+uniform mat4 MVP;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec3 LightPosition;
+uniform float LightRadius;
+uniform vec3 LightSpecular;
+uniform vec3 LightDiffuse;
+
+in VertexData
+{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoord;
+	vec4 DiffuseColor;
+	vec4 SpecularColor;
+	vec4 BoneIndices1;
+	vec4 BoneIndices2;
+	vec4 BoneWeights1;
+	vec4 BoneWeights2;
+} Input;
+
+out vec4 frag_Diffuse;
+
+vec4 phong(vec3 position, vec3 normal, vec3 specular, float specularExponent)
+{
+	// Diffuse
+	vec3 lightPos = vec3(V * vec4(LightPosition, 1.0));
+	vec3 distanceToLight = lightPos - position;
+	vec3 directionToLight = normalize(distanceToLight);
+	float dotProd = dot(directionToLight, normal);
+	dotProd = max(dotProd, 0.0);
+	vec3 Idiffuse = LightDiffuse * dotProd;
+
+	// Specular
+	//vec3 reflection = reflect(-directionToLight, normal);
+	vec3 surfaceToViewer = normalize(-position);
+	vec3 halfWay = normalize(surfaceToViewer + directionToLight);
+	float dotSpecular = max(dot(halfWay, normal), 0.0);
+	float specularFactor = pow(dotSpecular, specularExponent);
+	vec3 Ispecular = specular * LightSpecular * specularFactor;
+
+	//Attenuation
+	float dist = distance(lightPos, position);
+	//float attenuation = 1.0 - pow(dist / LightRadius, 2);
+	float attenuation = pow(max(0.0f, 1.0 - (dist / LightRadius)), 2);
+
+	return vec4((Idiffuse + Ispecular) * attenuation, 1.0);
+}
+
+void main()
+{
+	vec4 normalTexel = texture(NormalMap, Input.TextureCoord);
+	mat3 TBN = mat3(Input.Tangent, Input.BiTangent, Input.Normal);
+	vec3 normal = normalize(vec4(TBN * normalTexel.xyz, 0.0).xyz);
+
+	vec4 specularTexel = texture(SpecularMap, Input.TextureCoord);
+
+	vec4 diffuseTexel = texture(DiffuseTexture, Input.TextureCoord);
+
+	//frag_Diffuse = phong(Input.Position, normalize(normal), specularTexel.rgb, specularTexel.a);
+	frag_Diffuse = diffuseTexel;
+}

src/game/Core/Shaders/PureForward/Vertex.glsl

@@ -0,0 +1,83 @@
+/*
+	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/>.
+*/
+
+#version 440
+
+uniform mat4 MVP;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout (location = 0) in vec3 Position;
+layout (location = 1) in vec3 Normal;
+layout (location = 2) in vec3 Tangent;
+layout (location = 3) in vec3 BiTangent;
+layout (location = 4) in vec2 TextureCoord;
+layout (location = 5) in vec4 DiffuseColor;
+layout (location = 6) in vec4 SpecularColor;
+layout (location = 7) in vec4 BoneIndices1;
+layout (location = 8) in vec4 BoneIndices2;
+layout (location = 9) in vec4 BoneWeights1;
+layout (location = 10) in vec4 BoneWeights2;
+
+out VertexData
+{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoord;
+	vec4 DiffuseColor;
+	vec4 SpecularColor;
+	vec4 BoneIndices1;
+	vec4 BoneIndices2;
+	vec4 BoneWeights1;
+	vec4 BoneWeights2;
+} Output;
+
+void main()
+{
+	mat4 boneTransform = mat4(1);
+	if (length(BoneWeights1 + BoneWeights2) > 0) {
+		boneTransform = BoneWeights1[0] * Bones[int(BoneIndices1[0])]
+					  + BoneWeights1[1] * Bones[int(BoneIndices1[1])]
+					  + BoneWeights1[2] * Bones[int(BoneIndices1[2])]
+					  + BoneWeights1[3] * Bones[int(BoneIndices1[3])]
+					  + BoneWeights2[0] * Bones[int(BoneIndices2[0])]
+					  + BoneWeights2[1] * Bones[int(BoneIndices2[1])]
+					  + BoneWeights2[2] * Bones[int(BoneIndices2[2])]
+					  + BoneWeights2[3] * Bones[int(BoneIndices2[3])];
+	}
+
+	//gl_Position = MVP * boneTransform * vec4(Position, 1.0);
+	gl_Position = MVP * vec4(Position, 1.0);
+
+	//TODO: Make sure that boneTransform works here.
+	Output.Position = (V * M * boneTransform * vec4(Position, 1.0)).xyz;
+	Output.Normal = (inverse(transpose(V * M)) * boneTransform * vec4(Normal, 0.0)).xyz;
+	Output.Tangent = Tangent;
+	Output.BiTangent = BiTangent;
+	Output.TextureCoord = TextureCoord;
+	Output.DiffuseColor = DiffuseColor;
+	Output.SpecularColor = SpecularColor;
+	Output.BoneIndices1 = BoneIndices1;
+	Output.BoneIndices2 = BoneIndices2;
+	Output.BoneWeights1 = BoneWeights1;
+	Output.BoneWeights2 = BoneWeights2;
+}

src/game/Core/World.cpp

@@ -161,7 +161,7 @@ void dd::World::Initialize()
 	}
 }
 
-void dd::World::CommitEntity(EntityID entity)
+int dd::World::CommitEntity(EntityID entity)
 {
 	for (auto pair : m_Systems)
 	{

src/game/Game/LevelSystem.cpp

@@ -10,26 +10,79 @@
 void dd::Systems::LevelSystem::Initialize()
 {
     EVENT_SUBSCRIBE_MEMBER(m_EContact, LevelSystem::OnContact);
+    EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, LevelSystem::LifeLost);
+    EVENT_SUBSCRIBE_MEMBER(m_EScoreEvent, LevelSystem::ScoreEvent);
+
+    for (int i = 0; i < Lives(); i++) {
+        CreateLife(i);
+    }
 
     return;
 }
 
-void dd::Systems::LevelSystem::Update(double dt) {
+void dd::Systems::LevelSystem::CreateLife(int number)
+{
+    auto life = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
+    transform->Position = glm::vec3(-4.f + number * 0.5f, -2.f, -5.f);
+    transform->Scale = glm::vec3(0.25f, 0.25f, 0.25f);
+
+    std::shared_ptr<Components::Life> lifeNr = m_World->AddComponent<Components::Life>(life);
+    lifeNr->Number = number;
+
+    auto model = m_World->AddComponent<Components::Model>(life);
+    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+
+    /*std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(life);
+    sprite->SpriteFile = "Textures/Ball.png";*/
+
+    m_World->CommitEntity(life);
+}
+
+void dd::Systems::LevelSystem::Update(double dt)
+{
     if (!m_Initialized) {
-        CreateBasicLevel(tRows, tLines, tSpaceBetweenBricks, tSpaceToEdge);
+        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
         m_Initialized = true;
     }
 }
 
+void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+    auto ball = m_World->GetComponent<Components::Ball>(entity);
+
+    if (ball != NULL) {
+        auto transformBall = m_World->GetComponent<Components::Transform>(entity);
+        if (transformBall->Position.y < -10) {
+            if (Lives() == PastLives()) {
+                Events::LifeLost e;
+                e.Entity = entity;
+                EventBroker->Publish(e);
+                Events::ResetBall be;
+                EventBroker->Publish(be);
+                return;
+            }
+        }
+    }
+
+    if (Lives() != PastLives()) {
+        auto life = m_World->GetComponent<Components::Life>(entity);
+        if (life != NULL) {
+            if (life->Number + 1 == PastLives()) {
+                m_World->RemoveEntity(entity);
+                SetPastLives(Lives());
+            }
+        }
+    }
+}
+
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, int spaceToEdge)
 {
     int num = 0;
-    numberOfBricks = rows * lines;
-    for (int i = 0; i < rows; i++)
-    {
+    SetNumberOfBricks(rows * lines);
+    for (int i = 0; i < rows; i++) {
         num++;
-        for (int j = 0; j < lines; j++)
-        {
+        for (int j = 0; j < Lines(); j++) {
             CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
         }
         if (num == 7)
@@ -43,19 +96,21 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
 {
     auto brick = m_World->CreateEntity();
     std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(brick);
-    std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(brick);
+    //std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(brick);
+    auto model = m_World->AddComponent<Components::Model>(brick);
     std::shared_ptr<Components::Brick> cBrick = m_World->AddComponent<Components::Brick>(brick);
     std::shared_ptr<Components::RectangleShape> cRec = m_World->AddComponent<Components::RectangleShape>(brick);
     std::shared_ptr<Components::Physics> cPhys = m_World->AddComponent<Components::Physics>(brick);
     std::string fileName = "Textures/Bricks/";
     fileName.append(std::to_string(num));
     fileName.append(".png");
-    sprite->SpriteFile =  fileName;
+    //sprite->SpriteFile =  fileName;
+    model->ModelFile = "Models/Test/Brick/Brick.obj";
     float x = spaceToEdge + line * spacesBetweenBricks.x;
     float y = spaceToEdge + row * spacesBetweenBricks.y;
-    transform->Scale = glm::vec3(1.6, 0.4, 0.);
+    transform->Scale = glm::vec3(1.6, 0.35, 0.5);
     transform->Position = glm::vec3(x - 7, y + 1, -10.f);
-    //sprite->Color = glm::vec4(1.f, 1.f, 1.f, 1.f);
+    cBrick->Score = 10 * num;
     m_World->CommitEntity(brick);
     return;
 }
@@ -68,72 +123,57 @@ void dd::Systems::LevelSystem::ProcessCollision()
 
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
-    auto brick = m_World->GetComponent<Components::Brick>(entity);
-    if (brick != NULL)
-    {
+    /*auto brick = m_World->GetComponent<Components::Brick>(entity);
+    if (brick != NULL) {
         numberOfBricks--;
-        if (numberOfBricks < 1)
-        {
+        if (numberOfBricks < 1) {
             EndLevel();
         }
-    }
+    }*/
     return;
 }
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 {
-    /*event.Entity1 - Vi vet inte vilken som.
-      event.Entity2 - */
     EntityID entityBrick = event.Entity1;
     auto brick = m_World->GetComponent<Components::Brick>(entityBrick);
-    if (brick == NULL)
-    {
+    if (brick == NULL) {
         return false;
     }
     EntityID entityBall = event.Entity2;
-    //EntityID entity1 = event.Entity1;
-    //EntityID entity2 = event.Entity2;
 
-    //auto brick = m_World->GetComponent<Components::Brick>(entity1);
-    //auto ball = m_World->GetComponent<Components::Ball>(entity2);
-    //std::cout << brick << std::endl;
-    //std::cout << ball << std::endl;
-    /*if (brick != NULL)
-    {
-        std::cout << "Entity1 is a brick!" << std::endl;
-        entityBrick = entity1;
-        if (ball != NULL)
-        {
-            std::cout << "Entity2 is a ball!" << std::endl;
-            entityBall = entity2;
-        }
+    m_World->RemoveEntity(entityBrick);
+
+    SetNumberOfBricks(NumberOfBricks() - 1);
+    if (NumberOfBricks() == 0) {
+        Events::ScoreEvent es;
+        es.Score = 500;
+        EventBroker->Publish(es);
+        Events::ResetBall e;
+        EventBroker->Publish(e);
+        CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
     }
-    else
-    {
-        brick = m_World->GetComponent<Components::Brick>(entity2);
-        if (brick != NULL)
-        {
-            std::cout << "Entity2 is a brick!" << std::endl;
-            entityBrick = entity2;
-        }
+    Events::ScoreEvent es;
+    es.Score = brick->Score;
+    EventBroker->Publish(es);
 
-        ball = m_World->GetComponent<Components::Ball>(entity1);
-        if (ball != NULL)
-        {
-            std::cout << "Entity1 is a ball!" << std::endl;
-            entityBall = entity1;
-        }
-    }
+    std::cout << "Score: " << Score() << std::endl;
 
-    if (entityBrick != NULL && entityBall != NULL)
-    {*/
-        //std::cout << "We're destroying!" << std::endl;
-        m_World->RemoveEntity(entityBrick);
+    return true;
+}
 
-        return true;
-    //}
+bool dd::Systems::LevelSystem::LifeLost(const dd::Events::LifeLost &event)
+{
+    SetLives(Lives() - 1);
 
-    return false;
+    return true;
+}
+
+bool dd::Systems::LevelSystem::ScoreEvent(const dd::Events::ScoreEvent &event)
+{
+    SetScore(Score() += event.Score);
+
+    return true;
 }
 
 void dd::Systems::LevelSystem::EndLevel()

src/game/Game/PadSystem.cpp

@@ -7,6 +7,7 @@
 #include "Core/World.h"
 #include <iostream>
 #include <Game/CPad.h>
+#include <Rendering/CPointLight.h>
 
 
 void dd::Systems::PadSystem::Initialize()
@@ -24,74 +25,118 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, PadSystem::OnKeyDown);
     EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, PadSystem::OnKeyUp);
     EVENT_SUBSCRIBE_MEMBER(m_EContact, PadSystem::OnContact);
+    EVENT_SUBSCRIBE_MEMBER(m_EResetBall, PadSystem::ResetBall);
 
     return;
 }
 
+void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
+{
+    auto ball = m_World->GetComponent<Components::Ball>(entity);
+    if (ball != NULL) {
+        if (ReplaceBall() == true) {
+            SetReplaceBall(false);
+
+            auto transformEntity = m_World->GetComponent<Components::Transform>(entity);
+            transformEntity->Position = glm::vec3(20, 20, -10);
+
+            //Temporary. Create new ball.
+            /*auto ent = m_World->CreateEntity();
+            std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+            transform->Position = glm::vec3(0.5f, 0.f, -10.f);
+            transform->Scale = glm::vec3(1.f, 1.f, 1.f);
+            std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(ent);
+            sprite->SpriteFile = "Textures/Ball.png";
+            std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+            std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
+            std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+            physics->Static = false;*/
+
+            auto ent = m_World->CreateEntity();
+            std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+            transform->Position = glm::vec3(0.5f, 0.f, -10.f);
+            transform->Scale = glm::vec3(1.f, 1.f, 1.f);
+            auto model = m_World->AddComponent<Components::Model>(ent);
+            model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+            //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
+            std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+            std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
+            std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+            physics->Static = false;
+
+            m_World->RemoveEntity(entity);
+            m_World->CommitEntity(ent);
+
+            Events::SetImpulse e;
+            e.Entity = ent;
+            e.Impulse = glm::vec2(0.f, -7.f);
+            e.Point = glm::vec2(transform->Position.x, transform->Position.y);
+            EventBroker->Publish(e);
+        }
+    }
+}
+
 void dd::Systems::PadSystem::Update(double dt)
 {
-    if (ent == 0) {
+    if (Entity() == 0) {
         for (auto it = m_World->GetEntities()->begin(); it != m_World->GetEntities()->end(); it++) {
             if (m_World->GetProperty<std::string>(it->first, "Name") == "Pad") {
-                ent = it->first;
-                transform = m_World->GetComponent<Components::Transform>(ent);
+                SetEntity(it->first);
+                SetTransform(m_World->GetComponent<Components::Transform>(Entity()));
+                SetPad(m_World->GetComponent<Components::Pad>(Entity()));
                 break;
             }
         }
     }
 
-    if (transform->Velocity.x < -400.f)
-    {
-        transform->Velocity.x = -400.f;
+    auto transform = Transform();
+    auto pad = Pad();
+    auto acceleration = Acceleration();
+
+    if (transform->Velocity.x < -pad->MaxSpeed) {
+        transform->Velocity.x = -pad->MaxSpeed;
     }
-    else if (transform->Velocity.x > 400.f)
-    {
-        transform->Velocity.x = 400.f;
+    else if (transform->Velocity.x > pad->MaxSpeed) {
+        transform->Velocity.x = pad->MaxSpeed;
     }
     transform->Position += transform->Velocity * (float)dt;
     transform->Velocity += acceleration  * (float)dt;
-    transform->Velocity -= transform->Velocity * (0.9f * (float)dt);
+    transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float)dt;
 
-
-
-    if (left)
-    {
-        acceleration.x = -20.f;
+    if (Left()) {
+        acceleration.x = -pad->AccelerationSpeed;
     }
-    else if (right)
-    {
-        acceleration.x = 20.f;
+    else if (Right()) {
+        acceleration.x = pad->AccelerationSpeed;
     }
-    else
-    {
+    else {
         acceleration.x = 0.f;
     }
 
+    SetTransform(transform);
+    SetPad(pad);
+    SetAcceleration(acceleration);
+
     return;
 }
 
 bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 {
     int val = event.KeyCode;
-    if (val == 265)
-    {
+    if (val == GLFW_KEY_UP) {
         //std::cout << "Up!" << std::endl;
-    }
-    else if (val == 264)
-    {
+    } else if (val == GLFW_KEY_DOWN) {
         //std::cout << "Down!" << std::endl;
-    }
-    else if (val == 263)
-    {
+    } else if (val == GLFW_KEY_LEFT) {
         //std::cout << "Left!" << std::endl;
         //acceleration.x = -0.01f;
-        left = true;
-    }
-    else if (val = 262)
-    {
+        SetLeft(true);
+    } else if (val == GLFW_KEY_RIGHT) {
         //std::cout << "Right!" << std::endl;
         //acceleration.x = 0.01f;
-        right = true;
+        SetRight(true);
+    } else if (val == GLFW_KEY_R) {
+        SetReplaceBall(true);
     }
     return true;
 }
@@ -99,21 +144,14 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 bool dd::Systems::PadSystem::OnKeyUp(const dd::Events::KeyUp &event)
 {
     int val = event.KeyCode;
-    if (val == 265)
-    {
+    if (val == GLFW_KEY_UP) {
 
-    }
-    else if (val == 264)
-    {
+    } else if (val == GLFW_KEY_DOWN) {
 
-    }
-    else if (val == 263)
-    {
-        left = false;
-    }
-    else if (val = 262)
-    {
-        right = false;
+    } else if (val == GLFW_KEY_LEFT) {
+        SetLeft(false);
+    } else if (val == GLFW_KEY_RIGHT) {
+        SetRight(false);
     }
     return true;
 }
@@ -123,27 +161,38 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
     /*
     EntityID entityBall = event.Entity2;
     auto ball = m_World->GetComponent<Components::Ball>(entityBall);
-    if (ball == NULL)
-    {
+    if (ball == NULL) {
         return false;
     }
     EntityID entityPad = event.Entity1;
     auto pad = m_World->GetComponent<Components::Pad>(entityPad);
-    if (pad == NULL)
-    {
+    if (pad == NULL) {
         return false;
     }
     auto transformBall = m_World->GetComponent<Components::Transform>(entityBall);
     auto transformPad = m_World->GetComponent<Components::Transform>(entityPad);
 
-    float movementMultiplier = 2.f;
+    float movementMultiplier = 4.f;
 
     //float movementX = (event.ContactPoint.x - transformPad->Position.x) * movementMultiplier;
     //float movementY = glm::cos((abs(movementX) / (3.2f * movementMultiplier)) * 3.14159265359f / 2) * 2.f;
+    if (whatX > 0) {
+        movementX = movementMultiplier * whatX;
+        //std::cout << "Right!" << std::endl;
+    } else {
+        movementX = movementMultiplier * whatX;
+        //std::cout << "Left!" << std::endl;
+    }
 
    // std::cout << movementX << " " << movementY << std::endl;
 
+    //float movementX = (event.ContactPoint.x - transformPad->Position.x) * movementMultiplier;
+    float movementY = glm::cos((abs(movementX) / ((1.6f) * movementMultiplier)) * 3.14159265359f / 2) + 1;
+
+    //std::cout << movementX << " " << movementY << std::endl;
+
     float len = glm::length<float>(transformBall->Velocity);
+    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
 
     transformBall->Velocity += glm::vec3(transformPad->Velocity.x, 0, 0);
     transformBall->Velocity = glm::normalize(transformBall->Velocity) * len;
@@ -153,18 +202,21 @@ bool dd::Systems::PadSystem::OnContact(const dd::Events::Contact &event)
      */
 }
 
+bool dd::Systems::PadSystem::ResetBall(const dd::Events::ResetBall &event)
+{
+    SetReplaceBall(true);
+    return true;
+}
+
 bool dd::Systems::PadSystem::PadSteeringInputController::OnCommand(const Events::InputCommand &event)
 {
     std::string command = event.Command;
 
     std::cout << "Command!" << std::endl;
 
-    if (command == "right")
-    {
+    if (command == "right") {
         std::cout << "Right!" << std::endl;
-    }
-    else if (command == "left")
-    {
+    } else if (command == "left") {
         std::cout << "Left!" << std::endl;
     }
 

src/game/Physics/PhysicsSystem.cpp

@@ -55,7 +55,13 @@ void dd::Systems::PhysicsSystem::Update(double dt)
         b2Body* body = i.second;
 
         auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+        if (! transformComponent)
+            continue;
 
+        if (body == nullptr) {
+            //LOG_ERROR("This body should not exist");
+            continue;
+        }
 
         if (m_World->GetEntityParent(entity) == 0) { //TODO: Make this work with childs too
             b2Vec2 position;
@@ -66,7 +72,6 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 
             body->SetTransform(position, angle);
 
-
             body->SetLinearVelocity(b2Vec2(transformComponent->Velocity.x, transformComponent->Velocity.y));
 
 
@@ -91,8 +96,14 @@ void dd::Systems::PhysicsSystem::Update(double dt)
         EntityID entity = i.first;
         b2Body* body = i.second;
 
-        auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+        if (body == nullptr) {
+            //LOG_ERROR("This body should not exist");
+            continue;
+        }
 
+        auto transformComponent = m_World->GetComponent<Components::Transform>(entity);
+        if (! transformComponent)
+            continue;
         if (m_World->GetEntityParent(entity) == 0) {
             b2Vec2 position = body->GetPosition();
             transformComponent->Position.x = position.x;
@@ -103,7 +114,6 @@ void dd::Systems::PhysicsSystem::Update(double dt)
 
             transformComponent->Orientation =  glm::quat(glm::vec3(0, 0, -angle));
 
-            //TODO: Fix this back for real bodies
             b2Vec2 velocity = body->GetLinearVelocity();
             transformComponent->Velocity.x = velocity.x;
             transformComponent->Velocity.y = velocity.y;
@@ -131,10 +141,13 @@ void dd::Systems::PhysicsSystem::OnEntityRemoved(EntityID entity)
 {
     b2Body* body = m_EntitiesToBodies[entity];
 
-    m_EntitiesToBodies.erase(entity);
-    m_BodiesToEntities.erase(body);
+    if (body != nullptr) {
+        m_EntitiesToBodies.erase(entity);
+        m_BodiesToEntities.erase(body);
+
+        m_PhysicsWorld->DestroyBody(body);
+    }
 
-    m_PhysicsWorld->DestroyBody(body);
 }
 
 

src/tests/CMakeLists.txt

@@ -10,7 +10,9 @@ include_directories(
 set(SOURCE_FILES
     main.cpp
     FileWatcherTest.cpp
+    EventTest.cpp
     ComponentCopyTest.cpp
+    EntityCloneTest.cpp
 )
 
 if(CMAKE_COMPILER_IS_GNUCXX)

src/tests/EntityCloneTest.cpp

@@ -0,0 +1,46 @@
+#include <boost/test/unit_test.hpp>
+#include "Core/EventBroker.h"
+#include "Core/World.h"
+#include "Core/CTemplate.h"
+using namespace dd;
+
+struct TestComponent : public Component
+{
+	int Int = 5;
+	float Float = 1.33333f;
+	double Double = 1.33333;
+	std::string String = "Hello World";
+};
+
+BOOST_AUTO_TEST_CASE(EntityCloneTest)
+{
+	// Setup world
+	std::shared_ptr<EventBroker> eventBroker = std::make_shared<EventBroker>();
+	World world(eventBroker);
+	world.ComponentFactory.Register<Components::Template>();
+	world.ComponentFactory.Register<TestComponent>();
+
+	// Create our original entity
+	EntityID entOriginal = world.CreateEntity();
+	world.AddComponent<Components::Template>(entOriginal);
+	world.AddComponent<TestComponent>(entOriginal);
+
+	// Clone it
+	EntityID entClone = world.CloneEntity(entOriginal);
+
+	// Check
+	// EntityID of clone should not be same as original (obviously)
+	BOOST_CHECK(entOriginal != entClone);
+	// Template component SHOULD be in clone
+	auto templateComponentClone = world.GetComponent<Components::Template>(entClone);
+	BOOST_REQUIRE(templateComponentClone != nullptr);
+	// Values should be the same across the clone
+	auto testComponentOriginal = world.GetComponent<TestComponent>(entOriginal);
+	BOOST_REQUIRE(testComponentOriginal != nullptr);
+	auto testComponentClone = world.GetComponent<TestComponent>(entClone);
+	BOOST_REQUIRE(testComponentClone != nullptr);
+	BOOST_CHECK(testComponentClone->Int == testComponentOriginal->Int);
+	BOOST_CHECK(testComponentClone->Float == testComponentOriginal->Float);
+	BOOST_CHECK(testComponentClone->Double == testComponentOriginal->Double);
+	BOOST_CHECK(testComponentClone->String == testComponentOriginal->String);
+}

src/tests/EventFixture.h

@@ -0,0 +1,54 @@
+#ifndef EVENTFIXTURE_H
+#define EVENTFIXTURE_H
+
+#include <boost/test/unit_test.hpp>
+#include "Core/EventBroker.h"
+
+template <typename EventType>
+struct EventFixture
+{
+	EventFixture()
+	{
+		this->EventBroker = new dd::EventBroker();
+		m_EEventType = decltype(m_EEventType)(std::bind(&OnEvent, this, std::placeholders::_1));
+		this->EventBroker->Subscribe(m_EEventType);
+		Run();
+		Check();
+	}
+	~EventFixture()
+	{
+		this->EventBroker->Unsubscribe(m_EEventType);
+		delete this->EventBroker;
+	}
+
+	dd::EventBroker* EventBroker = nullptr;
+	dd::EventRelay<EventFixture, EventType> m_EEventType;
+	bool m_EventRecieved = false;
+	EventType Before;
+	EventType After;
+
+	bool OnEvent(const EventType& event)
+	{
+		m_EventRecieved = true;
+		After = event;
+
+		return true;
+	}
+
+	void Run()
+	{
+		// Publish the event
+		this->EventBroker->Publish(Before);
+		// Clear to swap buffers
+		this->EventBroker->Clear();
+		// Process the event
+		this->EventBroker->template Process<EventFixture>();
+	}
+
+	void Check()
+	{
+		BOOST_CHECK(m_EventRecieved);
+	}
+};
+
+#endif

src/tests/EventTest.cpp

@@ -0,0 +1,21 @@
+#include <boost/test/unit_test.hpp>
+#include "EventFixture.h"
+
+using namespace dd;
+
+struct ETestEvent : public Event
+{
+	int Int = 5;
+	float Float = 1.33333f;
+	double Double = 1.33333;
+	std::string String = "Hello World";
+};
+
+BOOST_AUTO_TEST_CASE(EventBrokerTest)
+{
+	EventFixture<ETestEvent> f;
+	BOOST_CHECK(f.Before.Int == f.After.Int);
+	BOOST_CHECK_CLOSE(f.Before.Float, f.After.Float, 0.00001f);
+	BOOST_CHECK_CLOSE(f.Before.Double, f.After.Double, 0.00001f);
+	BOOST_CHECK(f.Before.String == f.After.String);
+}