Refactoring the GUECS UI::render and the components so that it's just calling a .render on each one. This will then let me allow registering any components people want.

demos/calc.cpp

@@ -150,7 +150,7 @@ struct CalculatorUI {
   }
 
   void init() {
-    $gui.set<guecs::Background>($gui.MAIN, {});
+    $gui.set<guecs::Background>($gui.MAIN, {$gui.$parser});
 
     for(auto& [name, cell] : $gui.cells()) {
       auto id = $gui.entity(name);

demos/clicker_game.cpp

@@ -111,6 +111,7 @@ struct ClickerUI {
 
   void render(sf::RenderWindow& window) {
     auto& shaker = $gui.get<Shake>($clicker);
+
     if(shaker.playing) {
       auto& sprite = $gui.get<guecs::Sprite>($clicker);
       shaker.render(sprite);
@@ -149,7 +150,7 @@ int main() {
   sfml::Backend backend;
   guecs::init(&backend);
 
-  sf::RenderWindow window(sf::VideoMode({WINDOW_WIDTH, WINDOW_HEIGHT}), "LEL-GUECS Calculator");
+  sf::RenderWindow window(sf::VideoMode({WINDOW_WIDTH, WINDOW_HEIGHT}), "Clicker the Dog");
   window.setFramerateLimit(FRAME_LIMIT);
   window.setVerticalSyncEnabled(VSYNC);
 

include/guecs/sfml/components.hpp

@@ -21,6 +21,7 @@ namespace guecs {
 
     void init(lel::Cell &cell, shared_ptr<sf::Font> font_ptr);
     void update(const std::wstring& new_content);
+    void render(sf::RenderWindow& window, sf::Shader *shader_ptr);
   };
 
   struct Label : public Textual {
@@ -49,6 +50,7 @@ namespace guecs {
 
     void init(lel::Cell &cell);
     void update(const string& new_name);
+    void render(sf::RenderWindow& window, sf::Shader *shader_ptr);
   };
 
   struct Rectangle {
@@ -59,6 +61,7 @@ namespace guecs {
     shared_ptr<sf::RectangleShape> shape = nullptr;
 
     void init(lel::Cell& cell);
+    void render(sf::RenderWindow& window, sf::Shader *shader_ptr);
   };
 
   struct Meter {
@@ -67,7 +70,8 @@ namespace guecs {
     Rectangle bar;
 
     void init(lel::Cell& cell);
-    void render(lel::Cell& cell);
+    void init(lel::Cell& cell, Rectangle& bg);
+    void render(lel::Cell& cell, sf::RenderWindow& window, sf::Shader *shader_ptr);
   };
 
   struct Effect {
@@ -82,8 +86,9 @@ namespace guecs {
     void init(lel::Cell &cell);
     void run();
     void stop();
-    void step();
-    shared_ptr<sf::Shader> checkout_ptr();
+    void render();
+    sf::Shader* get_shader(bool is_shape);
+
   };
 
   struct Sound {
@@ -111,5 +116,6 @@ namespace guecs {
     Background() {}
 
     void init();
+    void render(sf::RenderWindow& window);
   };
 }

include/guecs/ui.hpp

@@ -209,21 +209,12 @@ namespace guecs {
         }
 
       template<typename T>
-        void render_helper(sf::RenderWindow& window, Entity ent, bool is_shape, T& target) {
-          sf::Shader *shader_ptr = nullptr;
-
-          if(auto shader = get_if<Effect>(ent)) {
-            if(shader->$active) {
-              auto ptr = shader->checkout_ptr();
-              ptr->setUniform("is_shape", is_shape);
-              // NOTE: this is needed because SFML doesn't handle shared_ptr
-              shader_ptr = ptr.get();
-            }
-          }
-
+      void render_helper(sf::RenderWindow& window, T& target, sf::Shader *shader_ptr) {
         window.draw(*target, shader_ptr);
       }
 
+      sf::Shader* find_shader(Entity ent, bool is_shape);
+
       void show_sprite(const string& region, const string& sprite_name);
       void show_text(const string& region, const wstring& content);
       void show_label(const string& region, const wstring& content);

src/guecs/sfml/backend.cpp

@@ -45,8 +45,8 @@ namespace sfml {
     theme.LABEL_SIZE = 20;
     theme.FILL_COLOR = theme.DARK_MID;
     theme.TEXT_COLOR = theme.LIGHT_LIGHT;
-    theme.BG_COLOR = theme.MID;
-    theme.BORDER_COLOR = theme.LIGHT_DARK;
+    theme.BG_COLOR = theme.DARK_DARK;
+    theme.BORDER_COLOR = theme.DARK_LIGHT;
     theme.BG_COLOR_DARK = theme.BLACK;
     theme.FONT_FILE_NAME = "assets/text.otf";
 

src/guecs/sfml/components.cpp

@@ -24,6 +24,10 @@ namespace guecs {
     text->setCharacterSize(size);
   }
 
+  void Textual::render(sf::RenderWindow& window, sf::Shader *shader_ptr) {
+    window.draw(*text, shader_ptr);
+  }
+
   void Textual::update(const wstring& new_content) {
     content = new_content;
     text->setString(content);
@@ -56,6 +60,10 @@ namespace guecs {
         float(cell.h - padding * 2) / bounds.size.y});
   }
 
+  void Sprite::render(sf::RenderWindow& window, sf::Shader *shader_ptr) {
+    window.draw(*sprite, shader_ptr);
+  }
+
   void Rectangle::init(lel::Cell& cell) {
     sf::Vector2f size{float(cell.w) - padding * 2, float(cell.h) - padding * 2};
     if(shape == nullptr) shape = make_shared<sf::RectangleShape>(size);
@@ -65,15 +73,24 @@ namespace guecs {
     shape->setOutlineThickness(border_px);
   }
 
+  void Rectangle::render(sf::RenderWindow& window, sf::Shader *shader_ptr) {
+    window.draw(*shape, shader_ptr);
+  }
+
+  void Meter::init(lel::Cell& cell, Rectangle& bg) {
+    bg.shape->setFillColor(color);
+    init(cell);
+  }
 
   void Meter::init(lel::Cell& cell) {
     bar.init(cell);
   }
 
-  void Meter::render(lel::Cell& cell) {
+  void Meter::render(lel::Cell& cell, sf::RenderWindow& window, sf::Shader *shader_ptr) {
     float level = std::clamp(percent, 0.0f, 1.0f) * float(cell.w);
     // ZED: this 6 is a border width, make it a thing
     bar.shape->setSize({std::max(level, 0.0f), float(cell.h - 6)});
+    window.draw(*bar.shape, shader_ptr);
   }
 
   void Sound::play(bool hover) {
@@ -104,13 +121,17 @@ namespace guecs {
     assert(shape != nullptr && "failed to make rectangle");
   }
 
+  void Background::render(sf::RenderWindow& window) {
+    window.draw(*shape);
+  }
+
   void Effect::init(lel::Cell &cell) {
     $shader = BACKEND->shader_get(name);
     $shader->setUniform("u_resolution", sf::Vector2f({float(cell.w), float(cell.h)}));
     $clock = std::make_shared<sf::Clock>();
   }
 
-  void Effect::step() {
+  void Effect::render() {
     sf::Time cur_time = $clock->getElapsedTime();
     float u_time = cur_time.asSeconds();
 
@@ -129,12 +150,20 @@ namespace guecs {
     $u_time_end = u_time.asSeconds() + duration;
   }
 
-  shared_ptr<sf::Shader> Effect::checkout_ptr() {
+  sf::Shader* Effect::get_shader(bool is_shape) {
+    sf::Shader *shader_ptr = nullptr;
+
     if(BACKEND->shader_updated()) {
       $shader = BACKEND->shader_get(name);
     }
 
-    return $shader;
+    if($active) {
+      $shader->setUniform("is_shape", is_shape);
+      // NOTE: this is needed because SFML doesn't handle shared_ptr
+      shader_ptr = $shader.get();
+    }
+
+    return shader_ptr;
   }
 
   void Effect::stop() {

src/guecs/ui.cpp

@@ -66,12 +66,12 @@ namespace guecs {
       shader.init(cell);
     });
 
-    query<Rectangle, Meter>([](auto, auto& bg, auto &meter) {
-      bg.shape->setFillColor(meter.color);
-    });
-
-    query<lel::Cell, Meter>([](auto, auto &cell, auto& meter) {
+    query<lel::Cell, Meter>([this](auto ent, auto &cell, auto& meter) {
+      if(auto bg = get_if<Rectangle>(ent)) {
+        meter.init(cell, *bg);
+      } else {
         meter.init(cell);
+      }
     });
 
     query<lel::Cell, Textual>([this](auto, auto& cell, auto& text) {
@@ -98,34 +98,46 @@ namespace guecs {
     });
   }
 
+  sf::Shader* UI::find_shader(Entity ent, bool is_shape) {
+    if(auto shader = get_if<Effect>(ent)) {
+      return shader->get_shader(is_shape);
+    } else {
+      return nullptr;
+    }
+  }
+
   void UI::render(sf::RenderWindow& window) {
     if(auto bg = get_if<Background>(MAIN)) {
-      window.draw(*(bg->shape));
+      bg->render(window);
     }
 
     query<Effect>([&](auto, auto& shader) {
-      if(shader.$active) shader.step();
+      if(shader.$active) shader.render();
     });
 
     query<Rectangle>([&](auto ent, auto& rect) {
-        render_helper(window, ent, true, rect.shape);
+      auto shader_ptr = find_shader(ent, true);
+      rect.render(window, shader_ptr);
     });
 
     query<lel::Cell, Meter>([&](auto ent, auto& cell, auto &meter) {
-      meter.render(cell);
-      render_helper(window, ent, true, meter.bar.shape);
+      auto shader_ptr = find_shader(ent, true);
+      meter.render(cell, window, shader_ptr);
     });
 
     query<Sprite>([&](auto ent, auto& sprite) {
-        render_helper(window, ent, false, sprite.sprite);
+      auto shader_ptr = find_shader(ent, false);
+      sprite.render(window, shader_ptr);
     });
 
     query<Label>([&](auto ent, auto& text) {
-        render_helper(window, ent, false, text.text);
+      auto shader_ptr = find_shader(ent, false);
+      text.render(window, shader_ptr);
     });
 
     query<Textual>([&](auto ent, auto& text) {
-        render_helper(window, ent, false, text.text);
+      auto shader_ptr = find_shader(ent, false);
+      text.render(window, shader_ptr);
     });
   }