feat(ui): font size and perf overlay improvements

[soda3000]

This PR improves the UI/UX around global font sizing and the Performance Overlay. It adds one-click “restore default” flows, persists overlay settings reliably, and tightens overlay behavior for clarity and stability.

Summary by CodeRabbit

• New Features
  • Performance Overlay: Save/Load settings and a “Restore Defaults” button with tooltip; resets stats and history when restoring.
  • Theme & Fonts: New resolution-based automatic font size option with toggle, effective size readout, and manual slider (disabled in auto mode). “Restore Theme Defaults” button resets UI sizes, colors, and options; font scale updates immediately.
  • Reliability/UX: Settings load now falls back safely to defaults; improved font handling reduces unnecessary reloads.

[coderabbitai]

Walkthrough

Adds settings persistence and default-restore for PerformanceOverlay, introduces resolution-based font sizing via ThemeManager::ResolveFontSize, updates Menu to use resolved font size with cached value, adjusts OverlayRenderer::RenderOverlay to accept cachedFontSize by reference, and enhances Settings UI with restore/defaults and auto/manual font size controls.

Changes

Cohort / File(s)	Summary
PerformanceOverlay persistence and defaults src/Features/PerformanceOverlay.cpp, src/Features/PerformanceOverlay.h	Added SaveSettings(json&), LoadSettings(json&), RestoreDefaultSettings(); DrawSettings gains “Restore Defaults” button with tooltip; loading resizes history buffers and falls back to defaults on invalid JSON.
Font size resolution and caching src/Menu.cpp, src/Menu.h, src/Menu/ThemeManager.cpp, src/Menu/ThemeManager.h	ThemeManager adds ResolveFontSize(Menu) and uses it in ReloadFont; Menu uses resolved font size and introduces cachedFontSize; ThemeSettings.FontSize default set to 0.0f to enable dynamic resolution-based sizing.
Overlay renderer signature src/Menu/OverlayRenderer.cpp, src/Menu/OverlayRenderer.h	RenderOverlay parameter changed from float cachedFontSize to float& cachedFontSize to allow modification by callee; callers pass lvalue.
Settings UI for sizes/defaults src/Menu/SettingsTabRenderer.cpp	Adds “Restore Theme Defaults,” tooltip, auto/manual font size toggle (0.0f sentinel), effective-size readout, disabled slider in auto mode, and immediate FontGlobalScale updates.

Sequence Diagram(s)

sequenceDiagram
  autonumber
  actor User
  participant Menu
  participant ThemeManager
  participant OverlayRenderer

  User->>Menu: Open overlay / change theme size
  Menu->>ThemeManager: ResolveFontSize(menu)
  ThemeManager-->>Menu: effectiveFontSize
  Menu->>OverlayRenderer: RenderOverlay(..., cachedFontSize&, currentFontSize=effectiveFontSize)
  OverlayRenderer->>ThemeManager: ReloadFont(menu, cachedFontSize&)
  ThemeManager-->>OverlayRenderer: maybe update cachedFontSize
  OverlayRenderer-->>Menu: draw complete

Loading

sequenceDiagram
  autonumber
  actor User
  participant SettingsUI as Settings Tab UI
  participant Perf as PerformanceOverlay

  User->>SettingsUI: Click "Restore Defaults"
  SettingsUI->>Perf: RestoreDefaultSettings()
  Perf->>Perf: Reset settings, smoothed stats, frame history buffers

  User->>SettingsUI: Save / Load
  SettingsUI->>Perf: SaveSettings(json&) / LoadSettings(json&)
  Perf-->>SettingsUI: Settings serialized / applied (with fallback)

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Possibly related PRs

• feat(ui): improve dynamic font size, add font size setting #1247 — Also changes Menu/theme font sizing and reload paths; overlaps with ResolveFontSize/ReloadFont refactor.
• refactor(perf overlay): tidy up perf overlay state update #1340 — Touches PerformanceOverlay settings and frame-history handling, related to new save/load/defaults.
• feat(ui): add welcome window #1431 — Modifies ThemeManager font-loading behavior, adjacent to ReloadFont and new resolution-based sizing.

