Merge branch 'master' of https://github.com/teamfisk/AgileBreakOut

assets/Models/Brick/LifeBuoyBrick.mtl

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

assets/Models/Brick/StickyBrick.mtl

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

include/Core/Engine.h

@@ -201,6 +201,7 @@ public:
 		}
 
 		//Background
+		
 		{
 			auto background = m_World->CreateEntity();
 			auto transform = m_World->AddComponent<Components::Transform>(background);

include/Game/LevelSystem.h

@@ -43,6 +43,8 @@
 #include <fstream>
 #include <iostream>
 
+#include "Physics/ECreateParticleSequence.h"
+
 namespace dd
 {
 

include/Game/LifebuoySystem.h

@@ -53,7 +53,7 @@ private:
 	bool OnPause(const dd::Events::Pause &event);
 	bool OnLifebuoy(const dd::Events::Lifebuoy &event);
 
-	struct LifeBuoyInfo
+	struct LifebuoyInfo
 	{
 		EntityID Entity;
 		float TimeToLive = 15.f;
@@ -61,7 +61,8 @@ private:
 
 	float m_LeftEdge = -3.8f;
 	float m_RightEdge = 3.8f;
-	std::list<LifeBuoyInfo> m_LifeBuoys;
+	float m_DownEdge = -9.2f;
+	std::list<LifebuoyInfo> m_Lifebuoys;
 };
 
 }

include/Physics/CParticleEmitter.h

@@ -9,11 +9,13 @@ namespace Components
 
 struct ParticleEmitter : public Component
 {
+	EntityID Parent = 0;
     int NumberOfTicks = 10.f;
     float InitialSpeed = 1.f;
     double SpawnRate = 1;
     int ParticlesPerTick = 1;
-    double TimeSinceLastSpawn = 0;
+	//TODO: Refactor. Have cooldown instead of this
+    double TimeSinceLastSpawn = 100;
     int MaxCount = 0;
     float EmittingAngle = 0.f;
     float Spread = 0.f;

include/Physics/EContact.h

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

include/Physics/ECreateParticleSequence.h

@@ -22,9 +22,11 @@ struct CreateParticleSequence : public Event
     float Spread = 1.f;
     float EmittingAngle = 0.f;
     float MaxCount = 0;
+	glm::vec4 Color = glm::vec4(0);
+	EntityID parent = 0;
 
     //Particle
-    std::string SpriteFile = "Texures/Core/ErrorTexture.png";
+    std::string SpriteFile = "";
     double ParticleLifeTime = 3.f;
     ParticleFlags::Type Flags = static_cast<ParticleFlags::Type>(ParticleFlags::Powder | ParticleFlags::ParticleContactFilter | ParticleFlags::FixtureContactFilter);
     float Radius = 1.f;

include/Physics/PhysicsSystem.h

@@ -37,6 +37,7 @@
 #include "Game/CBall.h"
 
 #include "Rendering/CSprite.h"
+#include "Rendering/CModel.h"
 
 
 namespace dd
@@ -113,6 +114,8 @@ namespace dd
             bool OnPause(const dd::Events::Pause &event);
 			dd::EventRelay<PhysicsSystem, dd::Events::StageCleared> m_EStageCleared;
 			bool OnStageCleared(const dd::Events::StageCleared &event);
+			dd::EventRelay<PhysicsSystem, dd::Events::Contact> m_EContact;
+			bool OnContact(const dd::Events::Contact &event);
 			bool m_Travelling = false;
 			float m_DistanceTravelled = 0;
 
@@ -173,7 +176,7 @@ namespace dd
         {
             return false;
         }
-
+		
     };
 
 
@@ -196,7 +199,7 @@ namespace dd
         };
 
         DestructionListener* m_DestructionListener;
-        ParticleContactDisabler m_ParticleContactDisabler;
+        ParticleContactDisabler* m_ParticleContactDisabler;
         ContactListener* m_ContactListener;
         };
 

src/game/Core/Renderer.cpp

