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

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

include/Core/Engine.h

@@ -52,6 +52,8 @@
 #include "Physics/CRectangleShape.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"
@@ -111,10 +113,6 @@ public:
 		m_World->ComponentFactory.Register<Components::PowerUp>();
 		m_World->ComponentFactory.Register<Components::PowerUpBrick>();
 
-		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>();
@@ -124,11 +122,16 @@ public:
 		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::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::PointLight>();
 		m_World->ComponentFactory.Register<Components::WaterVolume>();
+		m_World->ComponentFactory.Register<Components::Particle>();
+		m_World->ComponentFactory.Register<Components::ParticleEmitter>();
 		m_World->Initialize();
 
 
@@ -136,12 +139,14 @@ public:
 		{
           	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, -9.f);
+			transform->Position = glm::vec3(-0.f, 0.26f, -10.f);
 			transform->Scale = glm::vec3(0.35f, 0.35f, 0.2f);
 			transform->Velocity = glm::vec3(0.0f, -10.f, 0.f);
           	auto model = m_World->AddComponent<Components::Model>(ent);
 			model->ModelFile = "Models/Test/Ball/Sid.obj";
           	std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+			circleShape->Radius = 0.35f;
+
 			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);
@@ -165,7 +170,7 @@ public:
 			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 = "Core/UnitSphere.obj";
+			model->ModelFile = "Models/Core/UnitSphere.obj";
 			m_World->CommitEntity(t_Light);
 		}
 		{
@@ -176,7 +181,7 @@ public:
 			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 = "Core/UnitSphere.obj";
+			model->ModelFile = "Models/Core/UnitSphere.obj";
 			m_World->CommitEntity(t_Light);
 		}
 
@@ -188,7 +193,7 @@ public:
 			transform->Scale = glm::vec3(6.f, 6.f, 10.f);
 			auto model = m_World->AddComponent<Components::Model>(t_halfPipe);
 			model->ModelFile = "Models/Test/halfpipe/Halfpipe.obj";
-			model->Color = glm::vec4(1.f, 1.f, 1.f, 0.3f);
+			model->Color = glm::vec4(1.f, 0.f, 0.f, 0.3f);
 			m_World->CommitEntity(t_halfPipe);
 		}
 
@@ -203,6 +208,44 @@ public:
 			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
 		{
 			auto t_waterBody = m_World->CreateEntity();
@@ -213,6 +256,7 @@ public:
 			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
 		{
@@ -222,8 +266,8 @@ public:
 			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>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(topWall);
-					topWall);
+			rectangleShape->Dimensions = glm::vec3(10.f, 0.5f);
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
 			physics->CollisionType = CollisionType::Type::Static;
 			m_World->CommitEntity(topWall);
@@ -267,8 +311,8 @@ public:
 			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>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(topWall);
-					topWall);
+			rectangleShape->Dimensions = glm::vec3(20.f, 0.5f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
 			physics->CollisionType = CollisionType::Type::Static;
@@ -288,8 +332,8 @@ public:
 			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>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(leftWall);
-					leftWall);
+			rectangleShape->Dimensions = glm::vec3(0.5f, 20.f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
 			physics->CollisionType = CollisionType::Type::Static;
@@ -309,35 +353,16 @@ public:
 			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>(
+			std::shared_ptr<Components::RectangleShape> rectangleShape = m_World->AddComponent<Components::RectangleShape>(rightWall);
-					rightWall);
+			rectangleShape->Dimensions = glm::vec3(0.5f, 20.f);
 
 			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
 			physics->CollisionType = CollisionType::Type::Static;
 			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, -3.5f, -10.f);
-			ctransform->Scale = glm::vec3(1.0f, 1.0f, 1.f);
-			auto rectangle = m_World->AddComponent<Components::RectangleShape>(ent);
-			auto physics = m_World->AddComponent<Components::Physics>(ent);
-			physics->CollisionType = CollisionType::Type::Kinematic;
-			physics->Category = CollisionLayer::Type::Pad;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::PowerUp;
-			physics->Calculate = true;
-			auto cModel = m_World->AddComponent<Components::Model>(ent);
-			cModel->ModelFile = "Models/Submarine2.obj";
-
-			auto pad = m_World->AddComponent<Components::Pad>(ent);
-			m_World->CommitEntity(ent);
-		}
 
 
 		//EVENT_SUBSCRIBE_MEMBER(m_EGameStart, &Engine::OnGameStart);
@@ -360,7 +385,7 @@ public:
 		// Swap event queues to get fresh input data in the read queue
 		//m_EventBroker->Swap();
 
-		ResourceManager::Update();
+		//ResourceManager::Update();
 		if (m_GameIsRunning) {
 			m_World->Update(dt);
 		}
@@ -449,7 +474,6 @@ public:
 			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
 			if (spriteComponent)
 			{
-
 				std::string normal = spriteComponent->NormalTexture;
 				std::string spec = spriteComponent->SpecularTexture;
 
@@ -472,7 +496,6 @@ public:
 				EnqueueSprite(texturediff, texturenorm, texturespec, modelMatrix, spriteComponent->Color, absoluteTransform.Position.z);
 			}
 		}
-
 	}
 
 	//TODO: Get this out of engine.h

include/Core/EventBroker.h

@@ -24,6 +24,7 @@
 #include <map>
 #include <unordered_map>
 #include <list>
+#include <tuple>
 
 #define EVENT_SUBSCRIBE_MEMBER(relay, handler) \
 	relay = decltype(relay)(std::bind(handler, this, std::placeholders::_1)); \
@@ -123,16 +124,23 @@ public:
 	void Unsubscribe(BaseEventRelay &relay);
 
 private:
+	bool m_IsProcessing = false;
+
 	typedef std::string ContextTypeName_t; // typeid(ContextType).name()
 	typedef std::string EventTypeName_t; // typeid(EventType).name()
 
 	typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
 	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
 	ContextRelays_t m_ContextRelays;
+	std::vector<BaseEventRelay*> m_RelaysToSubscribe;
+	std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
 
 	typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
 	std::shared_ptr<EventQueue_t> m_EventQueueRead;
 	std::shared_ptr<EventQueue_t> m_EventQueueWrite;
+
+	void subscribeImmediate(BaseEventRelay& relay);
+	void unsubscribeImmediate(BaseEventRelay& relay);
 };
 
 template <typename EventType>

include/Core/Renderer.h

@@ -16,8 +16,8 @@
 	along with Daydream Engine.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef Renderer_h__
+#ifndef DD_RENDERER_H__
-#define Renderer_h__
+#define DD_RENDERER_H__
 
 #include "Util/Rectangle.h"
 #include "Camera.h"
@@ -30,8 +30,6 @@ 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; }
@@ -39,8 +37,6 @@ 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)
 	{
@@ -50,7 +46,6 @@ public:
 			m_Camera = camera;
 		}
 	}
-
 	void Initialize();
 	void Draw(RenderQueueCollection& rq);
 
@@ -58,8 +53,6 @@ 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;
 
@@ -67,42 +60,37 @@ private:
 	std::string m_GLVendor;
 	GLFWwindow* m_Window = nullptr;
 
-	ShaderProgram* m_spDeferred1;
+	ShaderProgram* m_SpDeferred1;
-	ShaderProgram* m_spDeferred2;
+	ShaderProgram* m_SpDeferred2;
-	ShaderProgram* m_spDeferred3;
+	ShaderProgram* m_SpDeferred3;
-	ShaderProgram* m_spForward;
+	ShaderProgram* m_SpForward;
-	ShaderProgram* m_spScreen;
+	ShaderProgram* m_SpScreen;
-	ShaderProgram* t_m_spWater;
+	ShaderProgram* m_SpWater;
-	ShaderProgram* t_m_spWater2;
+	ShaderProgram* m_SpWater2;
 
 	GLuint m_ScreenQuad = 0;
 	Model* m_UnitSphere = nullptr;
 	Model* m_UnitQuad = nullptr;
 	Texture* m_StandardNormal;
 	Texture* m_StandardSpecular;
-	Texture* t_m_WhiteSphereTexture;
+	Texture* m_WhiteSphereTexture;
-
-	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;
-	//Water GTexture
-	GLuint t_m_Gwater = 0;
-	//Water blur texture
-	GLuint t_m_BWater;
-	GLuint t_m_BWater2;
-	//WAterpass Framebuffer
-	GLuint t_m_fbWater;
-	//Waterpass Framebuffer
-	GLuint t_m_fbWaterBlur;
-	GLuint t_m_fbWaterBlur2;
 
+	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_CurrentScreenBuffer = 0;
 	void LoadShaders();

include/GUI/Button.h