Suggested reviewers

• alandtse

Poem

A nibble, a hop, a font-size tune,
I tweak my UI by sun and moon.
Defaults restored with a thump of feet,
Frames tracked neatly, buffers neat.
Save, load—snap!—my whiskers twitch;
Settings persist without a glitch.
Carrot-approved. 🥕

Pre-merge checks and finishing touches

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 11.11% which is insufficient. The required threshold is 80.00%.	You can run @coderabbitai generate docstrings to improve docstring coverage.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title Check	✅ Passed	The PR title "feat(ui): font size and perf overlay improvements" succinctly and accurately summarizes the primary work in this changeset—updates to UI font sizing/resolution defaults and improvements to the performance overlay (persistence and restore defaults)—and is clear and relevant for a reviewer scanning history.

✨ Finishing touches

• 📝 Generate Docstrings

🧪 Generate unit tests

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Using provided base ref: a04ff60
Using base ref: a04ff60
Base commit date: 2025-09-22T13:31:21+01:00 (Monday, September 22, 2025 01:31 PM)
No actionable suggestions for changed features.

[coderabbitai]

Actionable comments posted: 0

🧹 Nitpick comments (2)

src/Menu.h (1)

279-279: Consider documenting the cached font size member.

The cachedFontSize member serves an important role in preventing redundant font reloads. Consider adding a brief comment explaining its purpose.

-	float cachedFontSize = ThemeManager::Constants::DEFAULT_FONT_SIZE;  // Tracks whether font has been modified and may require reloading
+	float cachedFontSize = ThemeManager::Constants::DEFAULT_FONT_SIZE;  // Caches the last loaded font size to detect changes and prevent redundant reloads

src/Features/PerformanceOverlay.cpp (1)

241-256: Defaults reset looks good; consider clearing comparison/test state.

Optional: clearing A/B and manual test artifacts avoids confusing deltas immediately after a reset.

 void PerformanceOverlay::RestoreDefaultSettings()
 {
   this->settings = PerformanceOverlay::Settings{};
   // Reset runtime buffers/state to match defaults
   this->state.frameTimeHistory.Resize(this->settings.FrameHistorySize);
   this->state.postFGFrameTimeHistory.Resize(this->settings.FrameHistorySize);
   this->state.smoothFps = 0.0f;
   this->state.smoothFrameTimeMs = 0.0f;
   this->state.postFGSmoothFps = 0.0f;
   this->state.postFGSmoothFrameTimeMs = 0.0f;
   this->state.minFrameTime = 1000.0f;
   this->state.maxFrameTime = 0.0f;
   this->state.smoothedMinFrameTime = 0.0f;
   this->state.smoothedMaxFrameTime = 50.0f;
+  // Optional: also clear comparison state
+  this->ClearTestData();
+  this->settingsDiff.clear();
+  this->settingsDiffLoaded = false;
 }

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between a04ff60 and 93c5adf.

📒 Files selected for processing (9)

• src/Features/PerformanceOverlay.cpp (1 hunks)
• src/Features/PerformanceOverlay.h (1 hunks)
• src/Menu.cpp (3 hunks)
• src/Menu.h (1 hunks)
• src/Menu/OverlayRenderer.cpp (1 hunks)
• src/Menu/OverlayRenderer.h (1 hunks)
• src/Menu/SettingsTabRenderer.cpp (3 hunks)
• src/Menu/ThemeManager.cpp (3 hunks)
• src/Menu/ThemeManager.h (1 hunks)

🧰 Additional context used

📓 Path-based instructions (2)

