Merge branch 'feature/#297_initialize_systems_in_constructor' into 'develop'

Feature/#297 initialize systems in constructor

See merge request VR-Group/Project_Phoenix!86

library/phx/display_system.hpp

@@ -26,6 +26,7 @@
 #include <memory>
 #include <vector>
 
+#include "phx/engine.hpp"
 #include "phx/export.hpp"
 #include "phx/hmd.hpp"
 #include "phx/system.hpp"
@@ -37,7 +38,6 @@ namespace phx {
 
 class PHOENIX_EXPORT DisplaySystem : public System {
  public:
-  explicit DisplaySystem(Engine* engine);
   DisplaySystem(const DisplaySystem&) = delete;
   DisplaySystem(DisplaySystem&&) = default;
   ~DisplaySystem();
@@ -57,6 +57,9 @@ class PHOENIX_EXPORT DisplaySystem : public System {
   void Update(const FrameTimer::TimeInfo&) override;
 
  protected:
+  explicit DisplaySystem(Engine* engine);
+  friend DisplaySystem* Engine::CreateSystem<DisplaySystem>();
+
   std::unique_ptr<Window> window_;
   std::unique_ptr<HMD> hmd_;
 };

library/phx/engine.cpp

@@ -57,27 +57,19 @@ void Engine::Run() {
 
   frame_timer_.Start();
 
-  InitializeSystems();
   is_running_ = true;
   while (is_running_) UpdateSystems();
-  TerminateSystems();
 }
 
 void Engine::Stop() { is_running_ = false; }
 
 bool Engine::IsRunning() const { return is_running_; }
 
-void Engine::InitializeSystems() {
-  for (auto& system : systems_) system->Initialize();
-}
 void Engine::UpdateSystems() {
   // before updating all systems, update the frame timer
   frame_timer_.Tick();
   for (auto& system : systems_) system->Update(frame_timer_.GetTimeInfo());
 }
-void Engine::TerminateSystems() {
-  for (auto& system : systems_) system->Terminate();
-}
 
 std::string Engine::ToString() const {
   return "(Engine, #Systems: " + std::to_string(systems_.size()) +

library/phx/engine.hpp

@@ -108,9 +108,7 @@ class PHOENIX_EXPORT Engine final : public Loggable {
     return typeid(SystemType) == typeid(system);
   }
 
-  void InitializeSystems();
   void UpdateSystems();
-  void TerminateSystems();
 
   std::vector<std::unique_ptr<System>> systems_;
   bool is_running_ = false;

library/phx/rendering_system.cpp

@@ -47,18 +47,20 @@
 
 namespace phx {
 
-RenderingSystem::RenderingSystem(Engine* engine) : System(engine) {}
+RenderingSystem::RenderingSystem(Engine* engine, DisplaySystem* display_system)
+    : System(engine) {
+  if (!display_system) error("RenderingSystem needs a valid DisplaySystem.");
+  InitializeOpenGL();
+  InitializeRenderTargets();
+  SetupFramegraph();
+}
 
-void RenderingSystem::Initialize() {
+void RenderingSystem::InitializeOpenGL() {
   if (!gl::initialize()) {
     error("Initializing gl failed");
   }
   std::string prefix = "[RenderingSystem] OpenGl Error: ";
   gl::print_error(prefix.c_str());
-
-  InitializeRenderTargets();
-
-  SetupFramegraph();
 }
 
 void RenderingSystem::InitializeRenderTargets() {

library/phx/rendering_system.hpp

@@ -28,6 +28,7 @@
 #include <string>
 #include <vector>
 
+#include "phx/display_system.hpp"
 #include "phx/engine.hpp"
 #include "phx/export.hpp"
 #include "phx/frame_graph.hpp"
@@ -45,7 +46,6 @@ class PHOENIX_EXPORT RenderingSystem : public System {
   RenderingSystem(RenderingSystem&&) = default;
   virtual ~RenderingSystem() = default;
 
-  void Initialize() override;
   void Update(const FrameTimer::TimeInfo& time_info) override;
 
   FrameGraph* GetFrameGraph() const;
@@ -58,11 +58,16 @@ class PHOENIX_EXPORT RenderingSystem : public System {
   RenderTarget* GetRightRenderTarget() const;
   RenderTarget* GetLeftRenderTarget() const;
 
+ protected:
+  RenderingSystem(Engine* engine, DisplaySystem* display_system);
+
  private:
+  void InitializeOpenGL();
   void InitializeRenderTargets();
   void SetupFramegraph();
 
-  friend RenderingSystem* Engine::CreateSystem<RenderingSystem>();
+  template <typename SystemType, typename... SystemArguments>
+  friend SystemType* Engine::CreateSystem(SystemArguments&&... arguments);
   explicit RenderingSystem(Engine* engine);
 
   std::unique_ptr<FrameGraph> frame_graph_;

library/phx/setup.cpp

@@ -45,8 +45,6 @@ std::unique_ptr<Engine> Setup::CreateDefaultEngine() {
   engine->CreateSystem<BehaviorSystem>();
   engine->CreateSystem<InputSystem>()->AddQuitCallback(
       [engine_ptr]() { engine_ptr->Stop(); });
-  engine->CreateSystem<TrackingSystem>();
-  engine->CreateSystem<RenderingSystem>();
 
   auto displaysys = engine->CreateSystem<DisplaySystem>();
   if (HMD::IsHMDPresent()) {
@@ -55,6 +53,8 @@ std::unique_ptr<Engine> Setup::CreateDefaultEngine() {
   } else {
     displaysys->CreateWindow("Phoenix", glm::uvec2(100, 100));
   }
+  engine->CreateSystem<RenderingSystem>(engine->GetSystem<DisplaySystem>());
+  engine->CreateSystem<TrackingSystem>(engine->GetSystem<DisplaySystem>());
 
   return engine;
 }

library/phx/system.hpp

@@ -37,9 +37,7 @@ class PHOENIX_EXPORT System : public Loggable {
   System() = delete;
   virtual ~System() = default;
 
-  virtual void Initialize() {}
   virtual void Update(const FrameTimer::TimeInfo&) {}
-  virtual void Terminate() {}
 
   Engine* GetEngine() const;
 

library/phx/tracking_system.cpp

@@ -26,14 +26,41 @@
 
 #include "display_system.hpp"
 #include "hmd.hpp"
+#include "logger.hpp"
 #include "projection.hpp"
 #include "runtime_component.hpp"
 #include "transform.hpp"
 
 namespace phx {
-TrackingSystem::TrackingSystem(Engine* engine) : System(engine) {}
 
-void TrackingSystem::Initialize() {
+TrackingSystem::TrackingSystem(Engine* engine, DisplaySystem* display_system)
+    : System(engine) {
+  if (!display_system) error("TrackingSystem needs a valid DisplaySystem.");
+  CreateRuntimeEntities();
+}
+
+void TrackingSystem::Update(const FrameTimer::TimeInfo&) {
+  const auto hmd = engine_->GetSystem<DisplaySystem>()->GetHMD();
+  if (hmd == nullptr) return;
+  hmd->UpdateTrackedDevices();
+  const auto head_transformation = hmd->GetHeadTransformation();
+  hmd_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
+      head_transformation);
+  const auto left_eye_transformation = hmd->GetEyeToHeadMatrix(HMD::LEFT_EYE);
+  left_eye_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
+      left_eye_transformation);
+  const auto right_eye_transformation = hmd->GetEyeToHeadMatrix(HMD::RIGHT_EYE);
+  right_eye_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
+      right_eye_transformation);
+
+  left_controller_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
+      hmd->GetLeftControllerTransformation());
+
+  right_controller_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
+      hmd->GetRightControllerTransformation());
+}
+
+void TrackingSystem::CreateRuntimeEntities() {
   const auto hmd = engine_->GetSystem<DisplaySystem>()->GetHMD();
   if (hmd == nullptr) {
     return;
@@ -48,16 +75,19 @@ void TrackingSystem::Initialize() {
     const auto virtual_platform = virtual_platforms[0];
     const auto virtual_platform_transform =
         virtual_platform->GetFirstComponent<Transform>();
+
     hmd_entity_ = scene->CreateEntity();
     hmd_entity_->AddComponent<RuntimeComponent<HEAD>>();
     auto hmd_transform = hmd_entity_->AddComponent<Transform>();
     hmd_transform->SetParent(virtual_platform_transform);
     left_eye_entity_ = scene->CreateEntity();
+
     left_eye_entity_->AddComponent<RuntimeComponent<LEFT_EYE>>();
     auto left_eye_transform = left_eye_entity_->AddComponent<Transform>();
     left_eye_transform->SetParent(hmd_transform);
     left_eye_entity_->AddComponent<Projection>();
     right_eye_entity_ = scene->CreateEntity();
+
     right_eye_entity_->AddComponent<RuntimeComponent<RIGHT_EYE>>();
     auto right_eye_transform = right_eye_entity_->AddComponent<Transform>();
     right_eye_entity_->AddComponent<Projection>();
@@ -78,32 +108,6 @@ void TrackingSystem::Initialize() {
   }
 }
 
-void TrackingSystem::Update(const FrameTimer::TimeInfo&) {
-  const auto hmd = engine_->GetSystem<DisplaySystem>()->GetHMD();
-  if (hmd == nullptr) {
-    return;
-  }
-  hmd->UpdateTrackedDevices();
-  const auto head_transformation = hmd->GetHeadTransformation();
-  if (hmd_entity_ != nullptr) {
-    hmd_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
-        head_transformation);
-    const auto left_eye_transformation = hmd->GetEyeToHeadMatrix(HMD::LEFT_EYE);
-    left_eye_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
-        left_eye_transformation);
-    const auto right_eye_transformation =
-        hmd->GetEyeToHeadMatrix(HMD::RIGHT_EYE);
-    right_eye_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
-        right_eye_transformation);
-
-    left_controller_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
-        hmd->GetLeftControllerTransformation());
-
-    right_controller_entity_->GetFirstComponent<Transform>()->SetLocalMatrix(
-        hmd->GetRightControllerTransformation());
-  }
-}
-
 std::string TrackingSystem::ToString() const { return "Tracking System"; }
 
 }  // namespace phx

library/phx/tracking_system.hpp

@@ -25,6 +25,7 @@
 
 #include <string>
 
+#include "phx/display_system.hpp"
 #include "phx/engine.hpp"
 #include "phx/export.hpp"
 #include "phx/system.hpp"
@@ -41,13 +42,18 @@ class PHOENIX_EXPORT TrackingSystem : public System {
   TrackingSystem& operator=(const TrackingSystem&) = delete;
   TrackingSystem& operator=(TrackingSystem&&) = default;
 
-  void Initialize() override;
   void Update(const FrameTimer::TimeInfo&) override;
 
   std::string ToString() const override;
 
+ protected:
+  TrackingSystem(Engine* engine, DisplaySystem* display_system);
+
  private:
-  friend TrackingSystem* Engine::CreateSystem<TrackingSystem>();
+  void CreateRuntimeEntities();
+
+  template <typename SystemType, typename... SystemArguments>
+  friend SystemType* Engine::CreateSystem(SystemArguments&&... arguments);
   explicit TrackingSystem(Engine* engine);
 
   Entity* hmd_entity_ = nullptr;

tests/CMakeLists.txt

@@ -224,7 +224,7 @@ add_mocked_test(test_geometry_pass MOCK_GLEW MOCK_SDL)
 add_mocked_test(test_rendering_system MOCK_GLEW MOCK_SDL)
 add_mocked_test(test_shader MOCK_GLEW)
 add_mocked_test(test_display_system MOCK_SDL)
-add_mocked_test(test_engine MOCK_SDL MOCK_OPENVR)
+add_mocked_test(test_engine MOCK_SDL MOCK_OPENVR MOCK_GLEW)
 add_mocked_test(test_tracking_system MOCK_SDL MOCK_OPENVR)
 
 add_mocked_test(integration_test_model_rendering MOCK_OPENVR)

tests/src/integration_test_model_rendering.cpp

@@ -114,7 +114,6 @@ SCENARIO(
     auto display_system = engine->GetSystem<phx::DisplaySystem>();
 
     WHEN("We render the scene") {
-      rendering_system->Initialize();
       rendering_system->Update(phx::FrameTimer::TimeInfo());
       display_system->Update(phx::FrameTimer::TimeInfo());
       THEN("the rendering matches our reference image") {
@@ -144,7 +143,6 @@ SCENARIO(
     auto display_system = engine->GetSystem<phx::DisplaySystem>();
 
     WHEN("We render the scene") {
-      rendering_system->Initialize();
       rendering_system->Update(phx::FrameTimer::TimeInfo{});
       display_system->Update(phx::FrameTimer::TimeInfo());
       THEN("the rendering matches our reference image") {

tests/src/integration_test_rendering.cpp

@@ -117,7 +117,6 @@ SCENARIO("We can render a simple triangle", "[phx][phx::Rendering]") {
     material_handle->SetMaterialProxy(material_proxy);
 
     WHEN("We render the scene") {
-      rendering_system->Initialize();
       rendering_system->Update(phx::FrameTimer::TimeInfo{});
       display_system->Update(phx::FrameTimer::TimeInfo{});
       THEN("the rendering matches our reference image") {
@@ -148,7 +147,6 @@ SCENARIO("If no material given a default red one is taken.",
     phx::Transform* transform = triangle->AddComponent<phx::Transform>();
 
     WHEN("We render the scene") {
-      rendering_system->Initialize();
       rendering_system->Update(phx::FrameTimer::TimeInfo{});
       display_system->Update(phx::FrameTimer::TimeInfo{});
       THEN("the rendering matches our reference image") {

tests/src/test_display_system.cpp

@@ -52,8 +52,9 @@ SCENARIO(
         "scope.") {
       REQUIRE_CALL(sdl_mock.Get(), SDL_VideoInit(nullptr)).RETURN(0);
       REQUIRE_CALL(sdl_mock.Get(), SDL_VideoQuit());
-      phx::DisplaySystem displaySystem(nullptr);
-      displaySystem.Initialize();
+      phx::Engine engine;
+      phx::DisplaySystem* displaySystem =
+          engine.CreateSystem<phx::DisplaySystem>();
 
       WHEN("We create a window.") {
         THEN("The window is created.") {
@@ -71,13 +72,13 @@ SCENARIO(
               .RETURN(0);
           REQUIRE_CALL(sdl_mock.Get(), SDL_GL_CreateContext(_))
               .RETURN(reinterpret_cast<SDL_GLContext>(1u));
-          displaySystem.CreateWindow("TestWindow", glm::uvec2(0, 0),
+          displaySystem->CreateWindow("TestWindow", glm::uvec2(0, 0),
                                       glm::uvec2(640, 480));
 
           WHEN("DisplaySystem Update is called") {
             THEN("SDL_GL_SwapWindow is called") {
               REQUIRE_CALL(sdl_mock.Get(), SDL_GL_SwapWindow(_));
-              displaySystem.Update(phx::FrameTimer::TimeInfo());
+              displaySystem->Update(phx::FrameTimer::TimeInfo());
             }
           }
         }

tests/src/test_engine.cpp

@@ -43,6 +43,7 @@ SUPPRESS_WARNINGS_BEGIN
 #include "mocks/openvr_mock.hpp"
 SUPPRESS_WARNINGS_END
 #include "mocks/sdl_mock.hpp"
+#include "mocks/opengl_mock.hpp"
 
 using trompeloeil::_;
 using trompeloeil::ne;
@@ -278,6 +279,7 @@ SCENARIO("An engine provides access to the behaviors", "[phx][phx::Engine]") {
 
 SCENARIO("An engine can be setup by the default setup", "[phx][phx::Engine]") {
   SDL_MOCK_ALLOW_ANY_CALL
+  OPENGL_MOCK_ALLOW_ANY_CALL
   ALLOW_CALL(openvr_mock.Get(), VR_IsHmdPresent()).RETURN(false);
   GIVEN("Nothing") {
     WHEN("An engine is setup with the default setup") {

tests/src/test_rendering_system.cpp

@@ -48,11 +48,11 @@ SCENARIO(
   phx::Engine engine;
 
   GIVEN("A rendering system.") {
+    auto diplay_system = engine.CreateSystem<phx::DisplaySystem>();
     phx::RenderingSystem* rendering_system =
-        engine.CreateSystem<phx::RenderingSystem>();
+        engine.CreateSystem<phx::RenderingSystem>(diplay_system);
 
     WHEN("We initialize the system") {
-      rendering_system->Initialize();
       THEN(
           "a default frame graph is created, that has 0 render passes, "
           "since there is currently to much inter-relation between the "

tests/src/test_tracking_system.cpp

@@ -81,8 +81,8 @@ SCENARIO(
         ->GetFirstComponent<phx::Transform>()
         ->SetLocalMatrix(platform_trans_mat);
     WHEN("A tracking system is created and initialized.") {
-      auto tracking_system = engine.CreateSystem<phx::TrackingSystem>();
-      tracking_system->Initialize();
+      auto tracking_system =
+          engine.CreateSystem<phx::TrackingSystem>(display_system);
       THEN("The HMD and the user's eyes are represented in the scene.") {
         auto entities = scene->GetEntitiesWithComponents<phx::Transform>();
         bool platform_present = false;