Files
NX2navi/runtime/ui/perf_panel.cpp
epicmeme546 d1bebd34cd Keep the previous picture on screen instead of showing a frame that lacks draws, and show the game's own VRAM in the overlay.
A draw whose shader or pipeline is still building is left out of its frame, and the frame was shown without it: a black or unlit picture with the interface intact when it was a lighting pass, a light going out, or ground missing for a frame. In a player's session a full-screen draw was skipped after its 50 ms and the frame came out black as a boulder hit.

The frame's present is now left out when draws were skipped (vk_backend.c frame_hold, NX2NAVI_FRAME_HOLD_MS, 120 by default, 0 off). The game runs on, so nothing waits. The hold comes from an allowance that fills again at an eighth of the clock's rate, so a long build or a run of them shows its frames as before and does not freeze the picture; a full-screen draw that would be skipped with the allowance spent waits on instead, 500 ms at most. Not with DLSS Frame Generation.

On a first walk through a village with no pipeline recorded, 21 of the 23 frames with skipped draws were held back; in the Lost Woods, 7 of 8.

The performance overlay: the VRAM line is the card's dedicated memory in use, which counts every program on it: a player read 14.5 GB as the game's while the game held 7.3 GB. The line's third cell now gives what this process holds on the device-local heaps (the driver's budget figure), in place of the GPU clock, which stays where the driver gives no budget.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-10 04:39:19 -05:00

224 lines
10 KiB
C++

