Changed System to take World through constructor and store it instead, cause it makes more sense.

src/Engine/Collision/CollidableOctreeSystem.cpp

@@ -1,11 +1,11 @@
 #include "Collision/CollidableOctreeSystem.h"
 
-void CollidableOctreeSystem::Update(World* world, double dt)
+void CollidableOctreeSystem::Update(double dt)
 {
     m_Octree->ClearDynamicObjects();
 }
 
-void CollidableOctreeSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void CollidableOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     if (entity.HasComponent("AABB")) {
         boost::optional<AABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);

src/Engine/Collision/CollisionSystem.cpp

@@ -2,7 +2,7 @@
 #include "Collision/CollisionSystem.h"
 #include "Core/AABB.h"
 
-void CollisionSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     if (!entity.HasComponent("Physics")) {
         return;

src/Engine/Collision/TriggerSystem.cpp

@@ -3,10 +3,10 @@
 #include "Core/AABB.h"
 #include "Rendering/Model.h"
 
-void TriggerSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void TriggerSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     //Currently only players can trigger things.
-    auto players = world->GetComponents("Player");
+    auto players = m_World->GetComponents("Player");
     if (players == nullptr) {
         return;
     }
@@ -18,7 +18,7 @@ void TriggerSystem::UpdateComponent(World* world, EntityWrapper& entity, Compone
     }
     for (auto& pc : *players) {
         EntityID pId = pc.EntityID;
-        boost::optional<AABB> playerBox = Collision::EntityAbsoluteAABB(EntityWrapper(world, pId));
+        boost::optional<AABB> playerBox = Collision::EntityAbsoluteAABB(EntityWrapper(m_World, pId));
         //The player can't trigger anything without an AABB.
         if (!playerBox) {
             continue;

src/Engine/Core/UniformScaleSystem.cpp

@@ -1,13 +1,13 @@
 #include "Core/UniformScaleSystem.h"
 
-UniformScaleSystem::UniformScaleSystem(EventBroker* eventBroker) 
-    : System(eventBroker)
+UniformScaleSystem::UniformScaleSystem(World* world, EventBroker* eventBroker) 
+    : System(world, eventBroker)
     , PureSystem("UniformScale")
 {
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &UniformScaleSystem::OnSetCamera);
 }
 
-void UniformScaleSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt)
+void UniformScaleSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt)
 {
     if (!m_Camera.Valid()) {
         return;

src/Engine/Editor/EditorRenderSystem.cpp

@@ -1,7 +1,7 @@
 #include "Editor/EditorRenderSystem.h"
 
-EditorRenderSystem::EditorRenderSystem(EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(eventBroker)
+EditorRenderSystem::EditorRenderSystem(World* m_World, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(m_World, eventBroker)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {
@@ -10,7 +10,7 @@ EditorRenderSystem::EditorRenderSystem(EventBroker* eventBroker, IRenderer* rend
     m_EditorCamera = new Camera((float)resolution.Width / resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
 }
 
-void EditorRenderSystem::Update(World* world, double dt)
+void EditorRenderSystem::Update(double dt)
 {
     if (m_CurrentCamera) {
         ComponentWrapper cameraTransform = m_CurrentCamera["Transform"];
@@ -23,7 +23,7 @@ void EditorRenderSystem::Update(World* world, double dt)
     scene.Camera = m_EditorCamera;
     scene.Viewport = Rectangle(1920, 1080);
 
-    auto models = world->GetComponents("Model");
+    auto models = m_World->GetComponents("Model");
     if (models != nullptr) {
         for (auto& cModel : *models) {
             if (!(bool)cModel["Visible"]) {
@@ -45,7 +45,7 @@ void EditorRenderSystem::Update(World* world, double dt)
                 }
             }
 
-            EntityWrapper entity(world, cModel.EntityID);
+            EntityWrapper entity(m_World, cModel.EntityID);
             glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
                 std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, nullptr, modelMatrix, matGroup, cModel, entity.World);
@@ -54,7 +54,7 @@ void EditorRenderSystem::Update(World* world, double dt)
         }
     }
 
-    auto pointLights = world->GetComponents("PointLight");
+    auto pointLights = m_World->GetComponents("PointLight");
     if (pointLights != nullptr) {
         for (auto& cPointLight : *pointLights) {
             bool visible = cPointLight["Visible"];
@@ -62,7 +62,7 @@ void EditorRenderSystem::Update(World* world, double dt)
                 continue;
             }
 
-            EntityWrapper entity(world, cPointLight.EntityID);
+            EntityWrapper entity(m_World, cPointLight.EntityID);
             ComponentWrapper& cTransform = entity["Transform"];
             std::shared_ptr<PointLightJob> pointLightJob = std::make_shared<PointLightJob>(cTransform, cPointLight, entity.World);
             scene.PointLightJobs.push_back(pointLightJob);

src/Engine/Editor/EditorSystem.cpp

@@ -2,13 +2,13 @@
 #include "Core/UniformScaleSystem.h"
 #include "Editor/EditorRenderSystem.h"
 
-EditorSystem::EditorSystem(EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(eventBroker)
+EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(world, eventBroker)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {
     m_EditorWorld = new World();
-    m_EditorWorldSystemPipeline = new SystemPipeline(eventBroker);
+    m_EditorWorldSystemPipeline = new SystemPipeline(m_EditorWorld, eventBroker);
     m_EditorWorldSystemPipeline->AddSystem<UniformScaleSystem>(0);
     m_EditorWorldSystemPipeline->AddSystem<EditorRenderSystem>(1, m_Renderer, m_RenderFrame);
     
@@ -45,11 +45,11 @@ EditorSystem::~EditorSystem()
     delete m_EditorWorld;
 }
 
-void EditorSystem::Update(World* world, double dt)
+void EditorSystem::Update(double dt)
 {
-    m_EditorWorldSystemPipeline->Update(m_EditorWorld, dt);
+    m_EditorWorldSystemPipeline->Update(dt);
 
-    m_EditorGUI->Draw(world);
+    m_EditorGUI->Draw(m_World);
     m_EditorStats->Draw(dt);
 
     m_DebugCameraInputController->Update(dt);

src/Engine/Editor/EditorSystemOld.cpp

@@ -2,8 +2,8 @@
 #define IMGUI_DEFINE_MATH_OPERATORS
 #include <imgui/imgui_internal.h>
 
-EditorSystemOld::EditorSystemOld(EventBroker* eventBroker, IRenderer* renderer) 
-    : System(eventBroker)
+EditorSystemOld::EditorSystemOld(World* world, EventBroker* eventBroker, IRenderer* renderer) 
+    : System(world, eventBroker)
     , ImpureSystem()
     , m_Renderer(renderer)
 {
@@ -23,10 +23,8 @@ EditorSystemOld::EditorSystemOld(EventBroker* eventBroker, IRenderer* renderer)
     EVENT_SUBSCRIBE_MEMBER(m_EFileDropped, &EditorSystemOld::OnFileDropped);
 }
 
-void EditorSystemOld::Update(World* world, double dt)
+void EditorSystemOld::Update(double dt)
 {
-    m_World = world;
-
     if (!m_Enabled) {
         return;
     }
@@ -37,7 +35,7 @@ void EditorSystemOld::Update(World* world, double dt)
     Picking();
     updateWidget();
 
-    drawUI(world, dt);
+    drawUI(m_World, dt);
 
     // Clear drop queue if it wasn't handled by any UI element
     if (!m_LastDroppedFile.empty()) {

src/Engine/Rendering/RenderSystem.cpp

@@ -1,7 +1,7 @@
 #include "Rendering/RenderSystem.h"
 
-RenderSystem::RenderSystem(EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame)
-    : System(eventBroker)
+RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(world, eventBroker)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {
@@ -29,9 +29,9 @@ bool RenderSystem::OnSetCamera(Events::SetCamera& e)
     return true;
 }
 
-void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
+void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs)
 {
-    auto models = world->GetComponents("Model");
+    auto models = m_World->GetComponents("Model");
     if (models == nullptr) {
         return;
     }
@@ -60,17 +60,17 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World
             }
         }
 
-        glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, world);
+        glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, m_World);
         for (auto matGroup : model->MaterialGroups()) {
-            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, matGroup, modelComponent, world));
+            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, matGroup, modelComponent, m_World));
             jobs.push_back(modelJob);
         }
     }
 }
 
-void RenderSystem::fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
+void RenderSystem::fillLight(std::list<std::shared_ptr<RenderJob>>& jobs)
 {
-    auto pointLights = world->GetComponents("PointLight");
+    auto pointLights = m_World->GetComponents("PointLight");
     if (pointLights == nullptr) {
         return;
     }
@@ -80,7 +80,7 @@ void RenderSystem::fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World*
         if (!visible) {
             continue;
         }
-        auto transformC = world->GetComponent(pointlightC.EntityID, "Transform");
+        auto transformC = m_World->GetComponent(pointlightC.EntityID, "Transform");
         if (&transformC == nullptr) {
             return;
         }
@@ -95,9 +95,8 @@ bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
     return false;
 }
 
-void RenderSystem::Update(World* world, double dt)
+void RenderSystem::Update(double dt)
 {
-    m_World = world;
     m_EventBroker->Process<RenderSystem>();
 
     if (m_CurrentCamera) {
@@ -110,8 +109,8 @@ void RenderSystem::Update(World* world, double dt)
     RenderScene scene;
     scene.Camera = m_Camera;
     scene.Viewport = Rectangle(1280, 720);
-    fillModels(scene.ForwardJobs, world);
-    fillLight(scene.PointLightJobs, world);
+    fillModels(scene.ForwardJobs);
+    fillLight(scene.PointLightJobs);
     m_RenderFrame->Add(scene);
    
 }

src/Game/Game.cpp

@@ -71,7 +71,7 @@ Game::Game(int argc, char* argv[])
     m_OctreeCollision = new Octree(AABB(glm::vec3(-100), glm::vec3(100)), 4);
     m_OctreeFrustrumCulling = new Octree(AABB(glm::vec3(-100), glm::vec3(100)), 4);
     // Create system pipeline
-    m_SystemPipeline = new SystemPipeline(m_EventBroker);
+    m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker);
 
     // All systems with orderlevel 0 will be updated first.
     unsigned int updateOrderLevel = 0;
@@ -143,7 +143,7 @@ void Game::Tick()
         m_ClientOrServer->Update();
     }
     // Iterate through systems and update world!
