Reduce number of calls to nvgText[Box]Bounds()

wjakob · wjakob · commit 658e9e55db2f · 2025-09-05T16:38:47.000+02:00
Rendering and layout computation of NanoGUI widgets can sometimes spend
a significant amount of time in the functions ``nvgText[Box]Bounds()``.
This commit introduces a simple local caching scheme that stores the
bounds of relevant strings in each widget.
diff --git a/include/nanogui/button.h b/include/nanogui/button.h
@@ -161,6 +161,10 @@ class NANOGUI_EXPORT Button : public Widget {
 
     /// The button group for radio buttons.
     std::vector<Button *> m_button_group;
+
+    /// Cache for text bounds calculations
+    mutable NVGTextBoundsCache m_caption_cache;
+    mutable NVGTextBoundsCache m_icon_cache;
 };
 
 NAMESPACE_END(nanogui)
diff --git a/include/nanogui/checkbox.h b/include/nanogui/checkbox.h
@@ -94,6 +94,9 @@ class NANOGUI_EXPORT CheckBox : public Widget {
 
     /// The function to execute when \ref nanogui::CheckBox::m_checked is changed.
     std::function<void(bool)> m_callback;
+
+    /// Cache for text bounds calculations
+    mutable NVGTextBoundsCache m_caption_cache;
 };
 
 NAMESPACE_END(nanogui)
diff --git a/include/nanogui/common.h b/include/nanogui/common.h
@@ -354,6 +354,45 @@ extern NANOGUI_EXPORT std::vector<std::pair<int, std::string>>
 extern NANOGUI_EXPORT int __nanogui_get_image(NVGcontext *ctx, std::string_view name,
                                               uint8_t *data, uint32_t size);
 
+/**
+ * \brief Cache for text bounds calculations
+ *
+ * Stores the result of nvgTextBounds or nvgTextBoxBounds to avoid redundant
+ * calculations. The cache must be invalidated when font properties change.
+ */
+struct NANOGUI_EXPORT NVGTextBoundsCache {
+    bool valid = false;
+    std::string text;
+    float bounds[4] = {0, 0, 0, 0};  // Bounds at origin (0,0)
+    float width = 0;                 // Return value from nvgTextBounds
+    float break_width = 0;           // For nvgTextBoxBounds only
+};
+
+/**
+ * \brief Cached version of nvgTextBounds
+ *
+ * This function is equivalent to \ref nvgTextBounds(), except that it tries to
+ * avoid the actual (costly) computation by consulting a provided cache. The
+ * caching scheme assumes that the other font parameters (font type, size, blur
+ * radius, etc.), are fixed. Otherwise, the cache should be manually reset.
+ */
+extern NANOGUI_EXPORT float nvgTextBoundsCached(NVGTextBoundsCache& cache, NVGcontext* ctx,
+                                                float x, float y, const char* string,
+                                                const char* end, float* bounds);
+
+/**
+ * \brief Caching version of nvgTextBoxBounds
+ *
+ * This function is equivalent to \ref nvgTextBoxBounds(), except that it tries
+ * to avoid the actual (costly) computation by consulting a provided cache. The
+ * caching scheme assumes that the other font parameters (font type, size, blur
+ * radius, etc.), are fixed. Otherwise, the cache should be manually reset.
+ */
+extern NANOGUI_EXPORT void nvgTextBoxBoundsCached(NVGTextBoundsCache& cache, NVGcontext* ctx,
+                                                  float x, float y, float breakRowWidth,
+                                                  const char* string, const char* end,
+                                                  float* bounds);
+
 NAMESPACE_END(nanogui)
 
 NAMESPACE_BEGIN(drjit)
diff --git a/include/nanogui/label.h b/include/nanogui/label.h
@@ -56,6 +56,7 @@ class NANOGUI_EXPORT Label : public Widget {
     std::string m_caption;
     std::string m_font;
     Color m_color;
+    mutable NVGTextBoundsCache m_caption_cache;
 };
 
 NAMESPACE_END(nanogui)
diff --git a/include/nanogui/popupbutton.h b/include/nanogui/popupbutton.h
@@ -46,6 +46,7 @@ class NANOGUI_EXPORT PopupButton : public Button {
 protected:
     Popup *m_popup;
     int m_chevron_icon;
+    mutable NVGTextBoundsCache m_chevron_cache;
 };
 
 NAMESPACE_END(nanogui)
