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

include/Engine/Collision/CollidableOctreeSystem.h

@@ -8,14 +8,14 @@
 class CollidableOctreeSystem : public ImpureSystem, public PureSystem
 {
 public:
-    CollidableOctreeSystem(EventBroker* eventBroker, Octree* octree)
+    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree* octree)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Collidable")
         , m_Octree(octree)
     { }
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree* m_Octree;

include/Engine/Collision/CollisionSystem.h

@@ -13,8 +13,8 @@
 class CollisionSystem : public PureSystem
 {
 public:
-    CollisionSystem(EventBroker* eventBroker, Octree* octree)
+    CollisionSystem(World* world, EventBroker* eventBroker, Octree* octree)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("AABB")
         , m_Octree(octree)
         , zPress(false)
@@ -23,7 +23,7 @@ public:
         EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &CollisionSystem::OnKeyUp);
     }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree* m_Octree;

include/Engine/Collision/TriggerSystem.h

@@ -14,13 +14,13 @@ class AABB;
 class TriggerSystem : public PureSystem
 {
 public:
-    TriggerSystem(EventBroker* eventBroker, Octree* octree)
+    TriggerSystem(World* world, EventBroker* eventBroker, Octree* octree)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Trigger")
         , m_Octree(octree)
     { }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree* m_Octree;

include/Engine/Core/System.h

@@ -11,14 +11,14 @@ class System
     friend class SystemPipeline;
 
 protected:
-    System()
+    System(World* world, EventBroker) { }
-        : m_EventBroker(nullptr)
+    System(World* world, EventBroker* eventBroker)
-    { }
+        : m_World(world)
-    System(EventBroker* eventBroker)
+        , m_EventBroker(eventBroker)
-        : m_EventBroker(eventBroker)
     { }
     virtual ~System() = default;
 
+    World* m_World;
     EventBroker* m_EventBroker;
 };
 
@@ -34,7 +34,7 @@ protected:
 
     const std::string m_ComponentType;
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) = 0;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt) = 0;
 };
 
 class ImpureSystem : public virtual System
@@ -45,7 +45,7 @@ protected:
     ImpureSystem() = default;
     virtual ~ImpureSystem() = default;
 
-    virtual void Update(World* world, double dt) = 0;
+    virtual void Update(double dt) = 0;
 };
 
 #endif

include/Engine/Core/SystemPipeline.h

@@ -9,9 +9,11 @@
 class SystemPipeline
 {
 public:
-    SystemPipeline(EventBroker* eventBroker)
+    SystemPipeline(World* world, EventBroker* eventBroker)
-        : m_EventBroker(eventBroker)
+        : m_World(world)
+        , m_EventBroker(eventBroker)
     { }
+
     ~SystemPipeline()
     {
         for (UnorderedSystems& group : m_OrderedSystemGroups) {
@@ -29,7 +31,7 @@ public:
             m_OrderedSystemGroups.resize(updateOrderLevel + 1);
         }
         UnorderedSystems& group = m_OrderedSystemGroups[updateOrderLevel];
-        System* system = new T(m_EventBroker, args...);
+        System* system = new T(m_World, m_EventBroker, args...);
         group.Systems[typeid(T).name()] = system;
 
         PureSystem* pureSystem = dynamic_cast<PureSystem*>(system);
@@ -47,7 +49,7 @@ public:
         }
     }
 