-    m_SystemPipeline->Update(m_World, dt);
+    m_SystemPipeline->Update(dt);
     debugTick(dt);
     m_Renderer->Update(dt);
     m_EventBroker->Process<Client>();

src/Game/Systems/HealthSystem.cpp

@@ -1,7 +1,7 @@
 #include "Systems/HealthSystem.h"
 
-HealthSystem::HealthSystem(EventBroker* eventBroker)
-    : System(eventBroker)
+HealthSystem::HealthSystem(World* m_World, EventBroker* eventBroker)
+    : System(m_World, eventBroker)
     , PureSystem("Health")
 {
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
@@ -9,10 +9,10 @@ HealthSystem::HealthSystem(EventBroker* eventBroker)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerHealthPickup, &HealthSystem::OnPlayerHealthPickup);
 }
 
-void HealthSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     //if entityID of health is 9 then the players ID is also 9 (player,health are connected to the same entity)
-    ComponentWrapper player = world->GetComponent(component.EntityID, "Player");
+    ComponentWrapper player = m_World->GetComponent(component.EntityID, "Player");
     double maxHealth = (double)component["MaxHealth"];
 
     //process the DeltaHealthVector and change the entitys health accordingly

src/Game/Systems/PlayerMovementSystem.cpp

@@ -1,6 +1,6 @@
 #include "Systems/PlayerMovementSystem.h"
 
