move unnecessary logic out of render functions

Author: dhthwy

library/SDLConsole_impl.cpp

@@ -2264,9 +2264,21 @@ class TextSelection {
 };
 
 class OutputPane : public Widget {
+private:
+    struct VisibleRow {
+        std::u32string_view text;
+        SDL_Point coord;
+        SDL_Color color;
+    };
+
+    struct VisibleRowsCache {
+        std::vector<VisibleRow> rows;
+        bool rebuild { true };
+    };
 public:
     // Use deque to hold a stable reference.
     std::deque<TextEntry> entries;
+    VisibleRowsCache visible_rows_cache;
     Prompt prompt;
     Scrollbar scrollbar;
     // Scrollbar could be made optional.
@@ -2346,7 +2358,7 @@ class OutputPane : public Widget {
         });
 
         scrollbar.connect<SDL_UserEvent>(InternalEventType::value_changed, [this](SDL_UserEvent& e) {
-            scroll_offset = SignalEmitter::copy_data1_from_userevent<int>(e, 0);
+            set_scroll_offset_from_scrollbar(SignalEmitter::copy_data1_from_userevent<int>(e, 0));
         });
     }
 
@@ -2475,12 +2487,20 @@ class OutputPane : public Widget {
         scrollbar.set_content_size(1);
         text_selection.reset();
         emit_text_selection_changed();
+        visible_rows_cache.rebuild = true;
     }
 
     void set_scroll_offset(int v)
     {
         scroll_offset = v;
         scrollbar.scroll_to(v);
+        visible_rows_cache.rebuild = true;
+    }
+
+    void set_scroll_offset_from_scrollbar(int v)
+    {
+        scroll_offset = v;
+        visible_rows_cache.rebuild = true;
     }
 
     void begin_text_selection(const SDL_Point p)
@@ -2519,22 +2539,23 @@ class OutputPane : public Widget {
 
     void scroll(ScrollAction sa)
     {
+        int v = 0;
         switch (sa) {
         case ScrollAction::up:
-            scroll_offset += 1;
+            v = 1;
             break;
         case ScrollAction::down:
-            scroll_offset -= 1;
+            v = -1;
             break;
         case ScrollAction::page_up:
-            scroll_offset += rows() / 2;
+            v = rows() / 2;
             break;
         case ScrollAction::page_down:
-            scroll_offset -= rows() / 2;
+            v = -rows() / 2;
             break;
         }
 
-        set_scroll_offset(std::min(std::max(0, scroll_offset), num_rows - 1));
+        set_scroll_offset(std::min(std::max(0, v + scroll_offset), num_rows - 1));
     }
 
     void resize(const SDL_Rect& rect) override
@@ -2551,6 +2572,8 @@ class OutputPane : public Widget {
             wrap_text(e);
         }
 
+        visible_rows_cache.rebuild = true;
+
         context.props.set(property::RT_OUTPUT_COLUMNS, columns());
         context.props.set(property::RT_OUTPUT_ROWS, rows());
     }
@@ -2604,6 +2627,7 @@ class OutputPane : public Widget {
         entry.wrap_text(font->char_width, content_rect.w);
         num_rows += entry.size;
         scrollbar.set_content_size(num_rows + prompt.entry.size);
+        visible_rows_cache.rebuild = true;
     }
 
     /*
@@ -2709,6 +2733,7 @@ class OutputPane : public Widget {
     }
 #endif
 
+
     void render() override
     {
         // SDL_RenderSetScale(renderer(), 1.2, 1.2);
@@ -2721,20 +2746,31 @@ class OutputPane : public Widget {
         // SDL_SetTextureColorMod(font->texture, 0, 128, 0);
 
         render_prompt_and_output();
+
         // SDL_SetTextureColorMod(font->texture, 255, 255, 255);
         prompt.render_cursor(scroll_offset);
         sdl_console::SDL_RenderSetViewport(renderer(), &parent->frame);
         scrollbar.render();
         // SDL_RenderSetScale(renderer(), 1.0, 1.0);
     }
 
-    void render_prompt_and_output()
+    void build_visible_prompt_and_output_rows()
     {
+        visible_rows_cache.rows.clear();
+        visible_rows_cache.rebuild = false;
+
         const int max_row = rows() + scroll_offset;
         int ypos = content_rect.h; // Start from the bottom
-        int row_counter = scroll_offset;
+        int row_counter = 0;
 
-        render_entry(prompt.entry, ypos, row_counter, max_row);
+        std::vector<VisibleRow> rows;
+
+        auto append_visible_rows = [this, &ypos, &row_counter, max_row](auto&& entry) {
+            auto more = get_visible_entry_rows(entry, ypos, row_counter, max_row);
+            std::ranges::move(more, std::back_inserter(visible_rows_cache.rows));
+        };
+
+        append_visible_rows(prompt.entry);
 
         if (entries.empty()) {
             return;
@@ -2744,14 +2780,15 @@ class OutputPane : public Widget {
             if (row_counter > max_row) {
                 break;
             }
-            render_entry(entry, ypos, row_counter, max_row);
+
+            append_visible_rows(entry);
         }
     }
 
     // FIXME: Position and rows to render calculations should be done elsewhere.
-    void render_entry(TextEntry& entry, int& ypos, int& row_counter, int max_row)
+    std::vector<VisibleRow> get_visible_entry_rows(TextEntry& entry, int& ypos, int& row_counter, int max_row)
     {
-        auto scoped_color = font->set_color(entry.color_opt);
+        std::vector<VisibleRow> vrows;
 
         for (auto& row : entry.fragments() | std::views::reverse) {
             row_counter++;
@@ -2765,6 +2802,24 @@ class OutputPane : public Widget {
 
             ypos -= font->line_height_with_spacing();
             row.coord.y = ypos;
+
+            vrows.push_back({
+                row.text,
+                { row.coord.x, ypos },
+                entry.color_opt.value_or(SDL_Color{255,255,255,255})
+            });
+        }
+        return vrows;
+    }
+
+    void render_prompt_and_output()
+    {
+        if (visible_rows_cache.rebuild) {
+            build_visible_prompt_and_output_rows();
+        }
+
+        for (const auto& row : visible_rows_cache.rows) {
+            font->set_color(row.color);
             font->render(row.text, row.coord.x, row.coord.y);
         }
     }
@@ -3170,15 +3225,15 @@ class SDLConsole_impl : public std::enable_shared_from_this<SDLConsole_impl> {
         handle_tasks();
 
         static auto last_tick = SDL_GetTicks64();
-        constexpr Uint32 shown_min_frame_time = 1000 / 20; // 20 fps;
-        constexpr Uint32 minimized_min_frame_time = 1000;
+        constexpr Uint32 shown_rate = 1000 / 20; // 20 fps;
+        constexpr Uint32 minimized_rate = 1000;
 
         auto current_tick = SDL_GetTicks64();
         if (main_window.is_shown)
         {
-            auto min_frame_time = main_window.is_minimized ? minimized_min_frame_time : shown_min_frame_time;
+            auto rate = main_window.is_minimized ? minimized_rate : shown_rate;
 
-            if (current_tick - last_tick >= min_frame_time) {
+            if (current_tick - last_tick >= rate) {
                 render_frame();
                 last_tick = current_tick;
             }