Red rocket

Conflicts:
	src/GameWorld.cpp
	src/Systems/ParticleSystem.cpp

src/Components/ParticleEmitter.h

@@ -19,7 +19,7 @@ struct ParticleEmitter : Component
 		, SpawnCount(0)
 		, SpreadAngle(0)
 		, LifeTime(0)
-		, TimeSinceLastSpawn(0) { } 
+		, TimeSinceLastSpawn(100) { } // TEMP fulhack så att partiklarna spawnar direkt
 
 	EntityID ParticleTemplate;
 	float SpawnFrequency;
@@ -34,10 +34,11 @@ struct ParticleEmitter : Component
 	std::vector<float> AngularVelocitySpectrum;
 	std::vector<glm::vec3> OrientationSpectrum; //Keep?
 
-	virtual ParticleEmitter* Clone() const override { return new ParticleEmitter(*this); }
-
 private:
 	double TimeSinceLastSpawn;
+
+	virtual ParticleEmitter* Clone() const override { return new ParticleEmitter(*this); }
+
 };
 
 }

src/Events/Collision.h

@@ -0,0 +1,18 @@
+#ifndef Events_Collision_h__
+#define Events_Collision_h__
+
+#include "Entity.h"
+#include "EventBroker.h"
+
+namespace Events
+{
+
+struct Collision : Event
+{
+	EntityID Entity1;
+	EntityID Entity2;
+};
+
+}
+
+#endif // Events_Collision_h__

src/GameWorld.cpp

@@ -335,7 +335,7 @@ void GameWorld::Initialize()
 			auto cameraTower = CreateEntity(tower);
 			{
 				auto transform = AddComponent<Components::Transform>(cameraTower);
-				transform->Position.z = 11.f;
+				transform->Position.z = 14.f;
 				transform->Position.y = 4.f;
 				//transform->Orientation = glm::quat(glm::vec3(glm::pi<float>() / 8.f, 0.f, 0.f));
 				auto cameraComp = AddComponent<Components::Camera>(cameraTower);
@@ -551,15 +551,16 @@ void GameWorld::Initialize()
 
 			auto entity = CreateEntity(tank);
 			auto transformComponent = AddComponent<Components::Transform>(entity);
-			transformComponent->Position = glm::vec3(2,-1.7,2.0);
+			transformComponent->Position = glm::vec3(-2,-1.7,2.0);
 			transformComponent->Scale = glm::vec3(3,3,3);
 			transformComponent->Orientation = glm::angleAxis(glm::pi<float>()/2, glm::vec3(1,0,0));
 			auto emitterComponent = AddComponent<Components::ParticleEmitter>(entity);
 			emitterComponent->SpawnCount = 2;
-			emitterComponent->SpawnFrequency = 0.005;
+			emitterComponent->SpawnFrequency = 10;
 			emitterComponent->SpreadAngle = glm::pi<float>();
 			emitterComponent->UseGoalVelocity = false;
 			emitterComponent->LifeTime = 0.5;
+			emitterComponent->Speed = 5;
 			//emitterComponent->AngularVelocitySpectrum.push_back(glm::pi<float>() / 100);
 			emitterComponent->ScaleSpectrum.push_back(glm::vec3(0.05));
 			CommitEntity(entity);
@@ -635,7 +636,7 @@ void GameWorld::Initialize()
 
 			auto entity = CreateEntity(tank);
 			auto transformComponent = AddComponent<Components::Transform>(entity);
-			transformComponent->Position = glm::vec3(-2,-1.7,2.0);
+			transformComponent->Position = glm::vec3(2,-1.7,2.0);
 			transformComponent->Scale = glm::vec3(3,3,3);
 			transformComponent->Orientation = glm::angleAxis(glm::pi<float>()/2, glm::vec3(1,0,0));
 			auto emitterComponent = AddComponent<Components::ParticleEmitter>(entity);
@@ -644,6 +645,7 @@ void GameWorld::Initialize()
 			emitterComponent->SpreadAngle = glm::pi<float>();
 			emitterComponent->UseGoalVelocity = false;
 			emitterComponent->LifeTime = 0.5;
+			emitterComponent->Speed = 5;
 			//emitterComponent->AngularVelocitySpectrum.push_back(glm::pi<float>() / 100);
 			emitterComponent->ScaleSpectrum.push_back(glm::vec3(0.05));
 			CommitEntity(entity);
@@ -654,7 +656,6 @@ void GameWorld::Initialize()
 			auto spriteComponent = AddComponent<Components::Sprite>(particleEntity);
 			spriteComponent->SpriteFile = "Models/Textures/Sprites/Dust.png";
 			emitterComponent->ParticleTemplate = particleEntity;
-
 			CommitEntity(particleEntity);
 		}
 