@@ -60,6 +60,10 @@ protected:
 
 	virtual bool OnMouseMove(const Events::MouseMove& event)
 	{
+		if (Hidden()) {
+			return false;
+		}
+
 		bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
 		if (isOver && !m_MouseIsOver) { // Enter
 			if (!m_IsDown) {
@@ -88,6 +92,11 @@ protected:
 	}
 	virtual bool OnMousePress(const Events::MousePress& event)
 	{
+		if (Hidden()) {
+			LOG_DEBUG("Pressed hidden button");
+			return false;
+		}
+
 		if (!Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1))) {
 			return false;
 		}
@@ -107,6 +116,11 @@ protected:
 	}
 	virtual bool OnMouseRelease(const Events::MouseRelease& event)
 	{
+		if (Hidden()) {
+			LOG_DEBUG("Released hidden button");
+			return false;
+		}
+
 		bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
 		if (!isOver && !m_IsDown) {
 			return false;

include/GUI/NumberFrame.h

@@ -1,6 +1,8 @@
 #ifndef GUI_NUMBERFRAME_H__
 #define GUI_NUMBERFRAME_H__
 
+#include <unordered_map>
+
 #include "GUI/TextureFrame.h"
 
 namespace dd
@@ -14,32 +16,16 @@ public:
 	NumberFrame(Frame* parent, std::string name)
 		: Frame(parent, name)
 	{
-		m_NumberTextures[0] = "Textures/GUI/Numbers/N0.png";
+		m_CharacterTextures['0'] = "Textures/GUI/Numbers/N0.png";
-		m_NumberTextures[1] = "Textures/GUI/Numbers/N1.png";
+		m_CharacterTextures['1'] = "Textures/GUI/Numbers/N1.png";
-		m_NumberTextures[2] = "Textures/GUI/Numbers/N2.png";
+		m_CharacterTextures['2'] = "Textures/GUI/Numbers/N2.png";
-		m_NumberTextures[3] = "Textures/GUI/Numbers/N3.png";
+		m_CharacterTextures['3'] = "Textures/GUI/Numbers/N3.png";
-		m_NumberTextures[4] = "Textures/GUI/Numbers/N4.png";
+		m_CharacterTextures['4'] = "Textures/GUI/Numbers/N4.png";
-		m_NumberTextures[5] = "Textures/GUI/Numbers/N5.png";
+		m_CharacterTextures['5'] = "Textures/GUI/Numbers/N5.png";
-		m_NumberTextures[6] = "Textures/GUI/Numbers/N6.png";
+		m_CharacterTextures['6'] = "Textures/GUI/Numbers/N6.png";
-		m_NumberTextures[7] = "Textures/GUI/Numbers/N7.png";
+		m_CharacterTextures['7'] = "Textures/GUI/Numbers/N7.png";
-		m_NumberTextures[8] = "Textures/GUI/Numbers/N8.png";
+		m_CharacterTextures['8'] = "Textures/GUI/Numbers/N8.png";
-		m_NumberTextures[9] = "Textures/GUI/Numbers/N9.png";
+		m_CharacterTextures['9'] = "Textures/GUI/Numbers/N9.png";
-
-		// Create number frame if missing
-		for (int i = 0; i < 10; i++) {
-			auto frame = new GUI::TextureFrame(this, "NumberFrameDigit");
-			frame->SetTexture(m_NumberTextures[0]);
-			frame->DisableScissor();
-			// Position frame based on alignment
-			if (i > 0) {
-				frame->X = i * 20;
-			}
-			Width += frame->Width;
-			if (Height < frame->Height) {
-				Height = frame->Height;
-			}
-			m_NumberFrames.push_front(frame);
-		}
 
 		SetNumber(0);
 	}
@@ -50,41 +36,40 @@ public:
 		m_Number = number;
 
 		// Clear number textures
-		//for (auto& frame : m_NumberFrames) {
+		for (auto& frame : m_NumberFrames) {
-		//	frame->SetTexture("");
+			frame->SetTexture("");
-		//}
+		}
 
-		//Width = 0;
+		Width = 0;
-		//Height = 0;
+		Height = 0;
 
-		int n = 0;
+		std::string digits = std::to_string(number);
-		do {
+
-//			// Create number frame if missing
+		int i = 0;
-//			if (m_NumberFrames.size() <= n) {
+		for (char& c : digits) {
-//				auto frame = new GUI::TextureFrame(this, "NumberFrameDigit");
+			// Create number frame if missing
-//				frame->DisableScissor();
+			if (i >= m_NumberFrames.size()) {
-//				m_NumberFrames.push_front(frame);
+				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
-			int digit = number % 10;
+			std::string texture = "Textures/Core/ErrorTexture.png";
-			m_NumberFrames[n]->SetTexture(m_NumberTextures[digit]);
+			if (m_CharacterTextures.find(c) != m_CharacterTextures.end()) {
-			//Width += m_NumberFrames[n]->Width;
+				texture = m_CharacterTextures.at(c);
-			//if (Height < m_NumberFrames[n]->Height) {
+			}
-			//	Height = m_NumberFrames[n]->Height;
+			m_NumberFrames[i]->SetTexture(m_CharacterTextures.at(c));
-			//}
+			Width += m_NumberFrames[i]->Width;
-//			// Position frame based on alignment
+			if (Height < m_NumberFrames[i]->Height) {
-//			if (n > 0) {
+				Height = m_NumberFrames[i]->Height;
-//				if (!m_LeftAligned) {
+			}
-//					m_NumberFrames[n]->SetLeft(m_NumberFrames[n - 1]->Right());
-//				} else {
-//					m_NumberFrames[n]->SetRight(m_NumberFrames[n - 1]->Left());
-//				}
-//			}
 
-			number /= 10;
+			i++;
-			n++;
+		}
-		} while (number > 0);
 	}
 
 	void SetLeftAlign() { m_LeftAligned = true; }
@@ -99,7 +84,7 @@ private:
 	int m_Number = 0;
 	bool m_LeftAligned = true;
 
-	std::string m_NumberTextures[10];
+	std::unordered_map<char, std::string> m_CharacterTextures;
 	std::deque<TextureFrame*> m_NumberFrames;
 };
 

include/Game/BallSystem.h

@@ -5,15 +5,30 @@
 #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"
 
-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) { }
@@ -39,11 +54,53 @@ public:
     // Called when an entity is removed
     void OnEntityRemoved(EntityID entity) override;
 
-private:
+    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; }
+
+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;
+
+    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;
+
+    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);
 };
 
 }
+
 }
 
 #endif

include/Game/CBall.h

@@ -17,6 +17,7 @@ struct Ball : Component
 {
     int Number = 0;
     float Speed = 5.f;
+    int Combo = 0;
 };
 
 }

include/Game/CPad.h

@@ -22,7 +22,7 @@ struct Pad : Component
 
     float SlowdownModifier = 5.f;
     float AccelerationSpeed = 40.f;
-    float MaxSpeed = 20.f;
+    float MaxSpeed = 5.f;
 };
 
 }

include/Game/EComboEvent.h

@@ -0,0 +1,27 @@
+//
+// 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/EMultiBallLost.h

@@ -0,0 +1,26 @@
+//
+// 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/FPSCounter.h

@@ -0,0 +1,43 @@
+#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_FrameTimes.resize(m_MaxSamples);
+		m_Numbers = new GUI::NumberFrame(this, "FPSCounterNumberFrame");
+	}
+
+	virtual void Update(double dt)
+	{
+		m_FrameTimes[m_CurrentFrame % m_MaxSamples] = dt;
+		double sum = std::accumulate(m_FrameTimes.begin(), m_FrameTimes.end(), 0.0);
+		sum /= std::min(m_CurrentFrame, m_MaxSamples);
+		m_Numbers->SetNumber(std::round(1.0 / sum));
+
+		m_CurrentFrame++;
+	}
+
+private:
+	NumberFrame* m_Numbers = nullptr;
+
+	int m_MaxSamples = 100;
+	int m_CurrentFrame = 0;
+	std::vector<double> m_FrameTimes;
+};
+
+}
+}
+#endif
+

include/Game/HUD.h

@@ -6,6 +6,7 @@
 #include "GUI/NumberFrame.h"
 #include "Core/EKeyUp.h"
 #include "Game/EScoreEvent.h"
+#include "Game/FPSCounter.h"
 
 namespace dd
 {
@@ -24,6 +25,15 @@ public:
 		m_LevelIndicator = new GUI::TextureFrame(this, "HUDLevelIndicator");
 		m_LevelIndicator->SetTexture("Textures/GUI/HUD/LevelIndicatorBG.png");
 
+		m_AreaNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
+		m_AreaNumberFrame->X = 132;
+		m_AreaNumberFrame->Y = 19;
+		m_AreaNumberFrame->SetNumber(6);
+		m_StageNumberFrame = new GUI::NumberFrame(m_LevelIndicator, "HUDScoreNumberFrameawdawdwa");
+		m_StageNumberFrame->X = 165;
+		m_StageNumberFrame->Y = 19;
+		m_StageNumberFrame->SetNumber(5);
+
 		m_ScoreIndicator = new GUI::TextureFrame(this, "HUDScoreIndicator");
 		m_ScoreIndicator->SetTexture("Textures/GUI/HUD/ScoreIndicatorBG.png");
 		m_ScoreIndicator->SetRight(Right());
@@ -31,13 +41,18 @@ public:
 		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_AreaNumberFrame = nullptr;
+	NumberFrame* m_StageNumberFrame = nullptr;
 	NumberFrame* m_ScoreNumberFrame = nullptr;
+	FPSCounter* m_FPSCounter = nullptr;
 
 	EventRelay<Frame, Events::ScoreEvent> m_EScore;
 

include/Game/LevelSystem.h

@@ -7,6 +7,7 @@
 
 #include "Core/System.h"
 #include "Core/CTransform.h"
+#include "Core/CTemplate.h"
 #include "Core/EventBroker.h"
 #include "Core/World.h"
 #include "Rendering/CSprite.h"
@@ -19,14 +20,16 @@
 #include "Game/ELifeLost.h"
 #include "Game/EResetBall.h"
 #include "Game/EScoreEvent.h"
-#include "Physics/CRectangleShape.h"
+#include "Game/EComboEvent.h"
 #include "Game/EMultiBall.h"
+#include "Game/EMultiBallLost.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"
@@ -61,7 +64,6 @@ 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);
@@ -78,10 +80,6 @@ public:
     void SetRestarting(const bool& restarting) { m_Restarting = restarting; }
     bool Initialized() const { return m_Initialized; }
     void SetInitialized(const bool& initialized) { m_Initialized = initialized; }
