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

Conflicts:
	include/Core/Engine.h
	src/game/Game/LevelSystem.cpp

.gitignore

@@ -2,5 +2,4 @@
 /bin/
 /lib/
 # CLion
-.idea/
-.orig
+.idea/

assets/Models/Submarine2.mtl

@@ -1,12 +0,0 @@
-# Blender MTL File: 'submarine.blend'
-# Material Count: 1
-
-newmtl Material
-Ns 96.078431
-Ka 0.000000 0.000000 0.000000
-Kd 0.640000 0.640000 0.640000
-Ks 0.500000 0.500000 0.500000
-Ni 1.000000
-d 1.000000
-illum 2
-map_Kd SubmarineTexture.png

assets/Models/Test/Ball/Sid.mtl

@@ -1,21 +0,0 @@
-# Blender MTL File: 'Sid.blend'
-# Material Count: 2
-
-newmtl Derp
-Ns 96.078431
-Ka 0.000000 0.000000 0.000000
-Kd 0.800000 0.800000 0.800000
-Ks 0.500000 0.500000 0.500000
-Ni 1.000000
-d 1.000000
-illum 2
-map_Kd SquidTexture.png
-
-newmtl None
-Ns 0
-Ka 0.000000 0.000000 0.000000
-Kd 0.8 0.8 0.8
-Ks 0.8 0.8 0.8
-d 1
-illum 2
-map_Kd SquidTexture.png

include/Core/Engine.h

@@ -45,67 +45,52 @@
 #include "Game/CPad.h"
 #include "Game/CBrick.h"
 #include "Game/BallSystem.h"
-#include "Game/HitLagSystem.h"
 #include "Game/Bricks/CPowerUpBrick.h"
 
 #include "Physics/PhysicsSystem.h"
 #include "Physics/CPhysics.h"
-#include "Physics/CRectangleShape.h"
+#include "Physics/CBoxShape.h"
 #include "Physics/ESetImpulse.h"
-#include "Physics/CWaterVolume.h"
-#include "Physics/CParticle.h"
-#include "Physics/CParticleEmitter.h"
 
-#include "Game/EGameStart.h"
-#include "Sound/EPlaySound.h"
-
-#include "GUI/Frame.h"
-#include "GUI/Button.h"
-#include "Game/MainMenu.h"
-#include "Game/HUD.h"
+#include "Core/EKeyDown.h"
 
 namespace dd
 {
 
 class Engine
 {
-
 public:
 	Engine(int argc, char* argv[]) {
-		m_EventBroker = std::make_shared<EventBroker>();
+        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->SetResolution(Rectangle(0, 0, 675, 1080));
+        m_Renderer = std::make_shared<Renderer>();
+        m_Renderer->SetFullscreen(false);
+        //m_Renderer->SetResolution(Rectangle(0, 0, 1920, 1080));
+        m_Renderer->SetResolution(Rectangle(0, 0, 675, 1080));
 		m_Renderer->Initialize();
 
-		m_FrameStack = new GUI::Frame(m_EventBroker.get());
-		m_FrameStack->Width = 675;
-		m_FrameStack->Height = 1080;
-		auto menu = new GUI::MainMenu(m_FrameStack, "MainMenu");
-
-		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
+        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>();
+
+
+        //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>();
 		m_World->ComponentFactory.Register<Components::Model>();
 		m_World->ComponentFactory.Register<Components::Template>();
 
 		m_World->ComponentFactory.Register<Components::CollisionSound>();
-		m_World->SystemFactory.Register<Systems::SoundSystem>(
-				[this]() { return new Systems::SoundSystem(m_World.get(), m_EventBroker); });
+		m_World->SystemFactory.Register<Systems::SoundSystem>([this]() { return new Systems::SoundSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::SoundSystem>();
 
-		m_World->ComponentFactory.Register<Components::Sprite>();
+        m_World->ComponentFactory.Register<Components::Sprite>();
 
-		m_World->ComponentFactory.Register<Components::RectangleShape>();
-		m_World->ComponentFactory.Register<Components::Physics>();
+        m_World->ComponentFactory.Register<Components::RectangleShape>();
+        m_World->ComponentFactory.Register<Components::Physics>();
 		m_World->ComponentFactory.Register<Components::Ball>();
 		m_World->ComponentFactory.Register<Components::Brick>();
 		m_World->ComponentFactory.Register<Components::Pad>();
@@ -114,242 +99,139 @@ public:
 		m_World->ComponentFactory.Register<Components::PowerUp>();
 		m_World->ComponentFactory.Register<Components::PowerUpBrick>();
 
-		m_World->SystemFactory.Register<Systems::LevelSystem>(
-				[this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
+        m_World->SystemFactory.Register<Systems::PhysicsSystem>(
+                [this]() { return new Systems::PhysicsSystem(m_World.get(), m_EventBroker); });
+        m_World->AddSystem<Systems::PhysicsSystem>();
+
+		m_World->SystemFactory.Register<Systems::LevelSystem>([this]() { return new Systems::LevelSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::LevelSystem>();
-		m_World->SystemFactory.Register<Systems::PadSystem>(
-				[this]() { return new Systems::PadSystem(m_World.get(), m_EventBroker); });
+		m_World->SystemFactory.Register<Systems::PadSystem>([this]() { return new Systems::PadSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::PadSystem>();
-		m_World->SystemFactory.Register<Systems::BallSystem>(
-				[this]() { return new Systems::BallSystem(m_World.get(), m_EventBroker); });
+		m_World->SystemFactory.Register<Systems::BallSystem>([this]() { return new Systems::BallSystem(m_World.get(), m_EventBroker); });
 		m_World->AddSystem<Systems::BallSystem>();
-		m_World->SystemFactory.Register<Systems::HitLagSystem>(
-				[this]() { return new Systems::HitLagSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::HitLagSystem>();
-		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->ComponentFactory.Register<Components::Model>();
+        m_World->ComponentFactory.Register<Components::Template>();
 		m_World->ComponentFactory.Register<Components::PointLight>();
-		m_World->ComponentFactory.Register<Components::WaterVolume>();
-		m_World->ComponentFactory.Register<Components::Particle>();
-		m_World->ComponentFactory.Register<Components::ParticleEmitter>();
-		m_World->Initialize();
+        m_World->Initialize();
 
 
+		//TODO: Remove tobias light-test code.
+		/*{
+		}*/
+
+		//OctoBall
+        {
+            auto ent = m_World->CreateEntity();
+            std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+            transform->Position = glm::vec3(-0.f, 0.26f, -10.f);
+			transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
+			transform->Velocity = glm::vec3(0.0f, -10.f, 0.f);
+
+            auto model = m_World->AddComponent<Components::Model>(ent);
+			model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+
+            std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+			std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
+			ball->Speed = 10.f;
+            std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+            physics->Static = false;
+
+			auto plight = m_World->AddComponent<Components::PointLight>(ent);
+			plight->Radius = 2.f;
+
+            m_World->CommitEntity(ent);
+
+
+        }
+
 		//PointLightTest
 		{
 			auto t_Light = m_World->CreateEntity();
 			auto transform = m_World->AddComponent<Components::Transform>(t_Light);
-			transform->Position = glm::vec3(-3.f, 6.f, -5.f);
+			transform->Position = glm::vec3(2.f, 1.5f, -9.f);
 			auto pl = m_World->AddComponent<Components::PointLight>(t_Light);
-			pl->Radius = 20.f;
-			pl->Diffuse = glm::vec3(0.8f, 0.7f, 0.05f);
-			auto model = m_World->AddComponent<Components::Model>(t_Light);
-			model->ModelFile = "Models/Core/UnitSphere.obj";
-			m_World->CommitEntity(t_Light);
-		}
-		{
-			auto t_Light = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(t_Light);
-			transform->Position = glm::vec3(3.f, -5.f, -5.f);
-			auto pl = m_World->AddComponent<Components::PointLight>(t_Light);
-			pl->Radius = 15.f;
-			pl->Diffuse = glm::vec3(0.1f, 0.5f, 0.8f);
-			auto model = m_World->AddComponent<Components::Model>(t_Light);
-			model->ModelFile = "Models/Core/UnitSphere.obj";
-			m_World->CommitEntity(t_Light);
+			pl->Radius = 8.f;
 		}
 
 		//Halfpipe background test model.
 		{
 			auto t_halfPipe = m_World->CreateEntity();
 			auto transform = m_World->AddComponent<Components::Transform>(t_halfPipe);
-			transform->Position = glm::vec3(0.f, 0.f, -15.f);
-			transform->Scale = glm::vec3(6.f, 6.f, 10.f);
+			transform->Position = glm::vec3(0.f, 0.f, -13.f);
+			transform->Scale = glm::vec3(5.f);
 			auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
 			model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
-			model->Color = glm::vec4(1.f, 0.f, 0.f, 0.3f);
-			m_World->CommitEntity(t_halfPipe);
 		}
 
-		//Background
-		{
-			auto background = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(background);
-			transform->Position = glm::vec3(0.f, 0.f, -30.f);
-			transform->Scale = glm::vec3(2681.f / 50.f, 1080.f / 50.f, 1.f);
-			auto sprite = m_World->AddComponent<Components::Sprite>(background);
-			sprite->SpriteFile = "Textures/Background.png";
-			m_World->CommitEntity(background);
-		}
-
-		//ParticleTest
-//		{
-//			auto Pe = m_World->CreateEntity();
-//			auto transform = m_World->AddComponent<Components::Transform>(Pe);
-//			auto particleEmitter= m_World->AddComponent<Components::ParticleEmitter>(Pe);
-//
-//			transform->Position = glm::vec3(0.f, -5.f, -10.f);
-//			particleEmitter->GravityScale = 0.0f;
-//			particleEmitter->SpawnRate = 1.0f;
-//
-//			{
-//				auto Pt = m_World->CreateEntity(Pe);
-//				auto PtTransform = m_World->AddComponent<Components::Transform>(Pt);
-//				auto PtSprite = m_World->AddComponent<Components::Sprite>(Pt);
-//				//auto PtModel = m_World->AddComponent<Components::Model>(Pt);
-//				auto PtParticle = m_World->AddComponent<Components::Particle>(Pt);
-//				auto PtTemplate = m_World->AddComponent<Components::Template>(Pt);
-//
-//				PtTransform->Velocity = glm::vec3(1.0f, 0.f, 0.f);
-//				PtTransform->Position = transform->Position;
-//				PtSprite->SpriteFile = "Textures/Ball.png";
-//
-//				//PtModel->ModelFile = "Models/Brick/Brick.obj";
-//				PtParticle->LifeTime = 1000.f;
-//				PtParticle->Flags = ParticleFlags::Type::powderParticle;
-//			}
-//			m_World->CommitEntity(Pe);
-//		}
-
-		{
-			auto Pt = m_World->CreateEntity();
-			auto PtTransform = m_World->AddComponent<Components::Transform>(Pt);
-			auto PtSprite = m_World->AddComponent<Components::Sprite>(Pt);
-
-			PtTransform->Position = glm::vec3(2.f, 0.f, -10.f);
-			PtSprite->SpriteFile = "Textures/Ball.png";
-		}
-		
-		//Water test
-		{
-			float amount = 1.5f;
-
-			auto t_waterBody = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
-			transform->Position = glm::vec3(0.f, -6.25f + (amount / 2), -10.f);
-			transform->Scale = glm::vec3(7.f, amount, 1.f);
-			auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
-			auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
-			m_World->CommitEntity(t_waterBody);
-		}
-
-		//TODO: Why does the ball not collide with these bricks?
-		//BottomBox
 		{
 			auto topWall = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(topWall);
-			transform->Position = glm::vec3(0.f, -6.f, -9.9f);
-			transform->Scale = glm::vec3(10.f, 0.5f, 1.f);
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					topWall);
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-			physics->Static = true;
-			m_World->CommitEntity(topWall);
-		}
-		//SideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(3.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.f, 1.f);
-//			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-//			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-//			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
-//		//OtherSideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(-4.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.0f, 1.f);
-//			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-//			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-//			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
-
-		/*{
-			auto topWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					topWall);
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
 			transform->Position = glm::vec3(0.f, 6.f, -10.f);
 			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
 
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					topWall);
+			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(topWall);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
 			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
 
 			m_World->CommitEntity(topWall);
-		}*/
-
+		}
 		{
 			auto leftWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					leftWall);
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(leftWall);
 			transform->Position = glm::vec3(-4.f, 1.f, -10.f);
-			transform->Scale = glm::vec3(0.5f, 35.f, 1.f);
+			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
 
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(leftWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					leftWall);
+			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(leftWall);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
 			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
 
 			m_World->CommitEntity(leftWall);
 		}
-
 		{
 			auto rightWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					rightWall);
+			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(rightWall);
 			transform->Position = glm::vec3(4.f, 1.f, -10.f);
-			transform->Scale = glm::vec3(0.5f, 35.f, 1.f);
+			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
 
 			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(rightWall);
 			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
 
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					rightWall);
+			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(rightWall);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
 			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
 
 			m_World->CommitEntity(rightWall);
 		}
 
+		{
+			auto ent = m_World->CreateEntity();
+			m_World->SetProperty(ent, "Name", "Pad");
+			auto ctransform = m_World->AddComponent<Components::Transform>(ent);
+			ctransform->Position = glm::vec3(0.f, -5.f, -10.f);
+			ctransform->Scale = glm::vec3(1.6, 0.4, 0.);
+			auto rectangle = m_World->AddComponent<Components::RectangleShape>(ent);
+			auto physics = m_World->AddComponent<Components::Physics>(ent);
+			physics->Static = false;
+			auto csprite = m_World->AddComponent<Components::Sprite>(ent);
+			auto pad = m_World->AddComponent<Components::Pad>(ent);
+			csprite->SpriteFile = "Textures/Pad.png";
+			m_World->CommitEntity(ent);
+		}
 
-		//EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &Engine::OnGameStart);
-		m_EGameStart = decltype(m_EGameStart)(std::bind(&Engine::OnGameStart, this, std::placeholders::_1));
-		m_EventBroker->Subscribe(m_EGameStart);
-
-			m_LastTime = glfwGetTime();
+		//EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::OnStopSound);
+		m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Engine::OnKeyDown, this, std::placeholders::_1));
+		m_EventBroker->Subscribe(m_EKeyDown);
+		m_LastTime = glfwGetTime();
 	}
 
 	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
@@ -360,32 +242,61 @@ public:
 		double dt = currentTime - m_LastTime;
 		m_LastTime = currentTime;
 
+		double start = glfwGetTime();
+		ResourceManager::Update();
+		double stop = glfwGetTime();
+		double time = stop - start;
+		tm.resourceManagerT += time;
+
 		// Update input
+		start = glfwGetTime();
 		m_InputManager->Update(dt);
-		// Swap event queues to get fresh input data in the read queue
-		//m_EventBroker->Swap();
+		stop = glfwGetTime();
+		time = stop - start;
+		tm.inputManagerT += time;
 
-		//ResourceManager::Update();
-		if (m_GameIsRunning) {
-			m_World->Update(dt);
-		}
-		m_EventBroker->Process<GUI::Frame>();
-		m_FrameStack->UpdateLayered(dt);
+		start = glfwGetTime();
+		m_World->Update(dt);
+		stop = glfwGetTime();
+		time = stop - start;
+		tm.worldT += time;
 
-		m_RendererQueue.Clear();
-		m_FrameStack->DrawLayered(m_RendererQueue);
+
+//
+//		if (glfwGetKey(m_Renderer->Window(), GLFW_KEY_R)) {
+//			ResourceManager::Reload("Shaders/Deferred/3/Fragment.glsl");
+//		}
+//
 		//TODO Fill up the renderQueue with models (Temp fix)
-		if (m_GameIsRunning) {
-			TEMPAddToRenderQueue();
-		}
+//		TEMPAddToRenderQueue();
 
 		// Render scene
 		//TODO send renderqueue to draw.
+//		m_Renderer->Draw(m_RendererQueue);
+
+		if (glfwGetKey(m_Renderer->Window(), GLFW_KEY_R)) {
+			ResourceManager::Reload("Shaders/Deferred/3/Fragment.glsl");
+		}
+
+		//TODO Fill up the renderQueue with models (Temp fix)
+		start = glfwGetTime();
+		TEMPAddToRenderQueue();
+		stop = glfwGetTime();
+		time = stop - start;
+		tm.addToRenderQueueT += time;
+
+		// Render scene
+		//TODO send renderqueue to draw.
+		start = glfwGetTime();
 		m_Renderer->Draw(m_RendererQueue);
+		stop = glfwGetTime();
+		time = stop - start;
+		tm.rendererT += time;
 
 		m_EventBroker->Process<Engine>();
+
 		// Swap event queues
-		m_EventBroker->Swap();
+		m_EventBroker->Clear();
 
 		glfwPollEvents();
 	}
@@ -396,9 +307,12 @@ public:
 	//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;
@@ -427,6 +341,8 @@ public:
 				}
 			}
 
+			//TODO: Add LightLoadShit
+
 			auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
 			if (pointLightComponent)
 			{
@@ -437,23 +353,11 @@ public:
 								  pointLightComponent->Radius);
 			}
 
-			auto parent = m_World->GetEntityParent(entity);
-			if(parent != 0) {
-				auto waterParticleComponent = m_World->GetComponent<Components::WaterVolume>(parent);
-				if (waterParticleComponent) {
-					//TODO: Remove hardcoded color.
-					//TODO: Do i even need modelMatrix?
-					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-					glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
-											* glm::scale(absoluteTransform.Scale);
-					EnqueueWaterParticles(absoluteTransform.Position, glm::vec4(1.f, 1.f, 1.f, 1.f), modelMatrix, absoluteTransform.Position.z);
-				}
-			}
-
 
 			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
 			if (spriteComponent)
 			{
+
 				std::string normal = spriteComponent->NormalTexture;
 				std::string spec = spriteComponent->SpecularTexture;
 
@@ -476,6 +380,8 @@ public:
 				EnqueueSprite(texturediff, texturenorm, texturespec, modelMatrix, spriteComponent->Color, absoluteTransform.Position.z);
 			}
 		}
+
+		m_RendererQueue.Sort();
 	}
 
 	//TODO: Get this out of engine.h
