What is this I don't even *falls asleep*

src/GUI/GameFrame.h

@@ -6,6 +6,8 @@
 #include "GUI/Viewport.h"
 #include "GUI/TextureFrame.h"
 
+#include "Events/Damage.h"
+
 #include "GameWorld.h"
 
 namespace GUI
@@ -17,6 +19,8 @@ public:
 	GameFrame(Frame* parent, std::string name)
 		: Frame(parent, name)
 	{
+		EVENT_SUBSCRIBE_MEMBER(m_EDamage, &GameFrame::OnDamage);
+
 		m_World = std::make_shared<GameWorld>(EventBroker, ResourceManager);
 		auto worldFrame = new WorldFrame(this, "GameWorldFrame", m_World);
 		{
@@ -27,16 +31,30 @@ public:
 			vp2->X = vp1->Right();
 			vp2->Width = 640;
 
-			auto tex = new TextureFrame(vp1, "TextureFrameThingy");
+			tex = new TextureFrame(vp1, "TextureFrameThingy");
 			tex->SetTexture("Textures/GUI/hurt.png");
 		}
 		m_World->Initialize();
 	}
 
+	void Update(double dt)
+	{
+
+	}
+
+	bool OnDamage(const Events::Damage &event)
+	{
+		//tex->SetTexture("Textures/GUI/hurt.png");
+
+		return false;
+	}
+
 private:
+	EventRelay<Frame, Events::Damage> m_EDamage;
 	std::shared_ptr<GameWorld> m_World;
 	Viewport* vp1;
 	Viewport* vp2;
+	TextureFrame* tex;
 };
 
 }

src/GameWorld.cpp

@@ -55,12 +55,6 @@ void GameWorld::Initialize()
 		cameraComp->FarClip = 2000.f;
 		auto freeSteering = AddComponent<Components::FreeSteering>(camera);
 	}
-	{
-		Events::SetViewportCamera e;
-		e.CameraEntity = camera;
-		e.ViewportFrame = "Viewport2";
-		EventBroker->Publish(e);
-	}
 	
 
 	auto player1 = CreateEntity();
@@ -106,27 +100,61 @@ void GameWorld::Initialize()
 	{
 		auto ground = CreateEntity();
 		auto transform = AddComponent<Components::Transform>(ground);
-		transform->Position = glm::vec3(0, -5, 0);
+		transform->Position = glm::vec3(0, -50, 0);
-		transform->Scale = glm::vec3(1600.0f, 10.0f, 1600.0f);
+		//transform->Scale = glm::vec3(400.0f, 10.0f, 400.0f);
 		transform->Orientation = glm::quat(glm::vec3(0.0f, 0.0f, 0.0f));
 		auto model = AddComponent<Components::Model>(ground);
-		model->ModelFile = "Models/Placeholders/PhysicsTest/Cube.obj";
+		model->ModelFile = "Models/TestScene3/testScene.obj";
+		//model->ModelFile = "Models/Placeholders/Terrain/Terrain2.obj";
 
 		auto physics = AddComponent<Components::Physics>(ground);
 		physics->Mass = 10;
 		physics->Static = true;
+		physics->CollisionLayer = 1;
 
 		auto groundshape = CreateEntity(ground);
 		auto transformshape = AddComponent<Components::Transform>(groundshape);
-		auto box = AddComponent<Components::BoxShape>(groundshape);
+		auto meshShape = AddComponent<Components::MeshShape>(groundshape);
-		box->Width = 800;
+		//meshShape->ResourceName = "Models/Placeholders/Terrain/Terrain2.obj";
-		box->Height = 5;
+		meshShape->ResourceName = "Models/TestScene3/testScene.obj";
-		box->Depth = 800;
+
 
 		CommitEntity(groundshape);
 		CommitEntity(ground);
 	}
 
+	{
+		auto flag = CreateEntity();
+		auto transform = AddComponent<Components::Transform>(flag);
+		transform->Position = glm::vec3(0, -50, 100);
+		auto model = AddComponent<Components::Model>(flag);
+		model->ModelFile = "Models/Flag/FishingRod/FishingRod.obj";
+		{
+			auto fish = CreateEntity(flag);
+			auto transform = AddComponent<Components::Transform>(fish);
+			transform->Position = glm::vec3(-1.3f, 1.0, 0);
+			auto model = AddComponent<Components::Model>(fish);
+			model->ModelFile = "Models/Flag/LeFish/Salmon.obj";
+			CommitEntity(fish);
+		}
+
+		auto trigger = AddComponent<Components::Trigger>(flag);
+		{
+			auto shape = CreateEntity(flag);
+			auto transform = AddComponent<Components::Transform>(shape);
+			transform->Position = glm::vec3(-0.9f, 0.9f, 0);
+			auto box = AddComponent<Components::BoxShape>(shape);
+			box->Width = 1.1f;
+			box->Depth = 0.7f;
+			box->Height = 3.9f;
+			CommitEntity(shape);
+		}
+
+		auto flagComponent = AddComponent<Components::Flag>(flag);
+
+		CommitEntity(flag);
+	}
+
 	//for (int i = 0; i < 500; i++)
 	//{
 	//	auto Light = CreateEntity();