@@ -753,7 +754,7 @@ void GameWorld::Initialize()
 			auto cameraTower = CreateEntity(tower);
 			{
 				auto transform = AddComponent<Components::Transform>(cameraTower);
-				transform->Position.z = 11.f;
+				transform->Position.z = 14.f;
 				transform->Position.y = 4.f;
 				//transform->Orientation = glm::quat(glm::vec3(glm::pi<float>() / 8.f, 0.f, 0.f));
 				auto cameraComp = AddComponent<Components::Camera>(cameraTower);

src/Renderer.cpp

@@ -357,18 +357,7 @@ void Renderer::AddTextureToDraw(Texture* texture, glm::vec3 position, glm::quat
 {
 	glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
 
-	glm::vec3 camToParticle = glm::normalize(m_Camera->Position() - position);
+	TexturesToRender.push_back(std::make_tuple(texture, modelMatrix, position));
-	glm::vec3 up = glm::vec3(0,1,0);
-	glm::vec3 rightVec = glm::normalize(glm::cross(up, camToParticle));
-	glm::vec3 up2 = glm::normalize(glm::cross(camToParticle, rightVec));
-	
-	glm::mat4 billboardMatrix;
-	billboardMatrix[0] = glm::vec4(rightVec, 0);
-	billboardMatrix[1] = glm::vec4(up2, 0);
-	billboardMatrix[2] = glm::vec4(camToParticle, 0);
-	//billboardMatrix[3] = glm::vec4(position, 0);
-
-	TexturesToRender.push_back(std::make_tuple(texture, modelMatrix, billboardMatrix));
 }
 
 void Renderer::AddPointLightToDraw(
@@ -770,10 +759,22 @@ void Renderer::DrawFBOScene(Viewport &viewport)
 	{
 		Texture* texture;
 		glm::mat4 modelMatrix;
-		glm::mat4 billboardMatrix;
+		glm::vec3 position;
-		std::tie(texture, modelMatrix, billboardMatrix) = tuple;
+		std::tie(texture, modelMatrix, position) = tuple;
 		
 		//MVP = cameraMatrix * glm::inverse(glm::toMat4(m_Camera->Orientation()) * modelMatrix );
+
+		glm::vec3 camToParticle = glm::normalize(viewport.Camera->Position() - position);
+		glm::vec3 up = glm::vec3(0,1,0);
+		glm::vec3 rightVec = glm::normalize(glm::cross(up, camToParticle));
+		glm::vec3 up2 = glm::normalize(glm::cross(camToParticle, rightVec));
+
+		glm::mat4 billboardMatrix;
+		billboardMatrix[0] = glm::vec4(rightVec, 0);
+		billboardMatrix[1] = glm::vec4(up2, 0);
+		billboardMatrix[2] = glm::vec4(camToParticle, 0);
+		//billboardMatrix[3] = glm::vec4(position, 0);
+
 		MVP = cameraMatrix * modelMatrix * billboardMatrix;
 
 		depthMVP = depthCameraMatrix * modelMatrix;

src/Renderer.h

@@ -26,7 +26,7 @@ public:
 	int Height() const { return m_Height; }
 
 	std::list<std::tuple<Model*, glm::mat4, bool, bool>> ModelsToRender;
-	std::list<std::tuple<Texture*, glm::mat4, glm::mat4>> TexturesToRender;
+	std::list<std::tuple<Texture*, glm::mat4, glm::vec3>> TexturesToRender;
 	std::list<std::tuple<glm::mat4, bool>> AABBsToRender;
 
 	Renderer();

src/Shaders/Fragment.glsl

@@ -40,7 +40,7 @@ void main()
 {
 	
 	// Diffuse Texture
-	frag_Diffuse = texture(DiffuseTexture, Input.TextureCoord) * Shadow(Input.ShadowCoord);
+	frag_Diffuse = texture(DiffuseTexture, Input.TextureCoord); // * Shadow(Input.ShadowCoord);
 
 	// G-buffer Position
 	frag_Position = vec4(Input.Position.xyz, 1.0);

src/System.h

@@ -33,6 +33,7 @@ public:
 	virtual void OnComponentRemoved(std::string type, Component* component) { }
 	// Called when components are committed to an entity
 	virtual void OnEntityCommit(EntityID entity) { }
+	virtual void OnEntityRemoved(EntityID entity) { }
 
 protected:
 	World* m_World;

src/Systems/ParticleSystem.cpp

@@ -7,11 +7,32 @@
 void Systems::ParticleSystem::Initialize()
 {
 	m_TransformSystem = m_World->GetSystem<Systems::TransformSystem>();
+	tempSpawnedExplosions = false;
+	EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Systems::ParticleSystem::OnKeyUp);
 }
 
 void Systems::ParticleSystem::Update(double dt)
 {
+	std::map<EntityID, double>::iterator it;
+	for(it = m_ExplosionEmitters.begin(); it != m_ExplosionEmitters.end();)
+	{
+		EntityID explosionID = it->first;
+		double spawnTime = it->second;
 		
+		double timeLived = glfwGetTime() - spawnTime;
+		auto eComp = m_World->GetComponent<Components::ParticleEmitter>(explosionID);
+
+		if(timeLived > eComp->LifeTime)
+		{
+			m_World->RemoveEntity(explosionID);
+			it = m_ExplosionEmitters.erase(it);
+			//LOG_INFO("Deleted explosion emitter successfully");
+		}
+		else 
+		{
+			it++;
+		}
+	}
 }
 
 void Systems::ParticleSystem::UpdateEntity(double dt, EntityID entity, EntityID parent)
@@ -101,43 +122,41 @@ void Systems::ParticleSystem::RegisterComponents(ComponentFactory* cf)
 
 void Systems::ParticleSystem::SpawnParticles(EntityID emitterID)
 {
-	auto emitterComponent = m_World->GetComponent<Components::ParticleEmitter>(emitterID);
+	auto eComponent = m_World->GetComponent<Components::ParticleEmitter>(emitterID);
-	auto emitterTransform = m_World->GetComponent<Components::Transform>(emitterID);
+	auto eTransform = m_World->GetComponent<Components::Transform>(emitterID);
-	glm::vec3 emitterPos = m_TransformSystem->AbsolutePosition(emitterID);
+	glm::vec3 ePosition = m_TransformSystem->AbsolutePosition(emitterID);
-	glm::quat emitterOrientation = emitterTransform->Orientation;
+	glm::quat eOrientation = eTransform->Orientation;
+	glm::vec3 paticleSpeed = glm::vec3(eComponent->Speed);
 
-	float tempSpeed =  4;
+	for(int i = 0; i < eComponent->SpawnCount; i++)
-	glm::vec3 speed = glm::vec3(tempSpeed);
-
-	for(int i = 0; i < emitterComponent->SpawnCount; i++)
 	{
-		auto ent = m_World->CloneEntity(emitterComponent->ParticleTemplate);
+		auto particleEntity = m_World->CloneEntity(eComponent->ParticleTemplate);
 
-		auto particleTransform = m_World->GetComponent<Components::Transform>(ent);
+		auto particleTransform = m_World->GetComponent<Components::Transform>(particleEntity);
-		particleTransform->Position = emitterPos;
+		particleTransform->Position = ePosition;
 		
-		particleTransform->Orientation = emitterOrientation;
+		particleTransform->Orientation = eOrientation;
 		//The emitter's orientation as "start value" times the default direction for emitter. Times the speed, and then rotate on x and y axis with the randomized spread angle. 
-		float spreadAngle = emitterComponent->SpreadAngle;
+		float spreadAngle = eComponent->SpreadAngle;
-		particleTransform->Velocity = emitterOrientation * glm::vec3(0, 0, -1) * speed * 
+		particleTransform->Velocity = eOrientation * glm::vec3(0, 0, -1) * paticleSpeed * 
 			glm::normalize(glm::angleAxis(RandomizeAngle(spreadAngle), glm::vec3(1, 0, 0))) * 
 			glm::normalize(glm::angleAxis(RandomizeAngle(spreadAngle), glm::vec3(0, 1, 0))) *
 			glm::normalize(glm::angleAxis(RandomizeAngle(spreadAngle), glm::vec3(0, 0, 1)));
 
-		auto particle = m_World->AddComponent<Components::Particle>(ent);
+		auto particleComponent = m_World->AddComponent<Components::Particle>(particleEntity);
-		particle->LifeTime = emitterComponent->LifeTime;
+		particleComponent->LifeTime = eComponent->LifeTime - 0.5;
-		particle->ScaleSpectrum = emitterComponent->ScaleSpectrum; 
+		particleComponent->ScaleSpectrum = eComponent->ScaleSpectrum; 
-		particle->VelocitySpectrum.push_back(particleTransform->Velocity);
+		particleComponent->VelocitySpectrum.push_back(particleTransform->Velocity);
 		
-		if (emitterComponent->ScaleSpectrum.size() > 0)
+		if (eComponent->ScaleSpectrum.size() > 0)
 		{
-			if (emitterComponent->ScaleSpectrum.size() > 1)
+			if (eComponent->ScaleSpectrum.size() > 1)
 			{
-				particle->ScaleSpectrum = emitterComponent->ScaleSpectrum;
+				particleComponent->ScaleSpectrum = eComponent->ScaleSpectrum;
 			}
 			else
 			{
-				particleTransform->Scale = emitterComponent->ScaleSpectrum[0];
+				particleTransform->Scale = eComponent->ScaleSpectrum[0];
 			}
 		}
 		else
@@ -145,23 +164,22 @@ void Systems::ParticleSystem::SpawnParticles(EntityID emitterID)
 			particleTransform->Scale = glm::vec3(1, 1, 1);
 		}
 		
-		if(emitterComponent->UseGoalVelocity)
+		if(eComponent->UseGoalVelocity)
-			particle->VelocitySpectrum.push_back(emitterComponent->GoalVelocity);
+			particleComponent->VelocitySpectrum.push_back(eComponent->GoalVelocity);
-		particle->OrientationSpectrum = emitterComponent->OrientationSpectrum;
+		particleComponent->OrientationSpectrum = eComponent->OrientationSpectrum;
-		if(particle->OrientationSpectrum.size() != 0)
+		if(particleComponent->OrientationSpectrum.size() != 0)
-			particleTransform->Orientation = glm::angleAxis(0.f, particle->OrientationSpectrum[0]);
+			particleTransform->Orientation = glm::angleAxis(0.f, particleComponent->OrientationSpectrum[0]);
-		particle->AngularVelocitySpectrum = emitterComponent->AngularVelocitySpectrum;
+		particleComponent->AngularVelocitySpectrum = eComponent->AngularVelocitySpectrum;
 		
 
 		ParticleData data;
-		data.ParticleID = ent;
+		data.ParticleID = particleEntity;
 		data.SpawnTime = glfwGetTime();
-		if (particle->AngularVelocitySpectrum.size() != 0)
+		if (particleComponent->AngularVelocitySpectrum.size() != 0)
-			data.AngularVelocity = particle->AngularVelocitySpectrum[0];
+			data.AngularVelocity = particleComponent->AngularVelocitySpectrum[0];
-		if (particle->OrientationSpectrum.size() != 0)
+		if (particleComponent->OrientationSpectrum.size() != 0)
-			data.Orientation = particle->OrientationSpectrum[0];
+			data.Orientation = particleComponent->OrientationSpectrum[0];
-		else data.Orientation = emitterOrientation * glm::vec3(0,0,-1);
+		else data.Orientation = eOrientation * glm::vec3(0,0,-1);
-		
 		m_ParticleEmitter[emitterID].push_back(data);
 	}
 }
@@ -206,3 +224,54 @@ void Systems::ParticleSystem::ScalarInterpolation(double timeProgress, std::vect
 		dAlpha *= -1;
 	alpha = spectrum[0] + dAlpha * timeProgress; 
 }
+
+void Systems::ParticleSystem::CreateExplosion(glm::vec3 _pos, double _lifeTime, int _particlesToSpawn, std::string _spritePath, glm::quat _relativeUpOri, float _speed, float _spreadAngle, float _particleScale)
+{
+	auto explosion = m_World->CreateEntity();
+	auto emitter = m_World->AddComponent<Components::ParticleEmitter>(explosion);
+	emitter->LifeTime = _lifeTime;
+	emitter->SpawnCount = _particlesToSpawn;
+	emitter->Speed = _speed;
+	emitter->SpreadAngle = _spreadAngle; 
+	emitter->SpawnFrequency = _lifeTime + 20; //temp
+// 	emitter->UseGoalVelocity = true;
+// 	emitter->GoalVelocity = glm::vec3(0,-_speed, 0);
+	m_World->CommitEntity(explosion);
+
+	auto particleEnt = m_World->CreateEntity();
+	auto TEMP = m_World->AddComponent<Components::Transform>(particleEnt);
+	TEMP->Scale = glm::vec3(0);
+	auto spriteComponent = m_World->AddComponent<Components::Sprite>(particleEnt);
+	spriteComponent->SpriteFile = _spritePath;
+	m_World->CommitEntity(particleEnt);
+	emitter->ParticleTemplate = particleEnt;
+	
+	auto transform = m_World->AddComponent<Components::Transform>(explosion);
+	transform->Position = _pos;
+	transform->Orientation = _relativeUpOri;
+	
+	SpawnParticles(explosion);
+	m_ExplosionEmitters[explosion] = glfwGetTime();
+}
+
+bool Systems::ParticleSystem::OnKeyUp(const Events::KeyUp &e)
+{
+	if(!tempSpawnedExplosions)
+	{
+		if (e.KeyCode == GLFW_KEY_B)
+		{
+			tempSpawnedExplosions = true;
+			CreateExplosion(
+				glm::vec3(0, 10, 0),
+				0.5,
+				60,
+				"Textures/Sprites/NewtonTreeDeleteASAPPlease.png",
+				glm::angleAxis(glm::pi<float>()/2, glm::vec3(1,0,0)),
+				40,
+				glm::pi<float>(),
+				0.5f
+				);
+		}
+	}
+	return true;
+}

src/Systems/ParticleSystem.h

@@ -6,8 +6,9 @@
 #include "Components/Transform.h"
 #include "Components/ParticleEmitter.h"
 #include "Components/Particle.h"
-#include "Components/Model.h"
+#include "Components/Sprite.h"
-#include "Components/PointLight.h"
+#include "EventBroker.h"
+#include "Events/KeyUp.h"
 #include "Color.h"
 #include <GLFW/glfw3.h>
 
@@ -33,6 +34,11 @@ public:
 	void Update(double dt) override;
 	void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 	void Initialize() override;
+
+	void CreateExplosion(glm::vec3 _pos, double _lifeTime, int _particlesToSpawn, std::string _spritePath, glm::quat _relativeUpOri, float _speed, float _spreadAngle, float _particleScale);
+
+	virtual bool OnCommand(const Events::KeyUp &event) { return false; }
+
 private:
 	void SpawnParticles(EntityID emitterID);
 	float RandomizeAngle(float spreadAngle);
@@ -43,8 +49,13 @@ private:
 	void Billboard();
 	std::map<EntityID, std::list<ParticleData>> m_ParticleEmitter;
 	std::map<EntityID, double> m_TimeSinceLastSpawn;
+	std::map<EntityID, double> m_ExplosionEmitters;
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
 
+	bool tempSpawnedExplosions;
+	
+	EventRelay<Events::KeyUp> m_EKeyUp;
+	bool OnKeyUp(const Events::KeyUp &e);
 
 };
 

src/Systems/PhysicsSystem.cpp

@@ -78,7 +78,7 @@ void Systems::PhysicsSystem::Initialize()
 		worldInfo.m_broadPhaseBorderBehaviour = hkpWorldCinfo::BROADPHASE_BORDER_DO_NOTHING;
 
 		// You must specify the size of the broad phase - objects should not be simulated outside this region
-		worldInfo.setBroadPhaseWorldSize(1000.0f);
+		worldInfo.setBroadPhaseWorldSize(1500.0f);
 		m_PhysicsWorld = new hkpWorld(worldInfo);
 
 		// When the simulation type is SIMULATION_TYPE_MULTITHREADED, in the debug build, the sdk performs checks
@@ -107,7 +107,7 @@ void Systems::PhysicsSystem::Initialize()
 
 		m_PhysicsWorld->unmarkForWrite();
 
-		m_collisionResolution = new MyCollisionResolution;
+		m_collisionResolution = new MyCollisionResolution(this);
 	}
 
 }