-    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; }
@@ -99,16 +97,12 @@ public:
 
     glm::vec2& SpaceBetweenBricks() { return m_SpaceBetweenBricks; }
     void SetSpaceBetweenBricks(const glm::vec2& spaceBetweenBricks) { m_SpaceBetweenBricks = spaceBetweenBricks; }
-    float& EdgeX() { return m_EdgeX; }
+    float& NotResettingTheStage() { return m_NotResettingTheStage; }
-    void SetEdgeX(const float& edgeX) { m_EdgeX = edgeX; }
+    void SetNotResettingTheStage(const float& notResettingTheStage) { m_NotResettingTheStage = notResettingTheStage; }
-    float& EdgeY() { return m_EdgeY; }
-    void SetEdgeY(const float& edgeY) { m_EdgeY = edgeY; }
 
 private:
     bool m_Restarting = false;
     bool m_Initialized = false;
-    int m_Lives = 3;
-    int m_PastLives = 3;
     int m_MultiBalls = 0;
     int m_PowerUps = 0;
     int m_Score = 0;
@@ -117,21 +111,20 @@ private:
     int m_Lines = 7;
     float m_SpaceToEdge = 0.25f;
     glm::vec2 m_SpaceBetweenBricks = glm::vec2(1, 0.4);
-    float m_EdgeX = 3.2f;
+    float m_NotResettingTheStage = 5.f;
-    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;
 
     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);

include/Game/PadSystem.h

@@ -9,6 +9,7 @@
 #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"
@@ -45,8 +46,6 @@ 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; }
@@ -56,10 +55,8 @@ public:
     void SetLeft(const bool& left) { m_Left = left; }
     bool Right() const { return m_Right; }
     void SetRight(const bool& right) { m_Right = right; }
-    bool ReplaceBall() const { return m_ReplaceBall; }
+    float Edge() const { return m_Edge; }
-    void SetReplaceBall(const bool& replaceBall) { m_ReplaceBall = replaceBall; }
+    void SetEdge(const float& edge) { m_Edge = edge; }
-    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; }
@@ -69,16 +66,18 @@ public:
 private:
     EntityID m_Entity = 0;
     glm::vec3 m_Acceleration = glm::vec3(0.f, 0.f, 0.f);
-    bool m_Left = false, m_Right = false, m_ReplaceBall = false, m_MultiBall = false;
+    bool m_Left = false;
-    Components::Transform* m_Transform;
+    bool m_Right = false;
-    Components::Pad* m_Pad;
+    bool m_ReplaceBall = false;
+    bool m_MultiBall = false;
+    float m_Edge = 2.8f;
+    Components::Transform* m_Transform = nullptr;
+    Components::Pad* m_Pad = nullptr;
 
     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;
 
     bool OnKeyDown(const dd::Events::KeyDown &event);
@@ -86,8 +85,6 @@ private:
 
     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);
 
     class PadSteeringInputController;

include/Physics/CParticle.h

@@ -0,0 +1,65 @@
+#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

@@ -0,0 +1,25 @@
+#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/CWaterVolume.h

@@ -9,7 +9,7 @@ namespace Components
 
 struct WaterVolume : public Component
 {
-
+    float Radius;
 };
 
 }

include/Physics/PhysicsSystem.h

@@ -8,96 +8,123 @@
 #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/CPhysics.h"
+#include "Physics/CWaterVolume.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/CWaterVolume.h"
+#include "Physics/CParticleEmitter.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
 {
 
-namespace Systems
+    namespace Systems
-{
-
-class PhysicsSystem : public System
-{
-    friend class ContractListener;
-
-public:
-    PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker) { }
-
-    ~PhysicsSystem();
-
-    void RegisterComponents(ComponentFactory* cf) override;
-    void Initialize() override;
-    void Update(double dt) override;
-    void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
-    void OnEntityCommit(EntityID entity) override;
-    void OnEntityRemoved(EntityID entity) override;
-
-private:
-    struct Impulse
     {
-        b2Body* Body;
-        b2Vec2 Impulse;
-        b2Vec2 Point;
-    };
 
-    b2Vec2 m_Gravity = b2Vec2(0.f, -9.82f);
+        class PhysicsSystem : public System
-    b2World* m_PhysicsWorld = nullptr;
+        {
-    float m_TimeStep = 1.f/60.f;
+            friend class ContractListener;
-    float m_Accumulator = 0.f;
-    int m_VelocityIterations = 6;
-    int m_PositionIterations = 2;
 
-    b2ParticleSystem *m_ParticleSystem;
+        public:
-    b2ParticleGroup* t_watergroup;
+            PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
+                    : System(world, eventBroker) { }
 
-    std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
+            ~PhysicsSystem();
-    std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
-    std::unordered_map<EntityID, const b2ParticleHandle*> m_EntitiesToParticleHandle;
-    std::unordered_map<const b2ParticleHandle*, EntityID> m_ParticleHandleToEntities;
 
-    std::list<Impulse> m_Impulses;
+            void RegisterComponents(ComponentFactory* cf) override;
+            void Initialize() override;
+            void Update(double dt) override;
+            void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
+            void OnEntityCommit(EntityID entity) override;
+            void OnEntityRemoved(EntityID entity) override;
 
-    void CreateBody(EntityID entity);
+        private:
-    void SyncEntitiesWithBodies();
+            struct Impulse
-    void SyncBodiesWithEntities();
+            {
-    void InitializeWater();
+                b2Body* Body;
-    void SyncWater(); //TODO: Probably remove this
+                b2Vec2 Impulse;
-    void CreateParticleGroup(EntityID entity);
+                b2Vec2 Point;
+            };
+            bool m_Pause = false;
 
-    EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
-    bool SetImpulse(const Events::SetImpulse &event);
 
-    class ContactListener : public b2ContactListener
+            b2Vec2 m_Gravity = b2Vec2(0.f, -9.82f);
-    {
+            b2World* m_PhysicsWorld = nullptr;
-    public:
+            float m_TimeStep = 1.f/60.f;
-        ContactListener(PhysicsSystem* physicsSystem)
+            float m_Accumulator = 0.f;
-                : m_PhysicsSystem(physicsSystem) { }
+            int m_VelocityIterations = 6;
+            int m_PositionIterations = 2;
 
-        void BeginContact(b2Contact* contact);
+            std::vector<b2ParticleSystem*> m_ParticleSystem;
-        void EndContact(b2Contact* contact);
+            std::vector<b2ParticleGroup*> t_ParticleGroup;
-        void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
-        void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
 
-    private:
+            std::vector<std::unordered_map<EntityID, const b2ParticleHandle*>> m_EntitiesToParticleHandle;
-        PhysicsSystem* m_PhysicsSystem;
+            std::vector<std::unordered_map<const b2ParticleHandle*, EntityID>> m_ParticleHandleToEntities;
-    };
+            std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
+            std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
 
-    ContactListener* m_ContactListener;
-};
 
-}
+
+            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);
+
+            //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;
+
+
+
+            class ContactListener : public b2ContactListener
+            {
+            public:
+                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);
+
+            private:
+                PhysicsSystem* m_PhysicsSystem;
+            };
+
+            ContactListener* m_ContactListener;
+        };
+
+    }
 
 }
 

src/game/CMakeLists.txt

@@ -94,8 +94,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Physics}
     ${SOURCE_FILES_Game}
     ${SOURCE_FILES_Sound}
-    ${SOURCE_FILES_GUI}
+    ${SOURCE_FILES_GUI})
-)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")

src/game/Core/EventBroker.cpp

