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

.gitignore

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

assets/Models/Submarine2.obj

@@ -1,6 +1,6 @@
 # Blender v2.75 (sub 0) OBJ File: 'submarine.blend'
 # www.blender.org
-mtllib submarine2.mtl
+mtllib Submarine2.mtl
 o Cube
 v -0.378953 -0.002680 -0.065172
 v 0.212611 0.044805 -0.044067

include/Core/Engine.h.orig

@@ -1,562 +0,0 @@
-/*
-	This file is part of Daydream Engine.
-	Copyright 2014 Adam Byléhn, Tobias Dahl, Simon Holmberg, Viktor Ljung
-	
-	Daydream Engine is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-	
-	Daydream Engine is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-	
-	You should have received a copy of the GNU Lesser General Public License
-	along with Daydream Engine.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <string>
-#include <sstream>
-#include <Sound/CCollisionSound.h>
-
-#include "ResourceManager.h"
-#include "OBJ.h"
-#include "Model.h"
-#include "Texture.h"
-#include "EventBroker.h"
-#include "RenderQueue.h"
-#include "Renderer.h"
-#include "InputManager.h"
-//TODO: Remove includes that are only here for the temporary draw solution.
-#include "World.h"
-#include "CTransform.h"
-#include "Core/EventBroker.h"
-#include "Rendering/CModel.h"
-#include "Rendering/CSprite.h"
-#include "CTemplate.h"
-#include "Rendering/CPointLight.h"
-#include "Transform/TransformSystem.h"
-#include "Sound/SoundSystem.h"
-#include "Sound/CCollisionSound.h"
-#include "Game/LevelSystem.h"
-#include "Game/PadSystem.h"
-#include "Game/CBall.h"
-#include "Game/CPad.h"
-#include "Game/CBrick.h"
-#include "Game/BallSystem.h"
-#include "Game/Bricks/CPowerUpBrick.h"
-
-#include "Physics/PhysicsSystem.h"
-#include "Physics/CPhysics.h"
-#include "Physics/CRectangleShape.h"
-#include "Physics/ESetImpulse.h"
-#include "Physics/CWaterVolume.h"
-
-#include "Game/EGameStart.h"
-#include "Sound/EPlaySound.h"
-
-#include "GUI/Frame.h"
-#include "GUI/Button.h"
-#include "Game/MainMenu.h"
-#include "Game/HUD.h"
-
-namespace dd
-{
-
-class Engine
-{
-
-public:
-	Engine(int argc, char* argv[]) {
-		m_EventBroker = std::make_shared<EventBroker>();
-
-		m_Renderer = std::make_shared<Renderer>();
-		m_Renderer->SetFullscreen(false);
-		//m_Renderer->SetResolution(Rectangle(0, 0, 1920, 1080));
-		m_Renderer->SetResolution(Rectangle(0, 0, 675, 1080));
-		m_Renderer->Initialize();
-
-		m_FrameStack = new GUI::Frame(m_EventBroker.get());
-		m_FrameStack->Width = 675;
-		m_FrameStack->Height = 1080;
-		auto hud = new GUI::HUD(m_FrameStack, "HUD");
-		auto menu = new GUI::MainMenu(m_FrameStack, "MainMenu");
-
-		m_InputManager = std::make_shared<InputManager>(m_Renderer->Window(), m_EventBroker);
-
-		m_World = std::make_shared<World>(m_EventBroker);
-
-		//TODO: Move this out of engine.h
-		m_World->ComponentFactory.Register<Components::Transform>();
-		m_World->SystemFactory.Register<Systems::TransformSystem>(
-				[this]() { return new Systems::TransformSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::TransformSystem>();
-		m_World->ComponentFactory.Register<Components::Model>();
-		m_World->ComponentFactory.Register<Components::Template>();
-
-		m_World->ComponentFactory.Register<Components::CollisionSound>();
-		m_World->SystemFactory.Register<Systems::SoundSystem>(
-				[this]() { return new Systems::SoundSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::SoundSystem>();
-
-		m_World->ComponentFactory.Register<Components::Sprite>();
-
-		m_World->ComponentFactory.Register<Components::RectangleShape>();
-		m_World->ComponentFactory.Register<Components::Physics>();
-		m_World->ComponentFactory.Register<Components::Ball>();
-		m_World->ComponentFactory.Register<Components::Brick>();
-		m_World->ComponentFactory.Register<Components::Pad>();
-		m_World->ComponentFactory.Register<Components::Life>();
-
-		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>();
-		m_World->SystemFactory.Register<Systems::PadSystem>(
-				[this]() { return new Systems::PadSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::PadSystem>();
-		m_World->SystemFactory.Register<Systems::BallSystem>(
-				[this]() { return new Systems::BallSystem(m_World.get(), m_EventBroker); });
-		m_World->AddSystem<Systems::BallSystem>();
-
-		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->Initialize();
-
-
-		//OctoBall
-		{
-          	auto ent = m_World->CreateEntity();
-        	std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
-			transform->Position = glm::vec3(-0.f, 0.26f, -9.f);
-			transform->Scale = glm::vec3(0.5f, 0.5f, 0.5f);
-			transform->Velocity = glm::vec3(0.0f, -10.f, 0.f);
-          	auto model = m_World->AddComponent<Components::Model>(ent);
-			model->ModelFile = "Models/Test/Ball/Ballopus.obj";
-          	std::shared_ptr<Components::CircleShape> circleShape = m_World->AddComponent<Components::CircleShape>(ent);
-			std::shared_ptr<Components::Ball> ball = m_World->AddComponent<Components::Ball>(ent);
-			ball->Speed = 5.f;
-<<<<<<< HEAD
-            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;
-=======
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(ent);
-			physics->Static = false;
->>>>>>> origin/master
-
-			auto plight = m_World->AddComponent<Components::PointLight>(ent);
-			plight->Radius = 2.f;
-
-			m_World->CommitEntity(ent);
-		}
-
-		//PointLightTest
-		{
-			auto t_Light = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(t_Light);
-			transform->Position = glm::vec3(2.f, 1.5f, -9.f);
-			auto pl = m_World->AddComponent<Components::PointLight>(t_Light);
-			pl->Radius = 8.f;
-			m_World->CommitEntity(t_Light);
-		}
-
-		//Halfpipe background test model.
-		{
-			auto t_halfPipe = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(t_halfPipe);
-			transform->Position = glm::vec3(0.f, 0.f, -15.f);
-			transform->Scale = glm::vec3(15.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);
-			m_World->CommitEntity(t_halfPipe);
-		}
-
-		//Background
-		{
-			auto background = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(background);
-			transform->Position = glm::vec3(0.f, 0.f, -30.f);
-			transform->Scale = glm::vec3(2681.f / 50.f, 1080.f / 50.f, 1.f);
-			auto sprite = m_World->AddComponent<Components::Sprite>(background);
-			sprite->SpriteFile = "Textures/Background.png";
-			m_World->CommitEntity(background);
-		}
-
-		//Water test
-		{
-			auto t_waterBody = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(t_waterBody);
-			transform->Position = glm::vec3(0.f, -4.5f, -10.f);
-			transform->Scale = glm::vec3(7.f, 1.5f, 1.f);
-			auto water = m_World->AddComponent<Components::WaterVolume>(t_waterBody);
-			auto body = m_World->AddComponent<Components::RectangleShape>(t_waterBody);
-			m_World->CommitEntity(t_waterBody);
-		}
-		//TODO: Why does the ball not collide with these bricks?
-		//BottomBox
-		{
-			auto topWall = m_World->CreateEntity();
-			auto transform = m_World->AddComponent<Components::Transform>(topWall);
-			transform->Position = glm::vec3(0.f, -6.f, -9.9f);
-			transform->Scale = glm::vec3(10.f, 0.5f, 1.f);
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					topWall);
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-			physics->Static = true;
-			m_World->CommitEntity(topWall);
-		}
-		//SideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(3.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.f, 1.f);
-//			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-//			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-//			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
-//		//OtherSideBox
-//		{
-//			auto topWall = m_World->CreateEntity();
-//			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(topWall);
-//			transform->Position = glm::vec3(-4.f, -3.0f, -9.9f);
-//			transform->Scale = glm::vec3(0.5f, 3.0f, 1.f);
-//			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-//			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-//			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-//					topWall);
-//			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-//			physics->Static = true;
-//			m_World->CommitEntity(topWall);
-//		}
-
-		{
-			auto topWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					topWall);
-			transform->Position = glm::vec3(0.f, 6.f, -10.f);
-			transform->Scale = glm::vec3(20.f, 0.5f, 1.f);
-
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(topWall);
-			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					topWall);
-
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(topWall);
-			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
-
-			m_World->CommitEntity(topWall);
-		}
-
-		{
-			auto leftWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					leftWall);
-			transform->Position = glm::vec3(-4.f, 1.f, -10.f);
-			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
-
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(leftWall);
-			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					leftWall);
-
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(leftWall);
-			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
-
-			m_World->CommitEntity(leftWall);
-		}
-
-		{
-			auto rightWall = m_World->CreateEntity();
-			std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(
-					rightWall);
-			transform->Position = glm::vec3(4.f, 1.f, -10.f);
-			transform->Scale = glm::vec3(0.5f, 20.f, 1.f);
-
-			std::shared_ptr<Components::Sprite> sprite = m_World->AddComponent<Components::Sprite>(rightWall);
-			sprite->SpriteFile = "Textures/Core/ErrorTexture.png";
-
-			std::shared_ptr<Components::RectangleShape> boxShape = m_World->AddComponent<Components::RectangleShape>(
-					rightWall);
-
-			std::shared_ptr<Components::Physics> physics = m_World->AddComponent<Components::Physics>(rightWall);
-			physics->Static = true;
-			physics->Category = CollisionLayer::Type::Wall;
-			physics->Mask = CollisionLayer::Type::Ball | CollisionLayer::Type::Brick;
-
-			m_World->CommitEntity(rightWall);
-		}
-
-		{
-			auto ent = m_World->CreateEntity();
-			m_World->SetProperty(ent, "Name", "Pad");
-			auto ctransform = m_World->AddComponent<Components::Transform>(ent);
-			ctransform->Position = glm::vec3(0.f, -5.f, -10.f);
-			ctransform->Scale = glm::vec3(1.0f, 1.0f, 1.f);
-			auto rectangle = m_World->AddComponent<Components::RectangleShape>(ent);
-			auto physics = m_World->AddComponent<Components::Physics>(ent);
-			physics->Static = false;
-			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);
-		m_EGameStart = decltype(m_EGameStart)(std::bind(&Engine::OnGameStart, this, std::placeholders::_1));
-		m_EventBroker->Subscribe(m_EGameStart);
-
-			m_LastTime = glfwGetTime();
-	}
-
-	bool Running() const { return !glfwWindowShouldClose(m_Renderer->Window()); }
-
-	void Tick()
-	{
-		double currentTime = glfwGetTime();
-		double dt = currentTime - m_LastTime;
-		m_LastTime = currentTime;
-
-		// Update input
-		m_InputManager->Update(dt);
-		// Swap event queues to get fresh input data in the read queue
-		//m_EventBroker->Swap();
-
-		ResourceManager::Update();
-		if (m_GameIsRunning) {
-			m_World->Update(dt);
-		}
-		m_EventBroker->Process<GUI::Frame>();
-		m_FrameStack->UpdateLayered(dt);
-
-		m_RendererQueue.Clear();
-		m_FrameStack->DrawLayered(m_RendererQueue);
-		//TODO Fill up the renderQueue with models (Temp fix)
-		if (m_GameIsRunning) {
-			TEMPAddToRenderQueue();
-		}
-
-		// Render scene
-		//TODO send renderqueue to draw.
-		m_Renderer->Draw(m_RendererQueue);
-
-		m_EventBroker->Process<Engine>();
-		// Swap event queues
-		m_EventBroker->Swap();
-
-		glfwPollEvents();
-	}
-
-	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
-	std::shared_ptr<Systems::LevelSystem> m_LevelSystem;
-
-	//TODO: Get this out of engine.h
-	void TEMPAddToRenderQueue()
-	{
-		if (!m_TransformSystem)
-			m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
-
-		for (auto &pair : *m_World->GetEntities())
-		{
-			EntityID entity = pair.first;
-
-			auto templateComponent = m_World->GetComponent<Components::Template>(entity);
-			if (templateComponent)
-				continue;
-
-			auto transform = m_World->GetComponent<Components::Transform>(entity);
-			if (!transform)
-				continue;
-
-			auto modelComponent = m_World->GetComponent<Components::Model>(entity);
-			if (modelComponent)
-			{
-				Model* modelAsset = nullptr;
-				modelAsset = ResourceManager::Load<Model>(modelComponent->ModelFile);
-
-				if (modelAsset)
-				{
-					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-					glm::mat4 modelMatrix = glm::translate(glm::mat4(), absoluteTransform.Position)
-						* glm::toMat4(absoluteTransform.Orientation)
-						* glm::scale(absoluteTransform.Scale);
-					EnqueueModel(modelAsset, modelMatrix, modelComponent->Transparent, modelComponent->Color, modelComponent->ModelFile);
-				}
-			}
-
-			auto pointLightComponent = m_World->GetComponent<Components::PointLight>(entity);
-			if (pointLightComponent)
-			{
-				Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-				EnqueuePointLight(absoluteTransform.Position,
-								  pointLightComponent->Diffuse,
-								  pointLightComponent->Specular,
-								  pointLightComponent->Radius);
-			}
-
-			auto parent = m_World->GetEntityParent(entity);
-			if(parent != 0) {
-				auto waterParticleComponent = m_World->GetComponent<Components::WaterVolume>(parent);
-				if (waterParticleComponent) {
-					//TODO: Remove hardcoded color.
-					//TODO: Do i even need modelMatrix?
-					Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-					glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
-											* glm::scale(absoluteTransform.Scale);
-					EnqueueWaterParticles(absoluteTransform.Position, glm::vec4(1.f, 1.f, 1.f, 1.f), modelMatrix, absoluteTransform.Position.z);
-				}
-			}
-
-
-			auto spriteComponent = m_World->GetComponent<Components::Sprite>(entity);
-			if (spriteComponent)
-			{
-
-				std::string normal = spriteComponent->NormalTexture;
-				std::string spec = spriteComponent->SpecularTexture;
-
-				if (normal.empty()) {
-					normal = "Textures/Core/NeutralNormalMap.png";
-				}
-				if (spec.empty()) {
-					spec = "Textures/Core/NeutralSpecularMap.png";
-				}
-				auto texturediff = ResourceManager::Load<Texture>(spriteComponent->SpriteFile);
-				auto texturenorm = ResourceManager::Load<Texture>(normal);
-				auto texturespec = ResourceManager::Load<Texture>(spec);
-
-
-				Components::Transform absoluteTransform = m_TransformSystem->AbsoluteTransform(entity);
-				glm::quat orientation2D = glm::angleAxis(glm::eulerAngles(absoluteTransform.Orientation).z, glm::vec3(0, 0, -1));
-				glm::mat4 modelMatrix = glm::translate(absoluteTransform.Position)
-					* glm::toMat4(orientation2D)
-					* glm::scale(absoluteTransform.Scale);
-				EnqueueSprite(texturediff, texturenorm, texturespec, modelMatrix, spriteComponent->Color, absoluteTransform.Position.z);
-			}
-		}
-
-	}
-
-	//TODO: Get this out of engine.h
-	void EnqueueModel(Model* model, glm::mat4 modelMatrix, float transparent, glm::vec4 color, std::string fileName)
-	{
-		for (auto texGroup : model->TextureGroups)
-		{
-			ModelJob job;
-			job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-			job.DiffuseTexture = (texGroup.Texture) ? *texGroup.Texture : 0;
-			job.NormalTexture = (texGroup.NormalMap) ? *texGroup.NormalMap : 0;
-			job.SpecularTexture = (texGroup.SpecularMap) ? *texGroup.SpecularMap : 0;
-			job.VAO = model->VAO;
-			job.ElementBuffer = model->ElementBuffer;
-			job.StartIndex = texGroup.StartIndex;
-			job.EndIndex = texGroup.EndIndex;
-			job.ModelMatrix = modelMatrix;
-			job.Color = color;
-
-			m_RendererQueue.Deferred.Add(job);
-		}
-	}
-
-	// TODO: Get this out of engine.h
-	void EnqueueSprite(Texture* texture, Texture* normalTexture, Texture* specularTexture, glm::mat4 modelMatrix, glm::vec4 color, float depth)
-	{
-		SpriteJob job;
-		job.TextureID = texture->ResourceID;
-		job.DiffuseTexture = *texture;
-		job.NormalTexture = *normalTexture;
-		job.SpecularTexture = *specularTexture;
-		job.ModelMatrix = modelMatrix;
-		job.Color = color;
-		job.Depth = depth;
-
-
-		m_RendererQueue.Forward.Add(job);
-	}
-
-	void EnqueuePointLight(glm::vec3 position, glm::vec3 diffuseColor, glm::vec3 specularColor, float radius)
-	{
-		PointLightJob job;
-		job.Position = position;
-		job.DiffuseColor = diffuseColor;
-		job.SpecularColor = specularColor;
-		job.Radius = radius;
-
-		m_RendererQueue.Lights.Add(job);
-
-	}
-
-	void EnqueueWaterParticles(glm::vec3 position, glm::vec4 color, glm::mat4 modelMatrix, float depth)
-	{
-		WaterParticleJob job;
-		job.Position = position;
-		job.Color = color;
-		job.ModelMatrix = modelMatrix;
-		job.Depth = depth;
-
-		m_RendererQueue.Forward.Add(job);
-	}
-
-private:
-	std::shared_ptr<EventBroker> m_EventBroker;
-	GUI::Frame* m_FrameStack = nullptr;
-	std::shared_ptr<Renderer> m_Renderer;
-	RenderQueueCollection m_RendererQueue;
-	std::shared_ptr<InputManager> m_InputManager;
-	std::shared_ptr<World> m_World;
-
-	//TODO: Redo
-	bool m_GameIsRunning = false;
-	dd::EventRelay<Engine, dd::Events::GameStart> m_EGameStart;
-	bool OnGameStart(const dd::Events::GameStart &event)
-	{
-		m_GameIsRunning = true;
-		//Todo: Move this
-		{
-			dd::Events::PlaySound e;
-			e.path = "Sounds/BGM/under-the-sea-instrumental.wav";
-			e.isAmbient = true;
-			m_EventBroker->Publish(e);
-		}
-		{
-			dd::Events::PlaySound e;
-			e.path = "Sounds/BGM/water-flowing.wav";
-			e.volume = 0.3f;
-			e.isAmbient = true;
-			m_EventBroker->Publish(e);
-		}
-	};
-	double m_LastTime;
-};
-
-}

include/Game/LevelSystem.h

@@ -33,7 +33,6 @@
 #include "Game/PadSystem.h"
 #include <fstream>
 #include <iostream>
-#include <intrin.h>
 
 namespace dd
 {

include/Physics/PhysicsSystem.h

@@ -57,8 +57,8 @@ public:
 private:
     b2Vec2 m_Gravity;
     b2World* m_PhysicsWorld;
-    float m_TimeStep;
-    float m_Accumulator;
+    double m_TimeStep;
+    double m_Accumulator;
 
     int m_VelocityIterations, m_PositionIterations;
 

include/Physics/PhysicsSystem.h.orig

@@ -1,149 +0,0 @@
-#ifndef DAYDREAM_PHYSICSSYSTEM_H
-#define DAYDREAM_PHYSICSSYSTEM_H
-
-#include <unordered_map>
-
-#include "Core/System.h"
-#include "Core/World.h"
-#include "CRectangleShape.h"
-#include "Physics/CPhysics.h"
-#include <Box2D/Box2D.h>
-#include "Core/CTransform.h"
-#include "Transform/TransformSystem.h"
-#include "Physics/EContact.h"
-#include "Physics/ESetImpulse.h"
-#include "Physics/CCircleShape.h"
-#include "Core/EventBroker.h"
-#include "Game/CPad.h"
-<<<<<<< HEAD
-#include "Game/CBall.h"
-=======
-#include "Physics/CWaterVolume.h"
-#include "Rendering/CSprite.h"
->>>>>>> origin/master
-
-
-namespace dd
-{
-
-namespace Systems
-{
-
-
-class PhysicsSystem : public System
-{
-    friend class ContractListener;
-
-public:
-    PhysicsSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-    : System(world, eventBroker) {}
-
-    ~PhysicsSystem();
-
-    EventRelay<PhysicsSystem, Events::SetImpulse> m_SetImpulse;
-    bool SetImpulse(const Events::SetImpulse &event);
-
-    void RegisterComponents(ComponentFactory* cf) override;
-    void Initialize() override;
-
-    // Called once per system every tick
-    void Update(double dt) override;
-    // Called once for every entity in the world every tick
-    void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
-
-    // Called when components are committed to an entity
-    void OnEntityCommit(EntityID entity) override;
-
-    // Called when an entity is removed
-    void OnEntityRemoved(EntityID entity) override;
-
-private:
-    b2Vec2 m_Gravity;
-    b2World* m_PhysicsWorld;
-    float m_TimeStep;
-    float m_Accumulator;
-
-    int m_VelocityIterations, m_PositionIterations;
-
-    std::unordered_map<EntityID, b2Body*> m_EntitiesToBodies;
-    std::unordered_map<b2Body*, EntityID> m_BodiesToEntities;
-
-    void CreateBody(EntityID entity);
-
-    b2ParticleSystem *m_ParticleSystem;
-    b2ParticleGroup* t_watergroup;
-
-    std::unordered_map<EntityID, const b2ParticleHandle*> m_EntitiesToParticleHandle;
-    std::unordered_map<const b2ParticleHandle*, EntityID> m_ParticleHandleToEntities;
-
-    void InitializeWater();
-    void SyncWater(); //TODO: Probably remove this
-    void CreateParticleGroup(EntityID entity);
-
-    struct Impulse
-    {
-        b2Body* Body;
-        b2Vec2 Impulse;
-        b2Vec2 Point;
-    };
-    std::list<Impulse> m_Impulses;
-
-
-
-    class ContactListener : public b2ContactListener
-    {
-    public:
-        ContactListener(PhysicsSystem* physicsSystem)
-                : m_PhysicsSystem(physicsSystem) { }
-
-        void BeginContact(b2Contact* contact)
-        {
-            b2WorldManifold worldManifold;
-
-            contact->GetWorldManifold(&worldManifold);
-
-            Events::Contact e;
-            e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
-            e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
-            e.Normal = glm::normalize(glm::vec2(contact->GetManifold()->localNormal.x, contact->GetManifold()->localNormal.y));
-            e.SignificantNormal = glm::normalize((glm::abs(e.Normal.x) > glm::abs(e.Normal.y)) ? glm::vec2(e.Normal.x, 0) : glm::vec2(0, e.Normal.y));
-
-            m_PhysicsSystem->EventBroker->Publish(e);
-        }
-        void EndContact(b2Contact* contact)
-        {
-
-        }
-        void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
-        {
-            EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
-            EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
-
-            auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
-            auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
-
-            if (physicsComponentA != nullptr && physicsComponentB != nullptr) {
-                if (physicsComponentA->Calculate || physicsComponentB->Calculate) {
-                    // Turn of collisions
-                    contact->SetEnabled(false);
-                }
-            }
-
-
-        }
-        void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
-        {
-
-        }
-
-    private:
-        PhysicsSystem* m_PhysicsSystem;
-    };
-
-    ContactListener* m_ContactListener;
-};
-
-}
-}
-
-#endif //DAYDREAM_PHYSICSSYSTEM_H

src/game/Game/BallSystem.cpp

@@ -13,7 +13,7 @@ void dd::Systems::BallSystem::RegisterComponents(ComponentFactory *cf)
 void dd::Systems::BallSystem::Initialize()
 {
 
-    EVENT_SUBSCRIBE_MEMBER(m_Contact, BallSystem::Contact);
+    EVENT_SUBSCRIBE_MEMBER(m_Contact, &BallSystem::Contact);
 }
 
 void dd::Systems::BallSystem::Update(double dt)

src/game/Game/LevelSystem.cpp

@@ -9,13 +9,13 @@
 
 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_EPowerUpTaken, LevelSystem::OnPowerUpTaken);
-    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, LevelSystem::OnStageCleared);
+    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_EPowerUpTaken, &LevelSystem::OnPowerUpTaken);
+    EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &LevelSystem::OnStageCleared);
 
     for (int i = 0; i < Lives(); i++) {
         CreateLife(i);

src/game/Physics/PhysicsSystem.cpp

@@ -15,16 +15,16 @@ void dd::Systems::PhysicsSystem::Initialize()
     m_Gravity = b2Vec2(0.f, -9.82f);
     m_PhysicsWorld = new b2World(m_Gravity);
 
-    m_TimeStep = 1.f/60.f;
+    m_TimeStep = 1.0/60.0;
     m_VelocityIterations = 6;
     m_PositionIterations = 2;
-    m_Accumulator = 0.f;
+    m_Accumulator = 0.0;
 
     m_PhysicsWorld->SetContactListener(m_ContactListener);
 
     InitializeWater();
 
-    EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, PhysicsSystem::SetImpulse);
+    EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, &PhysicsSystem::SetImpulse);
 }
 
 void dd::Systems::PhysicsSystem::InitializeWater()
@@ -268,7 +268,7 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
 
 
     if(physicsComponent->Static) {
-        body->CreateFixture(&fixtureDef); //Density kanske ska vara 0 på statiska kroppar
+        body->CreateFixture(&fixtureDef); //Density kanske ska vara 0 p� statiska kroppar
     }
     else {
         fixtureDef.shape = pShape;
@@ -289,7 +289,7 @@ void dd::Systems::PhysicsSystem::CreateBody(EntityID entity)
 
 void dd::Systems::PhysicsSystem::CreateParticleGroup(EntityID e)
 {
-    //TODO: Lägg alla pd i en lista
+    //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");

src/game/Sound/Sound.cpp

@@ -26,7 +26,7 @@ ALuint dd::Sound::LoadFile(std::string path)
         return 0;
     }
 
-    fread(&m_Size, sizeof(unsigned long), 1, fp);
+    fread(&m_Size, 4*sizeof(char), 1, fp);
     fread(m_Type, sizeof(char), 4, fp);
     if (m_Type[0] != 'W' || m_Type[1] != 'A' || m_Type[2] != 'V' || m_Type[3]!= 'E') {
         LOG_ERROR("ERROR: Not WAVE-file");
@@ -40,13 +40,13 @@ ALuint dd::Sound::LoadFile(std::string path)
     }
 
     //READ THE DATA FROM WAVE-FILE
-    fread(&m_ChunkSize, sizeof(unsigned long), 1, fp);
-    fread(&m_FormatType, sizeof(short), 1, fp);
-    fread(&m_Channels, sizeof(short), 1, fp);
-    fread(&m_SampleRate, sizeof(unsigned long), 1, fp);
-    fread(&m_AvgBytesPerSec, sizeof(unsigned long), 1, fp);
-    fread(&m_BytesPerSample, sizeof(short), 1, fp);
-    fread(&m_BitsPerSample, sizeof(short), 1, fp);
+    fread(&m_ChunkSize, 4*sizeof(char), 1, fp);
+    fread(&m_FormatType, 2*sizeof(char), 1, fp);
+    fread(&m_Channels, 2*sizeof(char), 1, fp);
+    fread(&m_SampleRate, 4*sizeof(char), 1, fp);
+    fread(&m_AvgBytesPerSec, 4*sizeof(char), 1, fp);
+    fread(&m_BytesPerSample, 2*sizeof(char), 1, fp);
+    fread(&m_BitsPerSample, 2*sizeof(char), 1, fp);
 
     fread(m_Type, sizeof(char), 4, fp);
     if (m_Type[0] !='d' || m_Type[1] != 'a' || m_Type[2] != 't' || m_Type[3] != 'a') {
@@ -54,10 +54,10 @@ ALuint dd::Sound::LoadFile(std::string path)
         return 0;
     }
 
-    fread(&m_DataSize, sizeof(unsigned long), 1, fp);
+    fread(&m_DataSize, 4*sizeof(char), 1, fp);
 
     unsigned char* buf = new unsigned char[m_DataSize];
-    fread(buf, sizeof(unsigned char), m_DataSize, fp);
+    fread(buf, sizeof(char), m_DataSize, fp);
     fclose(fp);
 
     // Create buffer