diff --git a/include/nanogui/screen.h b/include/nanogui/screen.h
@@ -331,6 +331,7 @@ class NANOGUI_EXPORT Screen : public Widget {
     std::function<void(Vector2i)> m_resize_callback;
     RunMode m_last_run_mode;
     ref<Texture> m_depth_stencil_texture;
+    mutable NVGTextBoundsCache m_tooltip_cache, m_tooltip_cache_box;
 #if defined(NANOGUI_USE_METAL)
     void *m_metal_texture = nullptr;
     void *m_metal_drawable = nullptr;
diff --git a/include/nanogui/tabwidget.h b/include/nanogui/tabwidget.h
@@ -134,6 +134,8 @@ class NANOGUI_EXPORT TabWidgetBase : public Widget {
     std::function<void(int)> m_close_callback;
     std::function<Popup*(int, Screen*)> m_popup_callback;
     Color m_background_color;
+    mutable std::vector<NVGTextBoundsCache> m_tab_caption_cache;
+    mutable NVGTextBoundsCache m_close_icon_cache;
 };
 
 /**
diff --git a/include/nanogui/textbox.h b/include/nanogui/textbox.h
@@ -154,6 +154,9 @@ class NANOGUI_EXPORT TextBox : public Widget {
     float m_text_offset;
     double m_last_click;
     Color m_solid_color;
+    mutable NVGTextBoundsCache m_value_cache;
+    mutable NVGTextBoundsCache m_units_cache;
+    mutable NVGTextBoundsCache m_value_temp_cache;
 };
 
 /**
diff --git a/include/nanogui/window.h b/include/nanogui/window.h
@@ -67,6 +67,7 @@ class NANOGUI_EXPORT Window : public Widget {
     Widget *m_button_panel;
     bool m_modal;
     bool m_drag;
+    mutable NVGTextBoundsCache m_title_cache;
 };
 
 NAMESPACE_END(nanogui)
diff --git a/src/button.cpp b/src/button.cpp
@@ -26,15 +26,15 @@ Vector2i Button::preferred_size(NVGcontext *ctx) const {
     int font_size = m_font_size == -1 ? m_theme->m_button_font_size : m_font_size;
     nvgFontSize(ctx, font_size);
     nvgFontFace(ctx, "sans-bold");
-    float tw = nvgTextBounds(ctx, 0,0, m_caption.c_str(), nullptr, nullptr);
+    float tw = nvgTextBoundsCached(m_caption_cache, ctx, 0,0, m_caption.c_str(), nullptr, nullptr);
     float iw = 0.0f, ih = font_size;
 
     if (m_icon) {
         if (nvg_is_font_icon(m_icon)) {
             ih *= icon_scale();
             nvgFontFace(ctx, "icons");
             nvgFontSize(ctx, ih);
-            iw = nvgTextBounds(ctx, 0, 0, utf8(m_icon).data(), nullptr, nullptr)
+            iw = nvgTextBoundsCached(m_icon_cache, ctx, 0, 0, utf8(m_icon).data(), nullptr, nullptr)
                 + m_size.y() * 0.15f;
         } else {
             int w, h;
@@ -164,7 +164,7 @@ void Button::draw(NVGcontext *ctx) {
     int font_size = m_font_size == -1 ? m_theme->m_button_font_size : m_font_size;
     nvgFontSize(ctx, font_size);
     nvgFontFace(ctx, "sans-bold");
-    float tw = nvgTextBounds(ctx, 0,0, m_caption.c_str(), nullptr, nullptr);
+    float tw = nvgTextBoundsCached(m_caption_cache, ctx, 0,0, m_caption.c_str(), nullptr, nullptr);
 
     Vector2f center = Vector2f(m_pos) + Vector2f(m_size) * 0.5f;
     Vector2f text_pos(center.x() - tw * 0.5f, center.y() - 1);
@@ -181,7 +181,7 @@ void Button::draw(NVGcontext *ctx) {
             ih *= icon_scale();
             nvgFontSize(ctx, ih);
             nvgFontFace(ctx, "icons");
-            iw = nvgTextBounds(ctx, 0, 0, icon.data(), nullptr, nullptr);
+            iw = nvgTextBoundsCached(m_icon_cache, ctx, 0, 0, icon.data(), nullptr, nullptr);
         } else {
             int w, h;
             ih *= 0.9f;
diff --git a/src/checkbox.cpp b/src/checkbox.cpp
@@ -50,7 +50,7 @@ Vector2i CheckBox::preferred_size(NVGcontext *ctx) const {
     nvgFontSize(ctx, font_size());
     nvgFontFace(ctx, "sans");
     return Vector2i(
-        nvgTextBounds(ctx, 0, 0, m_caption.c_str(), nullptr, nullptr) +
+        nvgTextBoundsCached(m_caption_cache, ctx, 0, 0, m_caption.c_str(), nullptr, nullptr) +
             1.8f * font_size(),
         font_size() * 1.3f);
 }
diff --git a/src/common.cpp b/src/common.cpp
@@ -471,5 +471,48 @@ void object_init_py(void (*object_inc_ref_py_)(PyObject *) noexcept,
     object_dec_ref_py = object_dec_ref_py_;
 }
 
+float nvgTextBoundsCached(NVGTextBoundsCache& cache, NVGcontext* ctx,
+                          float x, float y, const char* string,
+                          const char* end, float* bounds) {
+    size_t len = end ? (end - string) : strlen(string);
+
+    if (!cache.valid || cache.text.size() != len ||
+        memcmp(cache.text.data(), string, len) != 0) {
+        cache.width = nvgTextBounds(ctx, 0, 0, string, end, cache.bounds);
+        cache.text.assign(string, len);
+        cache.valid = true;
+    }
+
+    if (bounds) {
+        bounds[0] = cache.bounds[0] + x;
+        bounds[1] = cache.bounds[1] + y;
+        bounds[2] = cache.bounds[2] + x;
+        bounds[3] = cache.bounds[3] + y;
+    }
+
+    return cache.width;
+}
+
+void nvgTextBoxBoundsCached(NVGTextBoundsCache& cache, NVGcontext* ctx,
+                            float x, float y, float breakRowWidth,
+                            const char* string, const char* end,
+                            float* bounds) {
+    size_t len = end ? (end - string) : strlen(string);
+
+    // Check if cache is valid for this text and break width
+    if (!cache.valid || cache.break_width != breakRowWidth ||
+        cache.text.size() != len || memcmp(cache.text.data(), string, len) != 0) {
+        nvgTextBoxBounds(ctx, 0, 0, breakRowWidth, string, end, cache.bounds);
+        cache.text.assign(string, len);
+        cache.break_width = breakRowWidth;
+        cache.valid = true;
+    }
+
+    bounds[0] = cache.bounds[0] + x;
+    bounds[1] = cache.bounds[1] + y;
+    bounds[2] = cache.bounds[2] + x;
+    bounds[3] = cache.bounds[3] + y;
+}
+
 NAMESPACE_END(nanogui)
 
diff --git a/src/label.cpp b/src/label.cpp
@@ -40,12 +40,12 @@ Vector2i Label::preferred_size(NVGcontext *ctx) const {
     if (m_fixed_size.x() > 0) {
         float bounds[4];
         nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_TOP);
-        nvgTextBoxBounds(ctx, m_pos.x(), m_pos.y(), m_fixed_size.x(), m_caption.c_str(), nullptr, bounds);
+        nvgTextBoxBoundsCached(m_caption_cache, ctx, m_pos.x(), m_pos.y(), m_fixed_size.x(), m_caption.c_str(), nullptr, bounds);
         return Vector2i(m_fixed_size.x(), bounds[3] - bounds[1]);
     } else {
         nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
         return Vector2i(
-            nvgTextBounds(ctx, 0, 0, m_caption.c_str(), nullptr, nullptr) + 2,
+            nvgTextBoundsCached(m_caption_cache, ctx, 0, 0, m_caption.c_str(), nullptr, nullptr) + 2,
             font_size()
         );
     }
diff --git a/src/popupbutton.cpp b/src/popupbutton.cpp
@@ -47,7 +47,7 @@ void PopupButton::draw(NVGcontext* ctx) {
         nvgFillColor(ctx, m_enabled ? text_color : NVGcolor(m_theme->m_disabled_text_color));
         nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
 
-        float iw = nvgTextBounds(ctx, 0, 0, icon.data(), nullptr, nullptr);
+        float iw = nvgTextBoundsCached(m_chevron_cache, ctx, 0, 0, icon.data(), nullptr, nullptr);
         Vector2f icon_pos(0, m_pos.y() + m_size.y() * 0.5f - 1);
 
         if (m_popup->side() == Popup::Right)
diff --git a/src/screen.cpp b/src/screen.cpp
@@ -795,21 +795,21 @@ void Screen::draw_widgets() {
                            Vector2i(widget->width() / 2, widget->height() + 10);
 
             std::string_view tooltip = widget->tooltip();
-            nvgTextBounds(m_nvg_context, pos.x(), pos.y(),
-                          tooltip.data(), tooltip.data() + tooltip.size(), bounds);
+            nvgTextBoundsCached(m_tooltip_cache, m_nvg_context, pos.x(), pos.y(),
+                                tooltip.data(), tooltip.data() + tooltip.size(), bounds);
 
             int h = (bounds[2] - bounds[0]) / 2;
             if (h > tooltip_width / 2) {
                 nvgTextAlign(m_nvg_context, NVG_ALIGN_CENTER | NVG_ALIGN_TOP);
-                nvgTextBoxBounds(m_nvg_context, pos.x(), pos.y(), tooltip_width,
-                                tooltip.data(), tooltip.data() + tooltip.size(), bounds);
+                nvgTextBoxBoundsCached(m_tooltip_cache_box, m_nvg_context, pos.x(), pos.y(), tooltip_width,
+                                       tooltip.data(), tooltip.data() + tooltip.size(), bounds);
 
                 h = (bounds[2] - bounds[0]) / 2;
             }
             int shift = 0;
 
             if (pos.x() - h - 8 < 0) {
-                /* Keep tooltips on screen */
+                // Keep tooltips on screen
                 shift = pos.x() - h - 8;
                 pos.x() -= shift;
                 bounds[0] -= shift;
diff --git a/src/tabwidget.cpp b/src/tabwidget.cpp
@@ -30,6 +30,7 @@ void TabWidgetBase::remove_tab(int id) {
     int index = tab_index(id);
     bool close_active = index == m_active_tab;
     m_tab_captions.erase(m_tab_captions.begin() + index);
+    m_tab_caption_cache.erase(m_tab_caption_cache.begin() + index);
     m_tab_ids.erase(m_tab_ids.begin() + index);
     if (index <= m_active_tab)
         m_active_tab = std::max(0, m_active_tab - 1);
@@ -45,6 +46,7 @@ void TabWidgetBase::remove_tab(int id) {
 int TabWidgetBase::insert_tab(int index, std::string_view caption) {
     int id = m_tab_counter++;
     m_tab_captions.insert(m_tab_captions.begin() + index, std::string(caption));
+    m_tab_caption_cache.insert(m_tab_caption_cache.begin() + index, NVGTextBoundsCache());
     m_tab_ids.insert(m_tab_ids.begin() + index, id);
     TabWidgetBase::perform_layout(screen()->nvg_context());
     if (index < m_active_tab)
@@ -80,8 +82,10 @@ void TabWidgetBase::perform_layout(NVGcontext* ctx) {
     m_tab_offsets.clear();
     int width = 0;
     float unused[4];
-    for (std::string_view label : m_tab_captions) {
-        int label_width = nvgTextBounds(ctx, 0, 0, label.data(), label.data() + label.size(), unused);
+    for (size_t i = 0; i < m_tab_captions.size(); i++) {
+        int label_width = nvgTextBoundsCached(m_tab_caption_cache[i], ctx, 0, 0,
+                                              m_tab_captions[i].data(),
+                                              m_tab_captions[i].data() + m_tab_captions[i].size(), unused);
         m_tab_offsets.push_back(width);
         width += label_width + 2 * m_theme->m_tab_button_horizontal_padding;
         if (m_tabs_closeable)
@@ -91,7 +95,7 @@ void TabWidgetBase::perform_layout(NVGcontext* ctx) {
 
     nvgFontFace(ctx, "icons");
     m_close_width =
-        nvgTextBounds(ctx, 0, 0, utf8(FA_TIMES_CIRCLE).data(), nullptr, unused);
+        nvgTextBoundsCached(m_close_icon_cache, ctx, 0, 0, utf8(FA_TIMES_CIRCLE).data(), nullptr, unused);
 }
 
 Vector2i TabWidgetBase::preferred_size(NVGcontext* ctx) const {
@@ -100,9 +104,11 @@ Vector2i TabWidgetBase::preferred_size(NVGcontext* ctx) const {
     nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_TOP);
 
     int width = 0;
-    for (std::string_view label : m_tab_captions) {
+    for (size_t i = 0; i < m_tab_captions.size(); i++) {
         float unused[4];
-        int label_width = nvgTextBounds(ctx, 0, 0, label.data(), label.data() + label.size(), unused);
+        int label_width = nvgTextBoundsCached(m_tab_caption_cache[i], ctx, 0, 0,
+                                              m_tab_captions[i].data(),
+                                              m_tab_captions[i].data() + m_tab_captions[i].size(), unused);
         width += label_width + 2 * m_theme->m_tab_button_horizontal_padding;
         if (m_tabs_closeable)
             width += m_close_width;
diff --git a/src/textbox.cpp b/src/textbox.cpp
@@ -70,14 +70,14 @@ Vector2i TextBox::preferred_size(NVGcontext *ctx) const {
         float uh = size[1] * 0.4f;
         uw = w * uh / h;
     } else if (!m_units.empty()) {
-        uw = nvgTextBounds(ctx, 0, 0, m_units.c_str(), nullptr, nullptr);
+        uw = nvgTextBoundsCached(m_units_cache, ctx, 0, 0, m_units.c_str(), nullptr, nullptr);
     }
     float sw = 0;
     if (m_spinnable) {
         sw = 14.f;
     }
 
-    float ts = nvgTextBounds(ctx, 0, 0, m_value.c_str(), nullptr, nullptr);
+    float ts = nvgTextBoundsCached(m_value_cache, ctx, 0, 0, m_value.c_str(), nullptr, nullptr);
     size[0] = size[1] + ts + uw + sw;
     return size;
 }
@@ -149,7 +149,7 @@ void TextBox::draw(NVGcontext* ctx) {
         nvgFill(ctx);
         unit_width += 2;
     } else if (!m_units.empty()) {
-        unit_width = nvgTextBounds(ctx, 0, 0, m_units.c_str(), nullptr, nullptr);
+        unit_width = nvgTextBoundsCached(m_units_cache, ctx, 0, 0, m_units.c_str(), nullptr, nullptr);
         nvgFillColor(ctx, Color(255, m_enabled ? 64 : 32));
         nvgTextAlign(ctx, NVG_ALIGN_RIGHT | NVG_ALIGN_MIDDLE);
         nvgText(ctx, m_pos.x() + m_size.x() - x_spacing, draw_pos.y(),
@@ -229,8 +229,8 @@ void TextBox::draw(NVGcontext* ctx) {
         const int max_glyphs = 1024;
         NVGglyphPosition glyphs[max_glyphs];
         float text_bound[4];
-        nvgTextBounds(ctx, draw_pos.x(), draw_pos.y(), m_value_temp.c_str(),
-                      nullptr, text_bound);
+        nvgTextBoundsCached(m_value_temp_cache, ctx, draw_pos.x(), draw_pos.y(), m_value_temp.c_str(),
+                            nullptr, text_bound);
         float lineh = text_bound[3] - text_bound[1];
 
         // find cursor positions
@@ -254,8 +254,8 @@ void TextBox::draw(NVGcontext* ctx) {
 
         // draw text with offset
         nvgText(ctx, draw_pos.x(), draw_pos.y(), m_value_temp.c_str(), nullptr);
-        nvgTextBounds(ctx, draw_pos.x(), draw_pos.y(), m_value_temp.c_str(),
-                      nullptr, text_bound);
+        nvgTextBoundsCached(m_value_temp_cache, ctx, draw_pos.x(), draw_pos.y(), m_value_temp.c_str(),
+                            nullptr, text_bound);
 
         // recompute cursor positions
         nglyphs = nvgTextGlyphPositions(ctx, draw_pos.x(), draw_pos.y(),
diff --git a/src/window.cpp b/src/window.cpp
@@ -31,7 +31,7 @@ Vector2i Window::preferred_size(NVGcontext *ctx) const {
     nvgFontSize(ctx, 18.0f);
     nvgFontFace(ctx, "sans-bold");
     float bounds[4];
-    nvgTextBounds(ctx, 0, 0, m_title.c_str(), nullptr, bounds);
+    nvgTextBoundsCached(m_title_cache, ctx, 0, 0, m_title.c_str(), nullptr, bounds);
 
     return Vector2i(
         std::max(result.x(), (int) (bounds[2]-bounds[0] + 20)),