-void PlayerMovementSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     ComponentWrapper& cTransform = entity["Transform"];
     if (!entity.HasComponent("Physics")) {

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,21 +1,21 @@
 #include "Systems/PlayerSpawnSystem.h"
 
-PlayerSpawnSystem::PlayerSpawnSystem(EventBroker* eventBroker) 
-    : System(eventBroker)
+PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker) 
+    : System(m_World, eventBroker)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
 }
 
-void PlayerSpawnSystem::Update(World* world, double dt)
+void PlayerSpawnSystem::Update(double dt)
 {
-    auto playerSpawns = world->GetComponents("PlayerSpawn");
+    auto playerSpawns = m_World->GetComponents("PlayerSpawn");
     if (playerSpawns == nullptr) {
         return;
     }
 
     for (auto& team : m_SpawnRequests) {
         for (auto& cPlayerSpawn : *playerSpawns) {
-            EntityWrapper spawner(world, cPlayerSpawn.EntityID);
+            EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
             if (!spawner.HasComponent("Spawner")) {
                 continue;
             }

src/Game/Systems/PlayerSystem.cpp

@@ -1,6 +1,6 @@
 #include "Systems/PlayerSystem.h"
 
-void PlayerSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
+void PlayerSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     component["Velocity"] = glm::vec3(0.f, 0.f, 0.f);
     if ((bool&)component["Forward"] == true) {
@@ -18,7 +18,7 @@ void PlayerSystem::UpdateComponent(World* world, EntityWrapper& entity, Componen
     }
 
     if ((glm::vec3)component["Velocity"] != glm::vec3(0.f)) {
-        ComponentWrapper& transform = world->GetComponent(component.EntityID, "Transform");
+        ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
         (glm::vec3&)transform["Position"] += (glm::vec3)component["Velocity"];
     }
 }

src/Game/Systems/SpawnerSystem.cpp

@@ -1,6 +1,7 @@
 #include "Systems/SpawnerSystem.h"
 
-SpawnerSystem::SpawnerSystem(EventBroker* eventBroker) : System(eventBroker)
+SpawnerSystem::SpawnerSystem(World* world, EventBroker* eventBroker) 
+    : System(world, eventBroker)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnSpawnerSpawn, &SpawnerSystem::OnSpawnerSpawn);
 }

src/Tests/HealthSystemTest.cpp

@@ -102,7 +102,7 @@ void GameHealthSystemTest::Tick()
     m_LastTime = currentTime;
 
     // Iterate through systems and update world!
-    m_SystemPipeline->Update(m_World, dt);
+    m_SystemPipeline->Update(dt);
 
     m_EventBroker->Swap();
     m_EventBroker->Clear();

src/Tests/OctTreeTestGameClass.cpp

@@ -179,7 +179,7 @@ void Game::Tick()
 #endif
 
     // Iterate through systems and update world!
-    m_SystemPipeline->Update(m_World, dt);
+    m_SystemPipeline->Update(dt);
     m_Renderer->Update(dt);
 
     m_RenderQueueFactory->Update(m_World);