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.

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) {
-      meter.init(cell);
+    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);
     });
   }
 
@@ -157,8 +169,8 @@ namespace guecs {
         });
 
         do_if<Sound>(ent, [hover](auto& sound) {
-            // here set that it played then only play once
-            sound.stop(hover);
+          // here set that it played then only play once
+          sound.stop(hover);
         });
       }
     });