@@ -334,15 +362,19 @@ void GameWorld::Initialize()
 					auto shot = CreateEntity(barrel);
 					auto transform = AddComponent<Components::Transform>(shot);
 					transform->Position = glm::vec3(0.35f, 0.f, -2.f);
-					transform->Orientation = glm::angleAxis(-glm::pi<float>()/2.f, glm::vec3(1, 0, 0));
+					transform->Orientation = glm::angleAxis(-glm::pi<float>() / 2.f, glm::vec3(1, 0, 0));
 					transform->Scale = glm::vec3(3.f);
 					AddComponent<Components::Template>(shot);
 					auto physics = AddComponent<Components::Physics>(shot);
 					physics->Mass = 25.f;
 					physics->Static = false;
+					physics->CollisionEvent = true;
 					auto modelComponent = AddComponent<Components::Model>(shot);
 					modelComponent->ModelFile = "Models/Placeholders/rocket/Rocket.obj";
-
+					auto tankShellComponent = AddComponent<Components::TankShell>(shot);
+					tankShellComponent->Damage = 20.f;
+					tankShellComponent->ExplosionRadius = 30.f;
+					tankShellComponent->ExplosionStrength = 300000.f;
 					{
 						auto shape = CreateEntity(shot);
 						auto transform = AddComponent<Components::Transform>(shape);
@@ -365,7 +397,7 @@ void GameWorld::Initialize()
 			auto cameraTower = CreateEntity(tower);
 			{
 				auto transform = AddComponent<Components::Transform>(cameraTower);
-				transform->Position.z = 11.f;
+				transform->Position.z = 16.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);
@@ -757,15 +789,19 @@ void GameWorld::Initialize()
 					auto shot = CreateEntity(barrel);
 					auto transform = AddComponent<Components::Transform>(shot);
 					transform->Position = glm::vec3(0.35f, 0.f, -2.f);
-					transform->Orientation = glm::angleAxis(-glm::pi<float>()/2.f, glm::vec3(1, 0, 0));
+					transform->Orientation = glm::angleAxis(-glm::pi<float>() / 2.f, glm::vec3(1, 0, 0));
 					transform->Scale = glm::vec3(3.f);
 					AddComponent<Components::Template>(shot);
 					auto physics = AddComponent<Components::Physics>(shot);
 					physics->Mass = 25.f;
 					physics->Static = false;
+					physics->CollisionEvent = true;
 					auto modelComponent = AddComponent<Components::Model>(shot);
 					modelComponent->ModelFile = "Models/Placeholders/rocket/Rocket.obj";
-
+					auto tankShellComponent = AddComponent<Components::TankShell>(shot);
+					tankShellComponent->Damage = 20.f;
+					tankShellComponent->ExplosionRadius = 30.f;
+					tankShellComponent->ExplosionStrength = 300000.f;
 					{
 						auto shape = CreateEntity(shot);
 						auto transform = AddComponent<Components::Transform>(shape);
@@ -796,6 +832,12 @@ void GameWorld::Initialize()
 				//auto freeSteering = AddComponent<Components::FreeSteering>(cameraTower);
 			}
 			CommitEntity(cameraTower);
+			{
+				Events::SetViewportCamera e;
+				e.CameraEntity = cameraTower;
+				e.ViewportFrame = "Viewport2";
+				EventBroker->Publish(e);
+			}
 		}
 
 		//{
@@ -1213,10 +1255,13 @@ void GameWorld::RegisterComponents()
 	m_ComponentFactory.Register<Components::Transform>([]() { return new Components::Transform(); }); 
 	m_ComponentFactory.Register<Components::Template>([]() { return new Components::Template(); });	
 	m_ComponentFactory.Register<Components::Player>([]() { return new Components::Player(); });	
