✨ scene system and empty world scene.

meson.build

@@ -30,6 +30,11 @@ executable(
     'src/Sprite.cpp',
     'src/Manifest.cpp',
 
+    # Scenes
+    'src/scenes/Scenes.cpp',
+    'src/scenes/Scene.cpp',
+    'src/scenes/World.cpp',
+
     # Logs
     'src/logs/Logs.cpp',
     'src/logs/FileLogs.cpp',

src/Game.cpp

@@ -1,11 +1,8 @@
 #include "Game.hpp"
-#include "logs/FileLogs.hpp"
-#include "events/Events.hpp"
-#include "logs/Logs.hpp"
-#include "gfx/Graphics.hpp"
-#include "inputs/Inputs.hpp"
+#include "ml.hpp"
 
 #include "Sprite.hpp"
+#include "scenes/World.hpp"
 
 namespace ml
 {
@@ -20,6 +17,7 @@ namespace ml
   void Game::start()
   {
     ML_SYS(FileLogs)->log(LEVEL_INFO, "game started");
+    ML_SYS(Scenes)->queue_add<World>("world");
 
     m_running = true;
 
@@ -28,8 +26,12 @@ namespace ml
     Sprite sprite {256.0f, 256.0f, 128.0f, 128.0f};
     sprite.set_texture("demo");
 
+    float dt = 0.0f;
+
     while (m_running)
       {
+        auto now = std::chrono::steady_clock::now();
+
         while (SDL_PollEvent(&event))
           {
             if (event.type == SDL_QUIT)
@@ -43,9 +45,16 @@ namespace ml
             ML_SYS(FileLogs)->log(LEVEL_DEBUG, "hello triggered");
           }
 
+        ML_SYS(Scenes)->update(dt);
+
         ML_SYS(Graphics)->clear(4, 139, 154);
+        ML_SYS(Scenes)->draw(*ML_SYS(Graphics));
         ML_SYS(Graphics)->draw(sprite);
         ML_SYS(Graphics)->update();
+
+        auto elapsed = std::chrono::steady_clock::now() - now;
+        dt = std::chrono::duration_cast<std::chrono::microseconds>(elapsed)
+          .count() / 1000000.0f;
       }
   }
 

src/Game.hpp

@@ -7,7 +7,8 @@
 namespace ml
 {
   /**
-   * Manage game state.
+   * Manage game state and scenes.
+   * @see Scene
    **/
   class Game
   {

src/commons.hpp

@@ -13,6 +13,7 @@
 #include <iostream>
 #include <fstream>
 #include <optional>
+#include <chrono>
 
 #define ML_ASSET(NAME) \
   (std::filesystem::path(ML_SHARE_DIR) / "assets" / NAME)

src/main.cpp

@@ -5,11 +5,7 @@
 
 // Services
 #include "Services.hpp"
-#include "logs/FileLogs.hpp"
-#include "events/Events.hpp"
-#include "gfx/Graphics.hpp"
-#include "res/Resources.hpp"
-#include "inputs/Inputs.hpp"
+#include "ml.hpp"
 
 #include "Manifest.hpp"
 #include "Game.hpp"
@@ -18,12 +14,11 @@ int main(int, char**)
 {
   ML->add<ml::FileLogs>
     (std::filesystem::temp_directory_path() / "mornelune.log");
-
   ML->add<ml::Resources>();
-
   ML->add<ml::Events>();
   ML->add<ml::Graphics>("Mornelune", 1024, 768);
   ML->add<ml::Inputs>();
+  ML->add<ml::Scenes>();
   ML->init();
 
   ml::Manifest man;

src/ml.hpp

@@ -5,5 +5,6 @@
 #include "inputs/Inputs.hpp"
 #include "gfx/Graphics.hpp"
 #include "events/Events.hpp"
+#include "scenes/Scenes.hpp"
 
 #endif

src/scenes/Scene.cpp

@@ -0,0 +1,12 @@
+#include "Scene.hpp"
+
+namespace ml
+{
+  /*explicit*/ Scene::Scene()
+  {
+  }
+
+  /*virtual*/ Scene::~Scene()
+  {
+  }
+}

src/scenes/Scene.hpp

@@ -0,0 +1,22 @@
+#ifndef ml_SCENE_HPP
+#define ml_SCENE_HPP
+
+#include "../commons.hpp"
+#include "../gfx/Graphics.hpp"
+
+namespace ml
+{
+  class Scene
+  {
+  public:
+    explicit Scene();
+    virtual ~Scene();
+
+    virtual void draw(Graphics&) {}
+    virtual void update(float) {}
+
+  private:
+  };
+}
+
+#endif

src/scenes/Scenes.cpp

@@ -0,0 +1,46 @@
+//#include "../logs/FileLogs.hpp"
+//#include "../Services.hpp"
+#include "../ml.hpp"
+#include "Scenes.hpp"
+
+namespace ml
+{
+  /*explicit*/ Scenes::Scenes()
+  {
+  }
+
+  /*virtual*/ Scenes::~Scenes()
+  {
+  }
+
+  void Scenes::draw(Graphics& gfx)
+  {
+    for (auto& entry: m_scenes)
+      {
+        entry.second->draw(gfx);
+      }
+  }
+
+  void Scenes::update(float dt)
+  {
+    for (auto& scene: m_add_queue)
+      {
+        m_scenes.insert({scene.first, std::move(scene.second)});
+      }
+
+    m_add_queue.clear();
+
+    for (auto& scene: m_remove_queue)
+      {
+        m_scenes.erase(m_scenes.find(scene));
+      }
+
+    m_remove_queue.clear();
+
+    for (auto& entry: m_scenes)
+      {
+        entry.second->update(dt);
+      }
+  }
+
+}

src/scenes/Scenes.hpp

@@ -0,0 +1,44 @@
+#ifndef ml_SCENES_HPP
+#define ml_SCENES_HPP
+
+#include "../commons.hpp"
+#include "../gfx/Graphics.hpp"
+#include "../logs/FileLogs.hpp"
+#include "../Services.hpp"
+#include "Scene.hpp"
+
+namespace ml
+{
+  class Scenes: public Service
+  {
+  public:
+    explicit Scenes();
+    virtual ~Scenes();
+
+    void draw(Graphics& gfx);
+    void update(float dt);
+
+    template <typename T, typename... Args>
+    void queue_add(std::string const& name, Args... args);
+
+  private:
+    std::unordered_map<std::string,
+                       std::unique_ptr<Scene>> m_scenes;
+
+    std::vector<std::pair<std::string,
+                          std::unique_ptr<Scene>>> m_add_queue;
+
+    std::vector<std::string> m_remove_queue;
+  };
+
+  template <typename T, typename... Args>
+  void Scenes::queue_add(std::string const& name, Args... args)
+  {
+    ML_SYS(FileLogs)->log(LEVEL_DEBUG, "add scene '"
+                          + name + "'");
+
+    m_scenes.insert({name, std::make_unique<T>(args...)});
+  }
+}
+
+#endif

src/scenes/World.cpp

@@ -0,0 +1,22 @@
+#include "World.hpp"
+#include "../ml.hpp"
+
+namespace ml
+{
+  /*explicit*/ World::World()
+  {
+  }
+
+  /*virtual*/ World::~World()
+  {
+  }
+
+  void World::update(float) /*override*/
+  {
+  }
+
+  void World::draw(Graphics& gfx) /*override*/
+  {
+    gfx.clear(0, 0, 0);
+  }
+}

src/scenes/World.hpp

@@ -0,0 +1,22 @@
+#ifndef ml_WORLD_HPP
+#define ml_WORLD_HPP
+
+#include "../commons.hpp"
+#include "Scene.hpp"
+
+namespace ml
+{
+  class World: public Scene
+  {
+  public:
+    explicit World();
+    virtual ~World();
+
+    void update(float dt) override;
+    void draw(Graphics& gfx) override;
+
+  private:
+  };
+}
+
+#endif