-    void Update(World* world, double dt)
+    void Update(double dt)
     {
         for (UnorderedSystems& group : m_OrderedSystemGroups) {
             // Process events
@@ -57,18 +59,18 @@ public:
 
             // Update
             for (auto& system : group.ImpureSystems) {
-                system->Update(world, dt);
+                system->Update(dt);
             }
             for (auto& pair : group.PureSystems) {
                 const std::string& componentName = pair.first;
                 auto& systems = pair.second;
-                const ComponentPool* pool = world->GetComponents(componentName);
+                const ComponentPool* pool = m_World->GetComponents(componentName);
                 if (pool == nullptr) {
                     continue;
                 }
                 for (auto& component : *pool) {
                     for (auto& system : systems) {
-                        system->UpdateComponent(world, EntityWrapper(world, component.EntityID), component, dt);
+                        system->UpdateComponent(EntityWrapper(m_World, component.EntityID), component, dt);
                     }
                 }
             }
@@ -76,7 +78,9 @@ public:
     }
 
 private:
+    World* m_World;
     EventBroker* m_EventBroker;
+
     struct UnorderedSystems
     {
         std::map<std::string, System*> Systems;

include/Engine/Core/UniformScaleSystem.h

@@ -8,9 +8,9 @@
 class UniformScaleSystem : public PureSystem
 {
 public:
-    UniformScaleSystem(EventBroker* eventBroker);
+    UniformScaleSystem(World* world, EventBroker* eventBroker);
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt) override;
 
 private:
     EntityWrapper m_Camera = EntityWrapper::Invalid;

include/Engine/Editor/EditorRenderSystem.h

@@ -10,9 +10,9 @@
 class EditorRenderSystem : public ImpureSystem
 {
 public:
-    EditorRenderSystem(EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
+    EditorRenderSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
     IRenderer* m_Renderer;

include/Engine/Editor/EditorSystem.h

@@ -15,10 +15,10 @@
 class EditorSystem : public ImpureSystem
 {
 public:
-    EditorSystem(EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
+    EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
     ~EditorSystem();
 
-    void Update(World* world, double dt);
+    void Update(double dt);
 
 private:
     IRenderer* m_Renderer;

include/Engine/Editor/EditorSystemOld.h

@@ -18,13 +18,12 @@
 class EditorSystemOld : public ImpureSystem
 {
 public:
-    EditorSystemOld(EventBroker* eventBroker, IRenderer* renderer);
+    EditorSystemOld(World* world, EventBroker* eventBroker, IRenderer* renderer);
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
     IRenderer* m_Renderer;
-    World* m_World = nullptr;
     Camera* m_Camera = nullptr;
 
     bool m_Enabled;

include/Engine/Rendering/RenderSystem.h

@@ -20,13 +20,12 @@
 class RenderSystem : public ImpureSystem
 {
 public:
-    RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
+    RenderSystem(World* world, EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
     ~RenderSystem();
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
-    World* m_World = nullptr;
     const IRenderer* m_Renderer;
     RenderFrame* m_RenderFrame;
     Camera* m_Camera;
@@ -37,8 +36,8 @@ private:
     EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
 
-    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs);
-    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
 };
 
 #endif

include/Game/Systems/HealthSystem.h

@@ -16,10 +16,10 @@
 class HealthSystem : public PureSystem
 {
 public:
-    HealthSystem(EventBroker* eventBroker);
+    HealthSystem(World* world, EventBroker* eventBroker);
 
     //updatecomponent
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     //methods which will take care of specific events

include/Game/Systems/PlayerMovementSystem.h

@@ -5,10 +5,10 @@
 class PlayerMovementSystem : public PureSystem
 {
 public:
-    PlayerMovementSystem(EventBroker* eventBroker)
+    PlayerMovementSystem(World* world, EventBroker* eventBroker)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Player")
     { }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt);
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt);
 };

include/Game/Systems/PlayerSpawnSystem.h

@@ -6,9 +6,9 @@
 class PlayerSpawnSystem : public ImpureSystem
 {
 public:
-    PlayerSpawnSystem(EventBroker* eventBroker);
+    PlayerSpawnSystem(World* world, EventBroker* eventBroker);
 
-    virtual void Update(World* world, double dt) override;
+    virtual void Update(double dt) override;
 
 private:
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;

include/Game/Systems/PlayerSystem.h

@@ -11,8 +11,8 @@
 class PlayerSystem : public PureSystem
 {
 public:
-    PlayerSystem(EventBroker* eventBroker)
+    PlayerSystem(World* world, EventBroker* eventBroker)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("Player")
     {
         EVENT_SUBSCRIBE_MEMBER(m_ETouch, &PlayerSystem::OnTouch);
@@ -20,7 +20,7 @@ public:
         EVENT_SUBSCRIBE_MEMBER(m_ELeave, &PlayerSystem::OnLeave);
     }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 private:
     float m_Speed = 5;
     EventRelay<PlayerSystem, Events::TriggerEnter> m_EEnter;

include/Game/Systems/RaptorCopterSystem.h

@@ -4,14 +4,14 @@
 class RaptorCopterSystem : public PureSystem
 {
 public:
-    RaptorCopterSystem(EventBroker* eventBroker)
+    RaptorCopterSystem(World* world, EventBroker* eventBroker)
-        : System(eventBroker)
+        : System(world, eventBroker)
         , PureSystem("RaptorCopter")
     { }
 
-    virtual void UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
     {
-        ComponentWrapper& transform = world->GetComponent(component.EntityID, "Transform");
+        ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
         (glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
     }
 };

include/Game/Systems/SpawnerSystem.h

@@ -13,7 +13,7 @@
 class SpawnerSystem : public System
 {
 public:
-    SpawnerSystem(EventBroker* eventBroker);
+    SpawnerSystem(World* world, EventBroker* eventBroker);
 
     static EntityWrapper Spawn(EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid);
 

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) 
+UniformScaleSystem::UniformScaleSystem(World* world, EventBroker* eventBroker) 
-    : System(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) 
+EditorRenderSystem::EditorRenderSystem(World* m_World, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(eventBroker)
+    : 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) 
+EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(eventBroker)
+    : 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) 
+EditorSystemOld::EditorSystemOld(World* world, EventBroker* eventBroker, IRenderer* renderer) 
-    : System(eventBroker)
+    : 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)
+RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(eventBroker)
+    : 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);
+    fillModels(scene.ForwardJobs);
-    fillLight(scene.PointLightJobs, world);
+    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)
+HealthSystem::HealthSystem(World* m_World, EventBroker* eventBroker)
-    : System(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) 
+PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker) 
-    : System(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);