@@ -440,7 +440,7 @@ void dd::Renderer::DrawScene(RenderQueue &objects, ShaderProgram &program)
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
 			glUniformMatrix4fv(glGetUniformLocation(shaderProgramHandle, "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
-			glUniform4fv(glGetUniformLocation(shaderProgramHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
+			glUniform4fv(glGetUniformLocation(shaderProgramHandle, "Color"), 1, glm::value_ptr(spriteJob->Color));
 
 			glActiveTexture(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, spriteJob->DiffuseTexture);

src/game/Core/Shaders/Forward/Fragment.glsl

@@ -30,6 +30,7 @@ uniform vec3 LightPosition;
 uniform float LightRadius;
 uniform vec3 LightSpecular;
 uniform vec3 LightDiffuse;
+uniform vec4 Color;
 
 in VertexData
 {
@@ -86,5 +87,5 @@ void main()
 	vec4 La = vec4(0.3, 0.3, 0.3, 1.0);
 	vec4 light = phong(Input.Position, normalize(normal), specularTexel.rgb, specularTexel.a);
 	//frag_Diffuse = light;
-	frag_Diffuse = diffuseTexel;
+	frag_Diffuse = diffuseTexel * Color;
 }

src/game/Game/LevelSystem.cpp

@@ -192,20 +192,20 @@ void dd::Systems::LevelSystem::CreateBrick(int row, int line, glm::vec2 spacesBe
     m_World->RemoveComponent<Components::Template>(brick);
     auto transform = m_World->GetComponent<Components::Transform>(brick);
     auto cBrick = m_World->GetComponent<Components::Brick>(brick);
-
     if (typeInt == StandardBrick) {
     } else if (typeInt == MultiBallBrick) {
         cBrick->Type = MultiBallBrick;
         auto model = m_World->GetComponent<Components::Model>(brick);
         model->ModelFile = "Models/Brick/IceBrick.obj";
+		
 	} else if (typeInt == LifebuoyBrick) {
 		cBrick->Type = LifebuoyBrick;
 		auto model = m_World->GetComponent<Components::Model>(brick);
-		model->Color = glm::vec4(1.f, 0.f, 0.f, .0f);
+		model->ModelFile = "Models/Brick/LifeBuoyBrick.obj";
 	} else if (typeInt == StickyBrick) {
 		cBrick->Type = StickyBrick;
 		auto model = m_World->GetComponent<Components::Model>(brick);
-		model->Color = glm::vec4(0.f, 0.f, 1.f, .0f);
+		model->ModelFile = "Models/Brick/StickyBrick.obj";
 	} else if (typeInt == InkBlasterBrick) {
 		cBrick->Type = InkBlasterBrick;
 		auto model = m_World->GetComponent<Components::Model>(brick);
@@ -316,6 +316,7 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
 
         auto transformComponentBrick = m_World->GetComponent<Components::Transform>(entityBrick);
         auto transformComponentBall = m_World->GetComponent<Components::Transform>(entityBall);
+		auto brickModel = m_World->GetComponent<Components::Model>(entityBrick);
 
         Events::SetImpulse e;
         e.Entity = entityBrick;
@@ -334,6 +335,21 @@ bool dd::Systems::LevelSystem::OnContact(const dd::Events::Contact &event)
         es.Score = brick->Score * ball->Combo;
         EventBroker->Publish(es);
 
+		Events::CreateParticleSequence ep;
+		ep.parent = entityBrick;
+		ep.EmitterLifeTime = 1.f;
+		ep.ParticleLifeTime = 1.5f;
+		ep.ParticlesPerTick = 1;
+		ep.SpawnRate = 0.2;
+		ep.EmittingAngle = glm::half_pi<float>();
+		ep.Spread = 1.5f;
+		ep.Position = transformComponentBrick->Position;
+		ep.Radius = 0.05;
+		ep.SpriteFile = "Textures/Particles/FadeBall.png";
+		ep.Color = brickModel->Color + glm::vec4(1);
+		ep.Speed = 50;
+		EventBroker->Publish(ep);
+
         //std::cout << "Combo: " << ball->Combo << std::endl;
         //std::cout << NumberOfBricks() << std::endl;
         //std::cout << "Brick Score: " << brick->Score  << std::endl;

src/game/Game/LifebuoySystem.cpp

@@ -43,20 +43,27 @@ void dd::Systems::LifebuoySystem::Initialize()
 
 void dd::Systems::LifebuoySystem::Update(double dt)
 {
-	for (auto it = m_LifeBuoys.begin(); it != m_LifeBuoys.end();) {
+	for (auto it = m_Lifebuoys.begin(); it != m_Lifebuoys.end();) {
 		it->TimeToLive -= dt;
-		if (it->TimeToLive < 0.f) {
+		auto transformComponent = m_World->GetComponent<Components::Transform>(it->Entity);
+
+		if (transformComponent->Position.y < m_DownEdge) {
 			m_World->RemoveEntity(it->Entity);
-			m_LifeBuoys.erase(it++);
+			m_Lifebuoys.erase(it++);
 		}
 		else {
-			auto transformComponent = m_World->GetComponent<Components::Transform>(it->Entity);
-
+			
 			if (transformComponent->Position.x > m_RightEdge) {
 				transformComponent->Position = glm::vec3(m_LeftEdge + 0.1f, transformComponent->Position.y, transformComponent->Position.z);
-			}
-			else if (transformComponent->Position.x < m_LeftEdge) {
+			} else if (transformComponent->Position.x < m_LeftEdge) {
 				transformComponent->Position = glm::vec3(m_RightEdge - 0.1f, transformComponent->Position.y, transformComponent->Position.z);
+			} else if (it->TimeToLive < 0.f) {
+				auto physicsComponent = m_World->GetComponent<Components::Physics>(it->Entity);
+				physicsComponent->Mask = CollisionLayer::Type::LifeBuoy;
+				physicsComponent->GravityScale = 10.f;
+
+				auto modelComponent = m_World->GetComponent<Components::Model>(it->Entity);
+				modelComponent->Color = glm::vec4(0.5f, 0.5f, 0.5f, 0.f);
 			}
 			++it;
 		}
@@ -101,11 +108,11 @@ bool dd::Systems::LifebuoySystem::OnLifebuoy(const dd::Events::Lifebuoy &event)
 	auto transform = m_World->GetComponent<Components::Transform>(ent);
 	auto physics = m_World->GetComponent<Components::Physics>(ent);
 	physics->CollisionType = CollisionType::Type::Dynamic;
-	transform->Position = glm::vec3(event.Transform->Position.x, transform->Position.y + 2.f, -10.f);
+	transform->Position = glm::vec3(0.f, 0.f, -10.f);
 	transform->Velocity = glm::vec3(20.f, 3.f, 0.f);
-	LifeBuoyInfo info;
+	LifebuoyInfo info;
 	info.Entity = ent;
-	m_LifeBuoys.push_back(info);
+	m_Lifebuoys.push_back(info);
 	
 	return true;
 }

src/game/Physics/ContactListener.cpp

@@ -12,7 +12,11 @@ void dd::Systems::PhysicsSystem::ContactListener::BeginContact(b2Contact* contac
     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);
+	//contact->GetManifold()->points
+	b2Vec2 pos = worldManifold.points[0];
+	glm::vec2 glmPos = glm::vec2(pos.x, pos.y);
+	e.IntersectionPoint = glmPos;
+	m_PhysicsSystem->EventBroker->Publish(e);
 }
 
 void dd::Systems::PhysicsSystem::ContactListener::EndContact(b2Contact* contact)

src/game/Physics/PhysicsSystem.cpp

@@ -15,15 +15,17 @@ void dd::Systems::PhysicsSystem::Initialize()
     m_DestructionListener = new DestructionListener(this);
     m_ContactListener = new ContactListener(this);
     m_PhysicsWorld = new b2World(m_Gravity);
+	m_ParticleContactDisabler = new ParticleContactDisabler();
     m_PhysicsWorld->SetContactListener(m_ContactListener);
-     m_PhysicsWorld->SetContactFilter(&m_ParticleContactDisabler);
-    m_PhysicsWorld->SetDestructionListener(m_DestructionListener);
+	m_PhysicsWorld->SetContactFilter(m_ParticleContactDisabler);
+	m_PhysicsWorld->SetDestructionListener(m_DestructionListener);
 
     InitializeWater();
     EVENT_SUBSCRIBE_MEMBER(m_SetImpulse, &PhysicsSystem::SetImpulse);
     EVENT_SUBSCRIBE_MEMBER(m_EPause, &PhysicsSystem::OnPause);
 	EVENT_SUBSCRIBE_MEMBER(m_EStageCleared, &PhysicsSystem::OnStageCleared);
     EVENT_SUBSCRIBE_MEMBER(m_ECreateParticleSequence, &PhysicsSystem::CreateParticleSequence);
+	EVENT_SUBSCRIBE_MEMBER(m_EContact, &PhysicsSystem::OnContact);
 }
 
 void dd::Systems::PhysicsSystem::InitializeWater()
@@ -261,7 +263,10 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
 		}
 	}
     auto particle = m_World->GetComponent<Components::Particle>(entity);
-    auto pTemplate = m_World->GetComponent<Components::Template>(entity);
+	auto pTemplate = m_World->GetComponent<Components::Template>(entity);
+	
+
+
     if (particle && !pTemplate) {
         particle->LifeTime -= dt;
         if (particle->LifeTime <= 0) {
@@ -280,7 +285,21 @@ void dd::Systems::PhysicsSystem::UpdateEntity(double dt, EntityID entity, Entity
                 m_World->RemoveEntity(entity);
             }
         }
+		auto sprite = m_World->GetComponent<Components::Sprite>(entity);
+		sprite->Color.w = particle->LifeTime;
     }
+
+	auto emitter = m_World->GetComponent<Components::ParticleEmitter>(entity);
+	if (emitter) {
+		EntityID emitterParent = emitter->Parent;
+		if (emitterParent != 0) {
+			auto emitterTransform = m_World->GetComponent<Components::Transform>(entity);
+			auto parentTransform = m_World->GetComponent<Components::Transform>(emitterParent);
+			if (emitterTransform && parentTransform) {
+				emitterTransform->Position = parentTransform->Position;
+			}
+		}
+	}
 }
 
 bool dd::Systems::PhysicsSystem::OnPause(const dd::Events::Pause &event)
@@ -335,6 +354,7 @@ void dd::Systems::PhysicsSystem::OnEntityRemoved(EntityID entity)
         m_BodiesToEntities.erase(it->second);
         m_EntitiesToBodies.erase(entity);
     }
+
 }
 
 
@@ -453,14 +473,14 @@ void dd::Systems::PhysicsSystem::CreateParticleGroup(EntityID e)
 void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 {
     std::vector<EntityID> emittersToDelete;
-    int pSizeTest = 0;
+	int pSizeTest = 0; //For debugging, delete this
+	int psListSize = 0;
     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];
         pSizeTest += ps->GetParticleCount();
-
-
+		psListSize++;
         auto emitter = m_World->GetComponent<Components::ParticleEmitter>(e);
         auto particleTemplate = m_World->GetComponent<Components::Particle>(pt);
         if(!emitter) {
@@ -471,8 +491,8 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
             LOG_INFO("ParticleTemplate Component is nil.");
             continue;
         }
-        auto TempTransform = m_World->GetComponent<Components::Transform>(e);
-        TempTransform->Orientation = glm::rotate(glm::quat(), 3.f, glm::vec3(0.f, 0.f, -1.f));
+        auto emitterTransform = m_World->GetComponent<Components::Transform>(e);
+        emitterTransform->Orientation = glm::rotate(glm::quat(), 3.f, glm::vec3(0.f, 0.f, -1.f));
 
         emitter->TimeSinceLastSpawn += dt;
         emitter->LifeTime -= dt;
@@ -497,20 +517,22 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 
             std::uniform_real_distribution<float> dis(eAngle - halfSpread, eAngle + halfSpread);
             float pAngle = dis(gen);
+			std::uniform_real_distribution<float> dis2(0.3, 1.5);
+			float speedMultiplier = dis2(gen);
             glm::vec2 unitVec = glm::normalize(glm::vec2(glm::cos(pAngle), glm::sin(pAngle)));
-            glm::vec2 vel = unitVec * emitter->Speed;
+			glm::vec2 vel = unitVec * emitter->Speed * (float)dt * speedMultiplier * 0.5f;
             particleDef.velocity = b2Vec2(vel.x, vel.y);
-            particleDef.position = b2Vec2(templateTransform->Position.x, templateTransform->Position.y);
+			particleDef.position = b2Vec2(emitterTransform->Position.x, emitterTransform->Position.y);
 
 
             auto particle = m_World->CloneEntity(pt, 0);
             m_World->RemoveComponent<Components::Template>(particle);
-            auto transform2 = m_World->GetComponent<Components::Transform>(particle);
+			auto transform2 = m_World->GetComponent<Components::Transform>(particle);
 
             std::uniform_real_distribution<float> dist(0, 1);
             float zDistribution = dist(gen);
-            transform2->Position = glm::vec3(transform2->Position.x, transform2->Position.y, -9.5f + zDistribution);
-            transform2->Scale = glm::vec3(particleTemplate->Radius * 2.f, particleTemplate->Radius * 2.f, 1);
+			transform2->Position = glm::vec3(emitterTransform->Position.x, emitterTransform->Position.y, -9.5f + zDistribution);
+			transform2->Scale = glm::vec3(particleTemplate->Radius * 2.f / speedMultiplier, particleTemplate->Radius * 2.f / speedMultiplier, 1);
 
 
             auto b2Particle = ps->CreateParticle(particleDef);
@@ -518,8 +540,25 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
             auto b2ParticleHandle = ps->GetParticleHandleFromIndex(b2Particle);
             m_EntitiesToParticleHandle[i].insert(std::make_pair(particle, b2ParticleHandle));
             m_ParticleHandleToEntities[i].insert(std::make_pair(b2ParticleHandle, particle));
+			
+			
         }
+		
     }