@@ -29,32 +29,26 @@ dd::BaseEventRelay::~BaseEventRelay()
 
 void dd::EventBroker::Unsubscribe(BaseEventRelay &relay) // ?
 {
-	auto contextIt = m_ContextRelays.find(relay.m_ContextTypeName);
+	if (m_IsProcessing) {
-	if (contextIt == m_ContextRelays.end())
+		m_RelaysToUnsubscribe.push_back(&relay);
-		return;
+	} else {
-
+		unsubscribeImmediate(relay);
-	auto eventRelays = contextIt->second;
-
-	auto itpair = eventRelays.equal_range(relay.m_EventTypeName);
-	for (auto it = itpair.first; it != itpair.second; ++it)
-	{
-		if (it->second == &relay)
-		{
-			relay.m_Broker = nullptr;
-			eventRelays.erase(it);
-			break;
-		}
 	}
 }
 
 void dd::EventBroker::Subscribe(BaseEventRelay &relay)
 {
-	relay.m_Broker = this;
+	if (m_IsProcessing) {
-	m_ContextRelays[relay.m_ContextTypeName].insert(std::make_pair(relay.m_EventTypeName, &relay));
+		m_RelaysToSubscribe.push_back(&relay);
+	} else {
+		subscribeImmediate(relay);
+	}
 }
 
 int dd::EventBroker::Process(std::string contextTypeName)
 {
+	m_IsProcessing = true;
+
 	auto it = m_ContextRelays.find(contextTypeName);
 	if (it == m_ContextRelays.end())
 		return 0;
@@ -68,14 +62,29 @@ 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++)
 		{
-			auto relay = it2->second;
+			std::string name = it2->first;
+			BaseEventRelay* relay = it2->second;
 			relay->Receive(event);
 			eventsProcessed++;
 		}
 	}
 
+	m_IsProcessing = false;
+
+	// Process pending subscriptions
+	for (auto& r : m_RelaysToSubscribe) {
+		subscribeImmediate(*r);
+	}
+	m_RelaysToSubscribe.clear();
+
+	// Process pending unsubscriptions
+	for (auto& r : m_RelaysToUnsubscribe) {
+		unsubscribeImmediate(*r);
+	}
+	m_RelaysToUnsubscribe.clear();
+
 	return eventsProcessed;
 }
 
@@ -83,4 +92,29 @@ void dd::EventBroker::Swap()
 {
 	std::swap(m_EventQueueRead, m_EventQueueWrite);
 	m_EventQueueWrite->clear();
+
+}
+
+void dd::EventBroker::subscribeImmediate(dd::BaseEventRelay& relay)
+{
+	relay.m_Broker = this;
+	m_ContextRelays[relay.m_ContextTypeName].insert(std::make_pair(relay.m_EventTypeName, &relay));
+}
+
+void dd::EventBroker::unsubscribeImmediate(dd::BaseEventRelay& relay)
+{
+	auto contextIt = m_ContextRelays.find(relay.m_ContextTypeName);
+	if (contextIt == m_ContextRelays.end()) {
+		return;
+	}
+
+	auto eventRelays = contextIt->second;
+	auto itpair = eventRelays.equal_range(relay.m_EventTypeName);
+	for (auto it = itpair.first; it != itpair.second; ++it) {
+		if (it->second == &relay) {
+			relay.m_Broker = nullptr;
+			eventRelays.erase(it);
+			break;
+		}
+	}
 }

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,39 +79,39 @@ void dd::Renderer::LoadShaders()
 	*/
 
 	// Pass #1: Fill G-buffers
-	m_spDeferred1 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/1/");
+	m_SpDeferred1 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/1/");
-	m_spDeferred1->BindFragDataLocation(0, "GDiffuse");
+	m_SpDeferred1->BindFragDataLocation(0, "GDiffuse");
-	m_spDeferred1->BindFragDataLocation(1, "GPosition");
+	m_SpDeferred1->BindFragDataLocation(1, "GPosition");
-	m_spDeferred1->BindFragDataLocation(2, "GNormal");
+	m_SpDeferred1->BindFragDataLocation(2, "GNormal");
-	m_spDeferred1->BindFragDataLocation(3, "GSpecular");
+	m_SpDeferred1->BindFragDataLocation(3, "GSpecular");
-	m_spDeferred1->Link();
+	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();
+	m_SpDeferred2->Link();
 
 	//Water Pass
-	t_m_spWater = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water/");
+	m_SpWater = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water/");
-	t_m_spWater->Link();
+	m_SpWater->Link();
-	t_m_spWater2 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water2/");
+	m_SpWater2 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/water2/");
-	t_m_spWater2->Link();
+	m_SpWater2->Link();
 
 	// Pass #3: Combining into final image
-	m_spDeferred3 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/3/");
+	m_SpDeferred3 = ResourceManager::Load<ShaderProgram>("Shaders/Deferred/3/");
-	m_spDeferred3->Link();
+	m_SpDeferred3->Link();
 
 	/*
 		Forward rendering
 	*/
-	m_spForward = ResourceManager::Load<ShaderProgram>("Shaders/Forward/");
+	m_SpForward = ResourceManager::Load<ShaderProgram>("Shaders/Forward/");
-	m_spForward->Link();
+	m_SpForward->Link();
 
 	/*
 		Screen draw
 	*/
-	m_spScreen = ResourceManager::Load<ShaderProgram>("Shaders/Screen/");
+	m_SpScreen = ResourceManager::Load<ShaderProgram>("Shaders/Screen/");
-	m_spScreen->Link();
+	m_SpScreen->Link();
 }
 
 void dd::Renderer::CreateBuffers()
@@ -122,10 +122,10 @@ void dd::Renderer::CreateBuffers()
 	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");
-	t_m_WhiteSphereTexture = ResourceManager::Load<Texture>("Textures/Test/Water.png");
+	m_WhiteSphereTexture = ResourceManager::Load<Texture>("Textures/Test/Water.png");
 
-	glGenRenderbuffers(1, &m_rbDepthBuffer);
+	glGenRenderbuffers(1, &m_RbDepthBuffer);
-	glBindRenderbuffer(GL_RENDERBUFFER, m_rbDepthBuffer);
+	glBindRenderbuffer(GL_RENDERBUFFER, m_RbDepthBuffer);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Resolution.Width, m_Resolution.Height);
 
 	// Generate G-buffer textures
@@ -157,8 +157,8 @@ 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, &t_m_Gwater);
+	glGenTextures(1, &m_Gwater);
-	glBindTexture(GL_TEXTURE_2D, t_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);
@@ -166,9 +166,9 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
 	// Create first pass framebuffer
-	glGenFramebuffers(1, &m_fbDeferred1);
+	glGenFramebuffers(1, &m_FbDeferred1);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred1);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred1);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbDepthBuffer);
+	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 +176,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);
+	glGenTextures(1, &m_TLighting);
-	glBindTexture(GL_TEXTURE_2D, 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,19 +190,19 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
 	// Create second pass framebuffer
-	glGenFramebuffers(1, &m_fbDeferred2);
+	glGenFramebuffers(1, &m_FbDeferred2);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred2);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred2);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tLighting, 0);
+	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, &t_m_Gwater);
+	glGenTextures(1, &m_Gwater);
-	glBindTexture(GL_TEXTURE_2D, t_m_Gwater);
+	glBindTexture(GL_TEXTURE_2D, m_Gwater);
 	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);
@@ -210,19 +210,19 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
 	//Fill water pass
-	glGenFramebuffers(1, &t_m_fbWater);
+	glGenFramebuffers(1, &m_FbWater);
-	glBindFramebuffer(GL_FRAMEBUFFER, t_m_fbWater);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWater);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, t_m_Gwater, 0);
+	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);
+		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 
 	//water Blur texture
-	glGenTextures(1, &t_m_BWater);
+	glGenTextures(1, &m_BWater);
-	glBindTexture(GL_TEXTURE_2D, t_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);
@@ -230,20 +230,20 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	//Fill waterBlur pass
-	glGenFramebuffers(1, &t_m_fbWaterBlur);
+	glGenFramebuffers(1, &m_FbWaterBlur);
-	glBindFramebuffer(GL_FRAMEBUFFER, t_m_fbWaterBlur);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, t_m_BWater, 0);
+	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);
+		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 
 	//water Blur texture2
-	glGenTextures(1, &t_m_BWater2);
+	glGenTextures(1, &m_BWater2);
-	glBindTexture(GL_TEXTURE_2D, t_m_BWater2);
+	glBindTexture(GL_TEXTURE_2D, m_BWater2);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbDepthBuffer);
+	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);
@@ -251,19 +251,19 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	//Fill waterBlur pass2
-	glGenFramebuffers(1, &t_m_fbWaterBlur2);
+	glGenFramebuffers(1, &m_FbWaterBlur2);
-	glBindFramebuffer(GL_FRAMEBUFFER, t_m_fbWaterBlur2);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur2);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, t_m_BWater2, 0);
+	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);
+		LOG_ERROR("m_FbDeferred2 incomplete: 0x%x\n", fbStatus);
 		exit(EXIT_FAILURE);
 	}
 
 	// Generate final deferred texture
-	glGenTextures(1, &m_tFinal);
+	glGenTextures(1, &m_TFinal);
-	glBindTexture(GL_TEXTURE_2D, 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);
@@ -271,14 +271,14 @@ void dd::Renderer::CreateBuffers()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	// Create third pass framebuffer
-	glGenFramebuffers(1, &m_fbDeferred3);
+	glGenFramebuffers(1, &m_FbDeferred3);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred3);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbDepthBuffer);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_RbDepthBuffer);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tFinal, 0);
+	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);
 	}
 }
@@ -298,7 +298,7 @@ void dd::Renderer::Draw(RenderQueueCollection& rq)
 	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);