@@ -494,6 +400,7 @@ public:
 			job.EndIndex = texGroup.EndIndex;
 			job.ModelMatrix = modelMatrix;
 			job.Color = color;
+			job.fileName = fileName;
 
 			m_RendererQueue.Deferred.Add(job);
 		}
@@ -527,46 +434,61 @@ public:
 
 	}
 
-	void EnqueueWaterParticles(glm::vec3 position, glm::vec4 color, glm::mat4 modelMatrix, float depth)
-	{
-		WaterParticleJob job;
-		job.Position = position;
-		job.Color = color;
-		job.ModelMatrix = modelMatrix;
-		job.Depth = depth;
-
-		m_RendererQueue.Forward.Add(job);
-	}
-
 private:
+	std::shared_ptr<ResourceManager> m_ResourceManager;
 	std::shared_ptr<EventBroker> m_EventBroker;
-	GUI::Frame* m_FrameStack = nullptr;
 	std::shared_ptr<Renderer> m_Renderer;
 	RenderQueueCollection m_RendererQueue;
 	std::shared_ptr<InputManager> m_InputManager;
 	std::shared_ptr<World> m_World;
 
-	//TODO: Redo
-	bool m_GameIsRunning = false;
-	dd::EventRelay<Engine, dd::Events::GameStart> m_EGameStart;
-	bool OnGameStart(const dd::Events::GameStart &event)
+	struct TickMetric
 	{
-		m_GameIsRunning = true;
-		//Todo: Move this
+		double resourceManagerT = 0;
+		double inputManagerT = 0;
+		double worldT = 0;
+		double addToRenderQueueT = 0;
+		double rendererT = 0;
+		double Total()
 		{
-			dd::Events::PlaySound e;
-			e.FilePath = "Sounds/BGM/under-the-sea-instrumental.wav";
-			e.IsAmbient = true;
-			m_EventBroker->Publish(e);
-		}
+			return resourceManagerT
+				   + inputManagerT
+				   + worldT
+				   + addToRenderQueueT
+				   + rendererT;
+		};
+	};
+	TickMetric tm;
+
+	dd::EventRelay<Engine, dd::Events::KeyDown> m_EKeyDown;
+	bool OnKeyDown(const dd::Events::KeyDown &event)
+	{
+		if (event.KeyCode == 78)
 		{
-			dd::Events::PlaySound e;
-			e.FilePath = "Sounds/BGM/water-flowing.wav";
-			e.Gain = 0.3f;
-			e.IsAmbient = true;
-			m_EventBroker->Publish(e);
+			double total = tm.Total();
+
+			std::ofstream outFile;
+			outFile.open("../tools/engine-metrics.txt");
+			outFile.clear();
+			outFile << "----------------------- Time measurements -----------------------\n";
+			outFile << "Type: ResourceManager->Update()" << std::endl;
+			outFile << "Total: " << tm.resourceManagerT / total * 100 << " %" << std::endl << std::endl;
+			outFile << "Type: InputManager->Update()" << std::endl;
+			outFile << "Total: " << tm.inputManagerT / total * 100 << " %" << std::endl << std::endl;
+			outFile << "Type: World->Update()" << std::endl;
+			outFile << "Total: " << tm.worldT / total * 100 << " %" << std::endl << std::endl;
+			outFile << "Type: AddToRenderQueue()" << std::endl;
+			outFile << "Total: " << tm.addToRenderQueueT / total * 100 << " %" << std::endl << std::endl;
+			outFile << "Type: Renderer->Draw()" << std::endl;
+			outFile << "Total: " << tm.rendererT / total * 100 << " %" << std::endl << std::endl;
+			outFile  << "-----------------------------------------------------------------";
+			outFile.close();
+			return true;
 		}
 	};
+
+
+
 	double m_LastTime;
 };
 

include/Core/EventBroker.h

@@ -119,7 +119,7 @@ public:
 	template <typename ContextType>
 	int Process();
 	int Process(std::string contextTypeName);
-	void Swap();
+	void Clear();
 	void Unsubscribe(BaseEventRelay &relay);
 
 private:

include/Core/PNG.h

@@ -33,6 +33,9 @@ class PNG : public Image
 public:
 	PNG(std::string path);
 	~PNG();
+
+private:
+
 };
 
 }

include/Core/RenderQueue.h

@@ -22,9 +22,8 @@
 #include <cstdint>
 #include <forward_list>
 
-#include "Core/Util/Rectangle.h"
-#include "Core/Texture.h"
-#include "Core/Model.h"
+#include "Texture.h"
+#include "Model.h"
 
 namespace dd
 {
@@ -53,8 +52,8 @@ struct ModelJob : RenderJob
 	unsigned int ShaderID;
 	unsigned int TextureID;
 
-	glm::mat4 ProjectionMatrix;
-	glm::mat4 ViewMatrix;
+	std::string fileName;
+
 	glm::mat4 ModelMatrix;
 	GLuint DiffuseTexture;
 	GLuint NormalTexture;
@@ -91,8 +90,6 @@ struct SpriteJob : RenderJob
 	unsigned int ShaderID;
 	unsigned int TextureID;
 
-	glm::mat4 ProjectionMatrix;
-	glm::mat4 ViewMatrix;
 	glm::mat4 ModelMatrix;
 	GLuint DiffuseTexture;
 	GLuint NormalTexture;
@@ -118,30 +115,6 @@ struct PointLightJob : RenderJob
 	}
 };
 
-struct FrameJob : SpriteJob
-{
-	Rectangle Scissor;
-	Rectangle Viewport;
-	std::string Name;
-
-	void CalculateHash() override
-	{
-		Hash = 0;
-	}
-};
-
-struct WaterParticleJob : RenderJob
-{
-	glm::vec3 Position;
-	glm::vec4 Color;
-	glm::mat4 ModelMatrix;
-
-	void CalculateHash() override
-	{
-		Hash = 0;
-	}
-};
-
 class RenderQueue
 {
 public:
@@ -149,8 +122,7 @@ public:
 	void Add(T &job)
 	{
 		job.CalculateHash();
-		Jobs.push_back(std::shared_ptr<T>(new T(job)));
-		m_Size++;
+		Jobs.push_front(std::shared_ptr<T>(new T(job)));
 	}
 
 	void Sort()
@@ -161,24 +133,19 @@ public:
 	void Clear()
 	{
 		Jobs.clear();
-		m_Size = 0;
 	}
 
-	int Size() const { return m_Size; }
-	std::list<std::shared_ptr<RenderJob>>::const_iterator begin()
+	std::forward_list<std::shared_ptr<RenderJob>>::const_iterator begin()
 	{
 		return Jobs.begin();
 	}
 
-	std::list<std::shared_ptr<RenderJob>>::const_iterator end()
+	std::forward_list<std::shared_ptr<RenderJob>>::const_iterator end()
 	{
 		return Jobs.end();
 	}
 
-	std::list<std::shared_ptr<RenderJob>> Jobs;
-
-private:
-	int m_Size = 0;
+	std::forward_list<std::shared_ptr<RenderJob>> Jobs;
 };
 
 struct RenderQueueCollection
@@ -186,14 +153,12 @@ struct RenderQueueCollection
 	RenderQueue Deferred;
 	RenderQueue Forward;
 	RenderQueue Lights;
-	RenderQueue GUI;
 
 	void Clear()
 	{
 		Deferred.Clear();
 		Forward.Clear();
 		Lights.Clear();
-		GUI.Clear();
 	}
 
 	void Sort()
@@ -201,7 +166,6 @@ struct RenderQueueCollection
 		Deferred.Sort();
 		Forward.Sort();
 		Lights.Sort();
-		GUI.Sort();
 	}
 };
 

include/Core/Renderer.h

@@ -16,8 +16,8 @@
 	along with Daydream Engine.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef DD_RENDERER_H__
-#define DD_RENDERER_H__
+#ifndef Renderer_h__
+#define Renderer_h__
 
 #include "Util/Rectangle.h"
 #include "Camera.h"
@@ -30,6 +30,8 @@ namespace dd
 class Renderer
 {
 public:
+	//Render();
+
 	GLFWwindow* Window() const { return m_Window; }
 	Rectangle Resolution() const { return m_Resolution; }
 	void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
@@ -37,6 +39,8 @@ public:
 	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
 	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
+	//void SetViewport(const Rectangle& viewport) { m_Viewport = viewport; }
+	//void SetScissor(const Rectangle& scissor) { m_Scissor = scissor; }
 	const dd::Camera* Camera() const { return m_Camera; }
 	void SetCamera(const dd::Camera* camera)
 	{
@@ -46,6 +50,7 @@ public:
 			m_Camera = camera;
 		}
 	}
+
 	void Initialize();
 	void Draw(RenderQueueCollection& rq);
 
@@ -53,6 +58,8 @@ private:
 	Rectangle m_Resolution = Rectangle(1280, 720);
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
+	//Rectangle m_Viewport;
+	//Rectangle m_Scissor;
 	std::unique_ptr<dd::Camera> m_DefaultCamera = nullptr;
 	const dd::Camera* m_Camera = nullptr;
 
@@ -60,43 +67,33 @@ private:
 	std::string m_GLVendor;
 	GLFWwindow* m_Window = nullptr;
 
-	ShaderProgram* m_SpDeferred1;
-	ShaderProgram* m_SpDeferred2;
-	ShaderProgram* m_SpDeferred3;
-	ShaderProgram* m_SpForward;
-	ShaderProgram* m_SpScreen;
-	ShaderProgram* m_SpWater;
-	ShaderProgram* m_SpWater2;
+	ShaderProgram* m_spDeferred1;
+	ShaderProgram* m_spDeferred2;
+	ShaderProgram* m_spDeferred3;
+	ShaderProgram* m_spForward;
+	ShaderProgram* m_spScreen;
 
 	GLuint m_ScreenQuad = 0;
 	Model* m_UnitSphere = nullptr;
 	Model* m_UnitQuad = nullptr;
 	Texture* m_StandardNormal;
 	Texture* m_StandardSpecular;
-	Texture* m_WhiteSphereTexture;
 
-	GLuint m_RbDepthBuffer = 0;	//DepthBuffer Texture
-	GLuint m_FbDeferred1 = 0;	//Framebuffer for first pass
-	GLuint m_GDiffuse = 0;		//Texture for diffuseColors
-	GLuint m_GPosition = 0;		//Texture for positions
-	GLuint m_GNormal = 0;		//Texture for normals
-	GLuint m_GSpecular = 0;		//Texture for specular
-	GLuint m_FbDeferred2 = 0;	//Framebuffer that handles the lighting pass
-	GLuint m_TLighting = 0;		//Texture for the lighting pass
-	GLuint m_FbDeferred3 = 0;	//Frambuffer for handling the last pass.
-	GLuint m_TFinal = 0;		//Final Texture to be printed to screen
-	GLuint m_Gwater = 0;		//Water Color Texture
-	GLuint m_BWater;			//Water blur texture
-	GLuint m_BWater2;			//Water blur texture
-	GLuint m_FbWater;			//Waterpass Framebuffer
-	GLuint m_FbWaterBlur; 		//Waterpass Framebuffer
-	GLuint m_FbWaterBlur2;		//Waterpass Framebuffer
+	GLuint m_rbDepthBuffer = 0;
+	GLuint m_fbDeferred1 = 0;
+	GLuint m_GDiffuse = 0;
+	GLuint m_GPosition = 0;
+	GLuint m_GNormal = 0;
+	GLuint m_GSpecular = 0;
+	GLuint m_fbDeferred2 = 0;
+	GLuint m_tLighting = 0;
+	GLuint m_fbDeferred3 = 0;
+	GLuint m_tFinal = 0;
 
 	GLuint m_CurrentScreenBuffer = 0;
 	void LoadShaders();
 	void CreateBuffers();
 	GLuint CreateQuad();
-	GLuint CreateWaterParticleVAO(RenderQueue &particles);
 
 	static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
 
@@ -104,8 +101,6 @@ private:
 	void DrawForward(RenderQueue &objects, RenderQueue &lights);
 	void DrawScene(RenderQueue &objects, ShaderProgram &program);
 	void DrawLightSpheres(RenderQueue &lights);
-	void DrawWater(RenderQueue &objects);
-	void DrawGUI(RenderQueue& rq);
 	void DebugKeys();
 };
 

include/Core/Texture.h

@@ -43,9 +43,6 @@ public:
 
 	operator GLuint() const { return m_Texture; }
 
-	unsigned int Width = 0;
-	unsigned int Height = 0;
-
 private:
 	GLuint m_Texture = 0;
 };

include/Core/Util/Rectangle.h

@@ -44,30 +44,29 @@ struct Rectangle
 	int Height;
 
 	virtual int Left() const { return X; }
-	virtual void SetLeft(int left)
+	void SetLeft(int left)
 	{
-		//Width += X - left;
+		Width += X - left;
 		X = left;
 	}
 	virtual int Right() const { return X + Width; }
-	virtual void SetRight(int right)
+	void SetRight(int right)
 	{
 		Width = right - X;
 	}
 	virtual int Top() const { return Y; }
-	virtual void SetTop(int top)
+	void SetTop(int top)
 	{
-		//Height += Y - top;
+		Height += Y - top;
 		Y = top;
 	}
 	virtual int Bottom() const { return Y + Height; }
-	virtual void SetBottom(int bottom)
+	int SetBottom(int bottom)
 	{
 		Height = bottom - Y;
 	}
 
-	Rectangle& operator+=(const Rectangle &rhs)
-	{
+	Rectangle& operator+=(const Rectangle &rhs)	{
 		SetLeft(std::min(Left(), rhs.Left()));
 		SetRight(std::max(Right(), rhs.Right()));
 		SetTop(std::min(Top(), rhs.Top()));

include/Core/World.h

@@ -37,6 +37,8 @@
 #include "EComponentCreated.h"
 #include "ResourceManager.h"
 
+#include "EKeyDown.h"
+
 namespace dd
 {
 
@@ -52,6 +54,10 @@ public:
 		, m_LastEntityID(0) { }
 	~World() { }
 
+	dd::EventRelay<World, dd::Events::KeyDown> m_EKeyDown;
+	bool OnKeyDown(const dd::Events::KeyDown &event);
+
+
 	/** Initialize the world.
 
 		
@@ -248,6 +254,15 @@ protected:
 	EntityID GenerateEntityID();
 
 	void RecycleEntityID(EntityID id);
+
+private:
+	//Benchmarking
+	struct TimeMeasure	{
+		double EventTime;
+		double SystemTime;
+		double RSystemTime;
+	};
+	std::map<std::string, TimeMeasure> m_typeToTimeMap;
 };
 
 template <class T>

include/GUI/Button.h

@@ -1,147 +0,0 @@
-#ifndef GUI_BUTTON_H__
-#define GUI_BUTTON_H__
-
-#include "GUI/TextureFrame.h"
-#include "GUI/EButtonEnter.h"
-#include "GUI/EButtonLeave.h"
-#include "GUI/EButtonPress.h"
-#include "GUI/EButtonRelease.h"
-#include "Core/EMouseMove.h"
-#include "Core/EMousePress.h"
-#include "Core/EMouseRelease.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class Button : public TextureFrame
-{
-public:
-	Button(Frame* parent, std::string name)
-		: TextureFrame(parent, name)
-	{
-		EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &Button::OnMouseMove);
-		EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &Button::OnMousePress);
-		EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &Button::OnMouseRelease);
-	}
-
-	void SetTextureHover(std::string resourceName)
-	{
-		m_TextureHover = resourceName;
-	}
-	void SetTextureReleased(std::string resourceName)
-	{
-		m_TextureReleased = resourceName;
-		SetTexture(resourceName);
-	}
-	void SetTexturePressed(std::string resourceName)
-	{
-		m_TexturePressed = resourceName;
-	}
-
-	void Draw(RenderQueueCollection& rq) override
-	{
-		if (m_Texture == nullptr && !m_TextureReleased.empty()) {
-			SetTexture(m_TextureReleased);
-		}
-
-		TextureFrame::Draw(rq);
-	}
-
-	virtual void OnEnter() { }
-	virtual void OnLeave() { }
-	virtual void OnPress() { }
-	virtual void OnRelease() { }
-
-protected:
-	bool m_MouseIsOver = false;
-	bool m_IsDown = false;
-
-	virtual bool OnMouseMove(const Events::MouseMove& event)
-	{
-		bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
-		if (isOver && !m_MouseIsOver) { // Enter
-			if (!m_IsDown) {
-				if (!m_TextureHover.empty()) {
-					SetTexture(m_TextureHover);
-				}
-			}
-			OnEnter();
-			Events::ButtonEnter e;
-			e.FrameName = m_Name;
-			EventBroker->Publish(e);
-		} else if (!isOver && m_MouseIsOver) { // Leave
-			if (!m_IsDown) {
-				if (!m_TextureReleased.empty()) {
-					SetTexture(m_TextureReleased);
-				}
-			}
-			OnLeave();
-			Events::ButtonLeave e;
-			e.FrameName = m_Name;
-			EventBroker->Publish(e);
-		}
-		m_MouseIsOver = isOver;
-
-		return true;
-	}
-	virtual bool OnMousePress(const Events::MousePress& event)
-	{
-		if (!Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1))) {
-			return false;
-		}
-
-		if (!m_TexturePressed.empty()) {
-			SetTexture(m_TexturePressed);
-		}
-
-		m_IsDown = true;
-		OnPress();
-		Events::ButtonPress e;
-		e.FrameName = m_Name;
-		e.Button = this;
-		EventBroker->Publish(e);
-
-		return true;
-	}
-	virtual bool OnMouseRelease(const Events::MouseRelease& event)
-	{
-		bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
-		if (!isOver && !m_IsDown) {
-			return false;
-		}
-
-		if (m_MouseIsOver) {
-			if (!m_TextureHover.empty()) {
-				SetTexture(m_TextureHover);
-			}
-		} else {
-			if (!m_TextureReleased.empty()) {
-				SetTexture(m_TextureReleased);
-			}
-		}
-
-		m_IsDown = false;
-		OnRelease();
-		Events::ButtonRelease e;
-		e.FrameName = m_Name;
-		e.Button = this;
-		EventBroker->Publish(e);
-
-		return true;
-	}
-
-private:
-	EventRelay<Frame, Events::MouseMove> m_EMouseMove;
-	EventRelay<Frame, Events::MousePress> m_EMousePress;
-	EventRelay<Frame, Events::MouseRelease> m_EMouseRelease;
-
-	std::string m_TextureHover;
-	std::string m_TexturePressed;
-	std::string m_TextureReleased;
-};
-
-}
-}
-#endif

include/GUI/EButtonEnter.h

@@ -1,40 +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/>.
-*/
-
-#ifndef Events_ButtonEnter_h__
-#define Events_ButtonEnter_h__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-/** Thrown on GUI button hover. */
-struct ButtonEnter : Event
-{
-	std::string FrameName;
-};
-
-}
-
-}
-
-#endif // Events_ButtonEnter_h__

include/GUI/EButtonLeave.h

@@ -1,40 +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/>.
-*/
-
-#ifndef Events_ButtonLeave_h__
-#define Events_ButtonLeave_h__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-/** Thrown on GUI button hover. */
-struct ButtonLeave : Event
-{
-	std::string FrameName;
-};
-
-}
-
-}
-
-#endif // Events_ButtonLeave_h__

