mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 21:29:58 -04:00
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>
224 lines
10 KiB
C++
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();
|
|
}
|