@@ -317,12 +317,12 @@ void dd::Renderer::DrawDeferred(RenderQueue &objects, RenderQueue &lights)
 	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();
+	m_SpDeferred1->Bind();
-	DrawScene(objects, *m_spDeferred1);
+	DrawScene(objects, *m_SpDeferred1);
 
 	// Pass #2: Lighting
 	glEnable(GL_CULL_FACE);
@@ -332,24 +332,24 @@ 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);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred2);
 	glClearColor(0, 0, 0, 0);
 	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);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
 	glClearColor(0, 0, 0, 0);
 	glClear(GL_COLOR_BUFFER_BIT);
-	m_spDeferred3->Bind();
+	m_SpDeferred3->Bind();
-	glUniform3fv(glGetUniformLocation(*m_spDeferred3, "La"), 1, glm::value_ptr(glm::vec3(0.5f)));
+	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);
 }
@@ -365,12 +365,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();
+	m_SpForward->Bind();
-	DrawScene(objects, *m_spForward);
+	DrawScene(objects, *m_SpForward);
 
 	//WaterPass
 	glDisable(GL_CULL_FACE);
@@ -379,10 +379,10 @@ void dd::Renderer::DrawForward(RenderQueue &objects, RenderQueue &lights)
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glBindFramebuffer(GL_FRAMEBUFFER, t_m_fbWater);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWater);
 	glClearColor(0, 0, 0, 0);
 	glClear(GL_COLOR_BUFFER_BIT);
-	t_m_spWater->Bind();
+	m_SpWater->Bind();
 	DrawWater(objects);
 }
 
@@ -444,6 +444,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 			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);
 			glActiveTexture(GL_TEXTURE1);
@@ -462,7 +463,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);
@@ -499,7 +500,7 @@ void dd::Renderer::DrawLightSpheres(RenderQueue &lights)
 
 void dd::Renderer::DrawWater(RenderQueue &rq)
 {
-	GLuint shaderProgramHandle = *t_m_spWater;
+	GLuint shaderProgramHandle = *m_SpWater;
 
 	glm::mat4 projectionMatrix = m_Camera->ProjectionMatrix();
 	glm::mat4 viewMatrix = m_Camera->ViewMatrix();
@@ -517,7 +518,7 @@ void dd::Renderer::DrawWater(RenderQueue &rq)
 							   glm::value_ptr(viewMatrix));
 
 			glActiveTexture(GL_TEXTURE0);
-			glBindTexture(GL_TEXTURE_2D, *t_m_WhiteSphereTexture);
+			glBindTexture(GL_TEXTURE_2D, *m_WhiteSphereTexture);
 
 			glBindVertexArray(m_UnitQuad->VAO);
 			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_UnitQuad->ElementBuffer);
@@ -528,16 +529,17 @@ void dd::Renderer::DrawWater(RenderQueue &rq)
 
 
 	//blur1
-	shaderProgramHandle = *t_m_spWater2;
+	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, t_m_fbWaterBlur);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbWaterBlur);
 	glClearColor(0, 0, 0, 0);
 	glClear(GL_COLOR_BUFFER_BIT);
-	t_m_spWater2->Bind();
+	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)));
@@ -545,64 +547,31 @@ void dd::Renderer::DrawWater(RenderQueue &rq)
 	glUniform1f(glGetUniformLocation(shaderProgramHandle, "radius"), radius);
 
 	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, t_m_Gwater);
+	glBindTexture(GL_TEXTURE_2D, m_Gwater);
 	glBindVertexArray(m_ScreenQuad);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
 
 
 	//blur2
-	shaderProgramHandle = *t_m_spWater2;
+	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);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
-	t_m_spWater2->Bind();
+	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, t_m_BWater);
+	glBindTexture(GL_TEXTURE_2D, m_BWater);
 	glBindVertexArray(m_ScreenQuad);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
 }
 
-
-
-GLuint dd::Renderer::CreateWaterParticleVAO(RenderQueue &particles)
-{
-	float waterVerts[particles.Size()];
-	int i = 0;
-
-	for ( auto &job : particles ) {
-		auto waterJob = std::dynamic_pointer_cast<WaterParticleJob>(job);
-		if (!waterJob)
-			continue;
-		waterVerts[i  ] = waterJob->Position.x;
-		waterVerts[i+1] = waterJob->Position.y;
-		waterVerts[i+2] = waterJob->Position.z;
-		i+3;
-	}
-
-	GLuint vbo[1], vao;
-	glGenBuffers(1, vbo);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
-	glBufferData(GL_ARRAY_BUFFER, 3 * particles.Size() * sizeof(float), waterVerts, GL_STATIC_DRAW);
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
-	glEnableVertexAttribArray(0);
-
-	glBindVertexArray(0);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	return vao;
-}
-
 GLuint dd::Renderer::CreateQuad()
 {
 	float quadVertices[] =
@@ -649,7 +618,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;
@@ -664,19 +633,19 @@ void dd::Renderer::DebugKeys()
 		m_CurrentScreenBuffer = m_GSpecular;
 	}
 	if (glfwGetKey(m_Window, GLFW_KEY_F6)) {
-		m_CurrentScreenBuffer = m_tLighting;
+		m_CurrentScreenBuffer = m_TLighting;
 	}
 	if (glfwGetKey(m_Window, GLFW_KEY_F7)) {
-		m_CurrentScreenBuffer  = t_m_Gwater;
+		m_CurrentScreenBuffer  = m_Gwater;
 	}
 	if (glfwGetKey(m_Window, GLFW_KEY_F8)) {
-		m_CurrentScreenBuffer  = t_m_BWater;
+		m_CurrentScreenBuffer  = m_BWater;
 	}
 }
 
 void dd::Renderer::DrawGUI(dd::RenderQueue& rq)
 {
-	glBindFramebuffer(GL_FRAMEBUFFER, m_fbDeferred3);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_FbDeferred3);
 	glDisable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
 	glDisable(GL_DEPTH_TEST);
@@ -684,7 +653,7 @@ void dd::Renderer::DrawGUI(dd::RenderQueue& rq)
 	//glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
 	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
 
-	m_spScreen->Bind();
+	m_SpScreen->Bind();
 
 	glm::mat4 MVP;
 
@@ -696,9 +665,9 @@ void dd::Renderer::DrawGUI(dd::RenderQueue& rq)
 			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, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