// The full performance overlay's panel (ui/perf_panel.h) in the settings menu's look: the menu's framed dark panel
// (ui/menu_skin.cpp), the numbers in tables with gold labels and parchment values, the game's divider between the
// machine, the frames, the per-frame waits and the picture, and the frame times as a gold line.
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "imgui.h"
#include "imgui_internal.h" // the window's draw cursor (the plot does not widen the panel)
#include "ui/menu_skin.h"
#include "ui/perf_panel.h"
extern "C" {
#include "ui_text.h"
}
namespace {
const ImVec4 kLabel(236 / 255.0f, 196 / 255.0f, 104 / 255.0f, 1); // SKIN_GOLD
const ImVec4 kValue(244 / 255.0f, 236 / 255.0f, 214 / 255.0f, 1); // SKIN_TEXT
const ImVec4 kDimText(170 / 255.0f, 152 / 255.0f, 120 / 255.0f, 1);
struct PerfCol { UiTextId fmt; float sample; };
float text_w(UiTextId fmt, float v) {
char b[64];
snprintf(b, sizeof b, menu_text(fmt), v);
return ImGui::CalcTextSize(b).x;
}
// The panel keeps its width while the numbers change: every column is as wide as the widest text it can show, measured
// on samples of 8s (the menu fonts' digits share one width), and the numbers are right-aligned in it.
// A fixed column as wide as the widest of the formats (with their samples) and labels given.
void column(const char *id, const PerfCol *cols, int n, const UiTextId *labels = nullptr, int nl = 0) {
float w = ImGui::CalcTextSize(menu_text(UI_MENU_OV_NONE)).x;
for (int i = 0; i < n; i++) w = fmaxf(w, text_w(cols[i].fmt, cols[i].sample));
for (int i = 0; i < nl; i++) w = fmaxf(w, ImGui::CalcTextSize(menu_text(labels[i])).x);
ImGui::TableSetupColumn(id, ImGuiTableColumnFlags_WidthFixed, w);
}
void right(const char *s, bool dim) {
float pad = ImGui::GetContentRegionAvail().x - ImGui::CalcTextSize(s).x;
if (pad > 0) ImGui::SetCursorPosX(ImGui::GetCursorPosX() + pad);
ImGui::TextColored(dim ? kDimText : kValue, "%s", s);
}
// One cell: fmt (a catalog format, one number) with v, or "-" when the machine gives none.
void cell(UiTextId fmt, float v) {
ImGui::TableNextColumn();
if (v < 0) return right(menu_text(UI_MENU_OV_NONE), true);
char b[64];
snprintf(b, sizeof b, menu_text(fmt), v);
right(b, false);
}
void label(UiTextId id) {
ImGui::TableNextColumn();
ImGui::TextColored(kLabel, "%s", menu_text(id));
}
float gb(float mb) { return mb < 0 ? -1 : mb / 1024; }
// The game's divider across the panel between two sections, smaller than the menu's.
void divider(float scale) {
float s = scale * 0.72f, h = skin_filigree_height(s);
ImVec2 p = ImGui::GetCursorScreenPos();
ImGuiWindow *win = ImGui::GetCurrentWindow();
float x1 = win->WorkRect.Max.x > p.x + 40 * s ? win->WorkRect.Max.x : p.x + 200 * s;
skin_filigree(ImGui::GetWindowDrawList(), p.x - 4 * s, x1 + 4 * s, p.y + h * 0.5f, s);
ImGui::Dummy(ImVec2(0, h));
}
void machine_and_frames(const PerfPanel *p, float scale) {
const PerfStats &s = p->s;
if (!ImGui::BeginTable("##perft", 4, ImGuiTableFlags_SizingFixedFit)) return;
static const UiTextId labels[] = {UI_MENU_OV_GPU, UI_MENU_OV_VRAM, UI_MENU_OV_CPU, UI_MENU_OV_RAM,
UI_MENU_OV_FPS_LABEL, UI_MENU_OV_FRAME_LABEL};
static const PerfCol c1[] = {{UI_MENU_OV_FMT_PCT, 100}, {UI_MENU_OV_FMT_GB, 888.8f}, {UI_MENU_OV_FMT_FPS, 888},
{UI_MENU_OV_FRAME_MS, 888.8f}};
static const PerfCol c2[] = {{UI_MENU_OV_FMT_TEMP, 188}, {UI_MENU_OV_FMT_GB_OF, 888.8f}, {UI_MENU_OV_LOW1, 888},
{UI_MENU_OV_MAX_MS, 8888.8f}};
static const PerfCol c3[] = {{UI_MENU_OV_FMT_POWER, 888}, {UI_MENU_OV_FMT_MHZ, 8888}, {UI_MENU_OV_GAME_PCT, 100},
{UI_MENU_OV_GAME_GB, 888.8f}, {UI_MENU_OV_LOW01, 888}};
column("##c0", nullptr, 0, labels, 6);
column("##c1", c1, 4);
column("##c2", c2, 4);
column("##c3", c3, 5);
label(UI_MENU_OV_GPU);
cell(UI_MENU_OV_FMT_PCT, s.gpu_pct);
cell(UI_MENU_OV_FMT_TEMP, s.gpu_temp_c);
cell(UI_MENU_OV_FMT_POWER, s.gpu_power_w);
label(UI_MENU_OV_VRAM);
cell(UI_MENU_OV_FMT_GB, gb(s.vram_used_mb));
cell(UI_MENU_OV_FMT_GB_OF, gb(s.vram_total_mb));
// the card's figure counts every program on it: this game's own share beside it, the clock where that is unknown
if (s.vram_game_mb >= 0) cell(UI_MENU_OV_GAME_GB, gb(s.vram_game_mb));
else cell(UI_MENU_OV_FMT_MHZ, s.gpu_clock_mhz);
label(UI_MENU_OV_CPU);
cell(UI_MENU_OV_FMT_PCT, s.cpu_total_pct);
cell(UI_MENU_OV_FMT_TEMP, s.cpu_temp_c);
cell(UI_MENU_OV_GAME_PCT, s.cpu_game_pct);
label(UI_MENU_OV_RAM);
cell(UI_MENU_OV_FMT_GB, gb(s.ram_used_mb));
cell(UI_MENU_OV_FMT_GB_OF, gb(s.ram_total_mb));
cell(UI_MENU_OV_GAME_GB, gb(s.ram_game_mb));
ImGui::EndTable();
divider(scale);
if (!ImGui::BeginTable("##perff", 4, ImGuiTableFlags_SizingFixedFit)) return;
column("##f0", nullptr, 0, labels, 6);
column("##f1", c1, 4);
column("##f2", c2, 4);
column("##f3", c3, 5);
// the frames: the rate over the last second with the lows over the last ten seconds, then the frame times
label(UI_MENU_OV_FPS_LABEL);
cell(UI_MENU_OV_FMT_FPS, s.fps);
cell(UI_MENU_OV_LOW1, s.low1_fps);
cell(UI_MENU_OV_LOW01, s.low01_fps);
if (p->fg_fps > 0) { // frame generation: what the display gets, generated frames included
label(UI_MENU_OV_FG_LABEL);
cell(UI_MENU_OV_FMT_FPS, p->fg_fps);
ImGui::TableNextColumn();
ImGui::TableNextColumn();
}
label(UI_MENU_OV_FRAME_LABEL);
cell(UI_MENU_OV_FRAME_MS, s.frame_ms_avg);
cell(UI_MENU_OV_MAX_MS, s.frame_ms_max);
ImGui::TableNextColumn();
ImGui::EndTable();
}
// The frame times of the last PERF_HISTORY frames as a gold line over a dark band, as wide as the tables made the panel
// (the plot does not count toward that width, so the panel can still shrink).
void frame_plot(const PerfStats &s, float scale) {
float top = s.frame_ms_max > 50 ? s.frame_ms_max : 50;
ImGuiWindow *win = ImGui::GetCurrentWindow();
float max_x = win->DC.CursorMaxPos.x;
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0, 0, 0, 0.32f));
ImGui::PushStyleColor(ImGuiCol_PlotLines, kLabel);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
ImGui::PlotLines("##ft", s.frame_ms, PERF_HISTORY, 0, nullptr, 0, top, ImVec2(-FLT_MIN, 48 * scale));
ImGui::PopStyleVar();
ImGui::PopStyleColor(2);
win->DC.CursorMaxPos.x = max_x;
}
// Per frame, averaged over the last half second; the labels' column stretches, so the numbers end at the panel's right
// edge, and the table still asks for no more than its widest label and number.
void waits(const PerfStats &s) {
if (!ImGui::BeginTable("##perfw", 2, ImGuiTableFlags_SizingFixedFit)) return;
static const PerfCol c1[] = {{UI_MENU_OV_FMT_MS, 888.88f}, {UI_MENU_OV_PER_FRAME, 888.8f}};
ImGui::TableSetupColumn("##w0", ImGuiTableColumnFlags_WidthStretch);
column("##w1", c1, 2);
label(UI_MENU_OV_REPLAY);
cell(UI_MENU_OV_FMT_MS, s.replay_ms);
label(UI_MENU_OV_GPU_TIME);
cell(UI_MENU_OV_FMT_MS, s.gpu_ms);
label(UI_MENU_OV_PIPE_WAIT);
cell(UI_MENU_OV_FMT_MS, s.pipe_wait_ms);
label(UI_MENU_OV_SHADER_WAIT);
cell(UI_MENU_OV_FMT_MS, s.xlate_ms);
label(UI_MENU_OV_TEX_UPLOADS);
cell(UI_MENU_OV_PER_FRAME, s.tex_uploads);
ImGui::EndTable();
}
void picture(const PerfPanel *p) {
static const UiTextId labels[10] = {UI_MENU_OV_WINDOW, UI_MENU_OV_OUTPUT, UI_MENU_OV_SCENE, UI_MENU_UPSCALING, UI_MENU_OV_LIMIT,
UI_MENU_PRESENT_VSYNC, UI_MENU_GAME_ASPECT, UI_MENU_GAME_RES, UI_MENU_HDR, UI_MENU_FRAMEGEN};
if (!ImGui::BeginTable("##perfp", 2, ImGuiTableFlags_SizingFixedFit)) return;
float vw = 0;
for (const auto &v : p->picture) vw = fmaxf(vw, ImGui::CalcTextSize(v).x);
ImGui::TableSetupColumn("##p0", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("##p1", ImGuiTableColumnFlags_WidthFixed, vw);
for (int i = 0; i < 10; i++) {
if ((i == 2 && !p->scene_known) || !p->picture[i][0]) continue;
label(labels[i]);
ImGui::TableNextColumn();
right(p->picture[i], false);
}
ImGui::EndTable();
}
} // namespace
void perf_panel_draw(const PerfPanel *p, float width, float scale) {
const float m = 12 * scale;
ImGui::SetNextWindowPos(ImVec2(width - m, m), ImGuiCond_Always, ImVec2(1, 0));
ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0)); // the panel below is the background
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(24 * scale, 20 * scale));
ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, ImVec2(7 * scale, 1.5f * scale));
ImGui::Begin("##perf", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize |
ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoSavedSettings);
ImGui::PopStyleVar(3);
ImGui::PopStyleColor();
// under the menu while it is open (the settings stay readable), else over everything
if (p->under_menu) ImGui::BringWindowToDisplayBack(ImGui::GetCurrentWindow());
else ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
ImDrawList *dl = ImGui::GetWindowDrawList();
dl->ChannelsSplit(2); // the panel goes under the text, drawn once the window's size is known
dl->ChannelsSetCurrent(1);
ImGui::SetWindowFontScale(0.72f);
// the port version and the game update first, so a screenshot in a bug report carries both
ImGui::TextColored(kDimText, "%s", p->version);
divider(scale);
machine_and_frames(p, scale);
ImGui::Dummy(ImVec2(0, 4 * scale));
frame_plot(p->s, scale);
ImGui::Dummy(ImVec2(0, 2 * scale));
waits(p->s);
divider(scale);
picture(p);
if (p->s.gpu_name[0] || p->s.cpu_name[0]) divider(scale);
if (p->s.gpu_name[0]) ImGui::TextColored(kDimText, "%s", p->s.gpu_name);
if (p->s.cpu_name[0]) ImGui::TextColored(kDimText, "%s", p->s.cpu_name);
dl->ChannelsSetCurrent(0);
ImVec2 a = ImGui::GetWindowPos(), sz = ImGui::GetWindowSize();
skin_panel(dl, a, ImVec2(a.x + sz.x, a.y + sz.y), scale * 0.8f, 0.94f);
dl->ChannelsMerge();
ImGui::End();
}