+	m_ComponentFactory.Register<Components::Flag>([]() { return new Components::Flag(); });
 }
 
 void GameWorld::RegisterSystems()
 {
+	m_SystemFactory.Register<Systems::TimerSystem>([this]() { return new Systems::TimerSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::DamageSystem>([this]() { return new Systems::DamageSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::TransformSystem>([this]() { return new Systems::TransformSystem(this, EventBroker, ResourceManager); });
 	//m_SystemFactory.Register<Systems::LevelGenerationSystem>([this]() { return new Systems::LevelGenerationSystem(this); });
 	m_SystemFactory.Register<Systems::InputSystem>([this]() { return new Systems::InputSystem(this, EventBroker, ResourceManager); });
@@ -1228,11 +1273,14 @@ void GameWorld::RegisterSystems()
 	m_SystemFactory.Register<Systems::TankSteeringSystem>([this]() { return new Systems::TankSteeringSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::SoundSystem>([this]() { return new Systems::SoundSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::PhysicsSystem>([this]() { return new Systems::PhysicsSystem(this, EventBroker, ResourceManager); });
+	m_SystemFactory.Register<Systems::TriggerSystem>([this]() { return new Systems::TriggerSystem(this, EventBroker, ResourceManager); });
 	m_SystemFactory.Register<Systems::RenderSystem>([this]() { return new Systems::RenderSystem(this, EventBroker, ResourceManager); });
 }
 
 void GameWorld::AddSystems()
 {
+	AddSystem<Systems::TimerSystem>();
+	AddSystem<Systems::DamageSystem>();
 	AddSystem<Systems::TransformSystem>();
 	//AddSystem<Systems::LevelGenerationSystem>();
 	AddSystem<Systems::InputSystem>();
@@ -1244,6 +1292,7 @@ void GameWorld::AddSystems()
 	AddSystem<Systems::TankSteeringSystem>();
 	AddSystem<Systems::SoundSystem>();
 	AddSystem<Systems::PhysicsSystem>();
+	AddSystem<Systems::TriggerSystem>();
 	AddSystem<Systems::RenderSystem>();
 }
 

src/Renderer.cpp

@@ -578,20 +578,20 @@ void Renderer::AddModelToDraw(Model* model, glm::vec3 position, glm::quat orient
 
 void Renderer::AddTextureToDraw(Texture* texture, glm::vec3 position, glm::quat orientation, glm::vec3 scale)
 {
-	glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
+	//glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
 
-	glm::vec3 camToParticle = glm::normalize(m_Camera->Position() - position);
+	//glm::vec3 camToParticle = glm::normalize(m_Camera->Position() - position);
-	glm::vec3 up = glm::vec3(0,1,0);
+	//glm::vec3 up = glm::vec3(0,1,0);
-	glm::vec3 rightVec = glm::normalize(glm::cross(up, camToParticle));
+	//glm::vec3 rightVec = glm::normalize(glm::cross(up, camToParticle));
-	glm::vec3 up2 = glm::normalize(glm::cross(camToParticle, rightVec));
+	//glm::vec3 up2 = glm::normalize(glm::cross(camToParticle, rightVec));
-	
+	//
-	glm::mat4 billboardMatrix;
+	//glm::mat4 billboardMatrix;
-	billboardMatrix[0] = glm::vec4(rightVec, 0);
+	//billboardMatrix[0] = glm::vec4(rightVec, 0);
-	billboardMatrix[1] = glm::vec4(up2, 0);
+	//billboardMatrix[1] = glm::vec4(up2, 0);
-	billboardMatrix[2] = glm::vec4(camToParticle, 0);
+	//billboardMatrix[2] = glm::vec4(camToParticle, 0);
-	//billboardMatrix[3] = glm::vec4(position, 0);
+	////billboardMatrix[3] = glm::vec4(position, 0);
 
-	TexturesToRender.push_back(std::make_tuple(texture, modelMatrix, billboardMatrix));
+	//TexturesToRender.push_back(std::make_tuple(texture, modelMatrix, billboardMatrix));
 }
 
 void Renderer::AddPointLightToDraw(

src/Systems/DamageSystem.h

@@ -12,8 +12,8 @@ namespace Systems
 	{
 	public:
 
-		DamageSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
+		DamageSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
-			: System(world, eventBroker) { }
+			: System(world, eventBroker, resourceManager) { }
 
 
 		void Initialize() override;

src/Systems/PhysicsSystem.h

@@ -147,8 +147,8 @@ public:
 	};
 	friend class PhantomCallbackShape;
 	
-	PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
+	PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
-		: System(world, eventBroker) { }
+		: System(world, eventBroker, resourceManager) { }
 
 	void RegisterComponents(ComponentFactory* cf) override;
 	void Initialize() override;

src/Systems/TimerSystem.h

@@ -13,8 +13,8 @@ namespace Systems
 	{
 	public:
 
-		TimerSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
+		TimerSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
-			: System(world, eventBroker) { }
+			: System(world, eventBroker, resourceManager) { }
 
 		void RegisterComponents(ComponentFactory* cf) override;
 		void UpdateEntity(double dt, EntityID entity, EntityID parent) override;

src/Systems/TriggerSystem.h

@@ -22,8 +22,8 @@ namespace Systems
 	{
 	public:
 		
-		TriggerSystem(World* world, std::shared_ptr<::EventBroker> eventBroker)
+		TriggerSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr<::ResourceManager> resourceManager)
-			: System(world, eventBroker) { }
+			: System(world, eventBroker, resourceManager) { }
 
 		void Initialize() override;
 		void RegisterComponents(ComponentFactory* cf) override;