The reload mechanism for shaders is a bit better, but still to make them unique.

combat_ui.cpp

@@ -18,7 +18,7 @@ namespace gui {
     $gui.set<Sprite>(button, {"leather_pouch-128"});
     // $gui.set<Rectangle>(button, {});
     $gui.set<Label>(button, {label});
-    $gui.set<Shader>(button, {.duration=0.1f});
+    $gui.set<Shader>(button, {.duration=10.0f});
     $gui.set<Clickable>(button,
         guecs::make_action(*$level.world, event));
   }

guecs.cpp

@@ -67,31 +67,39 @@ namespace guecs {
   }
 
   void Shader::init(lel::Cell &cell) {
-    auto shader = shaders::get(name);
+    $shader_version = shaders::version();
-    shader->setUniform("u_resolution", sf::Vector2f({float(cell.w), float(cell.h)}));
+    $shader = shaders::get(name);
-    clock = std::make_shared<sf::Clock>();
+    $shader->setUniform("u_resolution", sf::Vector2f({float(cell.w), float(cell.h)}));
+    $clock = std::make_shared<sf::Clock>();
   }
 
   void Shader::step() {
-    auto shader = shaders::get(name);
+    sf::Time cur_time = $clock->getElapsedTime();
-    sf::Time u_time = clock->getElapsedTime();
+    float u_time = cur_time.asSeconds();
-    float current_time = u_time.asSeconds();
 
-    if(current_time < u_time_end) {
+    if(u_time < $u_time_end) {
-      shader->setUniform("u_time", current_time);
+      $shader->setUniform("u_time", u_time);
     } else {
-      active = false;
+      $active = false;
     }
   }
 
   void Shader::run() {
-    auto shader = shaders::get(name);
+    $shader = checkout_ptr();
+    $active = true;
+    sf::Time u_time = $clock->getElapsedTime();
+    $u_time_end = u_time.asSeconds() + duration;
+    $shader->setUniform("u_duration", duration);
+    $shader->setUniform("u_time_end", $u_time_end);
+  }
 
-    active = true;
+  shared_ptr<sf::Shader> Shader::checkout_ptr() {
-    sf::Time u_time = clock->getElapsedTime();
+    if(shaders::updated($shader_version)) {
-    u_time_end = u_time.asSeconds() + duration;
+      $shader = shaders::get(name);
-    shader->setUniform("u_duration", duration);
+      $shader_version = shaders::version();
-    shader->setUniform("u_time_end", u_time_end);
+    }
+
+    return $shader;
   }
 
   UI::UI() {
@@ -185,7 +193,7 @@ namespace guecs {
     }
 
     $world.query<Shader>([&](auto, auto& shader) {
-      if(shader.active) shader.step();
+      if(shader.$active) shader.step();
     });
 
     $world.query<Rectangle>([&](auto ent, auto& rect) {

guecs.hpp

@@ -85,13 +85,16 @@ namespace guecs {
   struct Shader {
     float duration = 0.1f;
     std::string name{"ui_shader"};
-    float u_time_end = 0.0;
+    float $u_time_end = 0.0;
-    bool active = false;
+    bool $active = false;
-    std::shared_ptr<sf::Clock> clock = nullptr;
+    std::shared_ptr<sf::Clock> $clock = nullptr;
+    std::shared_ptr<sf::Shader> $shader = nullptr;
+    int $shader_version = 0;
 
     void init(lel::Cell &cell);
     void run();
     void step();
+    shared_ptr<sf::Shader> checkout_ptr();
   };
 
   struct Background {
@@ -198,9 +201,11 @@ namespace guecs {
         if($world.has<Shader>(ent)) {
           auto& shader = $world.get<Shader>(ent);
 
-          if(shader.active) {
+          if(shader.$active) {
-            shader_ptr = shaders::get(shader.name);
+            auto ptr = shader.checkout_ptr();
-            shader_ptr->setUniform("is_shape", is_shape);
+            ptr->setUniform("is_shape", is_shape);
+            // NOTE: this is needed because SFML doesn't handle shared_ptr
+            shader_ptr = ptr.get();
           }
         }
 

raycaster.cpp

@@ -393,7 +393,6 @@ void Raycaster::update_level(GameLevel level) {
 }
 
 void Raycaster::init_shaders() {
-  std::string the_fucking_name{"rayview_sprites"};
+  $brightness = shaders::get("rayview_sprites");
-  $brightness = shaders::get_shared(the_fucking_name);
   $brightness->setUniform("source", sf::Shader::CurrentTexture);
 }

shaders.cpp

@@ -10,7 +10,8 @@ namespace shaders {
   using std::shared_ptr, std::make_shared;
 
   static ShaderManager SMGR;
-  static bool initialized = false;
+  static bool INITIALIZED = false;
+  static int VERSION = 0;
 
   bool load_shader(std::string name, nlohmann::json& settings) {
     std::string file_name = settings["file_name"];
@@ -21,9 +22,9 @@ namespace shaders {
   }
 
   void init() {
-    if(!initialized) {
+    if(!INITIALIZED) {
       dbc::check(sf::Shader::isAvailable(), "no shaders?!");
-      initialized = true;
+      INITIALIZED = true;
       Config config("assets/shaders.json");
       bool good = load_shader("ERROR", config["ERROR"]);
       dbc::check(good, "Failed to load ERROR shader. Look in assets/shaders.json");
@@ -43,21 +44,27 @@ namespace shaders {
     }
   }
 
-  std::shared_ptr<sf::Shader> get_shared(std::string& name) {
+  std::shared_ptr<sf::Shader> get(const std::string& name) {
-    dbc::check(initialized, "you forgot to shaders::init()");
+    dbc::check(INITIALIZED, "you forgot to shaders::init()");
     dbc::check(SMGR.shaders.contains(name),
         fmt::format("shader name '{}' not in assets/shaders.json", name));
     auto& rec = SMGR.shaders.at(name);
     return rec.ptr;
   }
 
-  sf::Shader* get(std::string name) {
+  int reload() {
-    return get_shared(name).get();
+    VERSION++;
-  }
+    INITIALIZED = false;
-
-  void reload() {
-    initialized = false;
     SMGR.shaders.clear();
     init();
+    return VERSION;
+  }
+
+  bool updated(int my_version) {
+    return my_version != VERSION;
+  }
+
+  int version() {
+    return VERSION;
   }
 };

shaders.hpp

@@ -19,9 +19,10 @@ namespace shaders {
     std::unordered_map<std::string, Record> shaders;
   };
 
-  std::shared_ptr<sf::Shader> get_shared(std::string& name);
+  std::shared_ptr<sf::Shader> get(const std::string& name);
   void init();
   bool load_shader(std::string& name, nlohmann::json& settings);
-  sf::Shader* get(std::string name);
+  bool updated(int my_version);
-  void reload();
+  int reload();
+  int version();
 }

tests/shaders.cpp

@@ -7,16 +7,20 @@ using namespace fmt;
 
 TEST_CASE("shader loading/init works", "[shaders]") {
   shaders::init();
+  int version = shaders::version();
 
-  sf::Shader* ui_shader = shaders::get("ui_shader");
+  std::shared_ptr<sf::Shader> ui_shader = shaders::get("ui_shader");
   auto other_test = shaders::get("ui_shader");
 
   REQUIRE(ui_shader != nullptr);
   REQUIRE(ui_shader == other_test);
+  REQUIRE(shaders::updated(version) == false);
 
-  shaders::reload();
+  int new_version = shaders::reload();
+  REQUIRE(version != shaders::version());
+  REQUIRE(version != new_version);
+  REQUIRE(shaders::version() == new_version);
+  REQUIRE(shaders::updated(version) == true);
+  version = new_version;
 
-  // auto after_reload = shaders::get("ui_shader");
-  // REQUIRE(ui_shader != after_reload);
-  // REQUIRE(other_test != after_reload);
 }