include/GUI/EButtonPress.h

@@ -1,43 +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/>.
-*/
-
-#ifndef Events_ButtonPress_h__
-#define Events_ButtonPress_h__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace GUI { class Button; }
-
-namespace Events
-{
-
-/** Thrown on GUI button press. */
-struct ButtonPress : Event
-{
-	std::string FrameName;
-	GUI::Button* Button;
-};
-
-}
-
-}
-
-#endif // Events_ButtonPress_h__

include/GUI/EButtonRelease.h

@@ -1,43 +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/>.
-*/
-
-#ifndef Events_ButtonRelease_h__
-#define Events_ButtonRelease_h__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace GUI { class Button; }
-
-namespace Events
-{
-
-/** Thrown on GUI button release. */
-struct ButtonRelease : Event
-{
-	std::string FrameName;
-	GUI::Button* Button;
-};
-
-}
-
-}
-
-#endif // Events_ButtonRelease_h__

include/GUI/ESliderUpdate.h

@@ -1,45 +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/>.
-*/
-
-#ifndef Events_SliderUpdate_h__
-#define Events_SliderUpdate_h__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace GUI { class Slider; }
-
-namespace Events
-{
-
-/** Thrown when GUI slider is moved. */
-struct SliderUpdate : Event
-{
-	std::string FrameName;
-	GUI::Slider* Slider;
-	float Percentage;
-	float DeltaPercentage;
-};
-
-}
-
-}
-
-#endif // Events_SliderUpdate_h__

include/GUI/Frame.h

@@ -1,264 +0,0 @@
-#ifndef GUI_Frame_h__
-#define GUI_Frame_h__
-
-#include <memory>
-#include <map>
-
-#include "Core/Util/Rectangle.h"
-#include "Core/EventBroker.h"
-#include "Core/EKeyDown.h"
-#include "Core/EKeyUp.h"
-#include "Core/ResourceManager.h"
-#include "Core/Renderer.h"
-#include "Core/RenderQueue.h"
-#include "Core/Texture.h"
-#include "Input/EInputCommand.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class Frame : public Rectangle
-{
-public:
-	enum class Anchor
-	{
-		Left,
-		Right,
-		Top,
-		Bottom
-	};
-
-	static const int BaseWidth = 1280;
-	static const int BaseHeight = 720;
-
-	// Set up a base frame with an event broker
-	Frame(dd::EventBroker* eventBroker)
-		: EventBroker(eventBroker)
-		, BaseFrame(this)
-		, Rectangle() { }
-
-	// Create a frame as a child
-	Frame(Frame* parent, std::string name)
-		: m_Name(name)
-	{
-		SetParent(parent);
-		//EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &Frame::OnKeyDown);
-		//EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Frame::OnKeyUp);
-		//EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Frame::OnCommand);
-	}
-
-	~Frame()
-	{
-		/*for (auto layer : m_Children)
-		{
-			for (auto child : layer.second)
-			{
-				delete child.second;
-			}
-		}
-
-		if (m_Parent)
-		{
-			m_Parent->RemoveChild(this);
-		}*/
-	}
-
-	Frame* Parent() const { return m_Parent; }
-
-	void SetParent(Frame* parent)
-	{
-		if (parent == nullptr) {
-			LOG_ERROR("Failed to parent frame \"%s\": Invalid parent", m_Name.c_str());
-			return;
-		}
-
-		m_Layer = parent->Layer() + 1;
-		parent->AddChild(this);
-		m_Parent = parent;
-		EventBroker = parent->EventBroker;
-		BaseFrame = parent->BaseFrame;
-	}
-
-	void AddChild(Frame* child)
-	{
-		m_Children[child->m_Layer].insert(std::make_pair(child->Name(), child));
-		if (m_Parent) {
-			m_Parent->AddChild(child);
-		}
-	}
-
-	void RemoveChild(Frame* child)
-	{
-		auto it = m_Children.find(child->m_Layer);
-		if (it != m_Children.end()) {
-			m_Children.erase(it);
-		}
-
-		if (m_Parent) {
-			m_Parent->RemoveChild(child);
-		}
-	}
-
-	std::string Name() const { return m_Name; }
-	void SetName(std::string val) { m_Name = val; }
-
-	int Layer() const { return m_Layer; }
-
-	bool Hidden() const
-	{
-		if (m_Parent)
-			return m_Parent->Hidden() || m_Hidden;
-		else
-			return m_Hidden;
-	}
-	bool Visible() const
-	{
-		return !Hidden();
-	}
-
-	virtual void Hide() { m_Hidden = true; }
-	virtual void Show() { m_Hidden = false; }
-
-	int Left() const override
-	{
-		if (m_Parent)
-			return m_Parent->Left() + X;
-		else
-			return X;
-	}
-	void SetLeft(int absLeft) override
-	{
-		if (m_Parent) {
-			X = absLeft - m_Parent->Left();
-		} else {
-			X = absLeft;
-		}
-	}
-	int Right() const override
-	{
-		return Left() + Width;
-	}
-	void SetRight(int absRight) override
-	{
-		if (m_Parent) {
-			X = absRight - Width - m_Parent->Left();
-		} else {
-			X = absRight - Width;
-		}
-	}
-	int Top() const override
-	{
-		if (m_Parent)
-			return m_Parent->Top() + Y;
-		else
-			return Y;
-	}
-	void SetTop(int absTop) override
-	{
-		if (m_Parent) {
-			Y = absTop - m_Parent->Top();
-		} else {
-			Y = absTop;
-		}
-	}
-	int Bottom() const override
-	{
-		return Top() + Height;
-	}
-	void SetBottom(int absBottom) override
-	{
-		if (m_Parent) {
-			Y = absBottom - Height - m_Parent->Top();
-		} else {
-			Y = absBottom - Height;
-		}
-	}
-
-	glm::vec2 Scale()
-	{
-		if (m_Parent)
-			return m_Parent->Scale();
-		else
-			return glm::vec2(Width, Height) / glm::vec2(BaseWidth, BaseHeight);
-	}
-
-	Rectangle AbsoluteRectangle()
-	{
-		int left = Left();
-		if (m_Parent)
-			left = std::max(left, m_Parent->Left());
-		int top = Top();
-		if (m_Parent)
-			top = std::max(top, m_Parent->Top());
-		int width = Right() - left;
-		int height = Bottom() - top;
-		return Rectangle(left, top, width, height);
-	}
-
-	void UpdateLayered(double dt)
-	{
-		// Update ourselves
-		this->Update(dt);
-
-		// Update children
-		for (auto& pairLayer : m_Children) {
-			auto children = pairLayer.second;
-			for (auto& pairChild : children) {
-				auto child = pairChild.second;
-				child->Update(dt);
-			}
-		}
-	}
-
-	virtual void Update(double dt) { }
-
-	void DrawLayered(RenderQueueCollection& rq)
-	{
-		if (this->Hidden())
-			return;
-
-		// Draw ourselves
-		this->Draw(rq);
-
-		// Draw children
-		for (auto& pairLayer : m_Children) {
-			auto children = pairLayer.second;
-			for (auto& pairChild : children) {
-				auto child = pairChild.second;
-				if (child->Hidden())
-					continue;
-				child->Draw(rq);
-			}
-		}
-	}
-
-	virtual void Draw(RenderQueueCollection& rq) { }
-
-protected:
-	dd::EventBroker* EventBroker;
-	Frame* BaseFrame = nullptr;
-
-	std::string m_Name = "UIParent";
-	int m_Layer = 0;
-	bool m_Hidden = false;
-
-	Frame* m_Parent = nullptr;
-	typedef std::multimap<std::string, Frame*> Children_t; // name -> frame
-	std::map<int, Children_t> m_Children; // layer -> Children_t
-
-	virtual bool OnKeyDown(const Events::KeyDown& event) { return false; }
-	virtual bool OnKeyUp(const Events::KeyUp& event) { return false; }
-	virtual bool OnCommand(const Events::InputCommand& event) { return false; }
-
-private:
-	//EventRelay<Frame, Events::KeyDown> m_EKeyDown;
-	//EventRelay<Frame, Events::KeyUp> m_EKeyUp;
-	//EventRelay<Frame, Events::InputCommand> m_EInputCommand;
-};
-
-}
-}
-
-#endif // GUI_Frame_h__

include/GUI/NumberFrame.h

@@ -1,94 +0,0 @@
-#ifndef GUI_NUMBERFRAME_H__
-#define GUI_NUMBERFRAME_H__
-
-#include <unordered_map>
-
-#include "GUI/TextureFrame.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class NumberFrame : public Frame
-{
-public:
-	NumberFrame(Frame* parent, std::string name)
-		: Frame(parent, name)
-	{
-		m_CharacterTextures['0'] = "Textures/GUI/Numbers/N0.png";
-		m_CharacterTextures['1'] = "Textures/GUI/Numbers/N1.png";
-		m_CharacterTextures['2'] = "Textures/GUI/Numbers/N2.png";
-		m_CharacterTextures['3'] = "Textures/GUI/Numbers/N3.png";
-		m_CharacterTextures['4'] = "Textures/GUI/Numbers/N4.png";
-		m_CharacterTextures['5'] = "Textures/GUI/Numbers/N5.png";
-		m_CharacterTextures['6'] = "Textures/GUI/Numbers/N6.png";
-		m_CharacterTextures['7'] = "Textures/GUI/Numbers/N7.png";
-		m_CharacterTextures['8'] = "Textures/GUI/Numbers/N8.png";
-		m_CharacterTextures['9'] = "Textures/GUI/Numbers/N9.png";
-
-		SetNumber(0);
-	}
-
-	int Number() const { return m_Number; }
-	void SetNumber(int number)
-	{
-		m_Number = number;
-
-		// Clear number textures
-		for (auto& frame : m_NumberFrames) {
-			frame->SetTexture("");
-		}
-
-		Width = 0;
-		Height = 0;
-
-		std::string digits = std::to_string(number);
-
-		int i = 0;
-		for (char& c : digits) {
-			// Create number frame if missing
-			if (i >= m_NumberFrames.size()) {
-				auto frame = new GUI::TextureFrame(this, "NumberFrameDigit");
-				if (i > 0) {
-					frame->SetLeft(m_NumberFrames[i - 1]->Right());
-				}
-				frame->DisableScissor();
-				m_NumberFrames.push_back(frame);
-			}
-
-			// Update value
-			std::string texture = "Textures/Core/ErrorTexture.png";
-			if (m_CharacterTextures.find(c) != m_CharacterTextures.end()) {
-				texture = m_CharacterTextures.at(c);
-			}
-			m_NumberFrames[i]->SetTexture(m_CharacterTextures.at(c));
-			Width += m_NumberFrames[i]->Width;
-			if (Height < m_NumberFrames[i]->Height) {
-				Height = m_NumberFrames[i]->Height;
-			}
-
-			i++;
-		}
-	}
-
-	void SetLeftAlign() { m_LeftAligned = true; }
-	void SetRightAlign() { m_LeftAligned = false; }
-
-	virtual void Update(double dt) override
-	{
-
-	}
-
-private:
-	int m_Number = 0;
-	bool m_LeftAligned = true;
-
-	std::unordered_map<char, std::string> m_CharacterTextures;
-	std::deque<TextureFrame*> m_NumberFrames;
-};
-
-}
-}
-#endif
-

include/GUI/Slider.h

@@ -1,124 +0,0 @@
-#ifndef GUI_SLIDER_H__
-#define GUI_SLIDER_H__
-
-#include "GUI/TextureFrame.h"
-#include "GUI/Button.h"
-#include "GUI/EButtonPress.h"
-#include "GUI/EButtonRelease.h"
-#include "GUI/ESliderUpdate.h"
-#include "Core/EMouseMove.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class Slider : public TextureFrame
-{
-public:
-	Slider(Frame* parent, std::string name)
-		: TextureFrame(parent, name)
-	{
-		m_SliderButton = new GUI::Button(this, "SliderButton");
-		m_SliderButton->DisableScissor();
-
-		EVENT_SUBSCRIBE_MEMBER(m_EButtonPress, &Slider::OnButtonPress);
-		EVENT_SUBSCRIBE_MEMBER(m_EButtonRelease, &Slider::OnButtonRelease);
-		EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &Slider::OnMouseMove);
-	}
-
-	float Percentage() const { return m_Percentage; }
-	void SetPercentage(const float percentage)
-	{
-		m_Percentage = percentage;
-		m_SliderButton->X = percentage * (Width - m_SliderButton->Width);
-	}
-
-	void SetTextureHover(std::string resourceName)
-	{
-		m_SliderButton->SetTextureHover(resourceName);
-	}
-	void SetTextureReleased(std::string resourceName)
-	{
-		m_SliderButton->SetTextureReleased(resourceName);
-	}
-	void SetTexturePressed(std::string resourceName)
-	{
-		m_SliderButton->SetTexturePressed(resourceName);
-	}
-
-	void AlignVertically()
-	{
-		m_SliderButton->Y = (Height / 2) - (m_SliderButton->Height / 2);
-	}
-
-	~Slider()
-	{
-		if (m_SliderButton != nullptr) {
-			delete m_SliderButton;
-			m_SliderButton = nullptr;
-		}
-	}
-
-	virtual void Update(double dt) override
-	{
-
-	}
-
-private:
-	Button* m_SliderButton = nullptr;
-	bool m_IsGrabbed = false;
-	float m_Percentage = 0.f;
-
-	EventRelay<Frame, Events::ButtonPress> m_EButtonPress;
-	EventRelay<Frame, Events::ButtonRelease> m_EButtonRelease;
-	EventRelay<Frame, Events::MouseMove> m_EMouseMove;
-
-	virtual bool OnButtonPress(const Events::ButtonPress& event)
-	{
-		if (event.Button == m_SliderButton) {
-			m_IsGrabbed = true;
-		}
-
-		return true;
-	}
-
-	virtual bool OnButtonRelease(const Events::ButtonRelease& event)
-	{
-		if (event.Button == m_SliderButton) {
-			m_IsGrabbed = false;
-		}
-
-		return true;
-	}
-
-	virtual bool OnMouseMove(const Events::MouseMove& event)
-	{
-		if (m_IsGrabbed) {
-			// Set horizontal position
-			m_SliderButton->X += event.DeltaX;
-			if (m_SliderButton->Left() < Left()) {
-				m_SliderButton->SetLeft(Left());
-			} else if (m_SliderButton->Right() > Right()) {
-				m_SliderButton->SetRight(Right());
-			}
-
-			// Update percentage
-			float newPercentage = m_SliderButton->X / (float)(Width - m_SliderButton->Width);
-			Events::SliderUpdate e;
-			e.FrameName = Name();
-			e.Slider = this;
-			e.Percentage = newPercentage;
-			e.DeltaPercentage = newPercentage - m_Percentage;
-			EventBroker->Publish(e);
-			m_Percentage = newPercentage;
-		}
-
-		return true;
-	}
-};
-
-}
-}
-#endif
-

include/GUI/TextureFrame.h

@@ -1,111 +0,0 @@
-#ifndef GUI_TextureFrame_h__
-#define GUI_TextureFrame_h__
-
-#include "GUI/Frame.h"
-#include "Core/Texture.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class TextureFrame : public Frame
-{
-public:
-	TextureFrame(Frame* parent, std::string name)
-		: Frame(parent, name) { }
-
-	void EnableScissor() { m_ScissorEnabled = true; }
-	void DisableScissor() { m_ScissorEnabled = false; }
-
-	void Draw(RenderQueueCollection& rq) override
-	{
-		if (m_Texture == nullptr)
-			return;
-
-		// Main texture
-		{
-			FrameJob job;
-			job.Scissor = (m_ScissorEnabled) ? m_Parent->AbsoluteRectangle() : Rectangle();
-			job.Viewport = Rectangle(Left(), Top(), Width, Height);
-			job.TextureID = m_Texture->ResourceID;
-			job.DiffuseTexture = *m_Texture;
-			job.Color = glm::vec4(m_Color.r, m_Color.g, m_Color.b, m_Color.a * m_CurrentFade);
-			job.Name = Name();
-			rq.GUI.Add(job);
-		}
-
-		// Texture while fading
-		if (m_FadeTexture && m_CurrentFade < 1) {
-			FrameJob job;
-			job.Scissor = (m_ScissorEnabled) ? m_Parent->AbsoluteRectangle() : Rectangle();
-			job.Viewport = Rectangle(Left(), Top(), Width, Height);
-			job.TextureID = m_FadeTexture->ResourceID;
-			job.DiffuseTexture = *m_FadeTexture;
-			job.Color = glm::vec4(m_Color.r, m_Color.g, m_Color.b, m_Color.a);
-			job.Name = Name();
-			rq.GUI.Add(job);
-		}
-	}
-
-	dd::Texture* Texture() const { return m_Texture; }
-
-	void SetTexture(std::string resourceName)
-	{
-		if (resourceName.empty()) {
-			m_Texture = nullptr;
-			return;
-		}
-
-		m_Texture = ResourceManager::Load<dd::Texture>(resourceName);
-		if (m_Texture == nullptr) {
-			m_Texture = ResourceManager::Load<dd::Texture>("Textures/Core/ErrorTexture.png");
-		}
-		SizeToTexture();
-	}
-
-	void SizeToTexture()
-	{
-		if (m_Texture != nullptr) {
-			this->Width = m_Texture->Width;
-			this->Height = m_Texture->Height;
-		}
-	}
-
-	void FadeToTexture(std::string resourceName, double duration)
-	{
-		m_FadeTexture = m_Texture;
-		SetTexture(resourceName);
-		m_FadeDuration = duration;
-		m_CurrentFade = 0.f;
-	}
-
-	void Update(double dt) override
-	{
-		if (m_CurrentFade < 1) {
-			m_CurrentFade += dt / m_FadeDuration;
-			if (m_CurrentFade > 1) {
-				m_FadeTexture = nullptr;
-				m_CurrentFade = 1;
-				m_FadeDuration = 0;
-			}
-		}
-	}
-
-	glm::vec4 Color() const { return m_Color; }
-	void SetColor(glm::vec4 val) { m_Color = val; }
-
-protected:
-	bool m_ScissorEnabled = true;
-	dd::Texture* m_Texture = nullptr;
-	dd::Texture* m_FadeTexture = nullptr;
-	glm::vec4 m_Color = glm::vec4(1.f, 1.f, 1.f, 1.f);
-	float m_FadeDuration = 0.f;
-	float m_CurrentFade = 1.f;
-
-};
-
-}
-}
-
-#endif // GUI_TextureFrame_h__