**/*.{cpp,cxx,cc,c,h,hpp,hxx,hlsl,hlsli,fx,fxh,py}

📄 CodeRabbit inference engine (.github/copilot-instructions.md)

Do not include TODO/FIXME placeholders; provide complete, working solutions

Files:

• src/Menu.h
• src/Menu/OverlayRenderer.h
• src/Features/PerformanceOverlay.h
• src/Features/PerformanceOverlay.cpp
• src/Menu/OverlayRenderer.cpp
• src/Menu/ThemeManager.h
• src/Menu.cpp
• src/Menu/SettingsTabRenderer.cpp
• src/Menu/ThemeManager.cpp

src/**/*.{cpp,cxx,cc,h,hpp,hxx}

📄 CodeRabbit inference engine (.github/copilot-instructions.md)

src/**/*.{cpp,cxx,cc,h,hpp,hxx}: Ensure SE/AE/VR runtime compatibility; use runtime detection patterns (e.g., REL::RelocateMember())
Include robust error handling and resource management with graceful degradation in the plugin code

Files:

• src/Menu.h
• src/Menu/OverlayRenderer.h
• src/Features/PerformanceOverlay.h
• src/Features/PerformanceOverlay.cpp
• src/Menu/OverlayRenderer.cpp
• src/Menu/ThemeManager.h
• src/Menu.cpp
• src/Menu/SettingsTabRenderer.cpp
• src/Menu/ThemeManager.cpp

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Build plugin and addons

🔇 Additional comments (17)

src/Menu/OverlayRenderer.h (1)

43-43: LGTM! Reference parameter enables proper font size persistence.

Changing cachedFontSize from pass-by-value to pass-by-reference allows the overlay renderer to properly update the caller's cached value when fonts are reloaded. This aligns with the font size resolution flow where Menu::cachedFontSize needs to persist across frames.

src/Menu/ThemeManager.h (1)

10-12: LGTM! Well-documented resolution-based font sizing API.

The new ResolveFontSize method provides a clean interface for determining effective font size, with clear documentation explaining the dual behavior: dynamic resolution-based sizing when <= 0, or user-defined size when > 0.

src/Menu.h (1)

102-102: LGTM! Sensible default enables dynamic font sizing.

Setting FontSize = 0.0f as the default is a good design choice that triggers resolution-based sizing out of the box. The inline comment clearly documents the behavior.

src/Menu.cpp (3)

179-180: LGTM! Proper font size resolution through ThemeManager.

The code correctly delegates font size computation to ThemeManager::ResolveFontSize, maintaining consistent behavior across the application.

---

191-192: LGTM! Prevents redundant first-frame font reload.

Good optimization to initialize cachedFontSize with the effective size, avoiding unnecessary font reload on the first overlay render.

---

419-420: LGTM! Proper parameter passing to overlay renderer.

The code correctly passes both the cached font size (by reference) and the current resolved font size to the overlay renderer, enabling proper change detection and font reloading.

src/Menu/OverlayRenderer.cpp (1)

24-24: LGTM! Reference parameter matches header declaration.

The implementation correctly uses pass-by-reference for cachedFontSize, matching the header declaration and enabling proper font size persistence.

src/Menu/SettingsTabRenderer.cpp (3)

9-9: LGTM! Required include for ThemeManager usage.

The include is necessary for accessing ThemeManager::ResolveFontSize and related constants.

---

145-154: LGTM! Well-implemented theme reset with immediate font scale application.

The "Restore Theme Defaults" button properly resets the theme to defaults and immediately applies the global font scale. The tooltip clearly describes the action.

---

202-225: LGTM! Excellent resolution-based font sizing UI implementation.

The implementation provides a clean user experience:

• Clear checkbox to toggle between auto and manual font sizing
• Proper state transitions when switching modes
• Helpful "Effective size" display showing the computed font size
• Disabled slider in auto mode prevents confusion
• Good clamping when switching from auto to manual

src/Menu/ThemeManager.cpp (3)

9-9: LGTM! Required include for accessing screen size.

The State.h include is necessary for accessing globals::state->screenSize in the new ResolveFontSize method.

---

128-129: LGTM! Proper font size resolution and caching.

The implementation correctly:

1. Uses ResolveFontSize to compute the effective font size
2. Updates the cached value to enable proper change detection

Also applies to: 144-145

---

148-166: LGTM! Well-implemented resolution-based font sizing with proper fallback.

