Merge remote-tracking branch 'origin/physics' into water

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

include/Core/Engine.h

@@ -41,6 +41,7 @@
 #include "Game/CBall.h"
 #include "Game/CBrick.h"
 #include "Game/CPad.h"
+#include "Game/BallSystem.h"
 
 #include "Physics/PhysicsSystem.h"
 #include "Physics/CPhysics.h"
@@ -48,6 +49,7 @@
 #include "Physics/ESetImpulse.h"
 #include "Physics/CWaterVolume.h"
 
+
 namespace dd
 {
 
@@ -88,6 +90,8 @@ public:
 		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>();
@@ -106,6 +110,7 @@ public:
             std::shared_ptr<Components::Transform> transform = m_World->AddComponent<Components::Transform>(ent);
             transform->Position = glm::vec3(0.5f, 0.f, -9.9f);
 			transform->Scale = glm::vec3(1.f, 1.f, 1.f);
+			transform->Velocity = glm::vec3(1.0f, -5.f, 0.f);
 
             auto model = m_World->AddComponent<Components::Model>(ent);
 			model->ModelFile = "Models/Test/Ball/Ballopus.obj";
@@ -121,11 +126,7 @@ public:
 
             m_World->CommitEntity(ent);
 
-			Events::SetImpulse e;
-			e.Entity = ent;
-			e.Impulse = glm::vec2(0.f, -7.f);
-			e.Point = glm::vec2(0.5f, 0.f);
-			m_EventBroker->Publish(e);
+
         }
 
 		//PointLightTest
@@ -215,6 +216,7 @@ public:
 			ctransform->Scale = glm::vec3(3.2, 0.8, 0.);
 			auto rectangle = m_World->AddComponent<Components::RectangleShape>(ent);
 			auto physics = m_World->AddComponent<Components::Physics>(ent);
+			physics->Static = false;
 			auto csprite = m_World->AddComponent<Components::Sprite>(ent);
 			auto pad = m_World->AddComponent<Components::Pad>(ent);
 			csprite->SpriteFile = "Textures/Pad.png";

include/Game/BallSystem.h

@@ -0,0 +1,48 @@
+#ifndef DAYDREAM_BALLSYSTEM_H
+#define DAYDREAM_BALLSYSTEM_H
+
+#include "Core/System.h"
+#include "Core/World.h"
+#include "Core/CTransform.h"
+#include "Physics/EContact.h"
+#include "Core/EventBroker.h"
+#include "Game/CBall.h"
+
+namespace dd {
+
+namespace Systems {
+
+class BallSystem : public System {
+public:
+    BallSystem(World *world, std::shared_ptr<dd::EventBroker> eventBroker)
+            : System(world, eventBroker) { }
+
+    ~BallSystem();
+
+    EventRelay<BallSystem, Events::Contact> m_Contact;
+    bool Contact(const Events::Contact &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:
+
+};
+
+}
+}
+
+#endif

include/Physics/EContact.h

@@ -19,7 +19,7 @@ struct Contact : Event
 {
     EntityID Entity1;
     EntityID Entity2;
-    glm::vec2 ContactPoint;
+    glm::vec2 Normal;
 };
 
 }

include/Physics/PhysicsSystem.h

@@ -14,6 +14,7 @@
 #include "Physics/ESetImpulse.h"
 #include "Physics/CCircleShape.h"
 #include "Core/EventBroker.h"
+#include "Game/CPad.h"
 #include "Physics/CWaterVolume.h"
 
 
@@ -23,7 +24,6 @@ namespace dd
 namespace Systems
 {
 
-//KOLLA http://box2d.org/manual.pdf p52 Pre-Solve Event
 
 class PhysicsSystem : public System
 {
@@ -83,22 +83,41 @@ private:
 
         void BeginContact(b2Contact* contact)
         {
-            b2Vec2 contactPoint = contact->GetManifold()->localPoint;
+            b2WorldManifold worldManifold;
+
+            contact->GetWorldManifold(&worldManifold);
 
             Events::Contact e;
-            e.ContactPoint = glm::vec2(contactPoint.x, contactPoint.y);
             e.Entity1 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
             e.Entity2 = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureB()->GetBody()];
-
+            e.Normal = glm::normalize(glm::vec2(worldManifold.normal.x, worldManifold.normal.y));
 
             m_PhysicsSystem->EventBroker->Publish(e);
+
+            LOG_INFO("Entity1 = %i, Entity2 = %i\n", e.Entity1, e.Entity2);
         }
         void EndContact(b2Contact* contact)
-        { /* handle end event */ }
+        {
+
+        }
         void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
-        { /* handle pre-solve event */ }
+        {
+            EntityID entityA = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+            EntityID entityB = m_PhysicsSystem->m_BodiesToEntities[contact->GetFixtureA()->GetBody()];
+
+            auto physicsComponentA = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityA);
+            auto physicsComponentB = m_PhysicsSystem->m_World->GetComponent<Components::Physics>(entityB);
+
+            if (physicsComponentA != nullptr || physicsComponentB != nullptr) {
+                // Turn of collisions
+                contact->SetEnabled(false);
+            }
+
+        }
         void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
-        { /* handle post-solve event */ }
+        {
+
+        }
 
     private:
         PhysicsSystem* m_PhysicsSystem;