include/Game/BallSystem.h

@@ -5,31 +5,15 @@
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Core/CTransform.h"
-#include "Core/CTemplate.h"
-#include "Physics/CPhysics.h"
-#include "Physics/CCircleShape.h"
 #include "Physics/EContact.h"
-#include "Rendering/CModel.h"
-#include "Rendering/CPointLight.h"
 #include "Game/CBall.h"
 #include "Game/CPowerUp.h"
-#include "Game/CLife.h"
-#include "Game/ELifeLost.h"
-#include "Game/EComboEvent.h"
-#include "Game/EResetBall.h"
-#include "Game/EMultiBall.h"
-#include "Game/EMultiBallLost.h"
-#include "Game/EGameOver.h"
-#include "Game/EPause.h"
 
-namespace dd
-{
+namespace dd {
 
-namespace Systems
-{
+namespace Systems {
 
-class BallSystem : public System
-{
+class BallSystem : public System {
 public:
     BallSystem(World *world, std::shared_ptr<dd::EventBroker> eventBroker)
             : System(world, eventBroker) { }
@@ -55,61 +39,11 @@ public:
     // Called when an entity is removed
     void OnEntityRemoved(EntityID entity) override;
 
-    EntityID CreateBall();
-    void CreateLife(int);
-    EntityID Ball() { return m_Ball; };
-    void SetBall(const EntityID& ball) { m_Ball = ball; }
-
-    float& XMovementMultiplier() { return m_XMovementMultiplier; }
-    void SetXMovementMultiplier(const float& xMovementMultiplier) { m_XMovementMultiplier = xMovementMultiplier; }
-    float& EdgeX() { return m_EdgeX; }
-    void SetEdgeX(const float& edgeX) { m_EdgeX = edgeX; }
-    float& EdgeY() { return m_EdgeY; }
-    void SetEdgeY(const float& edgeY) { m_EdgeY = edgeY; }
-    int& MultiBalls() { return m_MultiBalls; }
-    void SetMultiBalls(const int& multiBalls) { m_MultiBalls = multiBalls; }
-    int& Lives() { return m_Lives; }
-    void SetLives(const int& lives) { m_Lives = lives; }
-    int& PastLives() { return m_PastLives; }
-    void SetPastLives(const int& pastLives) { m_PastLives = pastLives; }
-    bool ReplaceBall() const { return m_ReplaceBall; }
-    void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
-    bool MultiBall() const { return m_MultiBall; }
-    void SetMultiBall(const bool& multiBall) { m_MultiBall = multiBall; }
-    bool IsPaused() const { return m_Pause; }
-    void SetPause(const bool& pause) { m_Pause = pause; }
-
 private:
-    float m_XMovementMultiplier = 2.f;
-    float m_EdgeX = 3.2f;
-    float m_EdgeY = 5.2f;
-    int m_MultiBalls = 0;
-    int m_Lives = 3;
-    int m_PastLives = 3;
-    bool m_ReplaceBall = false;
-    bool m_MultiBall = false;
-    bool m_Pause = false;
 
-    glm::vec3 m_SavedSpeed;
-    bool m_InitializePause = false;
-
-    EntityID m_Ball;
-
-    dd::EventRelay<BallSystem, dd::Events::LifeLost> m_ELifeLost;
-    dd::EventRelay<BallSystem, dd::Events::MultiBallLost> m_EMultiBallLost;
-    dd::EventRelay<BallSystem, dd::Events::ResetBall> m_EResetBall;
-    dd::EventRelay<BallSystem, dd::Events::MultiBall> m_EMultiBall;
-    dd::EventRelay<BallSystem, dd::Events::Pause> m_EPause;
-
-    bool OnLifeLost(const dd::Events::LifeLost &event);
-    bool OnMultiBallLost(const dd::Events::MultiBallLost &event);
-    bool OnResetBall(const dd::Events::ResetBall &event);
-    bool OnMultiBall(const dd::Events::MultiBall &event);
-    bool OnPause(const dd::Events::Pause &event);
 };
 
 }
-
 }
 
 #endif

include/Game/CBall.h

@@ -17,9 +17,6 @@ struct Ball : Component
 {
     int Number = 0;
     float Speed = 5.f;
-    int Combo = 0;
-    bool Paused = false;
-    glm::vec3 SavedSpeed = glm::vec3(0, 0, 0);
 };
 
 }

include/Game/CBrick.h

@@ -15,8 +15,10 @@ namespace Components
 
 struct Brick : Component
 {
+    int Points = 10;
     int Hits = 1;
     int Score = 50;
+    bool Removed = false;
 };
 
 }

include/Game/CPad.h

@@ -17,9 +17,12 @@ namespace Components
 
 struct Pad : Component
 {
+    int Lives;
+    int Points;
+
     float SlowdownModifier = 5.f;
     float AccelerationSpeed = 40.f;
-    float MaxSpeed = 5.f;
+    float MaxSpeed = 20.f;
 };
 
 }

include/Game/EComboEvent.h

@@ -1,27 +0,0 @@
-//
-// Created by Adniklastrator on 2015-09-29.
-//
-
-#ifndef DAYDREAM_ECOMBOEVENT_H
-#define DAYDREAM_ECOMBOEVENT_H
-
-#include "Core/Entity.h"
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-struct ComboEvent : Event
-{
-    EntityID Ball;
-    int Combo;
-};
-
-}
-
-}
-
-#endif //DAYDREAM_ECOMBOEVENT_H

include/Game/EGameStart.h

@@ -1,25 +0,0 @@
-//
-// Created by Adam on 2015-09-25.
-//
-
-#ifndef EVENTS_EGAMESTART_H__
-#define EVENTS_EGAMESTART_H__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-struct GameStart : public Event
-{
-
-};
-
-}
-
-}
-
-#endif

include/Game/EHitLag.h

@@ -1,26 +0,0 @@
-//
-// Created by Administrator on 2015-09-30.
-//
-
-#ifndef DAYDREAM_EHITLAG_H
-#define DAYDREAM_EHITLAG_H
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-struct HitLag : Event
-{
-    float Time;
-    std::string Type;
-};
-
-}
-
-}
-
-#endif //DAYDREAM_EHITLAG_H

include/Game/EMultiBallLost.h

@@ -1,26 +0,0 @@
-//
-// Created by Adniklastrator on 2015-09-28.
-//
-
-#ifndef DAYDREAM_EMULTIBALLLOST_H
-#define DAYDREAM_EMULTIBALLLOST_H
-
-#include "Core/EventBroker.h"
-#include "Core/Entity.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-struct MultiBallLost : Event
-{
-
-};
-
-}
-
-}
-
-#endif //DAYDREAM_EMULTIBALLLOST_H

include/Game/EPause.h

@@ -1,25 +0,0 @@
-//
-// Created by Adniklastrator on 2015-09-30.
-//
-
-#ifndef DAYDREAM_EPAUSE_H
-#define DAYDREAM_EPAUSE_H
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-
-namespace Events
-{
-
-struct Pause : Event
-{
-    std::string Type;
-};
-
-}
-
-}
-
-#endif //DAYDREAM_EPAUSE_H

include/Game/FPSCounter.h

@@ -1,42 +0,0 @@
-#ifndef GUI_FPSCOUNTER_H__
-#define GUI_FPSCOUNTER_H__
-
-#include "GUI/Frame.h"
-#include "GUI/NumberFrame.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class FPSCounter : public Frame
-{
-public:
-	FPSCounter(Frame* parent, std::string name)
-		: Frame(parent, name)
-	{
-		m_Numbers = new GUI::NumberFrame(this, "FPSCounterNumberFrame");
-	}
-
-	virtual void Update(double dt)
-	{
-		m_NumFrames++;
-		m_Accum += dt;
-
-		m_Numbers->SetNumber(1.0/(m_Accum/m_NumFrames));
-		if (m_NumFrames % 20) {
-			//LOG_INFO("FPS: %f", 1.0/(m_Accum/m_NumFrames));
-		}
-	}
-
-private:
-	NumberFrame* m_Numbers = nullptr;
-
-	double m_Accum = 0.0;
-	int m_NumFrames = 0;
-};
-
-}
-}
-#endif
-

include/Game/HUD.h

@@ -1,70 +0,0 @@
-#ifndef GUI_HUD_H__
-#define GUI_HUD_H__
-
-#include "GUI/Frame.h"
-#include "GUI/TextureFrame.h"
-#include "GUI/NumberFrame.h"
-#include "Core/EKeyUp.h"
-#include "Game/EScoreEvent.h"
-#include "Game/FPSCounter.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class HUD : public Frame
-{
-public:
-	HUD(Frame* parent, std::string name)
-		: Frame(parent, name)
-	{
-		Width = parent->Width;
-		Height = parent->Height;
-
-		m_LevelIndicator = new GUI::TextureFrame(this, "HUDLevelIndicator");
-		m_LevelIndicator->SetTexture("Textures/GUI/HUD/LevelIndicatorBG.png");
-
-		m_A1 = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
-		m_A1->X = 40;
-		m_A1->SetNumber(1);
-		m_A2 = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
-		m_A2->X = 60;
-		m_A2->SetNumber(1);
-		//m_A3 = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
-		//m_A3->X = 80;
-		//m_A3->SetNumber(123);
-
-		m_ScoreIndicator = new GUI::TextureFrame(this, "HUDScoreIndicator");
-		m_ScoreIndicator->SetTexture("Textures/GUI/HUD/ScoreIndicatorBG.png");
-		m_ScoreIndicator->SetRight(Right());
-		m_ScoreNumberFrame = new GUI::NumberFrame(m_ScoreIndicator, "HUDScoreNumberFrame");
-		m_ScoreNumberFrame->X = 15;
-		m_ScoreNumberFrame->Y = 21;
-
-		//m_FPSCounter = new GUI::FPSCounter(this, "FPSCounter");
-
-		EVENT_SUBSCRIBE_MEMBER(m_EScore, &HUD::OnScore);
-	}
-
-private:
-	TextureFrame* m_LevelIndicator = nullptr;
-	TextureFrame* m_ScoreIndicator = nullptr;
-	NumberFrame* m_A1 = nullptr;
-	NumberFrame* m_A2 = nullptr;
-	//NumberFrame* m_A3 = nullptr;
-	NumberFrame* m_ScoreNumberFrame = nullptr;
-	FPSCounter* m_FPSCounter = nullptr;
-
-	EventRelay<Frame, Events::ScoreEvent> m_EScore;
-
-	bool OnScore(const Events::ScoreEvent& event)
-	{
-		m_ScoreNumberFrame->SetNumber(m_ScoreNumberFrame->Number() + event.Score);
-	}
-};
-
-}
-}
-#endif
-

include/Game/HitLagSystem.h

@@ -1,91 +0,0 @@
-//
-// Created by Adniklastrator on 2015-09-30.
-//
-
-#ifndef DAYDREAM_HITLAGSYSTEM_H
-#define DAYDREAM_HITLAGSYSTEM_H
-
-
-#include "Core/System.h"
-#include "Core/CTransform.h"
-#include "Core/CTemplate.h"
-#include "Core/EventBroker.h"
-#include "Core/World.h"
-#include "Rendering/CSprite.h"
-#include "Rendering/CModel.h"
-#include "Game/CBrick.h"
-#include "Game/CBall.h"
-#include "Game/CLife.h"
-#include "Game/CPowerUp.h"
-#include "Game/EStageCleared.h"
-#include "Game/ELifeLost.h"
-#include "Game/EResetBall.h"
-#include "Game/EScoreEvent.h"
-#include "Game/EComboEvent.h"
-#include "Game/EMultiBall.h"
-#include "Game/EMultiBallLost.h"
-#include "Game/EPause.h"
-#include "Game/EHitLag.h"
-#include "Game/EGameOver.h"
-#include "Game/ECreatePowerUp.h"
-#include "Game/EPowerUpTaken.h"
-#include "Game/Bricks/CPowerUpBrick.h"
-#include "Physics/CPhysics.h"
-#include "Physics/CCircleShape.h"
-#include "Physics/CRectangleShape.h"
-#include "Physics/ESetImpulse.h"
-#include "Physics/EContact.h"
-#include "Sound/CCollisionSound.h"
-#include "Game/PadSystem.h"
-#include <fstream>
-#include <iostream>
-
-
-namespace dd
-{
-
-namespace Systems
-{
-
-class HitLagSystem : public System
-{
-public:
-    HitLagSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker)
-    { }
-
-    void Initialize() override;
-
-    void Update(double dt) override;
-    void FlipPause();
-
-    bool IsPaused() const { return m_Pause; }
-    void SetPause(const bool& pause) { m_Pause = pause; }
-    bool HitLag() const { return m_HitLag; }
-    void SetHitLag(const bool& hitLag) { m_HitLag = hitLag; }
-    float& HitLagDuration() { return m_HitLagDuration; }
-    void SetHitLagDuration(const float& hitLagDuration) { m_HitLagDuration = hitLagDuration; }
-    float& HitLagTimer() { return m_HitLagTimer; }
-    void SetHitLagTimer(const float& hitLagTimer) { m_HitLagTimer = hitLagTimer; }
-    std::string& CurrentType() { return m_CurrentType; }
-    void SetCurrentType(const std::string& currentType) { m_CurrentType = currentType; }
-private:
-    bool m_Pause;
-    bool m_HitLag;
-    float m_HitLagDuration;
-    float m_HitLagTimer;
-    std::string m_CurrentType;
-
-    dd::EventRelay<HitLagSystem, dd::Events::Pause> m_EPause;
-    dd::EventRelay<HitLagSystem, dd::Events::HitLag> m_EHitLag;
-
-    bool OnPause(const dd::Events::Pause &event);
-    bool OnHitLag(const dd::Events::HitLag &event);
-
-};
-
-}
-
-}
-
-#endif //DAYDREAM_HITLAGSYSTEM_H

include/Game/LevelSystem.h

@@ -7,7 +7,6 @@
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
-#include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
 #include "Rendering/CSprite.h"
@@ -20,23 +19,21 @@
 #include "Game/ELifeLost.h"
 #include "Game/EResetBall.h"
 #include "Game/EScoreEvent.h"
-#include "Game/EComboEvent.h"
 #include "Game/EMultiBall.h"
-#include "Game/EMultiBallLost.h"
-#include "Game/EPause.h"
 #include "Game/EGameOver.h"
 #include "Game/ECreatePowerUp.h"
 #include "Game/EPowerUpTaken.h"
 #include "Game/Bricks/CPowerUpBrick.h"
+#include "Physics/CBoxShape.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
-#include "Physics/CRectangleShape.h"
 #include "Physics/ESetImpulse.h"
 #include "Physics/EContact.h"
 #include "Sound/CCollisionSound.h"
 #include "Game/PadSystem.h"
 #include <fstream>
 #include <iostream>
+#include <intrin.h>
 
 namespace dd
 {
@@ -65,7 +62,11 @@ public:
     void Initialize() override;
 
     void CreateBasicLevel(int, int, glm::vec2, float);
+    void CreateLife(int);
+    void SaveLevel(int, int, glm::vec2, int); // Shouldn't be here, but I'm experimenting.
+    void LoadLevel(char[20]);
     void CreateBrick(int, int, glm::vec2, float, int);
+    void ProcessCollision();
 
     void OnEntityRemoved(EntityID entity);
 
@@ -78,8 +79,10 @@ public:
     void SetRestarting(const bool& restarting) { m_Restarting = restarting; }
     bool Initialized() const { return m_Initialized; }
     void SetInitialized(const bool& initialized) { m_Initialized = initialized; }
-    bool IsPaused() const { return m_Pause; }
-    void SetPause(const bool& pause) { m_Pause = pause; }
+    int& Lives() { return m_Lives; }
+    void SetLives(const int& lives) { m_Lives = lives; }
+    int& PastLives() { return m_PastLives; }
+    void SetPastLives(const int& pastLives) { m_PastLives = pastLives; }
     int& MultiBalls() { return m_MultiBalls; }
     void SetMultiBalls(const int& multiBalls) { m_MultiBalls = multiBalls; }
     int& PowerUps() { return m_PowerUps; }
@@ -97,13 +100,16 @@ public:
 
     glm::vec2& SpaceBetweenBricks() { return m_SpaceBetweenBricks; }
     void SetSpaceBetweenBricks(const glm::vec2& spaceBetweenBricks) { m_SpaceBetweenBricks = spaceBetweenBricks; }
-    float& NotResettingTheStage() { return m_NotResettingTheStage; }
-    void SetNotResettingTheStage(const float& notResettingTheStage) { m_NotResettingTheStage = notResettingTheStage; }
+    float& EdgeX() { return m_EdgeX; }
+    void SetEdgeX(const float& edgeX) { m_EdgeX = edgeX; }
+    float& EdgeY() { return m_EdgeY; }
+    void SetEdgeY(const float& edgeY) { m_EdgeY = edgeY; }
 
 private:
     bool m_Restarting = false;
     bool m_Initialized = false;
-    bool m_Pause = false;
+    int m_Lives = 3;
+    int m_PastLives = 3;
     int m_MultiBalls = 0;
     int m_PowerUps = 0;
     int m_Score = 0;
@@ -112,25 +118,24 @@ private:
     int m_Lines = 7;
     float m_SpaceToEdge = 0.25f;
     glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.4);