+// 	system("cls");
+// 	std::cout << "Particles living: " << pSizeTest << std::endl;
+// 	std::cout << "particle systems: " << psListSize << std::endl;
+// 	int entHandles = 0;
+// 	for (int i = 0; i < m_EntitiesToParticleHandle.size(); i++)
+// 		entHandles += m_EntitiesToParticleHandle[i].size();
+// 	std::cout << "Entities and handles: " << entHandles << std::endl;
+// 	LOG_INFO("Particles living: %i", pSizeTest);
+// 	LOG_INFO("Particle systems: %i", psListSize);
+// 	int entHandles = 0;
+// 	for (int i = 0; i < m_EntitiesToParticleHandle.size(); i++)
+// 		entHandles += m_EntitiesToParticleHandle[i].size();
+// 	LOG_INFO("Entities and handles: %i", entHandles);
+
 
     for (int i = 0; i < emittersToDelete.size(); i++)
     {
@@ -542,6 +581,8 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
         }
     }
 
+	
+
     int stp = 0;
     for (auto ts : m_EntitiesToParticleHandle)
     {
@@ -552,10 +593,15 @@ void dd::Systems::PhysicsSystem::UpdateParticleEmitters(double dt)
 bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreateParticleSequence &event)
 {
     //Creating Emitter
-    auto emitter = m_World->CreateEntity();
+	EntityID emitter = m_World->CreateEntity();
+
     auto emitterTransform = m_World->AddComponent<Components::Transform>(emitter);
     auto particleEmitter= m_World->AddComponent<Components::ParticleEmitter>(emitter);
 
+	if (event.parent != 0) {
+		particleEmitter->Parent = event.parent;
+	}
+
     emitterTransform->Position = event.Position;
     particleEmitter->GravityScale = event.GravityScale;
     particleEmitter->SpawnRate = event.SpawnRate;
@@ -576,6 +622,7 @@ bool dd::Systems::PhysicsSystem::CreateParticleSequence(const Events::CreatePart
 
         particleTransform->Position = emitterTransform->Position;
         sprite->SpriteFile = event.SpriteFile;
+		sprite->Color = event.Color;
         particleComponent->LifeTime = event.ParticleLifeTime;
         particleComponent->Flags = event.Flags;
         particleComponent->Radius = event.Radius;
@@ -637,6 +684,40 @@ b2ParticleSystem* dd::Systems::PhysicsSystem::CreateParticleSystem(float radius,
     return m_PhysicsWorld->CreateParticleSystem(&m_ParticleSystemDef);
 }
 
+bool dd::Systems::PhysicsSystem::OnContact(const dd::Events::Contact &event)
+{
+	//Check if it is a brick colliding
+	auto brick = m_World->GetComponent<Components::Brick>(event.Entity1);
+	Components::Model* model;
+	
+	if (!brick) {
+		brick = m_World->GetComponent<Components::Brick>(event.Entity2);
+		if (!brick) {
+			return false;
+		}
+		else {
+			model = m_World->GetComponent<Components::Model>(event.Entity2);
+		}
+	}
+	else {
+		model = m_World->GetComponent<Components::Model>(event.Entity1);
+	}
+	Events::CreateParticleSequence e;
+	e.EmitterLifeTime = 4;
+	//- glm::atan(event.Normal.x, event.Normal.y
+	e.EmittingAngle = glm::half_pi<float>();
+	e.Spread = 0.5f;
+	e.NumberOfTicks = 1;
+	e.ParticleLifeTime = 1.f;
+	e.ParticlesPerTick = 15;
+	e.Position = glm::vec3(event.IntersectionPoint.x, event.IntersectionPoint.y, -10);
+	e.Radius = 0.2f;
+	e.SpriteFile = "Textures/Particles/Cloud_Particle.png";
+	e.Color = model->Color + glm::vec4(1);
+	e.Speed = 100;
+	EventBroker->Publish(e);
+	return true;
+}
 
 
 dd::Systems::PhysicsSystem::~PhysicsSystem()