Work in progress

src/engine.cpp

@@ -89,6 +89,11 @@ void engine::prefetch(const std::vector<std::string> &filenames) {
   _resourcemanager->prefetch(filenames);
 }
 
+void engine::flush() const {
+  _resourcemanager->pixmappool()->flush();
+  _resourcemanager->soundmanager()->flush();
+}
+
 bool engine::is_keydown(const input::keyevent &event) const {
   return _statemanager->is_keydown(event);
 }
@@ -141,8 +146,7 @@ void engine::_loop() {
   _eventmanager->update(delta);
   _entitymanager->update(delta);
 
-  std::for_each(_loopables.begin(), _loopables.end(),
-                [delta](auto &loopable) { loopable->loop(delta); });
+  std::for_each(_loopables.begin(), _loopables.end(), [delta](auto &loopable) { loopable->loop(delta); });
 
   _renderer->begin();
   _scenemanager->draw();

src/engine.hpp

@@ -48,6 +48,8 @@ class engine : public input::eventreceiver {
 
   void prefetch(const std::vector<std::string> &filenames);
 
+  void flush() const;
+
   bool is_keydown(const input::keyevent &event) const;
 
   const std::shared_ptr<entity> spawn(const std::string &kind);

src/entitymanager.cpp

@@ -3,7 +3,6 @@
 #include "entity.hpp"
 #include "entityprops.hpp"
 #include "io.hpp"
-#include "pixmap.hpp"
 #include "point.hpp"
 #include "rect.hpp"
 #include "resourcemanager.hpp"
@@ -15,19 +14,21 @@ using namespace framework;
 using json = nlohmann::json;
 
 void entitymanager::set_resourcemanager(
-    std::shared_ptr<resourcemanager> resourcemanager) {
+    std::shared_ptr<resourcemanager> resourcemanager
+) {
   _resourcemanager = resourcemanager;
 }
 
 std::shared_ptr<entity> entitymanager::spawn(const std::string &kind) {
   const auto buffer = storage::io::read(fmt::format("entities/{}.json", kind));
   const auto j = json::parse(buffer);
-  const auto spritesheet = _resourcemanager->pixmappool()->get(j["spritesheet"].template get<std::string_view>());
+  const auto spritesheet = _resourcemanager->pixmappool()->get(j["spritesheet"].template get<std::string>());
   const auto gravitic = j.value("gravitic", false);
   const auto scale = j.value("scale", 1.);
   const auto size = geometry::size{
       static_cast<int32_t>(j.value("width", 0) * scale),
-      static_cast<int32_t>(j.value("height", 0) * scale)};
+      static_cast<int32_t>(j.value("height", 0) * scale)
+  };
 
   std::map<std::string, std::vector<keyframe>> animations;
   for (const auto &[key, a] : j["animations"].get<json::object_t>()) {
@@ -83,7 +84,8 @@ std::shared_ptr<entity> entitymanager::spawn(const std::string &kind) {
       frame,
       last_frame,
       velocity,
-      visible};
+      visible
+  };
 
   const auto e = entity::create(std::move(props));
   std::cout << "[entitymanager] spawn: " << e->id() << std::endl;
@@ -98,10 +100,9 @@ void entitymanager::destroy(const std::weak_ptr<entity> entity) {
 }
 
 std::shared_ptr<entity> entitymanager::find(uint64_t id) const {
-  const auto it = std::find_if(_entities.begin(), _entities.end(),
-                               [id](const std::shared_ptr<entity> &entity) {
-                                 return entity->id() == id;
-                               });
+  const auto it = std::find_if(_entities.begin(), _entities.end(), [id](const std::shared_ptr<entity> &entity) {
+    return entity->id() == id;
+  });
 
   return (it != _entities.end()) ? *it : nullptr;
 }

src/pixmappool.cpp

@@ -7,17 +7,18 @@ using namespace graphics;
 pixmappool::pixmappool(const std::shared_ptr<renderer> renderer)
     : _renderer(renderer) {}
 
-void pixmappool::preload(const std::vector<std::string_view> &filenames) {
+void pixmappool::preload(const std::vector<std::string> &filenames) {
   for (const auto &filename : filenames) {
     get(filename);
   }
 }
 
-const std::shared_ptr<pixmap> pixmappool::get(const std::string_view filename) {
+const std::shared_ptr<pixmap> pixmappool::get(const std::string &filename) {
   auto [it, added] = _pool.try_emplace(filename, nullptr);
 
   if (added) {
     std::cout << "[pixmappool] cache miss: " << filename << std::endl;
+    assert(_renderer);
     it->second = std::make_shared<pixmap>(_renderer, filename);
   }
 

src/pixmappool.hpp

@@ -8,16 +8,14 @@ class pixmappool {
   explicit pixmappool(const std::shared_ptr<renderer> renderer);
   ~pixmappool() = default;
 
-  void preload(const std::vector<std::string_view> &filenames);
+  void preload(const std::vector<std::string> &filenames);
 
-  const std::shared_ptr<pixmap> get(const std::string_view filename);
+  const std::shared_ptr<pixmap> get(const std::string &filename);
 
   void flush();
 
 private:
   std::shared_ptr<renderer> _renderer;
-
-  std::unordered_map<std::string_view, std::shared_ptr<pixmap>, std::hash<std::string_view>>
-      _pool;
+  std::map<std::string, std::shared_ptr<pixmap>> _pool;
 };
 }

src/resourcemanager.cpp

@@ -10,14 +10,15 @@ using namespace framework;
 
 resourcemanager::resourcemanager(
     const std::shared_ptr<graphics::renderer> renderer,
-    const std::shared_ptr<audio::audiodevice> audiodevice)
+    const std::shared_ptr<audio::audiodevice> audiodevice
+)
     : _pixmappool(std::make_shared<graphics::pixmappool>(renderer)),
       _soundmanager(std::make_shared<audio::soundmanager>(audiodevice)) {
-  _handlers[".png"] = [this](const std::string_view filename) {
+  _handlers[".png"] = [this](const std::string &filename) {
     _pixmappool->get(filename);
   };
 
-  _handlers[".ogg"] = [this](const std::string_view filename) {
+  _handlers[".ogg"] = [this](const std::string &filename) {
     _soundmanager->get(filename);
   };
 }

src/resourcemanager.hpp

@@ -1,14 +1,14 @@
 #pragma once
 
 #include "common.hpp"
-#include <string_view>
 
 namespace framework {
 class resourcemanager {
 public:
   resourcemanager(
       const std::shared_ptr<graphics::renderer> renderer,
-      const std::shared_ptr<audio::audiodevice> audiodevice);
+      const std::shared_ptr<audio::audiodevice> audiodevice
+  );
 
   ~resourcemanager() = default;
 
@@ -23,7 +23,7 @@ class resourcemanager {
   std::shared_ptr<audio::soundmanager> soundmanager();
 
 private:
-  std::unordered_map<std::string, std::function<void(const std::string_view)>>
+  std::map<std::string, std::function<void(const std::string &)>>
       _handlers;
 
   std::list<std::string> _filenames;

src/scenemanager.cpp

@@ -11,7 +11,7 @@ scenemanager::scenemanager(const std::shared_ptr<graphics::pixmappool> pixmappoo
 void scenemanager::load(const std::string_view name) {
   const auto buffer = storage::io::read(fmt::format("scenes/{}.json", name));
   const auto j = json::parse(buffer);
-  _background = _pixmappool->get(j["background"].template get<std::string_view>());
+  _background = _pixmappool->get(j["background"].template get<std::string>());
   _size = {j.at("width").get<int32_t>(), j.at("height").get<int32_t>()};
 }
 

src/scriptengine.cpp

@@ -12,6 +12,7 @@
 #include "soundmanager.hpp"
 #include "ticks.hpp"
 #include "vector2d.hpp"
+#include <string>
 
 using namespace framework;
 
@@ -93,12 +94,14 @@ void scriptengine::run() {
       "add_loopable", &engine::add_loopable,
       "set_scene", &engine::set_scene,
       "prefetch", [](engine &engine, sol::table table) {
-        std::vector<std::string> filenames{table.size()};
-        for (auto &item : table) {
-          filenames.push_back(item.second.as<std::string>());
+        std::vector<std::string> filenames;
+        filenames.reserve(table.size());
+        for (const auto &item : table) {
+          filenames.emplace_back(item.second.as<std::string>());
         }
         engine.prefetch(filenames);
-      }
+      },
+      "flush", &engine::flush
   );
 
   lua.new_usertype<audio::soundmanager>(

src/soundmanager.cpp

@@ -5,13 +5,13 @@ using namespace audio;
 soundmanager::soundmanager(std::shared_ptr<audiodevice> audiodevice)
     : _audiodevice(audiodevice) {}
 
-void soundmanager::prefetch(const std::vector<std::string_view> &filenames) {
+void soundmanager::prefetch(const std::vector<std::string> &filenames) {
   for (const auto &filename : filenames) {
     get(filename);
   }
 }
 
-const std::shared_ptr<soundfx> soundmanager::get(const std::string_view filename) {
+const std::shared_ptr<soundfx> soundmanager::get(const std::string &filename) {
   auto [it, added] = _soundmap.try_emplace(filename, nullptr);
 
   if (added) {
@@ -27,11 +27,11 @@ const std::shared_ptr<soundfx> soundmanager::get(const std::string_view filename
   return it->second;
 }
 
-void soundmanager::play(const std::string_view filename, bool loop = false) {
+void soundmanager::play(const std::string &filename, bool loop = false) {
   get(fmt::format("blobs/{}.ogg", filename))->play(loop);
 }
 
-void soundmanager::stop(const std::string_view filename) {
+void soundmanager::stop(const std::string &filename) {
   get(filename)->stop();
 }
 

src/soundmanager.hpp

@@ -9,21 +9,18 @@ class soundmanager {
   soundmanager(std::shared_ptr<audiodevice> audiodevice);
   ~soundmanager() = default;
 
-  void prefetch(const std::vector<std::string_view> &filenames);
+  void prefetch(const std::vector<std::string> &filenames);
 
-  const std::shared_ptr<soundfx> get(const std::string_view filename);
+  const std::shared_ptr<soundfx> get(const std::string &filename);
 
-  void play(const std::string_view filename, bool loop);
+  void play(const std::string &filename, bool loop);
 
-  void stop(const std::string_view filename);
+  void stop(const std::string &filename);
 
   void flush();
 
 private:
   std::shared_ptr<audiodevice> _audiodevice;
-
-  std::unordered_map<std::string_view, std::shared_ptr<soundfx>,
-                     std::hash<std::string_view>>
-      _soundmap;
+  std::map<std::string_view, std::shared_ptr<soundfx>> _soundmap;
 };
 }