-    float m_NotResettingTheStage = 5.f;
+    float m_EdgeX = 3.2f;
+    float m_EdgeY = 5.2f;
 
     dd::EventRelay<LevelSystem, dd::Events::Contact> m_EContact;
+    dd::EventRelay<LevelSystem, dd::Events::LifeLost> m_ELifeLost;
     dd::EventRelay<LevelSystem, dd::Events::ScoreEvent> m_EScoreEvent;
     dd::EventRelay<LevelSystem, dd::Events::MultiBall> m_EMultiBall;
-    dd::EventRelay<LevelSystem, dd::Events::MultiBallLost> m_EMultiBallLost;
     dd::EventRelay<LevelSystem, dd::Events::CreatePowerUp> m_ECreatePowerUp;
     dd::EventRelay<LevelSystem, dd::Events::PowerUpTaken> m_EPowerUpTaken;
     dd::EventRelay<LevelSystem, dd::Events::StageCleared> m_EStageCleared;
-    dd::EventRelay<LevelSystem, dd::Events::Pause> m_EPause;
 
     bool OnContact(const dd::Events::Contact &event);
+    bool OnLifeLost(const dd::Events::LifeLost &event);
     bool OnScoreEvent(const dd::Events::ScoreEvent &event);
     bool OnMultiBall(const dd::Events::MultiBall &event);
-    bool OnMultiBallLost(const dd::Events::MultiBallLost &event);
     bool OnCreatePowerUp(const dd::Events::CreatePowerUp &event);
     bool OnPowerUpTaken(const dd::Events::PowerUpTaken &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
-    bool OnPause(const dd::Events::Pause &event);
 };
 
 }

include/Game/MainMenu.h

@@ -1,59 +0,0 @@
-#ifndef GUI_MAINMENU_H__
-#define GUI_MAINMENU_H__
-
-#include "GUI/TextureFrame.h"
-#include "Game/MainMenuMain.h"
-#include "Game/MainMenuOptions.h"
-#include "Core/EKeyUp.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class MainMenu : public TextureFrame
-{
-public:
-	MainMenu(Frame* parent, std::string name)
-		: TextureFrame(parent, name)
-	{
-		SetTexture("Textures/GUI/Menu/Background.png");
-		Width = 675;
-		Height = 1080;
-
-		m_LeftBanner = new GUI::TextureFrame(this, "MainMenuLeftBanner");
-		m_LeftBanner->SetTexture("Textures/GUI/Menu/Left.png");
-		m_LeftBanner->Width = 231;
-		m_LeftBanner->Height = 1080;
-
-		m_MainMenuMain = new GUI::MainMenuMain(this, "MainMenuMain");
-		m_MainMenuMain->SetLeft(m_LeftBanner->Right());
-		m_MainMenuMain->SetTop(60);
-
-		m_MainMenuOptions = new GUI::MainMenuOptions(this, "MainMenuOptions");
-		m_MainMenuOptions->SetLeft(m_LeftBanner->Right());
-		m_MainMenuOptions->SetTop(m_MainMenuMain->Bottom());
-
-		//EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &MainMenu::OnKeyUp);
-	}
-
-private:
-	TextureFrame* m_LeftBanner;
-	MainMenuMain* m_MainMenuMain;
-	MainMenuOptions* m_MainMenuOptions;
-
-	//EventRelay<Frame, Events::KeyUp> m_EKeyUp;
-	bool OnKeyUp(const Events::KeyUp& event)
-	{
-		if (event.KeyCode == GLFW_KEY_ESCAPE) {
-			Show();
-		}
-
-		return true;
-	}
-};
-
-}
-}
-#endif
-

include/Game/MainMenuMain.h

@@ -1,72 +0,0 @@
-#ifndef GUI_MAINMENUMAIN_H__
-#define GUI_MAINMENUMAIN_H__
-
-#include "GUI/TextureFrame.h"
-#include "GUI/Button.h"
-#include "Game/EGameStart.h"
-#include "Game/HUD.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class MainMenuMain : public TextureFrame
-{
-public:
-	MainMenuMain(Frame* parent, std::string name)
-		: TextureFrame(parent, name)
-	{
-		Width = 409;
-		Height = 543;
-
-		m_Title = new GUI::TextureFrame(this, "MainMenuMainTitle");
-		m_Title->SetTexture("Textures/GUI/Menu/MainTitle.png");
-
-		m_SquidoutButton = new GUI::Button(this, "MainMenuMainSquidoutButton");
-		m_SquidoutButton->SetTop(m_Title->Bottom());
-		m_SquidoutButton->SetTextureReleased("Textures/GUI/Menu/MainSquidout.png");
-		m_SquidoutButton->SetTextureHover("Textures/GUI/Menu/MainSquidoutHover.png");
-		m_SquidoutButton->SetTexturePressed("Textures/GUI/Menu/MainSquidoutClick.png");
-		m_SquidoutButton->SizeToTexture();
-
-		m_TimeAttackButton = new GUI::Button(this, "MainMenuMainTimeAttackButton");
-		m_TimeAttackButton->SetTop(m_SquidoutButton->Bottom());
-		m_TimeAttackButton->SetTextureReleased("Textures/GUI/Menu/MainTimeAttack.png");
-		m_TimeAttackButton->SetTextureHover("Textures/GUI/Menu/MainTimeAttackHover.png");
-		m_TimeAttackButton->SetTexturePressed("Textures/GUI/Menu/MainTimeAttackClick.png");
-		m_TimeAttackButton->SizeToTexture();
-
-		m_OptionsButton = new GUI::Button(this, "MainMenuMainOptionsButton");
-		m_OptionsButton->SetTop(m_TimeAttackButton->Bottom());
-		m_OptionsButton->SetTextureReleased("Textures/GUI/Menu/MainOptions.png");
-		m_OptionsButton->SetTextureHover("Textures/GUI/Menu/MainOptionsHover.png");
-		m_OptionsButton->SetTexturePressed("Textures/GUI/Menu/MainOptionsClick.png");
-		m_OptionsButton->SizeToTexture();
-
-		EVENT_SUBSCRIBE_MEMBER(m_EButtonRelease, &MainMenuMain::OnButtonRelease);
-	}
-
-private:
-	TextureFrame* m_Title;
-	Button* m_SquidoutButton;
-	Button* m_TimeAttackButton;
-	Button* m_OptionsButton;
-
-	EventRelay<Frame, Events::ButtonRelease> m_EButtonRelease;
-	virtual bool OnButtonRelease(const Events::ButtonRelease& event)
-	{
-		if (event.Button == m_SquidoutButton) {
-			Events::GameStart e;
-			EventBroker->Publish(e);
-			m_Parent->Hide();
-			auto hud = new GUI::HUD(BaseFrame, "HUD");
-		}
-
-		return true;
-	}
-};
-
-}
-}
-#endif

include/Game/MainMenuOptions.h

@@ -1,82 +0,0 @@
-#ifndef GUI_MAINMENUOPTIONS_H__
-#define GUI_MAINMENUOPTIONS_H__
-
-#include "GUI/TextureFrame.h"
-#include "GUI/Button.h"
-#include "GUI/Slider.h"
-#include "GUI/ESliderUpdate.h"
-#include "Sound/EMasterVolume.h"
-
-namespace dd
-{
-namespace GUI
-{
-
-class MainMenuOptions : public TextureFrame
-{
-public:
-	MainMenuOptions(Frame* parent, std::string name)
-		: TextureFrame(parent, name)
-	{
-		Width = 409;
-		Height = 1080;
-
-		m_Title = new GUI::TextureFrame(this, "MainMenuOptionsTitle");
-		m_Title->SetTexture("Textures/GUI/Menu/OptionsTitle.png");
-
-		m_TitleSFX = new GUI::TextureFrame(this, "MainMenuOptionsSFXTitle");
-		m_TitleSFX->SetTop(m_Title->Bottom() + 20);
-		m_TitleSFX->SetTexture("Textures/GUI/Menu/OptionsSFXTitle.png");
-		m_SFXSlider = new GUI::Slider(this, "MainMenuOptionsSFXSlider");
-		m_SFXSlider->X = 66;
-		m_SFXSlider->SetTop(m_TitleSFX->Bottom() + 10);
-		m_SFXSlider->SetTexture("Textures/GUI/Menu/SliderBackground.png");
-		m_SFXSlider->SetTextureReleased("Textures/GUI/Menu/SliderHandle.png");
-		m_SFXSlider->AlignVertically();
-		m_SFXSlider->SetPercentage(1.f);
-
-		m_TitleBGM = new GUI::TextureFrame(this, "MainMenuOptionsBGMTitle");
-		m_TitleBGM->SetTop(m_SFXSlider->Bottom() + 20);
-		m_TitleBGM->SetTexture("Textures/GUI/Menu/OptionsBGMTitle.png");
-		m_BGMSlider = new GUI::Slider(this, "MainMenuOptionsBGMSlider");
-		m_BGMSlider->X = 66;
-		m_BGMSlider->SetTop(m_TitleBGM->Bottom() + 10);
-		m_BGMSlider->SetTexture("Textures/GUI/Menu/SliderBackground.png");
-		m_BGMSlider->SetTextureReleased("Textures/GUI/Menu/SliderHandle.png");
-		m_BGMSlider->AlignVertically();
-		m_BGMSlider->SetPercentage(1.f);
-
-		EVENT_SUBSCRIBE_MEMBER(m_ESliderUpdate, &MainMenuOptions::OnSliderUpdate);
-	}
-
-private:
-	TextureFrame* m_Title = nullptr;
-	TextureFrame* m_TitleSFX = nullptr;
-	Slider* m_SFXSlider = nullptr;
-	Slider* m_BGMSlider = nullptr;
-	TextureFrame* m_TitleBGM = nullptr;
-
-	EventRelay<Frame, Events::SliderUpdate> m_ESliderUpdate;
-	bool OnSliderUpdate(const Events::SliderUpdate& event)
-	{
-		if (event.Slider == m_SFXSlider) {
-			Events::MasterVolume e;
-			e.IsAmbient = false;
-			e.Gain = event.Percentage;
-			EventBroker->Publish(e);
-		}
-
-		if (event.Slider == m_BGMSlider) {
-			Events::MasterVolume e;
-			e.IsAmbient = true;
-			e.Gain = event.Percentage;
-			EventBroker->Publish(e);
-		}
-
-		return true;
-	}
-};
-
-}
-}
-#endif

include/Game/PadSystem.h

@@ -9,13 +9,12 @@
 #include "Core/System.h"
 #include "Core/Component.h"
 #include "Core/CTransform.h"
-#include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/EKeyDown.h"
 #include "Core/EKeyUp.h"
 #include "Input/EBindKey.h"
 #include "Physics/EContact.h"
-#include "Physics/CRectangleShape.h"
+#include "Physics/CBoxShape.h"
 #include "Physics/CPhysics.h"
 #include "Physics/CCircleShape.h"
 #include "Physics/ESetImpulse.h"
@@ -28,8 +27,6 @@
 #include "Game/EMultiBall.h"
 #include "Game/EPowerUpTaken.h"
 #include "Game/EStageCleared.h"
-#include "Game/EPause.h"
-#include "Game/EHitLag.h"
 
 
 namespace dd
@@ -48,6 +45,8 @@ public:
     void Update(double dt) override;
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
+    EntityID CreateBall();
+
     EntityID& Entity() { return m_Entity; }
     void SetEntity(const EntityID& ent) { m_Entity = ent; }
     glm::vec3 Acceleration() const { return m_Acceleration; }
@@ -57,42 +56,39 @@ public:
     void SetLeft(const bool& left) { m_Left = left; }
     bool Right() const { return m_Right; }
     void SetRight(const bool& right) { m_Right = right; }
-    float Edge() const { return m_Edge; }
-    void SetEdge(const float& edge) { m_Edge = edge; }
+    bool ReplaceBall() const { return m_ReplaceBall; }
+    void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
+    bool MultiBall() const { return m_MultiBall; }
+    void SetMultiBall(const bool& multiBall) { m_MultiBall = multiBall; }
 
     Components::Transform* Transform() const { return m_Transform; }
     void SetTransform(Components::Transform* transform) { m_Transform = transform; }
     Components::Pad* Pad() const { return m_Pad; }
     void SetPad(Components::Pad* pad) { m_Pad = pad; }
 
-    bool IsPaused() const { return m_Pause; }
-    void SetPause(const bool& pause) { m_Pause = pause; }
-
 private:
     EntityID m_Entity = 0;
     glm::vec3 m_Acceleration = glm::vec3(0.f, 0.f, 0.f);
-    bool m_Left = false;
-    bool m_Right = false;
-    float m_Edge = 2.8f;
-    bool m_MultiBall = false;
-    Components::Transform* m_Transform = nullptr;
-    Components::Pad* m_Pad = nullptr;
-
-    bool m_Pause = false;
+    bool m_Left = false, m_Right = false, m_ReplaceBall = false, m_MultiBall = false;
+    Components::Transform* m_Transform;
+    Components::Pad* m_Pad;
 
     dd::EventRelay<PadSystem, dd::Events::KeyDown> m_EKeyDown;
     dd::EventRelay<PadSystem, dd::Events::KeyUp> m_EKeyUp;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContact;
     dd::EventRelay<PadSystem, dd::Events::Contact> m_EContactPowerUp;
+    dd::EventRelay<PadSystem, dd::Events::ResetBall> m_EResetBall;
+    dd::EventRelay<PadSystem, dd::Events::MultiBall> m_EMultiBall;
     dd::EventRelay<PadSystem, dd::Events::StageCleared> m_EStageCleared;
-    dd::EventRelay<PadSystem, dd::Events::Pause> m_EPause;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
     bool OnKeyUp(const dd::Events::KeyUp &event);
+
     bool OnContact(const dd::Events::Contact &event);
     bool OnContactPowerUp(const dd::Events::Contact &event);
+    bool OnResetBall(const dd::Events::ResetBall &event);
+    bool OnMultiBall(const dd::Events::MultiBall &event);
     bool OnStageCleared(const dd::Events::StageCleared &event);
-    bool OnPause(const dd::Events::Pause &event);
 
     class PadSteeringInputController;
     std::array<std::shared_ptr<PadSteeringInputController>, 4> m_PadInputControllers;

include/Physics/CParticle.h

@@ -1,65 +0,0 @@
-#ifndef COMPONENTS_PARTICLE_H__
-#define COMPONENTS_PARTICLE_H__
-#include "Core/Component.h"
-
-namespace dd {
-
-namespace ParticleFlags {
-
-enum Type {
-    waterParticle = 0,
-    zombieParticle = 1 << 1,
-    wallParticle = 1 << 2,
-    springParticle = 1 << 3,
-    elasticParticle = 1 << 4,
-    viscousParticle = 1 << 5,
-    powderParticle = 1 << 6,
-    tensileParticle = 1 << 7,
-    colorMixingParticle = 1 << 8,
-    destructionListenerParticle = 1 << 9,
-    barrierParticle = 1 << 10,
-    staticPressureParticle = 1 << 11,
-    reactiveParticle = 1 << 12,
-    repulsiveParticle = 1 << 13,
-    fixtureContactListenerParticle = 1 << 14,
-    particleContactListenerParticle = 1 << 15,
-    fixtureContactFilterParticle = 1 << 16,
-    particleContactFilterParticle = 1 << 17
-};
-}
-
-namespace Components
-{
-
-struct Particle : public Component
-{
-    float Radius = 0.5f;
-    float LifeTime = 5.0f;
-
-    ParticleFlags::Type Flags =
-            ParticleFlags::Type::waterParticle |
-            ParticleFlags::Type::zombieParticle |
-            ParticleFlags::Type::wallParticle |
-            ParticleFlags::Type::springParticle |
-            ParticleFlags::Type::elasticParticle |
-            ParticleFlags::Type::viscousParticle |
-            ParticleFlags::Type::powderParticle |
-            ParticleFlags::Type::tensileParticle |
-            ParticleFlags::Type::colorMixingParticle |
-            ParticleFlags::Type::destructionListenerParticle |
-            ParticleFlags::Type::barrierParticle |
-            ParticleFlags::Type::staticPressureParticle |
-            ParticleFlags::Type::reactiveParticle |
-            ParticleFlags::Type::repulsiveParticle |
-            ParticleFlags::Type::fixtureContactListenerParticle |
-            ParticleFlags::Type::particleContactListenerParticle |
-            ParticleFlags::Type::fixtureContactFilterParticle |
-            ParticleFlags::Type::particleContactFilterParticle;
-
-};
-
-}
-
-}
-
-#endif

include/Physics/CParticleEmitter.h

@@ -1,25 +0,0 @@
-#ifndef COMPONENTS_PARTICLEEMITTER_H__
-#define COMPONENTS_PARTICLEEMITTER_H__
-#include "Core/Component.h"
-
-namespace dd
-{
-namespace Components
-{
-
-struct ParticleEmitter : public Component
-{
-    int Amount = 10.f;
-    float InitialSpeed = 1.f;
-    double SpawnRate = 1.f;
-    double TimeSinceLastSpawn = 0;
-
-    //ParticleSystem variables
-    float GravityScale = 1.0f;
-};
-
-}
-
-}
-
-#endif

include/Physics/CPhysics.h