@@ -326,7 +326,7 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 				rigidBody->addContactListener( m_collisionResolution );
 				m_Vehicles[entity]->addToWorld(m_PhysicsWorld);
 				m_RigidBodies[entity] = rigidBody;
-				m_collisionResolution->m_RigidBodies[rigidBody] = entity;
+				m_RigidBodyEntities[rigidBody] = entity;
 
 
 				// The vehicle is an action
@@ -344,7 +344,7 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 				rigidBody->addContactListener( m_collisionResolution );
 				m_PhysicsWorld->addEntity(rigidBody);
 				m_RigidBodies[entity] = rigidBody;
-				m_collisionResolution->m_RigidBodies[rigidBody] = entity;
+				m_RigidBodyEntities[rigidBody] = entity;
 				m_PhysicsWorld->unmarkForWrite();
 
 				shape->removeReference();
@@ -397,7 +397,7 @@ void Systems::PhysicsSystem::OnEntityCommit( EntityID entity )
 			m_PhysicsWorld->markForWrite();
 			m_PhysicsWorld->addEntity(rigidBody);
 			m_RigidBodies[entity] = rigidBody;
-			m_collisionResolution->m_RigidBodies[rigidBody] = entity;
+			m_RigidBodyEntities[rigidBody] = entity;
 			m_PhysicsWorld->unmarkForWrite();
 
 			shape->removeReference();