-			glUniformMatrix4fv(glGetUniformLocation(*m_spScreen, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
+			glUniformMatrix4fv(glGetUniformLocation(*m_SpScreen, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
-			glUniformMatrix4fv(glGetUniformLocation(*m_spScreen, "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
+			glUniformMatrix4fv(glGetUniformLocation(*m_SpScreen, "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
 
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, frameJob->DiffuseTexture);

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

@@ -61,9 +61,9 @@ void main()
     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;
 
-    frag_Diffuse = vec4(sum.rgb, 1.0) * vec4(0.0, 0.6, 1.5, 1.0);
+    float avgColor = sum.r + sum.g + sum.b;
-    float avgColor = frag_Diffuse.r + frag_Diffuse.g + frag_Diffuse.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/Game/BallSystem.cpp

@@ -14,16 +14,115 @@ 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);
+
+    auto ent = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+    transform->Position = glm::vec3(-0.f, 50.f, -10.f);
+    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
+    transform->Velocity = glm::vec3(0.0f, 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->CollisionType = CollisionType::Type::Dynamic;
+    physics->Category = CollisionLayer::Type::Ball;
+    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
+    physics->Calculate = true;
+    m_World->CommitEntity(ent);
+
+    SetBall(ent);
+
+    for (int i = 0; i < Lives(); i++) {
+        CreateLife(i);
+    }
 }
 
 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 templateCheck = m_World->GetComponent<Components::Template>(entity);
+    if (templateCheck != nullptr){ return; }
     auto ballComponent = m_World->GetComponent<Components::Ball>(entity);
+    if (ballComponent != nullptr) {
+        if (ReplaceBall() == true) {
+            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);
+                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->RemoveComponent<Components::Life>(entity);
+                m_World->RemoveComponent<Components::Transform>(entity);
+                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));
@@ -86,11 +185,17 @@ bool dd::Systems::BallSystem::Contact(const Events::Contact &event)
 
     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;
+        float x = (ballTransform->Position.x - padTransform->Position.x) * XMovementMultiplier();
 
         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);
@@ -99,3 +204,96 @@ 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);
+
+   /* auto ent = m_World->CreateEntity();
+    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
+    transform->Position = glm::vec3(0.5f, 0.26f, -10.f);
+    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
+    auto model = m_World->AddComponent<Components::Model>(ent);
+    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
+    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
+    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
+    std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
+    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
+    physics->Static = false;
+    physics->Category = CollisionLayer::Type::Ball;
+    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
+    physics->Calculate = true;
+    cball->Speed = 5.f;
+
+    auto plight = m_World->AddComponent<Components::PointLight>(ent);
+    plight->Radius = 2.f;*/
+
+    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;
+
+    SetMultiBalls(MultiBalls() + 2);
+
+    return true;
+}

src/game/Game/LevelSystem.cpp

@@ -10,130 +10,54 @@
 void dd::Systems::LevelSystem::Initialize()
 {
     EVENT_SUBSCRIBE_MEMBER(m_EContact, &LevelSystem::OnContact);
-    EVENT_SUBSCRIBE_MEMBER(m_ELifeLost, &LevelSystem::OnLifeLost);
     EVENT_SUBSCRIBE_MEMBER(m_EScoreEvent, &LevelSystem::OnScoreEvent);
     EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &LevelSystem::OnMultiBall);
     EVENT_SUBSCRIBE_MEMBER(m_ECreatePowerUp, &LevelSystem::OnCreatePowerUp);
+    EVENT_SUBSCRIBE_MEMBER(m_EMultiBallLost, &LevelSystem::OnMultiBallLost);
     EVENT_SUBSCRIBE_MEMBER(m_EPowerUpTaken, &LevelSystem::OnPowerUpTaken);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
 
-    for (int i = 0; i < Lives(); i++) {
-        CreateLife(i);
-    }
-
     return;
 }
 
-void dd::Systems::LevelSystem::CreateLife(int number)
-{
-    auto life = m_World->CreateEntity();
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(life);
-    transform->Position = glm::vec3(-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);
-}
-
 void dd::Systems::LevelSystem::Update(double dt)
 {
     if (!m_Initialized) {
         CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
         m_Initialized = true;
     }
-
-    if (Lives() < 0)
-    {
-        SetLives(3);
-        Events::GameOver e;
-        EventBroker->Publish(e);
-    }
 }
 
 void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
+    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
+    if (templateCheck != nullptr){ return; }
+
     auto ball = m_World->GetComponent<Components::Ball>(entity);
+    SetNotResettingTheStage(NotResettingTheStage() + 0.01 * dt);
 
-    if (ball != nullptr) {
+    if (NumberOfBricks() <= 0 && Restarting() == false) {
-        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) {
-                SetMultiBalls(MultiBalls() - 1);
-//                m_World->RemoveComponent<Components::Ball>(entity);
-//                m_World->RemoveComponent<Components::Transform>(entity);
-//                m_World->RemoveComponent<Components::CircleShape>(entity);
-//                m_World->RemoveComponent<Components::Physics>(entity);
-                m_World->RemoveEntity(entity);
-            } 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->RemoveComponent<Components::Life>(entity);
-//                m_World->RemoveComponent<Components::Transform>(entity);
-                m_World->RemoveEntity(entity);
-                SetPastLives(Lives());
-            }
-        }
-    }
-    if (NumberOfBricks() <= 0) {
-        /*SetRestarting(true);
         if (MultiBalls() <= 0 && PowerUps() <= 0) {
-            Events::ResetBall e;
+            if (NotResettingTheStage() > 5) {
-            EventBroker->Publish(e);
+                SetRestarting(true);
-            Events::ScoreEvent es;
+                Events::ResetBall e;
-            es.Score = 500;
+                EventBroker->Publish(e);
-            EventBroker->Publish(es);
+                Events::ScoreEvent es;
-            Events::StageCleared ec;
+                es.Score = 500;
-            EventBroker->Publish(ec);
+                EventBroker->Publish(es);
-            CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+                Events::StageCleared ec;
+                EventBroker->Publish(ec);
+                SetNotResettingTheStage(0);
+                //CreateBasicLevel(Rows(), Lines(), SpaceBetweenBricks(), SpaceToEdge());
+            }
         } else {
             if (ball != nullptr && MultiBalls() > 0) {
-                SetMultiBalls(MultiBalls() - 1);
+                SetMultiBalls(MultiBalls()-1);
                 m_World->RemoveComponent<Components::Ball>(entity);
                 m_World->RemoveComponent<Components::Transform>(entity);
                 m_World->RemoveComponent<Components::CircleShape>(entity);
                 m_World->RemoveComponent<Components::Physics>(entity);
                 m_World->RemoveEntity(entity);
-                auto transformBall = m_World->GetComponent<Components::Transform>(entity);
             } else {
                 auto powerUp = m_World->GetComponent<Components::PowerUp>(entity);
                 if (powerUp != nullptr) {
@@ -143,22 +67,22 @@ void dd::Systems::LevelSystem::UpdateEntity(double dt, EntityID entity, EntityID
                     m_World->RemoveEntity(entity);
                 }
             }
-        }*/
+        }
     }
 }
 
 void dd::Systems::LevelSystem::CreateBasicLevel(int rows, int lines, glm::vec2 spacesBetweenBricks, float spaceToEdge)
 {
     SetNumberOfBricks(rows * lines);
-    std::cout << "You're only doing this once, right?" << std::endl;
+    //std::cout << "You're only doing this once, right?" << std::endl;
-    int num = 0;
+    int num = Lines();
     for (int i = 0; i < rows; i++) {
-        num++;
+        num--;
         for (int j = 0; j < Lines(); j++) {
             CreateBrick(i, j, spacesBetweenBricks, spaceToEdge, num);
         }
-        if (num == 7)
+        if (num == 1)
-            num = 0;
+            num = Lines();
     }
 
     SetNumberOfBricks(rows * lines);
@@ -179,12 +103,12 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     cPhys->Category = CollisionLayer::Type::Brick;
     cPhys->Mask = CollisionLayer::Type::Ball;
 
-    std::string fileName = "Textures/Bricks/";
+    /*std::string fileName = "Textures/Bricks/";
     fileName.append(std::to_string(num));
-    fileName.append(".png");
+    fileName.append(".png");*/
     //sprite->SpriteFile =  fileName;
     model->ModelFile = "Models/Test/Brick/Brick.obj";
-    if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 6 && row == 6)) {
+    if ((line == 1 && row == 4) || (line == 3 && row == 2) || (line == 5 && row == 2)) {
         std::shared_ptr<Components::PowerUpBrick> cPow = m_World->AddComponent<Components::PowerUpBrick>(brick);
         model->ModelFile = "Models/Brick/IceBrick.obj";
     }
@@ -210,17 +134,17 @@ void dd::Systems::LevelSystem::ProcessCollision()
 
 void dd::Systems::LevelSystem::OnEntityRemoved(EntityID entity)
 {
-    auto brick = m_World->GetComponent<Components::Brick>(entity);
+    /*auto brick = m_World->GetComponent<Components::Brick>(entity);
     if (brick != nullptr) {
         SetNumberOfBricks(NumberOfBricks() - 1);
         Events::ScoreEvent es;
         es.Score = brick->Score;
         EventBroker->Publish(es);
-        /*if (numberOfBricks < 1) {
+        if (numberOfBricks < 1) {
             EndLevel();
-        }*/
+        }
     }
-    return;
+    return;*/
 }
 
 bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
@@ -256,7 +180,7 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     }
 
     auto power = m_World->GetComponent<Components::PowerUpBrick>(entityBrick);
-    if (power != nullptr) {
+    if (power != nullptr && NumberOfBricks() > 1) {
         Events::CreatePowerUp e;
         auto transform = m_World->GetComponent<Components::Transform>(entityBrick);
         e.Position = transform->Position;
@@ -264,6 +188,12 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
     }
 
     if (ball != nullptr && Restarting() == false) {
+        ball->Combo += 1;
+        Events::ComboEvent ec;
+        ec.Combo = ball->Combo;
+        ec.Ball = entityBall;
+        EventBroker->Publish(ec);
+
         auto ballTransform = m_World->GetComponent<Components::Transform>(entityBall);
 
 //        m_World->RemoveComponent<Components::Brick>(entityBrick);
@@ -290,28 +220,24 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
         EventBroker->Publish(e);
         //TODO: Bricks dont collide with walls D=
 
+
         SetNumberOfBricks(NumberOfBricks() - 1);
         if (NumberOfBricks() <= 0) {
-            SetMultiBalls(MultiBalls() + 1);
+            //SetMultiBalls(MultiBalls() + 1);
         }
         Events::ScoreEvent es;
-        es.Score = brick->Score;
+        es.Score = brick->Score * ball->Combo;
         EventBroker->Publish(es);
 
-       // std::cout << NumberOfBricks() << std::endl;
+        std::cout << "Combo: " << ball->Combo << std::endl;
-        //std::cout << "Score: " << Score() << std::endl;
+        //std::cout << NumberOfBricks() << std::endl;
+        //std::cout << "Brick Score: " << brick->Score  << std::endl;
+        std::cout << "Score: " << Score() << std::endl;
     }
 
     return true;
 }
 
-bool dd::Systems::LevelSystem::OnLifeLost(const dd::Events::LifeLost &event)
-{
-    SetLives(Lives() - 1);
-
-    return true;
-}
-
 bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 {
     SetScore(Score() += event.Score);
@@ -322,6 +248,15 @@ bool dd::Systems::LevelSystem::OnScoreEvent(const dd::Events::ScoreEvent &event)
 bool dd::Systems::LevelSystem::OnMultiBall(const dd::Events::MultiBall &event)
 {
     SetMultiBalls(MultiBalls()+2);
+    std::cout << MultiBalls() << std::endl;
+    return true;
+}
+
+bool dd::Systems::LevelSystem::OnMultiBallLost(const dd::Events::MultiBallLost &event)
+{
+    SetMultiBalls(MultiBalls()-1);
+    std::cout << MultiBalls() << std::endl;
+    return true;
 }
 
 bool dd::Systems::LevelSystem::OnCreatePowerUp(const dd::Events::CreatePowerUp &event)

src/game/Game/PadSystem.cpp

@@ -26,23 +26,35 @@ void dd::Systems::PadSystem::Initialize()
     EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &PadSystem::OnKeyUp);
     EVENT_SUBSCRIBE_MEMBER(m_EContact, &PadSystem::OnContact);
     EVENT_SUBSCRIBE_MEMBER(m_EContactPowerUp, &PadSystem::OnContactPowerUp);