@@ -4,40 +4,17 @@
 
 namespace dd
 {
-
-namespace CollisionLayer
-{
-enum Type
-{
-    Pad = 1 << 0,
-    Ball = 1 << 1,
-    Brick = 1 << 2,
-    Water = 1 << 3,
-    PowerUp = 1 << 4,
-    Other = 1 << 5,
-    Wall = 1 << 6
-};
-}
 namespace Components
 {
 
 struct Physics: public Component
 {
+    //idk if anything should be here :)
     bool Static = true;
-    bool Calculate = false;
-    float GravityScale = 0.f;
-    CollisionLayer::Type Category = CollisionLayer::Type::Other;
-    CollisionLayer::Type Mask =
-            CollisionLayer::Type::Pad |
-            CollisionLayer::Type::Ball |
-            CollisionLayer::Type::Brick |
-            CollisionLayer::Type::Water |
-            CollisionLayer::Type::PowerUp |
-            CollisionLayer::Type::Wall |
-            CollisionLayer::Type::Other;
 };
 
 }
+
 }
 
 #endif //DAYDREAM_CPHYSICS_H

include/Physics/CWaterVolume.h

@@ -1,19 +0,0 @@
-#ifndef CWATERVOLUME_H
-#define CWATERVOLUME_H
-#include "Core/Component.h"
-
-namespace dd
-{
-namespace Components
-{
-
-struct WaterVolume : public Component
-{
-    float Radius;
-};
-
-}
-
-}
-
-#endif

include/Physics/PhysicsSystem.h

@@ -3,33 +3,19 @@
 
 #include <unordered_map>
 
-#include <Box2D/Box2D.h>
-
 #include "Core/System.h"
 #include "Core/World.h"
-#include "Core/EventBroker.h"
-#include "Core/CTemplate.h"
-
-#include "Physics/CRectangleShape.h"
-#include "Physics/CCircleShape.h"
+#include "Physics/CBoxShape.h"
 #include "Physics/CPhysics.h"
-#include "Physics/CWaterVolume.h"
+#include <Box2D/Box2D.h>
 #include "Core/CTransform.h"
 #include "Transform/TransformSystem.h"
-#include "CRectangleShape.h"
-#include "Physics/CPhysics.h"
 #include "Physics/EContact.h"
 #include "Physics/ESetImpulse.h"
-#include "Physics/CParticle.h"
 #include "Physics/CCircleShape.h"
-#include "Physics/CParticleEmitter.h"
-#include "Game/EPause.h"
+#include "Core/EventBroker.h"
 #include "Game/CPad.h"
-#include "Game/CPad.h"
-#include "Game/CBall.h"
-#include "Transform/TransformSystem.h"
-#include "Rendering/CSprite.h"
-#include "Core/CTemplate.h"
+
 
 namespace dd
 {
@@ -37,75 +23,54 @@ namespace dd
 namespace Systems
 {
 
+
 class PhysicsSystem : public System
 {
     friend class ContractListener;
 
 public:
     PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker) { }
+    : System(world, eventBroker) {}
 
     ~PhysicsSystem();
 
+    EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
+    bool SetImpulse(const Events::SetImpulse &event);
+
     void RegisterComponents(ComponentFactory* cf) override;
     void Initialize() override;
+
+    // Called once per system every tick
     void Update(double dt) override;
+    // Called once for every entity in the world every tick
     void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+
+    // Called when components are committed to an entity
     void OnEntityCommit(EntityID entity) override;
+
+    // Called when an entity is removed
     void OnEntityRemoved(EntityID entity) override;
 
 private:
+    b2Vec2 m_Gravity;
+    b2World* m_PhysicsWorld;
+    float m_TimeStep;
+    float m_Accumulator;
+
+    int m_VelocityIterations, m_PositionIterations;
+
+    std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
+    std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
+
+    void CreateBody(EntityID entity);
+
+
     struct Impulse
     {
         b2Body* Body;
         b2Vec2 Impulse;
         b2Vec2 Point;
     };
-    bool m_Pause = false;
-
-
-    b2Vec2 m_Gravity = b2Vec2(0.f, -9.82f);
-    b2World* m_PhysicsWorld = nullptr;
-    float m_TimeStep = 1.f/60.f;
-    float m_Accumulator = 0.f;
-    int m_VelocityIterations = 6;
-    int m_PositionIterations = 2;
-
-    std::vector<b2ParticleSystem*> m_ParticleSystem;
-    std::vector<b2ParticleGroup*> t_ParticleGroup;
-
-    std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
-    std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
-    std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
-    std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
-
-
-
-    void CreateBody(EntityID entity);
-    void SyncEntitiesWithBodies();
-    void SyncBodiesWithEntities();
-    void InitializeWater();
-    void CreateParticleGroup(EntityID entity);
-
-    b2ParticleSystem* CreateParticleSystem(float radius, float gravityScale);
-    void CreateParticleEmitter(EntityID entity);
-    void UpdateParticleEmitters(double dt); //TODO: Remove them and particles if needed.
-
-    EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
-    bool SetImpulse(const Events::SetImpulse &event);
-
-    dd::EventRelay<PhysicsSystem, dd::Events::Pause> m_EPause;
-    bool OnPause(const dd::Events::Pause &event);
-
-    //TODO: Fill struct with info needed.
-    struct ParticleEmitter
-    {
-        std::vector<b2ParticleSystem*> ParticleSystem;
-        std::vector<EntityID> ParticleEmitter;
-        std::vector<EntityID> ParticleTemplate;
-    };
-    ParticleEmitter m_ParticleEmitters;
-
     std::list<Impulse> m_Impulses;
 
 
@@ -116,10 +81,42 @@ private:
         ContactListener(PhysicsSystem* physicsSystem)
                 : m_PhysicsSystem(physicsSystem) { }
 
-        void BeginContact(b2Contact* contact);
-        void EndContact(b2Contact* contact);
-        void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
-        void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
+        void BeginContact(b2Contact* contact)
+        {
+            b2WorldManifold worldManifold;
+
+            contact->GetWorldManifold(&worldManifold);
+
+            Events::Contact e;
+            e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+            e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
+            e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
+            e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
+
+            m_PhysicsSystem->EventBroker->Publish(e);
+        }
+        void EndContact(b2Contact* contact)
+        {
+
+        }
+        void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
+        {
+            EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+            EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+
+            auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
+            auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
+
+            if (physicsComponentA != nullptr || physicsComponentB != nullptr) {
+                // Turn of collisions
+                contact->SetEnabled(false);
+            }
+
+        }
+        void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
+        {
+
+        }
 
     private:
         PhysicsSystem* m_PhysicsSystem;
@@ -129,7 +126,6 @@ private:
 };
 
 }
-
 }
 
-#endif
+#endif //DAYDREAM_PHYSICSSYSTEM_H

include/Sound/CCollisionSound.h

@@ -1,3 +1,7 @@
+//
+// Created by Adam on 2015-09-17.
+//
+
 #ifndef COMPONENTS_CCOLLISIONSOUND_H__
 #define COMPONENTS_CCOLLISIONSOUND_H__
 
@@ -5,15 +9,17 @@
 
 namespace dd
 {
+
 namespace Components
 {
 
 struct CollisionSound : public Component
 {
-    std::string FilePath;
+    std::string filePath;
 };
 
 }
+
 }
 
 #endif

include/Sound/EMasterVolume.h

@@ -1,21 +0,0 @@
-#ifndef EVENTS_EMASTERVOLUME_H__
-#define EVENTS_EMASTERVOLUME_H__
-
-#include "Core/EventBroker.h"
-
-namespace dd
-{
-namespace Events
-{
-
-struct MasterVolume : public Event
-{
-    float Gain = 1;
-    //To determine what channel group to apply the change to.
-    bool IsAmbient = false;
-};
-
-}
-}
-
-#endif

include/Sound/EPlaySound.h

@@ -1,22 +1,24 @@
-#ifndef EVENTS_PLAYSFX_H__
-#define EVENTS_PLAYSFX_H__
+#ifndef Events_PlaySFX_h__
+#define Events_PlaySFX_h__
 
 #include "Core/EventBroker.h"
 
 namespace dd
 {
+
 namespace Events
 {
 
 struct PlaySound : Event
 {
-	std::string FilePath;
-	float Gain = 1.f;
-	float Pitch = 1.f;
-	bool IsAmbient = false;
+	std::string path;
+	float volume = 1.f;
+	float pitch = 1.f;
+	bool loop = false;
 };
 
 }
+
 }
 
 #endif

include/Sound/EStopSound.h

@@ -8,12 +8,16 @@ namespace dd
 
 namespace Events
 {
+
 struct StopSound : public Event
 {
-    std::string FilePath;
+    std::string path;
 };
 
+
 }
+
+
 }
 
 #endif

include/Sound/Sound.h

@@ -12,31 +12,27 @@ namespace dd
 class Sound : public Resource
 {
     friend class ResourceManager;
-
 public:
     ALuint Buffer() { return m_Buffer; };
     std::string Path() { return m_Path; };
-    float Gain() { return m_Gain; };
-    void SetGain(const float Gain) { m_Gain = Gain; };
-
 private:
     Sound(std::string path);
 
-    float m_Gain = 1;
-    ALuint m_Buffer;
-    std::string m_Path;
-
     //File-info
     char m_Type[4];
     unsigned long m_Size, m_ChunkSize;
     short m_FormatType, m_Channels;
     unsigned long m_SampleRate, m_AvgBytesPerSec;
     short m_BytesPerSample, m_BitsPerSample;
-    unsigned int m_DataSize;
+    unsigned long m_DataSize;
     std::map<std::string, ALuint> m_BufferCache;
     ALuint LoadFile(std::string path);
+
+    ALuint m_Buffer;
+    std::string m_Path;
 };
 
+
 }
 
 #endif

include/Sound/SoundSystem.h

@@ -1,60 +1,57 @@
-#ifndef SYSTEMS_SOUNDSYSTEM_H__
-#define SYSTEMS_SOUNDSYSTEM_H__
+#ifndef DAYDREAM_SOUND_H
+#define DAYDREAM_SOUND_H
+
 
 #include "AL/al.h"
 #include "AL/alc.h"
-
 #include "Core/System.h"
 #include "Core/World.h"
 #include "Core/EventBroker.h"
-#include "Core/ResourceManager.h"
 #include "Sound.h"
 #include "Sound/EPlaySound.h"
 #include "Sound/EStopSound.h"
-#include "Sound/EMasterVolume.h"
-#include "Sound/CCollisionSound.h"
 #include "Physics/EContact.h"
 #include "Game/CBall.h"
 #include "Game/CBrick.h"
 #include "Game/CPad.h"
+#include "Sound/CCollisionSound.h"
+#include "Core/ResourceManager.h"
+
 
 namespace dd
 {
 namespace Systems
 {
-
 class SoundSystem : public System {
 public:
     SoundSystem(World *world, std::shared_ptr<dd::EventBroker> eventBroker)
             : System(world, eventBroker) { }
-
     ~SoundSystem();
-
     void Initialize() override;
     void Update(double dt) override;
 
-private:
-    float m_BGMMasterVolume = 1.f;
-    float m_SFXMasterVolume = 1.f;
-    std::map<ALuint, Sound*> m_BGMSourcesToBuffers;
-    std::map<ALuint, Sound*> m_SFXSourcesToBuffers;
-    ALCdevice* m_Device = nullptr;
 
+
+
+private:
     //Events
     dd::EventRelay<SoundSystem, dd::Events::PlaySound> m_EPlaySFX;
-    bool OnPlaySound(const dd::Events::PlaySound &event);
-    //On contact: play the sound given in the CCOllisionSound.
     dd::EventRelay<SoundSystem, dd::Events::Contact> m_EContact;
-    bool OnContact(const dd::Events::Contact &event);
     dd::EventRelay<SoundSystem, dd::Events::StopSound> m_EStopSound;
+    bool OnPlaySound(const dd::Events::PlaySound &event);
+    bool OnContact(const dd::Events::Contact &event);
     bool OnStopSound(const dd::Events::StopSound &event);
-    dd::EventRelay<SoundSystem, dd::Events::MasterVolume> m_EMasterVolume;
-    bool OnMasterVolume(const dd::Events::MasterVolume &event);
 
     ALuint CreateSource();
+
+    std::map<ALuint, Sound*> m_SourcesToBuffers;
+
+    ALCdevice* m_Device;
+
+    //Temp
+
 };
-
 }
 }
 
-#endif
+#endif //DAYDREAM_SOUND_H

src/game/CMakeLists.txt

@@ -79,12 +79,6 @@ file(GLOB SOURCE_FILES_Sound
 )
 source_group(Sound FILES ${SOURCE_FILES_Sound})
 
-file(GLOB SOURCE_FILES_GUI
-    "${INCLUDE_PATH}/GUI/*.h"
-    "GUI/*.cpp"
-)
-source_group(GUI FILES ${SOURCE_FILES_GUI})
-
 set(SOURCE_FILES
     ${SOURCE_FILES_Core}
     ${SOURCE_FILES_Core_Util}
@@ -93,13 +87,11 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Transform}
     ${SOURCE_FILES_Physics}
     ${SOURCE_FILES_Game}
-    ${SOURCE_FILES_Sound}
-    ${SOURCE_FILES_GUI})
+    ${SOURCE_FILES_Sound} ../../include/Game/EGameOver.h ../../include/Game/Bricks/CPowerUpBrick.h ../../include/Game/CPowerUp.h ../../include/Game/ECreatePowerUp.h ../../include/Game/EPowerUpTaken.h)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
-    set(STATIC_LIBRARY_FLAGS "${STATIC_LIBRARY_FLAGS}")
+    set(STATIC_LIBRARY_FLAGS  "${STATIC_LIBRARY_FLAGS}")
 endif()
 
 add_library(game ${SOURCE_FILES})

src/game/CMakeLists.txt.game

@@ -0,0 +1,38 @@
+project(game)
+
+find_package(OpenGL REQUIRED)
+find_package(GLEW REQUIRED)
+find_package(GLFW REQUIRED)
+find_package(Boost REQUIRED)
+find_package(assimp REQUIRED)
+find_package(ZLIB REQUIRED)
+find_package(PNG REQUIRED)
+
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include/dd
+    ${OPENGL_INCLUDE_DIR}
+    ${GLEW_INCLUDE_DIRS}
+    ${GLFW_INCLUDE_DIRS}
+    ${Boost_INCLUDE_DIRS}
+    ${assimp_INCLUDE_DIRS}
+    ${PNG_INCLUDE_DIRS}
+)
+
+set(SOURCE_FILES
+    main.cpp
+)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+endif()
+
+add_executable(game ${SOURCE_FILES})
+target_link_libraries(game
+    daydream
+    ${OPENGL_LIBRARIES}
+    ${GLEW_LIBRARIES}
+    ${GLFW_LIBRARIES}
+    ${Boost_LIBRARIES}
+    ${assimp_LIBRARIES}
+    ${PNG_LIBRARIES}
+)

src/game/Core/EventBroker.cpp

@@ -68,10 +68,9 @@ int dd::EventBroker::Process(std::string contextTypeName)
 		std::shared_ptr<Event> event = pair.second;
 
 		auto itpair = relays.equal_range(eventTypeName);
-		for (auto it2 = itpair.first; it2 != itpair.second; it2++)
+		for (auto it2 = itpair.first; it2 != itpair.second; ++it2)
 		{
-			std::string name = it2->first;
-			BaseEventRelay* relay = it2->second;
+			auto relay = it2->second;
 			relay->Receive(event);
 			eventsProcessed++;
 		}
@@ -80,7 +79,7 @@ int dd::EventBroker::Process(std::string contextTypeName)
 	return eventsProcessed;
 }
 
-void dd::EventBroker::Swap()
+void dd::EventBroker::Clear()
 {
 	std::swap(m_EventQueueRead, m_EventQueueWrite);
 	m_EventQueueWrite->clear();

src/game/Core/OBJ.cpp

@@ -263,7 +263,7 @@ void dd::OBJ::ParseMaterial()
 				ParseColorMap(currentLine, ss, prefix, arg, colorMap);
 			}
 
-			// HACK: Should we really have to specify the full FilePath here?
+			// HACK: Should we really have to specify the full path here?
 			colorMap.FileName = (m_MaterialPath.branch_path() / colorMap.FileName).string();
 			currentMaterial->DiffuseTexture = colorMap;
 			continue;
@@ -280,7 +280,7 @@ void dd::OBJ::ParseMaterial()
 				ParseColorMap(currentLine, ss, prefix, arg, colorMap);
 			}
 
-			// HACK: Should we really have to specify the full FilePath here?
+			// HACK: Should we really have to specify the full path here?
 			colorMap.FileName = (m_MaterialPath.branch_path() / colorMap.FileName).string();
 			currentMaterial->SpecularMap = colorMap;
 			continue;
@@ -297,7 +297,7 @@ void dd::OBJ::ParseMaterial()
 				ParseBumpMap(currentLine, ss, prefix, arg, bumpMap);
 			}
 
-			// HACK: Should we really have to specify the full FilePath here?
+			// HACK: Should we really have to specify the full path here?
 			bumpMap.FileName = (m_MaterialPath.branch_path() / bumpMap.FileName).string();
 			currentMaterial->NormalMap = bumpMap;
 			continue;

src/game/Core/Renderer.cpp

@@ -70,7 +70,7 @@ void dd::Renderer::Initialize()
 	LoadShaders();
 	CreateBuffers();
 