@@ -577,3 +577,17 @@ bool Systems::PhysicsSystem::OnApplyPointImpulse( const Events::ApplyPointImpuls
 	m_PhysicsWorld->unmarkForWrite();
 	return true;
 }
+
+void Systems::PhysicsSystem::OnEntityRemoved( EntityID entity )
+{
+	// TODO:
+	/*auto rigidBodyIt = m_RigidBodies.find(entity);
+	if (rigidBodyIt == m_RigidBodies.end())
+		return;
+
+	auto rigidBody = rigidBodyIt->second;
+	m_RigidBodies.erase(entity);
+	m_RigidBodyEntities.erase(rigidBody);
+	rigidBody->removeReference();*/
+
+}

src/Systems/PhysicsSystem.h

@@ -27,6 +27,7 @@
 #include "Events/SetVelocity.h"
 #include "Events/ApplyForce.h"
 #include "Events/ApplyPointImpulse.h"
+#include "Events/Collision.h"
 #include "OBJ.h"
 
 // Math and base include
@@ -75,27 +76,45 @@
 
 #include <Physics2012/Dynamics/Collide/ContactListener/hkpContactListener.h>
 
-class MyCollisionResolution: public hkReferencedObject, public hkpContactListener
+#include "Components/Model.h"
-{
-public:
-	std::unordered_map<hkpRigidBody*, EntityID> m_RigidBodies;
-
-	virtual void contactPointCallback( const hkpContactPointEvent& event ) 
-	{
-		
-		EntityID entity1 = m_RigidBodies[event.getBody(0)];
-		EntityID entity2 = m_RigidBodies[event.getBody(1)];
-		//LOG_INFO("Entities colliding: %i, %i ", entity1, entity2);
-
-	}
-};
-
-
 namespace Systems
 {
 class PhysicsSystem : public System
 {
 public:
+	class MyCollisionResolution: public hkReferencedObject, public hkpContactListener
+	{
+	public:
+
+		MyCollisionResolution(Systems::PhysicsSystem* physicsSystem)
+			: m_PhysicsSystem(physicsSystem) { }
+
+		virtual void contactPointCallback( const hkpContactPointEvent& event ) 
+		{
+			EntityID entity1 = m_PhysicsSystem->m_RigidBodyEntities[event.getBody(0)];
+			EntityID entity2 = m_PhysicsSystem->m_RigidBodyEntities[event.getBody(1)];
+
+			Events::Collision e;
+			e.Entity1 = entity1;
+			e.Entity2 = entity2;
+			m_PhysicsSystem->EventBroker->Publish(e);
+
+			auto modelComponent = m_PhysicsSystem->m_World->GetComponent<Components::Model>(entity1);
+
+			if (modelComponent && modelComponent->ModelFile == "Models/Placeholders/rocket/Rocket.obj" && entity2 == 6)
+			{
+				m_PhysicsSystem->m_PhysicsWorld->markForWrite();
+				m_PhysicsSystem->m_RigidBodies[entity1]->setPosition(hkVector4(2000, -2000, 2000));
+				m_PhysicsSystem->m_PhysicsWorld->unmarkForWrite();
+			}
+		}
+
+	private:
+		Systems::PhysicsSystem* m_PhysicsSystem;
+	};
+
+	friend class MyCollisionResolution;
+
 	PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
 		: System(world, eventBroker) { }
 
@@ -107,6 +126,7 @@ public:
 	void OnComponentCreated(std::string type, std::shared_ptr<Component> component) override;
 	void OnComponentRemoved(std::string type, Component* component) override;
 	void OnEntityCommit(EntityID entity) override;
+	void OnEntityRemoved(EntityID entity) override;
 
 private:
 	double m_Accumulator;
@@ -132,6 +152,7 @@ private:
 	void SetupPhysics(hkpWorld* physicsWorld);
 	
 	std::unordered_map<EntityID, hkpRigidBody*> m_RigidBodies;
+	std::unordered_map<hkpRigidBody*, EntityID> m_RigidBodyEntities;
 	
 	hkJobThreadPool* m_ThreadPool;
 	hkJobQueue* m_JobQueue;

src/Systems/TankSteeringSystem.cpp

@@ -11,6 +11,8 @@ void Systems::TankSteeringSystem::RegisterComponents( ComponentFactory* cf )
 
 void Systems::TankSteeringSystem::Initialize()
 {
+	EVENT_SUBSCRIBE_MEMBER(m_ECollision, &Systems::TankSteeringSystem::OnCollision);
+
 	for (int i = 0; i < 4; i++)
 	{
 		m_TankInputControllers[i] = std::shared_ptr<TankSteeringInputController>(new TankSteeringInputController(EventBroker, i + 1));
@@ -93,6 +95,32 @@ void Systems::TankSteeringSystem::UpdateEntity(double dt, EntityID entity, Entit
 	}
 }
 
+bool Systems::TankSteeringSystem::OnCollision( const Events::Collision &e )
+{
+	// TODO:
+	auto modelComponent = m_World->GetComponent<Components::Model>(e.Entity1);
+
+	if (modelComponent && modelComponent->ModelFile == "Models/Placeholders/rocket/Rocket.obj")
+	{
+		auto transform = m_World->GetComponent<Components::Transform>(e.Entity1);
+		m_World->GetSystem<Systems::ParticleSystem>()->CreateExplosion(
+			transform->Position,
+			1,
+			60,
+			"Textures/Sprites/NewtonTreeDeleteASAPPlease.png",
+			glm::angleAxis(glm::pi<float>()/2, glm::vec3(1,0,0)),
+			40,
+			glm::pi<float>(),
+			0.5f
+			);
+		//m_World->RemoveEntity(e.Entity1);
+	}
+
+	//LOG_INFO("Ent1 %i Ent2 %i", e.Entity1, e.Entity2);
+
+	return true;
+}
+
 void Systems::TankSteeringSystem::TankSteeringInputController::Update( double dt )
 {
 	PositionX = m_Horizontal;

src/Systems/TankSteeringSystem.h

@@ -5,6 +5,7 @@
 #include "Events/SetVelocity.h"
 #include "Events/ApplyForce.h"
 #include "Events/ApplyPointImpulse.h"
+#include "Events/Collision.h"
 #include "Components/Transform.h"
 #include "Components/TankSteering.h"
 #include "Components/TowerSteering.h"
@@ -12,7 +13,9 @@
 #include "Components/Physics.h"
 #include "Components/Vehicle.h"
 #include "Components/Player.h"
+#include "Components/Model.h"
 #include "Systems/TransformSystem.h"
+#include "Systems/ParticleSystem.h"
 #include "InputController.h"
 
 namespace Systems
@@ -31,6 +34,9 @@ namespace Systems
 		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;
 
 	private:
+		EventRelay<Events::Collision> m_ECollision;
+		bool OnCollision(const Events::Collision &e);
+
 		class TankSteeringInputController;
 		std::array<std::shared_ptr<TankSteeringInputController>, 4> m_TankInputControllers;
 

src/World.cpp

@@ -83,6 +83,12 @@ void World::RemoveEntity(EntityID entity)
 			m_EntitiesToRemove.push_back(pair.first);
 		}
 	}
+	// Trigger events
+	for (auto pair : m_Systems)
+	{
+		auto system = pair.second;
+		system->OnEntityRemoved(entity);
+	}
 }
 
 void World::ProcessEntityRemovals()

vs11/Returngeance/Returngeance.vcxproj

@@ -163,6 +163,7 @@
     <ClInclude Include="..\..\src\Events\BindGamepadButton.h" />
     <ClInclude Include="..\..\src\Events\BindKey.h" />
     <ClInclude Include="..\..\src\Events\BindMouseButton.h" />
+    <ClInclude Include="..\..\src\Events\Collision.h" />
     <ClInclude Include="..\..\src\Events\GamepadAxis.h" />
     <ClInclude Include="..\..\src\Events\GamepadButton.h" />
     <ClInclude Include="..\..\src\Events\InputCommand.h" />

vs11/Returngeance/Returngeance.vcxproj.filters

@@ -397,6 +397,9 @@
     <ClInclude Include="..\..\src\Components\Player.h">
       <Filter>Gameplay\Components</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\src\Events\Collision.h">
+      <Filter>Physics\Events</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\src\Shaders\Fragment2.glsl">