The ResolveFontSize implementation is robust:

• Clear precedence: user-configured size takes priority when > 0
• Dynamic sizing based on screen height with a sensible ratio (2.5%)
• Proper bounds clamping to prevent extreme values
• Fallback to default with warning log when screen size is unavailable
• Using std::round for the configured value check is appropriate for float comparison

src/Features/PerformanceOverlay.h (1)

132-135: Confirm JSON alias and contract for persistence APIs.

• Do we have a global using json = nlohmann::json; in scope for both the declaration and base interface? If not, prefer nlohmann::json& to avoid mismatch with the override.
• Please confirm the contract: does SaveSettings/LoadSettings receive the feature sub-object or the root JSON? This affects how the .cpp should read/write (direct object vs nested under GetShortName()).

src/Features/PerformanceOverlay.cpp (3)

207-213: Restore Defaults control: nice addition.

Button + tooltip reads well and is discoverable. No issues.

Should clicking “Restore Defaults” also clear any captured test data to avoid stale comparisons post‑reset?

---

221-226: Saving into root vs. feature subkey — verify expected JSON shape.

j = this->settings; will overwrite the passed object. If the caller hands you the root JSON, this can clobber other features. If the caller passes a feature‑scoped object, this is correct. Please confirm and, if needed, write under a subkey:

-void PerformanceOverlay::SaveSettings(json& j)
-{
-  // Persist all overlay settings to JSON
-  j = this->settings;  // uses NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT
-}
+void PerformanceOverlay::SaveSettings(json& j)
+{
+  if (!j.is_object()) j = json::object();
+  // If Save() is given the root object, persist under the short name.
+  // If the contract is feature‑scoped, keep direct assignment instead.
+  j[GetShortName()] = this->settings;
+}

---

227-240: Clamp and validate loaded settings to prevent pathological allocations and bad UI state.

File: src/Features/PerformanceOverlay.cpp — LoadSettings

Apply this diff:

-void PerformanceOverlay::LoadSettings(json& j)
-{
-  try {
-    // Load all settings from JSON (missing fields use defaults)
-    this->settings = j.get<PerformanceOverlay::Settings>();
-  } catch (...) {
-    // Fallback to defaults if JSON is invalid
-    this->settings = PerformanceOverlay::Settings{};
-  }
-  // Ensure history buffers match loaded size
-  this->state.frameTimeHistory.Resize(this->settings.FrameHistorySize);
-  this->state.postFGFrameTimeHistory.Resize(this->settings.FrameHistorySize);
-}
+void PerformanceOverlay::LoadSettings(json& j)
+{
+  // Accept either a direct block or a nested block under the feature short name.
+  const json* src = &j;
+  if (j.is_object() && j.contains(GetShortName())) {
+    src = &j[GetShortName()];
+  }
+  try {
+    this->settings = src->get<PerformanceOverlay::Settings>();
+  } catch (...) {
+    this->settings = PerformanceOverlay::Settings{};
+  }
+  // Sanitize loaded values
+  this->settings.FrameHistorySize = std::clamp(
+    this->settings.FrameHistorySize,
+    Settings::kMinFrameHistorySize,
+    Settings::kMaxFrameHistorySize);
+  this->settings.UpdateInterval = std::clamp(
+    this->settings.UpdateInterval, 0.001f, Settings::kMaxUpdateInterval);
+  this->settings.TextSize = std::clamp(this->settings.TextSize, 0.5f, 2.0f);
+  this->settings.BackgroundOpacity = std::clamp(this->settings.BackgroundOpacity, 0.0f, 1.0f);
+  // Ensure history buffers match sanitized size
+  this->state.frameTimeHistory.Resize(this->settings.FrameHistorySize);
+  this->state.postFGFrameTimeHistory.Resize(this->settings.FrameHistorySize);
+}

Also consider clamping/restoring Position (or set PositionSet = false) if it would end up off‑screen after a resolution change.

[github-actions]

✅ A pre-release build is available for this PR:
Download