-	m_CurrentScreenBuffer = m_TFinal;
+	m_CurrentScreenBuffer = m_tFinal;
 }
 void dd::Renderer::LoadShaders()
 {
@@ -79,53 +79,45 @@ void dd::Renderer::LoadShaders()
 	*/
 
 	// Pass #1: Fill G-buffers
-	m_SpDeferred1 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/1/");
-	m_SpDeferred1->BindFragDataLocation(0, "GDiffuse");
-	m_SpDeferred1->BindFragDataLocation(1, "GPosition");
-	m_SpDeferred1->BindFragDataLocation(2, "GNormal");
-	m_SpDeferred1->BindFragDataLocation(3, "GSpecular");
-	m_SpDeferred1->Link();
+	m_spDeferred1 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/1/");
+	m_spDeferred1->BindFragDataLocation(0, "GDiffuse");
+	m_spDeferred1->BindFragDataLocation(1, "GPosition");
+	m_spDeferred1->BindFragDataLocation(2, "GNormal");
+	m_spDeferred1->BindFragDataLocation(3, "GSpecular");
+	m_spDeferred1->Link();
 
 	// Pass #2: Lighting
-	m_SpDeferred2 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/2/");
+	m_spDeferred2 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/2/");
 	//glBindFragDataLocation(m_SPDeferred2, 0, "FragmentLighting");
-	m_SpDeferred2->Link();
-
-	//Water Pass
-	m_SpWater = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water/");
-	m_SpWater->Link();
-	m_SpWater2 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water2/");
-	m_SpWater2->Link();
+	m_spDeferred2->Link();
 
 	// Pass #3: Combining into final image
-	m_SpDeferred3 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/3/");
-	m_SpDeferred3->Link();
+	m_spDeferred3 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/3/");
+	m_spDeferred3->Link();
 
 	/*
 		Forward rendering
 	*/
-	m_SpForward = ResourceManager::Load<ShaderProgram>("Shaders/Forward/");
-	m_SpForward->Link();
+	m_spForward = ResourceManager::Load<ShaderProgram>("Shaders/Forward/");
+	m_spForward->Link();
 
 	/*
 		Screen draw
 	*/
-	m_SpScreen = ResourceManager::Load<ShaderProgram>("Shaders/Screen/");
-	m_SpScreen->Link();
+	m_spScreen = ResourceManager::Load<ShaderProgram>("Shaders/Screen/");
+	m_spScreen->Link();
 }
 
 void dd::Renderer::CreateBuffers()
 {
-	//TODO: Make the most common cases of texture create and FBO create into a function so it's not so cluttered in here.
 	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");
-	m_WhiteSphereTexture = ResourceManager::Load<Texture>("Textures/Test/Water.png");
 
-	glGenRenderbuffers(1, &m_RbDepthBuffer);
-	glBindRenderbuffer(GL_RENDERBUFFER, m_RbDepthBuffer);
+	glGenRenderbuffers(1, &m_rbDepthBuffer);
+	glBindRenderbuffer(GL_RENDERBUFFER, m_rbDepthBuffer);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Resolution.Width, m_Resolution.Height);
 
 	// Generate G-buffer textures
@@ -157,18 +149,11 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-	glGenTextures(1, &m_Gwater);
-	glBindTexture(GL_TEXTURE_2D, m_Gwater);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_FLOAT, NULL);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
 	// Create first pass framebuffer
-	glGenFramebuffers(1, &m_FbDeferred1);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred1);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_RbDepthBuffer);
+	glGenFramebuffers(1, &m_fbDeferred1);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred1);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbDepthBuffer);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_GDiffuse, 0);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, m_GPosition, 0);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, m_GNormal, 0);
@@ -176,13 +161,13 @@ void dd::Renderer::CreateBuffers()
 	GLenum firstPassDrawBuffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
 	glDrawBuffers(4, firstPassDrawBuffers);
 	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred1 incomplete: 0x%x\n", fbStatus);
+		LOG_ERROR("m_fbDeferred1 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 
 	// Generate lighting texture
-	glGenTextures(1, &m_TLighting);
-	glBindTexture(GL_TEXTURE_2D, m_TLighting);
+	glGenTextures(1, &m_tLighting);
+	glBindTexture(GL_TEXTURE_2D, m_tLighting);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -190,115 +175,54 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
 	// Create second pass framebuffer
-	glGenFramebuffers(1, &m_FbDeferred2);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred2);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_TLighting, 0);
+	glGenFramebuffers(1, &m_fbDeferred2);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred2);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tLighting, 0);
 	GLenum secondPassDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
 	glDrawBuffers(1, secondPassDrawBuffers);
 	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
+		LOG_ERROR("m_fbDeferred2 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 
-	//Fill Water Texture
-	glGenTextures(1, &m_Gwater);
-	glBindTexture(GL_TEXTURE_2D, m_Gwater);
+	// Generate final deferred texture
+	glGenTextures(1, &m_tFinal);
+	glBindTexture(GL_TEXTURE_2D, m_tFinal);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-	//Fill water pass
-	glGenFramebuffers(1, &m_FbWater);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWater);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_Gwater, 0);
-	GLenum waterPassDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
-	glDrawBuffers(1, waterPassDrawBuffers);
-	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
-		exit(EXIT_FAILURE);
-	}
-
-	//water Blur texture
-	glGenTextures(1, &m_BWater);
-	glBindTexture(GL_TEXTURE_2D, m_BWater);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-	//Fill waterBlur pass
-	glGenFramebuffers(1, &m_FbWaterBlur);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_BWater, 0);
-	GLenum waterBlurDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
-	glDrawBuffers(1, waterBlurDrawBuffers);
-	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
-		exit(EXIT_FAILURE);
-	}
-
-	//water Blur texture2
-	glGenTextures(1, &m_BWater2);
-	glBindTexture(GL_TEXTURE_2D, m_BWater2);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_RbDepthBuffer);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-	//Fill waterBlur pass2
-	glGenFramebuffers(1, &m_FbWaterBlur2);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur2);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_BWater2, 0);
-	GLenum waterBlur2DrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
-	glDrawBuffers(1, waterBlur2DrawBuffers);
-	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
-		exit(EXIT_FAILURE);
-	}
-
-	// Generate final deferred texture
-	glGenTextures(1, &m_TFinal);
-	glBindTexture(GL_TEXTURE_2D, m_TFinal);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Resolution.Width, m_Resolution.Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
 	// Create third pass framebuffer
-	glGenFramebuffers(1, &m_FbDeferred3);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_RbDepthBuffer);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_TFinal, 0);
+	glGenFramebuffers(1, &m_fbDeferred3);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred3);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbDepthBuffer);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tFinal, 0);
 	GLenum thirdPassDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
 	glDrawBuffers(1, thirdPassDrawBuffers);
 	if (GLenum fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-		LOG_ERROR("m_FbDeferred3 incomplete: 0x%x\n", fbStatus);
+		LOG_ERROR("m_fbDeferred3 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 }
 
 void dd::Renderer::Draw(RenderQueueCollection& rq)
 {
-	rq.Forward.Jobs.sort(dd::Renderer::DepthSort);
+
 	DrawDeferred(rq.Deferred, rq.Lights);
+	rq.Forward.Jobs.sort(dd::Renderer::DepthSort);
 	DrawForward(rq.Forward, rq.Lights);
-	DrawGUI(rq.GUI);
 
 	// Finally: Draw the deferred+forward combined texture to the screen
-	glDisable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
 	glDepthMask(GL_FALSE);
 	glDisable(GL_DEPTH_TEST);
 	glDisable(GL_BLEND);
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 	glClearColor(1, 0, 0, 1);
 	glClear(GL_COLOR_BUFFER_BIT);
-	m_SpScreen->Bind();
+	m_spScreen->Bind();
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_CurrentScreenBuffer);
 	glBindVertexArray(m_ScreenQuad);
@@ -312,17 +236,17 @@ void dd::Renderer::Draw(RenderQueueCollection& rq)
 void dd::Renderer::DrawDeferred(RenderQueue &objects, RenderQueue &lights)
 {
 	// Pass #1: Fill G-buffers
-	glEnable(GL_CULL_FACE);
+	glDisable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
 	glDepthMask(GL_TRUE);
 	glEnable(GL_DEPTH_TEST);
 	glDisable(GL_BLEND);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred1);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred1);
 	glClearColor(1, 1, 1, 1);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-	m_SpDeferred1->Bind();
-	DrawScene(objects, *m_SpDeferred1);
+	m_spDeferred1->Bind();
+	DrawScene(objects, *m_spDeferred1);
 
 	// Pass #2: Lighting
 	glEnable(GL_CULL_FACE);
@@ -332,30 +256,31 @@ void dd::Renderer::DrawDeferred(RenderQueue &objects, RenderQueue &lights)
 	glBlendEquation(GL_FUNC_ADD);
 	glBlendFunc(GL_ONE, GL_ONE);
 	glDepthMask(GL_FALSE);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred2);
-	glClearColor(0, 0, 0, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred2);
+	glClearColor(0, 0, 0, 1);
 	glClear(GL_COLOR_BUFFER_BIT);
-	m_SpDeferred2->Bind();
+	m_spDeferred2->Bind();
 	DrawLightSpheres(lights);
 
 	// Pass #3: Combine into final deferred image
 	glCullFace(GL_BACK);
 	glDisable(GL_BLEND);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	glClearColor(0, 0, 0, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred3);
+	glClearColor(0, 0, 0, 1);
 	glClear(GL_COLOR_BUFFER_BIT);
-	m_SpDeferred3->Bind();
-	glUniform3fv(glGetUniformLocation(*m_SpDeferred3, "La"), 1, glm::value_ptr(glm::vec3(0.5f)));
+	m_spDeferred3->Bind();
+	glUniform3fv(glGetUniformLocation(*m_spDeferred3, "La"), 1, glm::value_ptr(glm::vec3(0.5f)));
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_GDiffuse);
 	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_2D, m_TLighting);
+	glBindTexture(GL_TEXTURE_2D, m_tLighting);
 	glBindVertexArray(m_ScreenQuad);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
 }
 
 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);
@@ -365,25 +290,12 @@ void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 	//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);
+	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);
-
-	//WaterPass
-	glDisable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-	glDepthMask(GL_TRUE);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWater);
-	glClearColor(0, 0, 0, 0);
-	glClear(GL_COLOR_BUFFER_BIT);
-	m_SpWater->Bind();
-	DrawWater(objects);
+	m_spForward->Bind();
+	DrawScene(objects, *m_spForward);
 }
 
 void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
@@ -399,7 +311,6 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 		if (modelJob) {
 			glm::mat4 modelMatrix = modelJob->ModelMatrix;
 			MVP = PV * modelMatrix;
-			glUniform4fv(glGetUniformLocation(shaderProgramHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
 			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));
@@ -407,6 +318,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 			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);
 
 			glActiveTexture(GL_TEXTURE0);
@@ -427,6 +339,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 				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);
@@ -442,8 +355,6 @@ 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));
-			glUniform4fv(glGetUniformLocation(shaderProgramHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
-
 
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, spriteJob->DiffuseTexture);
@@ -463,7 +374,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 
 void dd::Renderer::DrawLightSpheres(RenderQueue &lights)
 {
-	GLuint shaderProgramHandle = *m_SpDeferred2;
+	GLuint shaderProgramHandle = *m_spDeferred2;
 
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_GPosition);
@@ -498,80 +409,6 @@ void dd::Renderer::DrawLightSpheres(RenderQueue &lights)
 	}
 }
 
-void dd::Renderer::DrawWater(RenderQueue &rq)
-{
-	GLuint shaderProgramHandle = *m_SpWater;
-
-	glm::mat4 projectionMatrix = m_Camera->ProjectionMatrix();
-	glm::mat4 viewMatrix = m_Camera->ViewMatrix();
-	glm::mat4 PV = projectionMatrix * viewMatrix;
-	glm::mat4 MVP;
-	for ( auto &job : rq ) {
-		auto waterJob = std::dynamic_pointer_cast<WaterParticleJob>(job);
-		if (waterJob) {
-			glm::mat4 modelMatrix = waterJob->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));
-			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "V"), 1, GL_FALSE,
-							   glm::value_ptr(viewMatrix));
-
-			glActiveTexture(GL_TEXTURE0);
-			glBindTexture(GL_TEXTURE_2D, *m_WhiteSphereTexture);
-
-			glBindVertexArray(m_UnitQuad->VAO);
-			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_UnitQuad->ElementBuffer);
-			glDrawElementsBaseVertex(GL_TRIANGLES, m_UnitQuad->m_Indices.size(), GL_UNSIGNED_INT, 0, 0);
-		}
-	}
-
-
-
-	//blur1
-	shaderProgramHandle = *m_SpWater2;
-	glDisable(GL_CULL_FACE);
-	glDepthMask(GL_FALSE);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur);
-	glClearColor(0, 0, 0, 0);
-	glClear(GL_COLOR_BUFFER_BIT);
-	m_SpWater2->Bind();
-	//TODO: Add this in water particle component. Blurradius
-	float radius = 3.f;
-
-	glUniform2fv(glGetUniformLocation(shaderProgramHandle, "dir"), 1, glm::value_ptr(glm::vec2(1.0f, 0.0f)));
-	glUniform1f(glGetUniformLocation(shaderProgramHandle, "res"), m_Resolution.Width);
-	glUniform1f(glGetUniformLocation(shaderProgramHandle, "radius"), radius);
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, m_Gwater);
-	glBindVertexArray(m_ScreenQuad);
-	glDrawArrays(GL_TRIANGLES, 0, 6);
-
-
-	//blur2
-	shaderProgramHandle = *m_SpWater2;
-	glDisable(GL_CULL_FACE);
-	glDisable(GL_DEPTH_TEST);
-	glDepthMask(GL_FALSE);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	m_SpWater2->Bind();
-
-	glUniform2fv(glGetUniformLocation(shaderProgramHandle, "dir"), 1, glm::value_ptr(glm::vec2(0.0f, 1.0f)));
-	glUniform1f(glGetUniformLocation(shaderProgramHandle, "res"), m_Resolution.Height);
-	glUniform1f(glGetUniformLocation(shaderProgramHandle, "radius"), radius);
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, m_BWater);
-	glBindVertexArray(m_ScreenQuad);
-	glDrawArrays(GL_TRIANGLES, 0, 6);
-}
-
 GLuint dd::Renderer::CreateQuad()
 {
 	float quadVertices[] =
@@ -618,7 +455,7 @@ GLuint dd::Renderer::CreateQuad()
 void dd::Renderer::DebugKeys()
 {
 	if (glfwGetKey(m_Window, GLFW_KEY_F1)) {
-		m_CurrentScreenBuffer = m_TFinal;
+		m_CurrentScreenBuffer = m_tFinal;
 	}
 	if (glfwGetKey(m_Window, GLFW_KEY_F2)) {
 		m_CurrentScreenBuffer = m_GDiffuse;
@@ -633,66 +470,6 @@ void dd::Renderer::DebugKeys()
 		m_CurrentScreenBuffer = m_GSpecular;
 	}
 	if (glfwGetKey(m_Window, GLFW_KEY_F6)) {
-		m_CurrentScreenBuffer = m_TLighting;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_F7)) {
-		m_CurrentScreenBuffer  = m_Gwater;
-	}
-	if (glfwGetKey(m_Window, GLFW_KEY_F8)) {
-		m_CurrentScreenBuffer  = m_BWater;
+		m_CurrentScreenBuffer = m_tLighting;
 	}
 }