-    EVENT_SUBSCRIBE_MEMBER(m_EResetBall, &PadSystem::OnResetBall);
-    EVENT_SUBSCRIBE_MEMBER(m_EMultiBall, &PadSystem::OnMultiBall);
     EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PadSystem::OnStageCleared);
+
+    {
+        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, -3.5f, -10.f);
+        ctransform->Scale = glm::vec3(1.0f, 1.0f, 1.f);
+        auto rectangleShape = m_World->AddComponent<Components::RectangleShape>(ent);
+        rectangleShape->Dimensions = glm::vec3(1.f, 0.5f);
+        auto physics = m_World->AddComponent<Components::Physics>(ent);
+        physics->CollisionType = CollisionType::Type::Dynamic;
+        physics->Category = CollisionLayer::Type::Pad;
+        physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::PowerUp;
+        physics->Calculate = true;
+        auto cModel = m_World->AddComponent<Components::Model>(ent);
+        cModel->ModelFile = "Models/Submarine2.obj";
+
+        auto pad = m_World->AddComponent<Components::Pad>(ent);
+        m_World->CommitEntity(ent);
+
+        SetEdge(3.2 - (ctransform->Scale.x / 2));
+    }
 }
 
 void dd::Systems::PadSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
 {
-    auto ball = m_World->GetComponent<Components::Ball>(entity);
+    auto templateCheck = m_World->GetComponent<Components::Template>(entity);
-    if (ball != nullptr) {
+    if (templateCheck != nullptr){ return; }
-        if (ReplaceBall() == true) {
-            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, -ball->Speed, 0.f);
-        }
-    }
 }
 
 void dd::Systems::PadSystem::Update(double dt)
@@ -69,9 +81,15 @@ void dd::Systems::PadSystem::Update(double dt)
         transform->Velocity.x = pad->MaxSpeed;
     }
     transform->Position += transform->Velocity * (float)dt;
+    if (transform->Position.x > Edge()) {
+        transform->Position.x = Edge();
+    } else if (transform->Position.x < -Edge()) {
+        transform->Position.x = -Edge();
+    }
     transform->Velocity += acceleration  * (float)dt;
-    transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float)dt;
+    if (glm::abs(transform->Velocity.x) > 1 || (!Left() && !Right())) {
-
+        transform->Velocity -= transform->Velocity * pad->SlowdownModifier * (float) dt;
+    }
 
     if (Left()) {
         acceleration.x = -pad->AccelerationSpeed;
@@ -85,40 +103,9 @@ void dd::Systems::PadSystem::Update(double dt)
     SetPad(pad);
     SetAcceleration(acceleration);
 
-    if (MultiBall() == true) {
-        SetMultiBall(false);
-
-        Events::MultiBall e;
-        e.padTransform = transform;
-        EventBroker->Publish(e);
-    }
-
     return;
 }
 
-EntityID dd::Systems::PadSystem::CreateBall()
-{
-    auto ent = m_World->CreateEntity();
-    std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-    transform->Position = glm::vec3(0.5f, 0.26f, -10.f);
-    transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-    auto model = m_World->AddComponent<Components::Model>(ent);
-    model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-    //auto pointlight = m_World->AddComponent<Components::PointLight>(ent);
-    std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-    std::shared_ptr<Components::Ball> cball = m_World->AddComponent<Components::Ball>(ent);
-    std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-    physics->CollisionType = CollisionType::Type::Dynamic;
-    physics->Category = CollisionLayer::Type::Ball;
-    physics->Mask = CollisionLayer::Type::Pad | CollisionLayer::Type::Brick | CollisionLayer::Type::Wall;
-    physics->Calculate = true;
-    cball->Speed = 5.f;
-
-    m_World->CommitEntity(ent);
-
-    return ent;
-}
-
 bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
 {
     int val = event.KeyCode;
@@ -135,9 +122,12 @@ bool dd::Systems::PadSystem::OnKeyDown(const dd::Events::KeyDown &event)
         //acceleration.x = 0.01f;
         SetRight(true);
     } else if (val == GLFW_KEY_R) {
-        SetReplaceBall(true);
+        Events::ResetBall e;
+        EventBroker->Publish(e);
     } else if (val == GLFW_KEY_M) {
-        SetMultiBall(true);
+        Events::MultiBall e;
+        e.padTransform = Transform();
+        EventBroker->Publish(e);
     } else if (val == GLFW_KEY_D) {
         return false;
     }
@@ -251,40 +241,9 @@ bool dd::Systems::PadSystem::OnContactPowerUp(const dd::Events::Contact &event)
     return true;
 }
 
-bool dd::Systems::PadSystem::OnResetBall(const dd::Events::ResetBall &event)
-{
-    SetReplaceBall(true);
-    return true;
-}
-
-bool dd::Systems::PadSystem::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;
-
-    return true;
-}
-
 bool dd::Systems::PadSystem::OnStageCleared(const dd::Events::StageCleared &event)
 {
-    auto entity = CreateBall();
+    //auto entity = CreateBall();
     return true;
 }
 

src/game/Physics/PhysicsSystem.cpp

@@ -1,6 +1,7 @@
 #include "PrecompiledHeader.h"
 #include "Physics/PhysicsSystem.h"
 
+
 void dd::Systems::PhysicsSystem::RegisterComponents(ComponentFactory* cf)
 {
     cf->Register<Components::CircleShape>();
@@ -18,9 +19,9 @@ void dd::Systems::PhysicsSystem::Initialize()
 
 void dd::Systems::PhysicsSystem::InitializeWater()
 {
-    b2ParticleSystemDef m_ParticleSystemDef;
+    float radius = 0.13f;
-    m_ParticleSystemDef.radius = 0.13f;
+    float gravityScale = 1.0f;
-    m_ParticleSystem = m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef);
+    CreateParticleSystem(radius, gravityScale);
 }
 
 bool dd::Systems::PhysicsSystem::SetImpulse(const Events::SetImpulse &event)