-
-void dd::Renderer::DrawGUI(dd::RenderQueue& rq)
-{
-	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	glDisable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-	glDisable(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);
-
-	m_SpScreen->Bind();
-
-	glm::mat4 MVP;
-
-	for (auto &job : rq) {
-		auto frameJob = std::dynamic_pointer_cast<FrameJob>(job);
-		if (frameJob) {
-			FrameJob jobCopy = *(frameJob.get());
-			glm::mat4 viewMatrix = glm::mat4(1); //frameJob->ViewMatrix;
-			glm::mat4 PV = glm::mat4(1); //frameJob->ProjectionMatrix * viewMatrix;
-			glm::mat4 modelMatrix = glm::mat4(1); //frameJob->ModelMatrix;
-			MVP = PV * modelMatrix;
-			glUniformMatrix4fv(glGetUniformLocation(*m_SpScreen, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
-			glUniformMatrix4fv(glGetUniformLocation(*m_SpScreen, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
-			glUniformMatrix4fv(glGetUniformLocation(*m_SpScreen, "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
-
-			glActiveTexture(GL_TEXTURE0);
-			glBindTexture(GL_TEXTURE_2D, frameJob->DiffuseTexture);
-			//glActiveTexture(GL_TEXTURE1);
-			//glBindTexture(GL_TEXTURE_2D, frameJob->NormalTexture);
-			//glActiveTexture(GL_TEXTURE2);
-			//glBindTexture(GL_TEXTURE_2D, frameJob->SpecularTexture);
-
-			Rectangle& vp = frameJob->Viewport;
-			glViewport(vp.X, m_Resolution.Height - vp.Y - vp.Height, vp.Width, vp.Height);
-			Rectangle& sc = frameJob->Scissor;
-			if (sc == Rectangle()) {
-				glDisable(GL_SCISSOR_TEST);
-			} else {
-				glEnable(GL_SCISSOR_TEST);
-				glScissor(sc.X, m_Resolution.Height - sc.Y - sc.Height, sc.Width, sc.Height);
-			}
-
-			glBindVertexArray(m_ScreenQuad);
-			glDrawArrays(GL_TRIANGLES, 0, 6);
-
-			continue;
-		}
-	}
-
-	glDisable(GL_SCISSOR_TEST);
-	glViewport(0, 0, m_Resolution.Width, m_Resolution.Height);
-}

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

@@ -24,7 +24,6 @@ layout (binding = 2) uniform sampler2D SpecularMap;
 
 uniform mat4 V;
 uniform float MaterialShininess;
-uniform vec4 Color;
 
 in VertexData
 {
@@ -50,7 +49,6 @@ void main()
 {
 	// Diffuse Texture
 	GDiffuse = texture(DiffuseTexture, Input.TextureCoord) * Input.DiffuseColor;
-	GDiffuse = GDiffuse * Color;
 
 	// G-buffer Position
 	GPosition = vec4(Input.Position.xyz, 1.0);

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

@@ -1,90 +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/>.
-*/
-
-#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);
-	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/Deferred/water/Vertex.glsl

@@ -1,83 +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/>.
-*/
-
-#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/Shaders/Deferred/water2/Fragment.glsl

@@ -1,70 +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/>.
-*/
-
-#version 440
-
-uniform vec2 dir;
-uniform float res;
-uniform float radius;
-
-layout (binding=0) uniform sampler2D WaterTexture;
-
-in VertexData
-{
-	vec3 Position;
-	vec2 TextureCoord;
-} Input;
-
-out vec4 frag_Diffuse;
-
-void main()
-{
-	vec4 WaterTexel = texture(WaterTexture, Input.TextureCoord);
-
-	vec4 sum = vec4(0.0);
-	vec2 tc = Input.TextureCoord;
-
-	//How much blur, 1 = blur by one pixel.
-	float blur = radius/res;
-
-	float hstep = dir.x;
-	float vstep = dir.y;
-
-	float Threshhold = 0.1;
-
-	//apply filter using a 9 tap filter with predefined gaussian weights
-
-	sum += texture(WaterTexture, vec2(tc.x - 4.0*blur*hstep, tc.y - 4.0*blur*vstep)) * 0.0162162162;
-	sum += texture(WaterTexture, vec2(tc.x - 3.0*blur*hstep, tc.y - 3.0*blur*vstep)) * 0.0540540541;
-    sum += texture(WaterTexture, vec2(tc.x - 2.0*blur*hstep, tc.y - 2.0*blur*vstep)) * 0.1216216216;
-    sum += texture(WaterTexture, vec2(tc.x - 1.0*blur*hstep, tc.y - 1.0*blur*vstep)) * 0.1945945946;
-
-    sum += texture(WaterTexture, vec2(tc.x, tc.y)) * 0.2270270270;
-
-    sum += texture(WaterTexture, vec2(tc.x + 1.0*blur*hstep, tc.y + 1.0*blur*vstep)) * 0.1945945946;
-    sum += texture(WaterTexture, vec2(tc.x + 2.0*blur*hstep, tc.y + 2.0*blur*vstep)) * 0.1216216216;
-    sum += texture(WaterTexture, vec2(tc.x + 3.0*blur*hstep, tc.y + 3.0*blur*vstep)) * 0.0540540541;
-    sum += texture(WaterTexture, vec2(tc.x + 4.0*blur*hstep, tc.y + 4.0*blur*vstep)) * 0.0162162162;
-
-    float avgColor = sum.r + sum.g + sum.b;
-    avgColor = avgColor/3;
-    frag_Diffuse = vec4(sum.r, sum.g, sum.b, 1.0);
-    if ( avgColor*dir.y > Threshhold ){
-    		frag_Diffuse = vec4(0.0, 0.3, 1.0, 1.0);
-    }
-}

src/game/Core/Shaders/Deferred/water2/Vertex.glsl

@@ -1,34 +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/>.
-*/
-
-#version 440
-
-layout (location = 0) in vec3 Position;
-
-out VertexData
-{
-	vec3 Position;
-	vec2 TextureCoord;
-} Output;
-
-void main()
-{
-	gl_Position = vec4(Position, 1.0);
-	Output.Position = Position;
-	Output.TextureCoord = (vec2(Position) + 1) / 2;
-}

src/game/Core/Texture.cpp

@@ -31,9 +31,6 @@ dd::Texture::Texture(std::string path)
 		}
 	}
 
-	this->Width = image->Width;
-	this->Height = image->Height;
-
 	GLint format;
 	switch (image->Format) {
 	case Image::ImageFormat::RGB:

src/game/Core/World.cpp

@@ -58,11 +58,36 @@ void dd::World::Update(double dt)
 	{
 		const std::string &type = pair.first;
 		auto system = pair.second;
-		EventBroker->Process(type);
-		system->Update(dt);
-		RecursiveUpdate(system, dt, 0);
-	}
 
+		std::map<std::string, TimeMeasure>::iterator it = m_typeToTimeMap.find(type.c_str());
+		if (it == m_typeToTimeMap.end()) {
+			//Does not contain item
+			TimeMeasure t;
+			t.EventTime = 0;
+			t.SystemTime = 0;
+			t.RSystemTime = 0;
+			m_typeToTimeMap[type.c_str()] = t;
+		}
+
+		double start = glfwGetTime();
+		EventBroker->Process(type);
+		double stop = glfwGetTime();
+		double t1 = stop - start;
+		m_typeToTimeMap[type.c_str()].EventTime += t1;
+
+		start = glfwGetTime();
+		system->Update(dt);
+		stop = glfwGetTime();
+		double t2 = stop - start;
+		m_typeToTimeMap[type.c_str()].SystemTime += t2;
+
+		start = glfwGetTime();
+		RecursiveUpdate(system, dt, 0);
+		stop = glfwGetTime();
+		double t3 = stop - start;
+		m_typeToTimeMap[type.c_str()].RSystemTime += t3;
+	}
+	EventBroker->Process<World>();
 	ProcessEntityRemovals();
 }
 
@@ -161,6 +186,8 @@ void dd::World::Initialize()
 		system->RegisterResourceTypes(ResourceManager);
 		system->Initialize();
 	}
+
+	EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &World::OnKeyDown);
 }
 
 int dd::World::CommitEntity(EntityID entity)
@@ -232,3 +259,41 @@ void dd::World::SetEntityParent(EntityID entity, EntityID newParent)
 	m_EntityParents[entity] = newParent;
 	m_EntityChildren[newParent].push_back(entity);
 }
+
+bool dd::World::OnKeyDown(const dd::Events::KeyDown &event)
+{
+	if (event.KeyCode == 78)
+	{
+		double eventTot = 0;
+		double updateTot = 0;
+		double rUpdateTot = 0;
+		double total = 0;
+
+		for (auto item : m_typeToTimeMap)
+		{
+			eventTot += item.second.EventTime;
+			updateTot += item.second.SystemTime;
+			rUpdateTot += item.second.RSystemTime;
+		}
+		total = eventTot + updateTot + rUpdateTot;
+
+		std::ofstream outFile;
+		outFile.open("../tools/system-metrics.txt");
+		outFile.clear();
+		outFile << "----------------------- Time measurements -----------------------\n";
+		for (auto item : m_typeToTimeMap)
+		{
+			outFile << "Type: " << item.first.c_str() << std::endl;
+			outFile << "Events: " << item.second.EventTime << " s. " << item.second.EventTime / eventTot  * 100 << " % of total event time.\n";
+			outFile << "Update: " << item.second.SystemTime << " s. " << item.second.SystemTime / updateTot  * 100 << " % of total update time.\n";
+			outFile << "Recursive Update: " << item.second.RSystemTime << " s. " << item.second.RSystemTime / rUpdateTot  * 100 << " % of total recursive update time.\n";
+			double totalComplexity = (item.second.EventTime + item.second.SystemTime + item.second.RSystemTime) / total * 100;
+			outFile << "Total: " << totalComplexity << "% total system time." << std::endl << std::endl;
+		}
+		outFile  << "-----------------------------------------------------------------";
+		outFile.close();
+		return true;
+
+	}
+	//return false;
+}

src/game/Game/BallSystem.cpp

@@ -13,154 +13,17 @@ void dd::Systems::BallSystem::RegisterComponents(ComponentFactory *cf)
 void dd::Systems::BallSystem::Initialize()
 {
 
-    EVENT_SUBSCRIBE_MEMBER(m_Contact, &BallSystem::Contact);
-    EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, &BallSystem::OnLifeLost);
-    EVENT_SUBSCRIBE_MEMBER(m_EMultiBallLost, &BallSystem::OnMultiBallLost);
-    EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &BallSystem::OnResetBall);
-    EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &BallSystem::OnMultiBall);
-    EVENT_SUBSCRIBE_MEMBER(m_EPause, &BallSystem::OnPause);
-
-    //OctoBall
-    {
-        auto ent = m_World->CreateEntity();
-        std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-        transform->Position = glm::vec3(-0.f, 50.26f, -10.f);
-        transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-        transform->Velocity = glm::vec3(0.f, 0.f, 0.f);
-        auto model = m_World->AddComponent<Components::Model>(ent);
-        model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-        std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-        std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
-        ball->Speed = 5.f;
-        std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-        std::shared_ptr<Components::Template> ballTemplate = m_World->AddComponent<Components::Template>(ent);
-        physics->Static = false;
-        physics->Category = CollisionLayer::Type::Ball;
-        physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
-        physics->Calculate = true;
-
-        //auto plight = m_World->AddComponent<Components::PointLight>(ent);
-        //plight->Radius = 2.f;
-
-        m_World->CommitEntity(ent);
-
-        SetBall(ent);
-
-        auto ent2 = CreateBall();
-        auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
-        transform2->Position = glm::vec3(-0.f, 0.26f, -10.f);
-        transform2->Velocity = glm::vec3(0.0f, -10.f, 0.f);
-
-        m_World->CommitEntity(ent2);
-    }
-
-    for (int i = 0; i < Lives(); i++) {
-        CreateLife(i);
-    }
+    EVENT_SUBSCRIBE_MEMBER(m_Contact, BallSystem::Contact);
 }
 
 void dd::Systems::BallSystem::Update(double dt)
 {
-    if (Lives() < 0)
-    {
-        SetLives(3);
-        Events::GameOver e;
-        EventBroker->Publish(e);
-    }
+
 }
 
 void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
     auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
-    if (IsPaused()) {
-        if (ballComponent != nullptr) {
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-
-            if (!ballComponent->Paused) {
-                ballComponent->Paused = true;
-                ballComponent->SavedSpeed = transform->Velocity;
-                transform->Velocity = glm::vec3(0, 0, 0);
-            }
-        }
-        return;
-    } else {
-        if (ballComponent != nullptr) {
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-
-            if (ballComponent->Paused) {
-                transform->Velocity = ballComponent->SavedSpeed;
-                ballComponent->Paused = false;
-            }
-        }
-    }
-
-    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
-    if (templateCheck != nullptr){ return; }
-
-    if (ballComponent != nullptr) {
-        if (ReplaceBall()) {
-            SetReplaceBall(false);
-
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
-            transform->Position = glm::vec3(0.0f, 0.26f, -10.f);
-            transform->Velocity = glm::vec3(0.0f, -ballComponent->Speed, 0.f);
-        }
-
-        auto transformBall = m_World->GetComponent<Components::Transform>(entity);
-        if (glm::abs(transformBall->Velocity.y) < 2) {
-            if (transformBall->Velocity.y > 0) {
-                transformBall->Velocity.y = 2;
-            } else {
-                transformBall->Velocity.y = -2;
-            }
-        }
-        if (transformBall->Position.y < -EdgeY() - 4) {
-            if (MultiBalls() != 0) {
-//                m_World->RemoveComponent<Components::Ball>(entity);
-//                m_World->RemoveComponent<Components::Transform>(entity);
-//                m_World->RemoveComponent<Components::CircleShape>(entity);
-//                m_World->RemoveComponent<Components::Physics>(entity);
-                transformBall->Velocity = glm::vec3(0, 0, 0);
-                ballComponent->SavedSpeed = glm::vec3(0, 0, 0);
-                m_World->RemoveEntity(entity);
-                Events::MultiBallLost e;
-                EventBroker->Publish(e);
-            } else if (Lives() == PastLives()) {
-                Events::ResetBall be;
-                EventBroker->Publish(be);
-                Events::LifeLost e;
-                e.Entity = entity;
-                EventBroker->Publish(e);
-                return;
-            }
-        } else if (transformBall->Position.x > EdgeX()) {
-            if (transformBall->Velocity.x > 0) {
-                glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(1, 0));
-                transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
-            }
-        } else if (transformBall->Position.x < -EdgeX()) {
-            if (transformBall->Velocity.x < 0) {
-                glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(-1, 0));
-                transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
-            }
-        } else if (transformBall->Position.y > EdgeY()) {
-            if (transformBall->Velocity.y > 0) {
-                glm::vec2 reflectedVelocity = glm::reflect(glm::vec2(transformBall->Velocity.x, transformBall->Velocity.y), glm::vec2(0, 1));
-                transformBall->Velocity = glm::vec3(reflectedVelocity, 0.f);
-            }
-        }
-    }
-
-    if (Lives() != PastLives()) {
-        auto life = m_World->GetComponent<Components::Life>(entity);
-        if (life != nullptr) {
-            if (life->Number + 1 == PastLives()) {
-                m_World->RemoveEntity(entity);
-                SetPastLives(Lives());
-            }
-        }
-    }
-
     if (ballComponent != nullptr) {
         auto transform = m_World->GetComponent<Components::Transform>(entity);
         glm::vec2 dir = glm::normalize(glm::vec2(transform->Velocity.x, transform->Velocity.y));
@@ -170,20 +33,6 @@ void dd::Systems::BallSystem::UpdateEntity(double dt, EntityID entity, EntityID
     }
 }
 
-bool dd::Systems::BallSystem::OnPause(const dd::Events::Pause &event)
-{
-    if (event.Type != "BallSystem" && event.Type != "All") {
-        return false;
-    }
-
-    if (IsPaused()) {
-        SetPause(false);
-    } else {
-        SetPause(true);
-    }
-    return true;
-}
-
 void dd::Systems::BallSystem::OnEntityCommit(EntityID entity)
 {
 
@@ -211,10 +60,9 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         return false;
     }
 
-
+    //Which is the ball?
     EntityID ballEntity, otherEntitiy;
 
-    //Which is the ball?
     if (ballComponent1 != nullptr) {
         ballEntity = event.Entity1;
         otherEntitiy = event.Entity2;
@@ -230,24 +78,17 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
         //TODO: Add support for power-up collisions
     }
 
-    //if this is a brick thats dead do not collide :)
-
     auto ballTransform = m_World->GetComponent<Components::Transform>(ballEntity);
     glm::vec2 ballVelocity = glm::vec2(ballTransform->Velocity.x, ballTransform->Velocity.y);
 
     if (m_World->GetProperty<std::string>(otherEntitiy, "Name") == "Pad"){
         auto padTransform = m_World->GetComponent<Components::Transform>(otherEntitiy);
-        float x = (ballTransform->Position.x - padTransform->Position.x) * XMovementMultiplier();
+        float x = ballTransform->Position.x - padTransform->Position.x;
 
+        float movementMultiplier = 5.0f;
         float y = glm::cos((abs(x) / (1.6f)) * glm::pi<float>() / 2.f) + 1.f;
 
         ballTransform->Velocity = glm::normalize(glm::vec3(x, y ,0.f)) * ballComponent->Speed;
-        ballComponent->Combo = 0;
-        Events::ComboEvent ec;
-        ec.Combo = ballComponent->Combo;
-        ec.Ball = ballEntity;
-        EventBroker->Publish(ec);
-        //std::cout << "Combo: " << ballComponent->Combo << std::endl;
     }
     else {
         glm::vec2 reflectedVelocity = glm::reflect(ballVelocity, event.Normal);
@@ -256,79 +97,3 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 
     return true;
 }
-
-EntityID dd::Systems::BallSystem::CreateBall()
-{
-    auto ent = m_World->CloneEntity(Ball());
-
-    m_World->RemoveComponent<Components::Template>(ent);
-
-    m_World->CommitEntity(ent);
-
-    return ent;
-}
-
-void dd::Systems::BallSystem::CreateLife(int number)
-{
-    auto life = m_World->CreateEntity();
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
-    transform->Position = glm::vec3(-1.5f + number * 0.15f, -2.f, -5.f);
-    transform->Scale = glm::vec3(0.1f, 0.1f, 0.1f);
-
-    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";
-
-
-    m_World->CommitEntity(life);
-}
-
-bool dd::Systems::BallSystem::OnLifeLost(const dd::Events::LifeLost &event)
-{
-    SetLives(Lives() - 1);
-
-    return true;
-}
-
-bool dd::Systems::BallSystem::OnMultiBallLost(const dd::Events::MultiBallLost &event)
-{
-    SetMultiBalls(MultiBalls()-1);
-    return true;
-}
-
-bool dd::Systems::BallSystem::OnResetBall(const dd::Events::ResetBall &event)
-{
-    SetReplaceBall(true);
-    return true;
-}
-
-bool dd::Systems::BallSystem::OnMultiBall(const dd::Events::MultiBall &event)
-{
-    auto ent1 = CreateBall();
-    auto ent2 = CreateBall();
-    auto transform1 = m_World->GetComponent<Components::Transform>(ent1);
-    auto transform2 = m_World->GetComponent<Components::Transform>(ent2);
-    auto ball1 = m_World->GetComponent<Components::Ball>(ent1);
-    auto ball2 = m_World->GetComponent<Components::Ball>(ent2);
-    auto padTransform = event.padTransform;
-    float x1 = padTransform->Position.x - 2, x2 = padTransform->Position.x + 2;
-    if (x1 < -3.1) {
-        x1 = 3;
-    }
-    if (x2 > 3.1) {
-        x2 = -3;
-    }
-    transform1->Position = glm::vec3(x1, -5.5, -10);
-    transform2->Position = glm::vec3(x2, -5.5, -10);
-
-    transform1->Velocity = glm::normalize(glm::vec3(5, 5 ,0.f)) * ball1->Speed;
-    transform2->Velocity = glm::normalize(glm::vec3(-5, 5 ,0.f)) * ball2->Speed;
-    //std::cout << "1: " <<transform1->Velocity.x << " " << transform1->Velocity.y << std::endl;
-    //std::cout << "2: " <<transform2->Velocity.x << " " << transform2->Velocity.y << std::endl;
-
-    SetMultiBalls(MultiBalls() + 2);
-
-    return true;
-}

src/game/Game/HitLagSystem.cpp

@@ -1,56 +0,0 @@
-//
-// Created by Adniklastrator on 2015-09-30.
-//
-
-#include "PrecompiledHeader.h"
-#include "Game/HitLagSystem.h"
-
-void dd::Systems::HitLagSystem::Initialize()
-{
-    EVENT_SUBSCRIBE_MEMBER(m_EPause, &HitLagSystem::OnPause);
-    EVENT_SUBSCRIBE_MEMBER(m_EHitLag, &HitLagSystem::OnHitLag);
-}
-
-void dd::Systems::HitLagSystem::Update(double dt)
-{
-    if (IsPaused()) {
-        if (HitLag()) {
-            SetHitLagTimer(HitLagTimer() += dt);
-            if (HitLagDuration() < HitLagTimer()) {
-                SetHitLagTimer(0);
-                SetHitLag(false);
-                FlipPause();
-            }
-        }
-        return;
-    }
-}
-
-void dd::Systems::HitLagSystem::FlipPause()
-{
-    Events::Pause e;
-    e.Type = CurrentType();
-    EventBroker->Publish(e);
-}
-
-bool dd::Systems::HitLagSystem::OnPause(const dd::Events::Pause &event)
-{
-    if (IsPaused()) {
-        SetPause(false);
-    } else {
-        SetPause(true);
-    }
-    return true;
-}
-
-bool dd::Systems::HitLagSystem::OnHitLag(const dd::Events::HitLag &event)
-{
-    if (HitLag()) {
-        FlipPause();
-    }
-    SetHitLag(true);
-    SetCurrentType(event.Type);
-    FlipPause();
-    SetHitLagDuration(event.Time);
-    return true;
-}