@@ -140,10 +141,16 @@ void dd::Systems::PhysicsSystem::SyncBodiesWithEntities()
 
 void dd::Systems::PhysicsSystem::Update(double dt)
 {
+    if (m_Pause) {
+        return;
+    }
+
     m_Accumulator += dt;
 
     while(m_Accumulator >= m_TimeStep)
     {
+
+        UpdateParticleEmitters(dt);
         SyncEntitiesWithBodies();
 
         //Apply Impulses Must be done after SyncEntitiesWithBodies
@@ -152,25 +159,33 @@ void dd::Systems::PhysicsSystem::Update(double dt)
         }
         m_Impulses.clear();
 
+
         //Update the PhysicsWorld
         m_PhysicsWorld->Step(m_TimeStep, m_VelocityIterations, m_PositionIterations);
 
         SyncBodiesWithEntities();
 
-        b2Vec2* positionBuffer = m_ParticleSystem->GetPositionBuffer();
-        for (auto i : m_EntitiesToParticleHandle) {
-            EntityID entity = i.first;
-            b2ParticleHandle* particleH = i.second;
 
-            b2Vec2 positionB2 = positionBuffer[particleH->GetIndex()];
+        for ( int e = 0; e < m_EntitiesToParticleHandle.size(); e++) {
-            glm::vec2 position = glm::vec2(positionB2.x, positionB2.y);
+            b2Vec2 *positionBuffer = m_ParticleSystem[e]->GetPositionBuffer();
+            for (auto i : m_EntitiesToParticleHandle[e]) {
+                EntityID entity = i.first;
+                b2ParticleHandle *particleH = i.second;
 
+                b2Vec2 positionB2 = positionBuffer[particleH->GetIndex()];
+                glm::vec2 position = glm::vec2(positionB2.x, positionB2.y);
 
-            EntityID entityParent = m_World->GetEntityParent(entity);
+                EntityID entityParent = m_World->GetEntityParent(entity);
-            auto transform = m_World->GetComponent<Components::Transform>(entity);
+                glm::vec3 parentTransform = glm::vec3(0.f);
-            auto transformParent = m_World->GetComponent<Components::Transform>(entityParent);
+                if (entityParent) {
+                    auto tp = m_World->GetComponent<Components::Transform>(entityParent);
+                    parentTransform = tp->Position;
+                }
+                auto transform = m_World->GetComponent<Components::Transform>(entity);
 
-            transform->Position = glm::vec3(position.x, position.y, -10) - transformParent->Position;
+                transform->Position = glm::vec3(position.x, position.y, -10) - parentTransform;
+
+            }
         }
 
         m_Accumulator -= dt;
@@ -186,15 +201,23 @@ void dd::Systems::PhysicsSystem::OnEntityCommit(EntityID entity)
 {
     auto physicsComponent = m_World->GetComponent<Components::Physics>(entity);
     auto waterComponent = m_World->GetComponent<Components::WaterVolume>(entity);
+    auto particleEmitterComponent = m_World->GetComponent<Components::ParticleEmitter>(entity);
 
     if (physicsComponent && waterComponent) {
         LOG_ERROR("Entity has both water and physics component, this is illegal. The police has been alerted.");
         return;
     }
+    if (physicsComponent && particleEmitterComponent) {
+        LOG_ERROR("Entity has both particle and physics component, this is illegal. The police has been alerted.");
+        return;
+    }
+
     if (physicsComponent) {
         CreateBody(entity);
     } else if (waterComponent) {
         CreateParticleGroup(entity);
+    } else if (particleEmitterComponent) {
+        CreateParticleEmitter(entity);
     }
 }
 
@@ -291,40 +314,133 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
     m_EntitiesToBodies.insert(std::make_pair(entity, body));
     m_BodiesToEntities.insert(std::make_pair(body, entity));
 }
-
 void dd::Systems::PhysicsSystem::CreateParticleGroup(EntityID e)
 {
-    //TODO: Lägg alla pd i en lista
     auto transform = m_World->GetComponent<Components::Transform>(e);
     if (!transform) {
         LOG_ERROR("No Transform component in CreateParticleGroup");
-        return;
     }
-
     b2ParticleGroupDef pd;
     b2PolygonShape shape;
+    auto water = m_World->GetComponent<Components::WaterVolume>(e);
+    if (water) {
 
-    shape.SetAsBox(transform->Scale.x/2.f, transform->Scale.y/2.f);
+        shape.SetAsBox(transform->Scale.x/2.f, transform->Scale.y/2.f);
-    pd.shape = &shape;
+        pd.shape = &shape;
-    pd.flags = b2_tensileParticle;
+        pd.flags = b2_tensileParticle;
-    pd.position.Set(transform->Position.x, transform->Position.y);
+        pd.position.Set(transform->Position.x, transform->Position.y);
-    //TODO: PUT IN LIST
+        t_ParticleGroup.push_back(m_ParticleSystem[0]->CreateParticleGroup(pd));
-    t_watergroup = m_ParticleSystem->CreateParticleGroup(pd);
+        b2Vec2* t_ParticlePositions = m_ParticleSystem[0]->GetPositionBuffer();
-    b2Vec2* t_ParticlePositions = m_ParticleSystem->GetPositionBuffer();
+        for(int i = 0; i < m_ParticleSystem[0]->GetParticleCount(); i++){
-    for(int i = 0; i < m_ParticleSystem->GetParticleCount(); i++){
+            {
-        {
+                auto t_waterparticle = m_World->CreateEntity(e);
-            auto t_waterparticle = m_World->CreateEntity(e);
+                auto transformChild = m_World->AddComponent<Components::Transform>(t_waterparticle);
-            auto transformChild = m_World->AddComponent<Components::Transform>(t_waterparticle);
+
-            transformChild->Position = glm::vec3(t_ParticlePositions[i].x - transform->Position.x, t_ParticlePositions[i].y - transform->Position.y, -9.5f);
+                transformChild->Position = glm::vec3(t_ParticlePositions[i].x - transform->Position.x, t_ParticlePositions[i].y - transform->Position.y, -9.5f);
-            transformChild->Scale = glm::vec3(m_ParticleSystem->GetRadius())/transform->Scale;
+                transformChild->Scale = glm::vec3(m_ParticleSystem[0]->GetRadius())/transform->Scale;
-            m_World->CommitEntity(t_waterparticle);
+                m_World->CommitEntity(t_waterparticle);
+
+                m_EntitiesToParticleHandle[0].insert(std::make_pair(t_waterparticle, m_ParticleSystem[0]->GetParticleHandleFromIndex(i)));
+                m_ParticleHandleToEntities[0].insert(std::make_pair( m_ParticleSystem[0]->GetParticleHandleFromIndex(i), t_waterparticle));
+            }
 
-            m_EntitiesToParticleHandle.insert(std::make_pair(t_waterparticle, m_ParticleSystem->GetParticleHandleFromIndex(i)));
-            m_ParticleHandleToEntities.insert(std::make_pair( m_ParticleSystem->GetParticleHandleFromIndex(i), t_waterparticle));
         }
 
     }
-    LOG_INFO("ParticleCount: %i", m_ParticleSystem->GetParticleCount());
+}
+
+void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
+{
+    for (int i = 0; i < m_ParticleEmitters.ParticleSystem.size(); i++) {
+        auto e = m_ParticleEmitters.ParticleEmitter[i];
+        auto pt = m_ParticleEmitters.ParticleTemplate[i];
+        auto ps = m_ParticleEmitters.ParticleSystem[i];
+
+
+        auto emitter = m_World->GetComponent<Components::ParticleEmitter>(e);
+        auto particleTemplate = m_World->GetComponent<Components::Particle>(pt);
+        emitter->TimeSinceLastSpawn += dt;
+        if(emitter->TimeSinceLastSpawn < emitter->SpawnRate) {
+            continue;
+        }
+        emitter->TimeSinceLastSpawn -= emitter->SpawnRate;
+        auto templateTransform = m_World->GetComponent<Components::Transform>(pt);
+
+        b2ParticleDef particleDef;
+        particleDef.flags = particleTemplate->Flags;
+        //particleDef.color TODO: Implement this if we want color mixing and shit.
+        particleDef.lifetime = particleTemplate->LifeTime;
+        particleDef.velocity = b2Vec2(templateTransform->Velocity.x, templateTransform->Velocity.y);
+        particleDef.position = b2Vec2(templateTransform->Position.x, templateTransform->Position.y);
+
+        auto particle = m_World->CloneEntity(pt, 0);
+        m_World->RemoveComponent<Components::Template>(particle);
+
+        auto b2Particle = ps->CreateParticle(particleDef);
+        auto b2ParticleHandle = ps->GetParticleHandleFromIndex(b2Particle);
+        m_EntitiesToParticleHandle[i].insert(std::make_pair(particle, b2ParticleHandle));
+        m_ParticleHandleToEntities[i].insert(std::make_pair(b2ParticleHandle, particle));
+
+        //TODO: Ta bort detta
+        int particles = 0;
+        for (auto i : m_EntitiesToParticleHandle)
+        {
+            particles += i.size();
+        }
+        LOG_INFO("--I have %i particles.", particles);
+    }
+}
+
+void dd::Systems::PhysicsSystem::CreateParticleEmitter(EntityID entity)
+{
+    auto childEntities = m_World->GetEntityChildren(entity);
+    if (childEntities.empty()) {
+        LOG_ERROR("Particle Emitter does not have any child. Please adopt one or this will not work.");
+        return;
+    }
+    int pf = 0;
+    dd::Components::Particle* particle;
+    EntityID childEntity;
+    for ( auto c : childEntities ) {
+        auto p = m_World->GetComponent<Components::Particle>(c);
+        auto particleTemplate = m_World->GetComponent<Components::Template>(c);
+        if (!p) {
+            continue;
+            LOG_WARNING("--ParticleEmitter's Child is not a particle.");
+        }
+        if(!particleTemplate) {
+            LOG_ERROR("ParticleEmitter's particleChild is not a template.");
+            continue;
+        }
+        if (pf != 0) {
+            LOG_WARNING("ParticleEmitter has more than one child that is a particleTemplate, only the first one is used.");
+            break;
+        }
+        childEntity = c;
+        particle = p;
+        pf++;
+    }
+    //TODO: Skicka med fler flaggor till particlesystemet;
+    m_ParticleEmitters.ParticleSystem.push_back(CreateParticleSystem(particle->Radius, 0.f));
+    m_ParticleEmitters.ParticleEmitter.push_back(entity);
+    m_ParticleEmitters.ParticleTemplate.push_back(childEntity);
+}
+
+
+b2ParticleSystem* dd::Systems::PhysicsSystem::CreateParticleSystem(float radius, float gravityScale)
+{
+    std::unordered_map<EntityID, const b2ParticleHandle*> m1;
+    std::unordered_map<const b2ParticleHandle*, EntityID> m2;
+    m_EntitiesToParticleHandle.push_back(m1);
+    m_ParticleHandleToEntities.push_back(m2);
+
+    b2ParticleSystemDef m_ParticleSystemDef;
+    m_ParticleSystemDef.radius = radius;
+    m_ParticleSystemDef.gravityScale = gravityScale;
+
+    m_ParticleSystem.push_back(m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef));
+
+    return m_ParticleSystem.back();
 }
 
 

src/tests/EventFixture.h

@@ -10,7 +10,7 @@ struct EventFixture
 	EventFixture()
 	{
 		this->EventBroker = new dd::EventBroker();
-		m_EEventType = decltype(m_EEventType)(std::bind(&OnEvent, this, std::placeholders::_1));
+		m_EEventType = decltype(m_EEventType)(std::bind(&EventFixture::OnEvent, this, std::placeholders::_1));
 		this->EventBroker->Subscribe(m_EEventType);
 		Run();
 		Check();