Compare commits

...
Author SHA1 Message Date
poli0981andClaude Opus 5.5 8aa8186643 feat(app): the new measurements as summary cards, a render scale chart, a clocks and fan chart, nine trend metrics and nine compare rows labelled (presented) where they are over presents (beta.14 PR-8, D49)
The App's half of D49 (PR-7 recorded the values). Every value is read from the stored row, never recomputed, and reads
N/A on a session recorded before beta.14.

Summary (SessionSummaryViewModel, the cards in AddFrameCards / AddPacingCards / AddMachineCards):
- Time below 60 FPS, with below 30 and "display under {refresh} Hz" beneath - the refresh share named for the display, as
  it is over the presents the display received - and Frame to frame; both carry (presented) where the lows do.
- VSync (share of frames, tearing allowed beneath), Ray tracing (share of frames, rays per pixel; only where measured),
  Game in focus (foreground over drain ticks), Capture quality (gaps, lost records, faults).
- The 1% Low card carries "displayed: N" where frames were generated - rule 6, beside the game's own, never instead.
- GPU clocks (core, memory; fan and memory temperature beneath), GPU held back (power, heat; NVIDIA only), Frames per watt.

Charts:
- RenderScaleChart over RenderScaleSeries: 100 x sqrt(render / output pixels) as steps, from the render_res blob where the
  resolution varied, a flat line at the row's extent where it did not, a sentence where never measured.
- SensorsChart: the memory temperature on the temperatures plot, in a new palette colour (Chart_SensorTertiary: no
  existing colour was 60 apart from all six beside it - ChartMathTests caught Chart_Histogram == Chart_Native), and a
  Clocks and fan plot - core and memory MHz, fan RPM on the right, the ticks a limit held the card back shaded
  (LimitRuns); collapsed when the session stored none of them.

Trend: nine metrics (time below 60 / refresh, frame to frame, render scale = 100 / upscale_ratio, VSync share, frames per
watt from hooked sessions; core clock, memory temperature, power-limit share from every session), with ms, MHz and FPS/W
axes. Compare: nine rows; the median, lows, stutter, time below 60 and frame to frame carry (presented) in the cell of a
present-only session, the best decided on the number, never the label. The Latency tab is shown only for a game with a
session that measured latency (nothing measures Reflex today). Formats.Share, Milliseconds, FramesPerJoule.

Tests: SessionSummaryViewModelTests (every new card with values, a pre-beta.14 row at N/A, the displayed low),
RenderScaleAndClocksTests (scale arithmetic, steps, flat line, limit runs, both charts drawn on the STA thread),
TrendSeriesBuilderTests, CompareViewModelTests (labels and bests), FormatsTests, GameDetailViewModelTests (Latency tab),
ChartMathTests (the clocks plot's colours too).

Docs: 08_UI (summary, trend, compare, latency), 03_METRICS (render scale over time), legal/ACCURACY.md (one bullet, mirrored
into README and DISCLAIMER by accuracy-check; Disclaimer version unchanged as in beta.13), guide/03-read-your-results,
LIMITATIONS, CHANGELOG. Strings en/vi, ja marked for review.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 04:44:02 +07:00
36 changed files with 1598 additions and 36 deletions

No files matched your search

+7
View File
@@ -46,6 +46,13 @@ numeric core and does not move; the heading is the full version — corrected 20
The session's sensor statistics table shows the new card readings in their own units. The database is migrated in
place (schema 0019), and an earlier version cannot open it afterwards.
- **Where the new measurements are shown:** the session summary has a card for each (the 1% low card also shows the
displayed frames' 1% low when frame generation was counted, beside the game's own), a **Render scale** chart — the
share of the screen's resolution the game rendered at, over the session — and a **Clocks and fan** chart under
Sensors, with the moments the card was held back shaded; the card's memory temperature joins the temperatures chart.
A game's **Trend** has nine more metrics and **Compare** nine more rows, where a figure taken over presents says
*(presented)* beside one taken over the game's own frames. The **Latency** tab is shown only for a game with a session
that measured latency — none does yet.
### Fixed
+2
View File
@@ -74,6 +74,8 @@ shown is recorded too, from outside the game. ([Capture](docs/04_CAPTURE.md))
## Upscaling and ray tracing
- **The render scale chart** (since 0.1.0-beta.14) is drawn only where the render resolution was measured — the
same games as *Render → output resolution* in the accuracy statement; elsewhere it says it was not measured.
- The upscaler is read from the game's calls: DLSS and NIS through NVIDIA Streamline, and FSR through AMD's
FidelityFX libraries. **Intel XeSS is not read** (its licence forbids it), FSR 2 and upscalers built into the
game are not identified, and Vulkan and OpenGL games read N/A. Where no hook saw DLSS but the NVIDIA driver
+9 -1
View File
@@ -9,7 +9,7 @@ anti-cheat, and look after your data, a page each. What FrameLedger cannot do is
[Limitations](LIMITATIONS.md). Both are in the app too (Help ▸ User guide, Help ▸ Limitations).
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.13`** (2026-10-04), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -73,6 +73,14 @@ anti-cheat, and look after your data, a page each. What FrameLedger cannot do is
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
+6
View File
@@ -640,6 +640,12 @@ Tier 2 has none of this: `upscaler = unknown`, ratio `N/A`.
> bookkeeping is per process, not per settings change. **Nothing native changed and no NGX hook was added**: the
> licence bar in `20_OPEN_QUESTIONS` stands.
**The render scale over time (beta.14, D49).** The session summary draws `100 × √(render pixels / output pixels)` — the
per-axis scale, `100 / upscale_ratio` — as steps over the session: from the `render_res` blob where the resolution
varied (the finalizer stores it only then), a flat line at the row's extent where it did not, and a sentence where the
upscaler's parameters were never measured (`App.Charts.RenderScaleSeries`). The Trend and Compare read the row's
`upscale_ratio`, the dominant extent.
## RT / PT / RR — evidence-based tri-state
Tri-state `Yes | No | N/A` per session with `source` (`measured | manual | inherited`).
+38 -1
View File
@@ -399,7 +399,14 @@ All screens are `Page`s registered with the navigation page provider and navigat
> per-present `vram_proc` (a held 1 Hz sample) and~~ the adapter-wide `vram_adapter` sensor ~~as two
> differently-labelled series~~ (corrected 2026-10-03: the Overlay never produced `vram_proc`, so the game's line was
> never drawn on any session; beta.12's two memory plots are described above). **Latency**: the `latency_us` blob with the stored avg / p95 lines, shown only
> when Reflex reported (`reflex_active`); otherwise the tab says so.
> when Reflex reported (`reflex_active`); otherwise the tab says so. **Since beta.14 the tab itself is shown only when one
> of the game's sessions measured latency** (`GameDetailViewModel.AnyLatency`): nothing measures Reflex today, and a tab
> that could only say "no data" was noise.
>
> **Trend, beta.14 (D49):** nine more metrics — *Time below 60 FPS %*, *Display under refresh rate %*, *Frame to frame
> ms*, *Render scale %* (`100 / upscale_ratio`), *VSync share %* and *Frames per watt* from hooked sessions; *Avg GPU core
> clock MHz*, *Max GPU memory °C* and *Held back by power limit %* from every session's telemetry. Each has its own unit
> (ms, MHz and FPS/W are new axes); a session recorded before beta.14 has no point (`TrendSeriesBuilderTests`).
>
> **Trend, corrected 2026-09-25 (beta.8, owner item 6: "does Trend really work?").** It did not, on first open: the
> view model started loading before the page existed, and a load that finished first raised `TrendPresented` to nobody
@@ -431,6 +438,29 @@ All screens are `Page`s registered with the navigation page provider and navigat
### Session summary (secondary `FluentWindow`, also the post-session toast target)
Stat cards (Avg uses `FpsReadout`, Median, 1% Low, 0.1% Low, Min/Max, σ, stutter %, duration, **Display** — beta.10: the mode shown longest with its share and the window's size, both tiers; **VRAM (this game)** and **RAM (this game)** — beta.12: the median with the peak beneath, both tiers), **Statistics per series** (beta.12: every stored series' mean / median / minimum / peak), TriState chips, API/PresentMode/upscaler line, **the display line** (beta.10: every mode's share, the changes, the window on its monitor at its refresh rate, the back buffer and swap effect, and what the facts rested on — "the swap chain said whether it was exclusive" or "from the window alone: exclusive fullscreen cannot be told from borderless"; absent for a session recorded before), crash `InfoBar` (Severity=Error) when `crashed`, frametime chart, sensor strip, tags/notes editor, Export buttons.
> **beta.14 (D49): the new measurements, as cards and charts.** The cards come in three methods (`AddFrameCards`,
> `AddPacingCards`, `AddMachineCards`), every value read from the row — never recomputed — and N/A on a row written before
> beta.14:
> - **Time below 60 FPS** with *below 30* and *display under {refresh} Hz* beneath it — the refresh share named for the
> display because it is over the presents the display received (`03_METRICS` §Pacing) — and **Frame to frame**; both
> carry *(presented)* where the session's statistics are over presents, as the lows do.
> - **VSync** (*{share} of frames*, with *tearing allowed* beneath), **Ray tracing** (*{share} of frames* and rays per
> pixel — the card appears only where ray tracing was measured), **Game in focus** (foreground ticks over drain ticks)
> and **Capture quality** (gaps · lost records · faults).
> - The **1% Low** card carries *displayed: {presents' 1% low}* beneath it where frames were generated (rule 6: beside the
> game's own, never instead of it).
> - **GPU clocks** (core · memory, with fan and memory temperature beneath), **GPU held back** (power · heat, NVIDIA only)
> and **Frames per watt** (*the game's own frames, GPU power only*).
>
> Charts: **Render scale** under Distribution (`Charts/RenderScaleChart` over `RenderScaleSeries`: `100 × √(render pixels /
> output pixels)` as steps — from the `render_res` blob where the resolution varied, a flat line at the row's extent where
> it did not, and a sentence where the upscaler's parameters were never measured), and on **Sensors** the card's memory
> temperature on the temperatures plot (its own palette colour, `Chart_SensorTertiary`: no existing one was 60 apart from
> all six beside it) and a fourth plot, **Clocks and fan** — core and memory clock in MHz, the fan in RPM on the right, and
> the ticks its power limit or heat held it back shaded behind them; collapsed when the session stored none of these.
> Tests: `SessionSummaryViewModelTests` (the new cards, a row before beta.14 at N/A, the displayed low),
> `RenderScaleAndClocksTests`, `ChartMathTests`.
>
> **Built 2026-09-14 (P3 PR-6).** `Windows/SessionSummaryWindow` (a secondary `FluentWindow` with its own
> `ContentDialogHost`), opened from a Sessions-tab row (double-click or Open) and from the Dashboard's recent
> list. Stat cards read the STORED aggregates — never recomputed — with the lows labelled *(presented)* when
@@ -535,6 +565,13 @@ Session picker (2–5, cross-game allowed) → overlaid percentile curves + stat
>
> **beta.10:** three rows after Duration — *Display mode* (every share), *Window* and *Monitor* (with its refresh
> rate) — facts, not scores: no mode is better than another, so none is ever marked best, and every tier has them.
>
> **beta.14 (D49):** *Time below 60 FPS* and *Frame to frame* (lower is better), *Display under refresh rate* (lower is
> better), *VSync share* and *Render scale* (settings: no best), *Avg GPU core clock* and *Held back by power limit*
> (facts: no best), *Max GPU memory °C* (lower) and *Frames per watt* (higher). **A statistic a present-only session has
> over its presents carries *(presented)* in its cell** — the median, the lows, stutter, time below 60, frame to frame —
> beside a session whose same statistic is over the game's own frames; the best is decided on the number, never the label
> (`CompareViewModel.Row`'s label, `CompareViewModelTests`).
### Logs
Tail view of `ui-*.log` / `agent-*.log` (toggle), level filter, search (`ui:AutoSuggestBox`), pause-scroll; buttons: Open logs folder, Export bug bundle (routes to 10_LOGGING flow).
+12 -2
View File
@@ -18,6 +18,14 @@ A value FrameLedger could not measure reads **N/A** — never 0, and never an es
- **1% low** and **0.1% low** are the frame rate of the slowest 1% and 0.1% of frames: the further they fall below the
average, the less smooth the game felt. **Stutter** counts frames that took much longer than the frames around them,
and the share of time they took.
- **Time below 60 FPS** (with *below 30* and *display under* your monitor's refresh rate beneath it) is how much of the
session ran slower than that. A game held at its limit is not counted as dropping below it for the tiny wobble every
frame limit has. **Frame to frame** is how much one frame's time differs from the next: lower is smoother.
- **VSync** is how many frames asked to wait for the display, and *tearing allowed* how many did not mind tearing — what
the game asked; your graphics driver can still override it.
- **GPU clocks**, the fan and the video memory's temperature are the card's own readings. **GPU held back** says how much
of the time its power limit or its temperature slowed it down (NVIDIA cards only). **Frames per watt** is the game's
own frames per second for each watt the graphics card drew — generated frames never count.
## Memory
@@ -38,8 +46,10 @@ correct it by hand — your correction is labelled as yours.
- **Frametime** — how long each frame took. Spikes are stutters.
- **Distribution** — how often each frame rate occurred.
- **Sensors** — temperatures, load and power; video memory; memory. The game's own line and the whole card's or the
whole PC's are drawn separately.
- **Render scale** — the share of the screen's resolution the game rendered at before upscaling (100% means no
upscaling), and when it changed.
- **Sensors** — temperatures, load and power; video memory; memory; and the card's clocks and fan, with the moments it
was held back shaded. The game's own line and the whole card's or the whole PC's are drawn separately.
- **Trend** (on the game's page) — one point per session over time, for example before and after a driver update.
Changes to your hardware or driver are marked on it.
- **Compare** (in the navigation on the left) — pick sessions, even of different games, and see them side by side.
+9 -1
View File
@@ -11,7 +11,7 @@
that changes what FrameLedger.Overlay or the capture host does; date the change.
HTML comments are not part of the block.
-->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.13`** (2026-10-04), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -75,6 +75,14 @@
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
+9 -1
View File
@@ -113,7 +113,7 @@ Software running inside another process can, in principle, destabilize it. Frame
Frame timing is derived from high-resolution timestamps taken at the moment the game presents each frame; upscaling, frame-generation and ray-tracing state are read from the parameters the game passes to those APIs. This is substantially more accurate than inferring settings from files on disk, but **no measurement is guaranteed to be exact**:
<!-- accuracy-block:begin -->
> ⚠ **What FrameLedger actually measures today — 2026-10-04.** The software is a beta; its latest
> ⚠ **What FrameLedger actually measures today — 2026-10-06.** The software is a beta; its latest
> **pre-release is `0.1.0-beta.13`** (2026-10-04), an unsigned installer built from that tag with its
> checksums published beside it. The source holds the desktop app
> (library, store import, charts, settings) and the background Agent, which records a session when a
@@ -177,6 +177,14 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
> and charted. **Not measured at all:** the video-memory budget Windows gives a game, which frame
> spikes were shader compilation, PC latency (Reflex), and HDR. Stutter count and stutter time are
> measured from frame times.
> - **Pacing, VSync and the graphics card (since beta.14):** the share of the time below 30 FPS, below 60 FPS and below
> the monitor's refresh rate, measured from frame times with small margins so that a game held at its limit is not
> counted as below it (a rate less than 2 % under the line reads partly as at it), and how much one frame's time
> differs from the next; for Direct3D titles, how many frames asked to wait for the display and how many allowed
> tearing — what the game asked, not what the driver did; the graphics card's clock speeds, fan speed and memory
> temperature in every session, and, on NVIDIA cards only, how much of the time its power limit or its temperature held
> it back, read once a second; and frames per watt — the game's own frames per second for each watt the graphics card
> drew, never counting generated frames, `N/A` where the game's own frame rate is not known.
> - **Processor and memory:** how busy the processor was (time busy, all cores together — not the
> frequency-scaled figure Task Manager draws) and how much system memory was in use, read from
> Windows once a second and charted. Processor temperature is read only when the Agent runs as
+5 -2
View File
@@ -25,13 +25,15 @@ public sealed record ChartPalette(
Color SensorSecondary,
Color Segment,
Color Histogram,
Color Percentile)
Color Percentile,
Color SensorTertiary)
{
/// <summary>The keys both dictionaries must carry, in the record's order.</summary>
public static readonly IReadOnlyList<string> Keys =
[
"Chart_Figure", "Chart_Data", "Chart_Axis", "Chart_Grid", "Chart_Native", "Chart_Displayed", "Chart_Stutter",
"Chart_StutterPso", "Chart_Sensor", "Chart_SensorSecondary", "Chart_Segment", "Chart_Histogram", "Chart_Percentile",
"Chart_SensorTertiary",
];
private static readonly Dictionary<ApplicationTheme, ChartPalette> _cache = [];
@@ -57,7 +59,7 @@ public sealed record ChartPalette(
{
ArgumentNullException.ThrowIfNull(dictionary);
Color[] c = [.. Keys.Select(k => Convert(dictionary, k))];
return new ChartPalette(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12]);
return new ChartPalette(c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10], c[11], c[12], c[13]);
}
/// <summary>The colour a key names — how a chart that assigns palette entries to series by name reads them (<c>SensorsChart</c>).</summary>
@@ -76,6 +78,7 @@ public sealed record ChartPalette(
"Chart_Segment" => Segment,
"Chart_Histogram" => Histogram,
"Chart_Percentile" => Percentile,
"Chart_SensorTertiary" => SensorTertiary,
_ => throw new ArgumentOutOfRangeException(nameof(key), key, "not a chart palette key"),
};
@@ -0,0 +1,17 @@
<!-- SPDX-License-Identifier: GPL-3.0-only -->
<!-- Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE -->
<UserControl x:Class="FrameLedger.App.Charts.RenderScaleChart"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
xmlns:res="clr-namespace:FrameLedger.App"
xmlns:sp="clr-namespace:ScottPlot.WPF;assembly=ScottPlot.WPF">
<!-- 08_UI §Session summary (beta.14, D49): the render scale over the session, as steps; a line saying it was not measured
where the upscaler's parameters never were. -->
<Grid>
<sp:WpfPlot x:Name="Plot" />
<ui:TextBlock x:Name="NotMeasured" Appearance="Secondary" TextWrapping="Wrap" VerticalAlignment="Center" HorizontalAlignment="Center"
Text="{x:Static res:Strings.Chart_RenderScale_NotMeasured}" Visibility="Collapsed" />
</Grid>
</UserControl>
@@ -0,0 +1,52 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using System.Windows.Controls;
using FrameLedger.Application.Persistence;
using ScottPlot;
using ScottPlot.Plottables;
namespace FrameLedger.App.Charts;
/// <summary>
/// The render scale over a session (beta.14, D49; <see cref="RenderScaleSeries"/>): a step line — a scale holds until the next
/// change — and, where the upscaler's parameters were never measured, a sentence saying so instead of an empty plot.
/// </summary>
public partial class RenderScaleChart : UserControl
{
public RenderScaleChart()
{
InitializeComponent();
ChartTheme.Attach(Plot);
}
/// <summary>The points drawn by the last <see cref="Show"/>; 0 when the scale was not measured.</summary>
public int DrawnPoints { get; private set; }
public void Show(SessionSeries? series, SessionRow? row)
{
ScottPlot.Plot plot = Plot.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(Strings.Chart_Axis_TimeFromFirstFrame);
plot.YLabel(Strings.Chart_Axis_RenderScale);
(double[] xs, double[] ys) = row is null ? ([], []) : RenderScaleSeries.Of(series, row);
DrawnPoints = xs.Length;
if (xs.Length > 0)
{
Scatter line = plot.Add.Scatter(xs, ys, ChartTheme.Current.Native);
line.ConnectStyle = ConnectStyle.StepHorizontal;
line.MarkerSize = 0;
line.LineWidth = 2;
plot.Axes.AutoScale();
// A scale reads against 0 and 100 %: an axis fitted to one flat line would make 66.7 % look like a cliff.
plot.Axes.SetLimitsY(0, Math.Max(100, ys.Max() * 1.05));
}
NotMeasured.Visibility = xs.Length > 0 ? Visibility.Collapsed : Visibility.Visible;
Plot.Visibility = xs.Length > 0 ? Visibility.Visible : Visibility.Hidden;
Plot.Refresh();
}
}
@@ -0,0 +1,78 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using FrameLedger.Application.Persistence;
namespace FrameLedger.App.Charts;
/// <summary>
/// The render scale over a session (beta.14, D49): <c>100 × √(render pixels / output pixels)</c> — the per-axis scale
/// <c>03_METRICS</c> §Upscaling names, so DLSS Quality's 1707×960 of 2560×1440 reads 66.7 %. Per present from the
/// <c>render_res</c> blob where the resolution varied, a flat line at the row's extent where it did not (the finalizer stores
/// the blob only then), and nothing where the upscaler's parameters were never measured.
/// </summary>
internal static class RenderScaleSeries
{
/// <summary>The scale in percent, or null when either size is unknown (0 is the writer's "unknown").</summary>
public static double? Scale(int renderW, int renderH, int outputW, int outputH) =>
renderW > 0 && renderH > 0 && outputW > 0 && outputH > 0
? 100.0 * Math.Sqrt((double)renderW * renderH / ((double)outputW * outputH))
: null;
/// <summary>
/// Seconds from the first present and the scale there — only the points where the scale changes, and the last one, since
/// a scale holds until the next change and a 300,000-present session has a handful (drawn as steps). Empty when nothing
/// was measured.
/// </summary>
public static (double[] Xs, double[] Ys) Of(SessionSeries? series, SessionRow row)
{
ArgumentNullException.ThrowIfNull(row);
if (series is null || series.Presents == 0)
{
return ([], []);
}
if (series.RenderRes is { } quads && quads.Length >= 4 * series.Presents)
{
return Changes(series, quads);
}
return Scale(row.RenderW ?? 0, row.RenderH ?? 0, row.OutputW ?? 0, row.OutputH ?? 0) is double flat
? ([0, series.DurationS], [flat, flat])
: ([], []);
}
private static (double[] Xs, double[] Ys) Changes(SessionSeries series, ushort[] quads)
{
var xs = new List<double>();
var ys = new List<double>();
double? last = null;
int lastIndex = -1;
for (int i = 0; i < series.Presents; i++)
{
if (Scale(quads[4 * i], quads[4 * i + 1], quads[4 * i + 2], quads[4 * i + 3]) is not double s)
{
continue;
}
lastIndex = i;
if (last is double previous && Math.Abs(previous - s) < 1e-9)
{
continue;
}
xs.Add(series.TimesS[i]);
ys.Add(s);
last = s;
}
// The last measured present closes the final step, so a scale held to the end is drawn to the end.
if (last is double end && xs.Count > 0 && series.TimesS[lastIndex] > xs[^1])
{
xs.Add(series.TimesS[lastIndex]);
ys.Add(end);
}
return ([.. xs], [.. ys]);
}
}
@@ -16,5 +16,11 @@
<sp:WpfPlot x:Name="Vram" Height="220" Margin="0,6,0,0" />
<ui:TextBlock Margin="0,12,0,0" FontTypography="BodyStrong" Text="{x:Static res:Strings.Sensors_Ram_Header}" />
<sp:WpfPlot x:Name="Ram" Height="220" Margin="0,6,0,0" />
<!-- beta.14 (D49): the card's clocks (MHz) and fan (RPM, right axis), with the ticks its power limit or heat held it
back shaded. Collapsed when the session stored none of them. -->
<StackPanel x:Name="ClocksSection">
<ui:TextBlock Margin="0,12,0,0" FontTypography="BodyStrong" Text="{x:Static res:Strings.Sensors_Clocks_Header}" />
<sp:WpfPlot x:Name="Clocks" Height="220" Margin="0,6,0,0" />
</StackPanel>
</StackPanel>
</UserControl>
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using System.Windows;
using System.Windows.Controls;
using FrameLedger.App.Services;
using FrameLedger.Application.Recording;
@@ -28,6 +29,7 @@ public partial class SensorsChart : UserControl
[
("gpu_temp", "Chart_Sensor", false),
("gpu_hotspot", "Chart_Stutter", false),
(SensorSeriesCatalog.GpuMemTemp, "Chart_SensorTertiary", false),
("gpu_load", "Chart_Native", false),
("gpu_power", "Chart_SensorSecondary", true),
("cpu_temp", "Chart_Percentile", false),
@@ -52,6 +54,21 @@ public partial class SensorsChart : UserControl
(SensorSeriesCatalog.RamSystem, "Chart_Percentile"),
];
/// <summary>The clocks plot's lines (beta.14): core and memory clock on the MHz axis, the fan on the right-hand RPM axis.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey, bool Rpm)> ClocksPlot =
[
(SensorSeriesCatalog.GpuCoreClock, "Chart_Native", false),
(SensorSeriesCatalog.GpuMemClock, "Chart_Displayed", false),
(SensorSeriesCatalog.GpuFan, "Chart_SensorSecondary", true),
];
/// <summary>The limits shaded on the clocks plot (beta.14): the ticks each one held the card back, NVIDIA only.</summary>
internal static readonly IReadOnlyList<(string Series, string PaletteKey)> LimitSpans =
[
(SensorSeriesCatalog.GpuPowerLimit, "Chart_Stutter"),
(SensorSeriesCatalog.GpuThermalLimit, "Chart_StutterPso"),
];
private const double _mibPerGb = 1024.0;
public SensorsChart()
@@ -60,8 +77,12 @@ public partial class SensorsChart : UserControl
ChartTheme.Attach(Temps);
ChartTheme.Attach(Vram);
ChartTheme.Attach(Ram);
ChartTheme.Attach(Clocks);
}
/// <summary>The shaded spans the last <see cref="Show"/> drew on the clocks plot.</summary>
public int LimitSpansDrawn { get; private set; }
public int DrawnSeries { get; private set; }
/// <summary>The temperatures plot, for a test's look at its axes.</summary>
@@ -73,6 +94,104 @@ public partial class SensorsChart : UserControl
DrawTemps(series);
DrawMemory(Vram, series, VideoMemoryPlot);
DrawMemory(Ram, series, SystemMemoryPlot);
DrawClocks(series);
}
/// <summary>
/// The card's clocks and fan (beta.14), and every run of ticks a limit held it back as a shaded span behind them — a span
/// from the first such tick to the next tick that was not, so one tick reads as a second. The section collapses for a
/// session that stored none of these series (recorded before beta.14, or a card no layer reads them on).
/// </summary>
private void DrawClocks(SessionSeries? series)
{
ScottPlot.Plot plot = Clocks.Plot;
plot.Clear();
ChartTheme.Apply(plot);
plot.XLabel(TimeAxisLabel(series));
plot.YLabel(Strings.Sensors_Axis_Mhz);
LimitSpansDrawn = 0;
bool any = false;
if (series is not null)
{
ChartPalette p = ChartTheme.Current;
foreach ((string name, string key) in LimitSpans)
{
string label = string.Equals(name, SensorSeriesCatalog.GpuPowerLimit, StringComparison.Ordinal) ? Strings.Sensors_Limit_Power : Strings.Sensors_Limit_Thermal;
LimitSpansDrawn += Spans(plot, series, name, label, p.ByKey(key));
}
foreach ((string name, string key, bool rpm) in ClocksPlot)
{
bool drawn = Line(plot, series, name, Label(name), p.ByKey(key), rpm ? plot.Axes.Right : null);
any |= drawn;
if (drawn && rpm)
{
plot.Axes.Right.Label.Text = Strings.Sensors_Axis_Rpm;
}
}
any |= LimitSpansDrawn > 0;
plot.Axes.AutoScale();
plot.ShowLegend(Alignment.UpperRight);
}
ClocksSection.Visibility = any ? Visibility.Visible : Visibility.Collapsed;
Clocks.Refresh();
}
/// <summary>Shades every run of ticks whose value is 100 (held back) in <paramref name="name"/>; how many spans it drew.</summary>
private static int Spans(ScottPlot.Plot plot, SessionSeries series, string name, string label, Color color)
{
SensorSeries? limit = series.Sensors.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.Ordinal));
if (limit is null)
{
return 0;
}
int drawn = 0;
foreach ((double from, double to) in LimitRuns(limit))
{
VerticalSpan span = plot.Add.VerticalSpan(from, to, color.WithAlpha(0.18));
span.LineWidth = 0;
if (drawn++ == 0)
{
span.LegendText = label;
}
}
return drawn;
}
/// <summary>
/// The runs of ticks held back, as (start, end) seconds: from a tick at 100 to the next tick, and through every tick at
/// 100 after it — the reading holds for the second until the next. Pure, for the tests.
/// </summary>
internal static IReadOnlyList<(double From, double To)> LimitRuns(SensorSeries limit)
{
ArgumentNullException.ThrowIfNull(limit);
var runs = new List<(double, double)>();
double? start = null;
for (int i = 0; i < limit.Values.Length; i++)
{
bool held = limit.Values[i] >= 50;
if (held && start is null)
{
start = limit.TimesS[i];
}
else if (!held && start is double s)
{
runs.Add((s, limit.TimesS[i]));
start = null;
}
}
if (start is double open)
{
double last = limit.TimesS[^1];
runs.Add((open, last > open ? last + (last - limit.TimesS[Math.Max(0, limit.TimesS.Length - 2)]) : open + 1));
}
return runs;
}
/// <summary>The time axis says where its zero is: the first frame when the sensors sit on the frames' axis, the session's start otherwise.</summary>
+25
View File
@@ -68,4 +68,29 @@ public enum TrendMetric
DisplayBorderlessShare,
DisplayWindowedShare,
/// <summary>
/// The nine below are beta.14's (D49): pacing and efficiency from the hooks, the card's clock, memory temperature and power
/// limit from the telemetry every session records. A session before beta.14 has no point on any of them.
/// </summary>
TimeBelow60,
/// <summary>The share of the presented time below the monitor's refresh rate — what the display received.</summary>
TimeBelowRefresh,
FrameToFrame,
/// <summary>The render scale, <c>100 / upscale_ratio</c> — the per-axis scale of the session's dominant extent.</summary>
RenderScale,
VsyncShare,
GpuCoreClock,
MaxGpuMemTemp,
PowerLimitShare,
/// <summary>Application frames per watt of the card's power — never displayed frames (rule 6).</summary>
Efficiency,
}
@@ -52,7 +52,10 @@ public static class TrendSeriesBuilder
public static string UnitOf(TrendMetric metric) => metric switch
{
TrendMetric.PresentedFps or TrendMetric.NativeFps or TrendMetric.Displayed or TrendMetric.P1Low or TrendMetric.P01Low => Strings.Trend_Unit_Fps,
TrendMetric.MaxGpuTemp or TrendMetric.MaxCpuTemp => Strings.Trend_Unit_Celsius,
TrendMetric.MaxGpuTemp or TrendMetric.MaxCpuTemp or TrendMetric.MaxGpuMemTemp => Strings.Trend_Unit_Celsius,
TrendMetric.FrameToFrame => Strings.Trend_Unit_Ms,
TrendMetric.GpuCoreClock => Strings.Trend_Unit_Mhz,
TrendMetric.Efficiency => Strings.Trend_Unit_FpsPerWatt,
TrendMetric.AvgGpuPower => Strings.Trend_Unit_Watts,
TrendMetric.AvgRam or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak => Strings.Trend_Unit_Gigabytes,
TrendMetric.FgFactor => Strings.Trend_Unit_Factor,
@@ -106,7 +109,8 @@ public static class TrendSeriesBuilder
/// </summary>
public static bool IsMachineMetric(TrendMetric metric) => metric is TrendMetric.MaxGpuTemp or TrendMetric.AvgGpuLoad or TrendMetric.AvgGpuPower
or TrendMetric.AvgCpuLoad or TrendMetric.MaxCpuTemp or TrendMetric.AvgRam
or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak;
or TrendMetric.GameVramMedian or TrendMetric.GameVramPeak or TrendMetric.GameRamMedian or TrendMetric.GameRamPeak
or TrendMetric.GpuCoreClock or TrendMetric.MaxGpuMemTemp or TrendMetric.PowerLimitShare;
public static int ExcludedCount(IReadOnlyList<SessionRow> rows, TrendMetric metric)
{
@@ -170,10 +174,25 @@ public static class TrendSeriesBuilder
TrendMetric.DisplayExclusiveShare => DisplayShare(row, DisplayMode.ExclusiveFullscreen),
TrendMetric.DisplayBorderlessShare => DisplayShare(row, DisplayMode.Borderless),
TrendMetric.DisplayWindowedShare => DisplayShare(row, DisplayMode.Windowed),
_ => null,
_ => Beta14ValueOf(row, metric),
};
}
/// <summary>beta.14 (D49): the values of schema 0019 — null on a row written before it, as on one where nothing measured them.</summary>
private static double? Beta14ValueOf(SessionRow row, TrendMetric metric) => metric switch
{
TrendMetric.TimeBelow60 => row.TimeBelow60Pct,
TrendMetric.TimeBelowRefresh => row.TimeBelowRefreshPct,
TrendMetric.FrameToFrame => row.FrametimeDeltaMeanMs,
TrendMetric.RenderScale => row.UpscaleRatio is > 0 ? 100.0 / row.UpscaleRatio.Value : null,
TrendMetric.VsyncShare => row.VsyncPresentPct,
TrendMetric.GpuCoreClock => row.AvgGpuCoreClockMhz,
TrendMetric.MaxGpuMemTemp => row.MaxGpuMemTemp,
TrendMetric.PowerLimitShare => row.PowerLimitPct,
TrendMetric.Efficiency => row.AppFramesPerJoule,
_ => null,
};
/// <summary>MiB as stored, in GB as Task Manager counts them (1 GB = 1024 MiB).</summary>
private static double? Gb(double? mib) => mib / 1024.0;
@@ -386,7 +386,7 @@
<charts:SensorsChart x:Name="Sensors" Visibility="{Binding ViewModel.SelectedHasSensors, Converter={StaticResource BoolToVis}}" />
</StackPanel>
</TabItem>
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}">
<TabItem Header="{x:Static vm:GameDetailViewModel.TabLatency}" Visibility="{Binding ViewModel.AnyLatency, Converter={StaticResource BoolToVis}}">
<StackPanel Margin="0,12,0,0">
<ui:TextBlock Appearance="Secondary" TextWrapping="Wrap" Text="{Binding ViewModel.SelectedNote}"
Visibility="{Binding ViewModel.SelectedNote, Converter={StaticResource NullToCollapsed}}" />
+12
View File
@@ -75,6 +75,18 @@ public static class Formats
/// <summary>A GPU's power as <c>215 W</c>; null → N/A.</summary>
public static string Power(double? watts) => watts is double w ? w.ToString("0", CultureInfo.CurrentCulture) + " W" : Strings.Common_NotAvailable;
/// <summary>
/// A share of time or of frames as <c>9.6%</c> (beta.14) — one decimal, because the small shares are the telling ones: a
/// game held at its limit reads 0.4 % below it, not "0%"; null → N/A, never 0%.
/// </summary>
public static string Share(double? pct) => pct is double v ? v.ToString("0.0", CultureInfo.CurrentCulture) + "%" : Strings.Common_NotAvailable;
/// <summary>A frame-time difference as <c>0.88 ms</c> (beta.14); null → N/A.</summary>
public static string Milliseconds(double? ms) => ms is double v ? string.Format(CultureInfo.CurrentCulture, Strings.Format_Milliseconds_Format, v) : Strings.Common_NotAvailable;
/// <summary>Application frames per joule as <c>0.31 FPS/W</c> (beta.14) — frames per second over watts; null → N/A.</summary>
public static string FramesPerJoule(double? perJoule) => perJoule is double v ? string.Format(CultureInfo.CurrentCulture, Strings.Format_FramesPerJoule_Format, v) : Strings.Common_NotAvailable;
/// <summary>A clock as <c>2,655 MHz</c> (beta.14); null → N/A.</summary>
public static string Frequency(double? mhz) => mhz is double f ? string.Format(CultureInfo.CurrentCulture, Strings.Format_Frequency_Format, f) : Strings.Common_NotAvailable;
+156
View File
@@ -106,6 +106,7 @@ public static class Strings
nameof(Chart_Axis_Fps),
nameof(Chart_Axis_Frametime),
nameof(Chart_Axis_Percentile),
nameof(Chart_Axis_RenderScale),
nameof(Chart_Axis_Sensor),
nameof(Chart_Axis_Time),
nameof(Chart_Axis_TimeFromFirstFrame),
@@ -115,6 +116,7 @@ public static class Strings
nameof(Chart_Note_NoApplicationFrames),
nameof(Chart_Note_OutsideRange_Format),
nameof(Chart_Note_PresentsTiming),
nameof(Chart_RenderScale_NotMeasured),
nameof(Chart_Series_AppFrames),
nameof(Chart_Series_Displayed),
nameof(Chart_Series_GpuLoad),
@@ -156,19 +158,28 @@ public static class Strings
nameof(Compare_Metric_Display),
nameof(Compare_Metric_Displayed),
nameof(Compare_Metric_Duration),
nameof(Compare_Metric_Efficiency),
nameof(Compare_Metric_FrameToFrame),
nameof(Compare_Metric_GameRamMedian),
nameof(Compare_Metric_GameRamPeak),
nameof(Compare_Metric_GameVramMedian),
nameof(Compare_Metric_GameVramPeak),
nameof(Compare_Metric_GpuCoreClock),
nameof(Compare_Metric_MaxCpuTemp),
nameof(Compare_Metric_MaxGpuMemTemp),
nameof(Compare_Metric_MaxGpuTemp),
nameof(Compare_Metric_Median),
nameof(Compare_Metric_Monitor),
nameof(Compare_Metric_Native),
nameof(Compare_Metric_P01Low),
nameof(Compare_Metric_P1Low),
nameof(Compare_Metric_PowerLimit),
nameof(Compare_Metric_Presented),
nameof(Compare_Metric_RenderScale),
nameof(Compare_Metric_StutterPct),
nameof(Compare_Metric_TimeBelow60),
nameof(Compare_Metric_TimeBelowRefresh),
nameof(Compare_Metric_Vsync),
nameof(Compare_Metric_Window),
nameof(Compare_Mixed_Body),
nameof(Compare_Mixed_Legend),
@@ -375,9 +386,11 @@ public static class Strings
nameof(FirstRun_Title),
nameof(Format_Duration_HoursMinutes_Format),
nameof(Format_Duration_MinutesSeconds_Format),
nameof(Format_FramesPerJoule_Format),
nameof(Format_Frequency_Format),
nameof(Format_Memory_Gb_Format),
nameof(Format_Memory_Mb_Format),
nameof(Format_Milliseconds_Format),
nameof(Format_Playtime_Hours_Format),
nameof(Format_Playtime_Minutes_Format),
nameof(Format_Resolution_Format),
@@ -678,8 +691,13 @@ public static class Strings
nameof(Rules_Update_NoAgent),
nameof(Rules_Update_Title),
nameof(Sensors_Axis_Gb),
nameof(Sensors_Axis_Mhz),
nameof(Sensors_Axis_Rpm),
nameof(Sensors_Axis_Watts),
nameof(Sensors_Clocks_Header),
nameof(Sensors_Empty),
nameof(Sensors_Limit_Power),
nameof(Sensors_Limit_Thermal),
nameof(Sensors_Ram_Header),
nameof(Sensors_Series_CpuLoad),
nameof(Sensors_Series_CpuTemp),
@@ -854,14 +872,27 @@ public static class Strings
nameof(Summary_Notes_Placeholder),
nameof(Summary_NotFound),
nameof(Summary_Open),
nameof(Summary_RenderScale_Header),
nameof(Summary_Save),
nameof(Summary_Saved),
nameof(Summary_Show_Displayed),
nameof(Summary_Show_Sensors),
nameof(Summary_Stat_Avg),
nameof(Summary_Stat_Below30_Format),
nameof(Summary_Stat_BelowRefresh_Format),
nameof(Summary_Stat_Capture),
nameof(Summary_Stat_Capture_Format),
nameof(Summary_Stat_Clocks_Format),
nameof(Summary_Stat_Cpu),
nameof(Summary_Stat_Display),
nameof(Summary_Stat_DisplayedLow_Format),
nameof(Summary_Stat_Duration),
nameof(Summary_Stat_Efficiency),
nameof(Summary_Stat_Efficiency_Note),
nameof(Summary_Stat_FanMemTemp_Format),
nameof(Summary_Stat_Focus),
nameof(Summary_Stat_Focus_Format),
nameof(Summary_Stat_FrameToFrame),
nameof(Summary_Stat_GameRam),
nameof(Summary_Stat_GameRam_Suffix_Format),
nameof(Summary_Stat_GameRamWs),
@@ -869,16 +900,25 @@ public static class Strings
nameof(Summary_Stat_GameVram),
nameof(Summary_Stat_GameVram_Suffix_Format),
nameof(Summary_Stat_Gpu),
nameof(Summary_Stat_GpuClocks),
nameof(Summary_Stat_GpuLimits),
nameof(Summary_Stat_Limits_Format),
nameof(Summary_Stat_LoadTemp_Format),
nameof(Summary_Stat_Median),
nameof(Summary_Stat_MinMax),
nameof(Summary_Stat_MinMax_Format),
nameof(Summary_Stat_OfFrames_Format),
nameof(Summary_Stat_P01Low),
nameof(Summary_Stat_P1Low),
nameof(Summary_Stat_RaysPerPixel_Format),
nameof(Summary_Stat_RayTracing),
nameof(Summary_Stat_StdDev),
nameof(Summary_Stat_StdDev_Format),
nameof(Summary_Stat_Stutter),
nameof(Summary_Stat_Stutter_Format),
nameof(Summary_Stat_Tearing_Format),
nameof(Summary_Stat_TimeBelow60),
nameof(Summary_Stat_Vsync),
nameof(Summary_Tags_Placeholder),
nameof(Summary_Tier2_Body),
nameof(Summary_Tier2_Why_Blocked_Format),
@@ -943,23 +983,35 @@ public static class Strings
nameof(Trend_Metric_Displayed),
nameof(Trend_Metric_DisplayExclusive),
nameof(Trend_Metric_DisplayWindowed),
nameof(Trend_Metric_Efficiency),
nameof(Trend_Metric_FgFactor),
nameof(Trend_Metric_FrameToFrame),
nameof(Trend_Metric_GameRamMedian),
nameof(Trend_Metric_GameRamPeak),
nameof(Trend_Metric_GameVramMedian),
nameof(Trend_Metric_GameVramPeak),
nameof(Trend_Metric_GpuCoreClock),
nameof(Trend_Metric_Label),
nameof(Trend_Metric_MaxCpuTemp),
nameof(Trend_Metric_MaxGpuMemTemp),
nameof(Trend_Metric_MaxGpuTemp),
nameof(Trend_Metric_NativeFps),
nameof(Trend_Metric_P01Low),
nameof(Trend_Metric_P1Low),
nameof(Trend_Metric_PowerLimitShare),
nameof(Trend_Metric_PresentedFps),
nameof(Trend_Metric_RenderScale),
nameof(Trend_Metric_TimeBelow60),
nameof(Trend_Metric_TimeBelowRefresh),
nameof(Trend_Metric_VsyncShare),
nameof(Trend_Partial_Note),
nameof(Trend_Unit_Celsius),
nameof(Trend_Unit_Factor),
nameof(Trend_Unit_Fps),
nameof(Trend_Unit_FpsPerWatt),
nameof(Trend_Unit_Gigabytes),
nameof(Trend_Unit_Mhz),
nameof(Trend_Unit_Ms),
nameof(Trend_Unit_Percent),
nameof(Trend_Unit_Watts),
nameof(Uninstall_DataFolder_Body),
@@ -1151,6 +1203,8 @@ public static class Strings
public static string Chart_Axis_Percentile => ResourceManager.GetString(nameof(Chart_Axis_Percentile), Culture) ?? nameof(Chart_Axis_Percentile);
public static string Chart_Axis_RenderScale => ResourceManager.GetString(nameof(Chart_Axis_RenderScale), Culture) ?? nameof(Chart_Axis_RenderScale);
public static string Chart_Axis_Sensor => ResourceManager.GetString(nameof(Chart_Axis_Sensor), Culture) ?? nameof(Chart_Axis_Sensor);
public static string Chart_Axis_Time => ResourceManager.GetString(nameof(Chart_Axis_Time), Culture) ?? nameof(Chart_Axis_Time);
@@ -1169,6 +1223,8 @@ public static class Strings
public static string Chart_Note_PresentsTiming => ResourceManager.GetString(nameof(Chart_Note_PresentsTiming), Culture) ?? nameof(Chart_Note_PresentsTiming);
public static string Chart_RenderScale_NotMeasured => ResourceManager.GetString(nameof(Chart_RenderScale_NotMeasured), Culture) ?? nameof(Chart_RenderScale_NotMeasured);
public static string Chart_Series_AppFrames => ResourceManager.GetString(nameof(Chart_Series_AppFrames), Culture) ?? nameof(Chart_Series_AppFrames);
public static string Chart_Series_Displayed => ResourceManager.GetString(nameof(Chart_Series_Displayed), Culture) ?? nameof(Chart_Series_Displayed);
@@ -1251,6 +1307,10 @@ public static class Strings
public static string Compare_Metric_Duration => ResourceManager.GetString(nameof(Compare_Metric_Duration), Culture) ?? nameof(Compare_Metric_Duration);
public static string Compare_Metric_Efficiency => ResourceManager.GetString(nameof(Compare_Metric_Efficiency), Culture) ?? nameof(Compare_Metric_Efficiency);
public static string Compare_Metric_FrameToFrame => ResourceManager.GetString(nameof(Compare_Metric_FrameToFrame), Culture) ?? nameof(Compare_Metric_FrameToFrame);
public static string Compare_Metric_GameRamMedian => ResourceManager.GetString(nameof(Compare_Metric_GameRamMedian), Culture) ?? nameof(Compare_Metric_GameRamMedian);
public static string Compare_Metric_GameRamPeak => ResourceManager.GetString(nameof(Compare_Metric_GameRamPeak), Culture) ?? nameof(Compare_Metric_GameRamPeak);
@@ -1259,8 +1319,12 @@ public static class Strings
public static string Compare_Metric_GameVramPeak => ResourceManager.GetString(nameof(Compare_Metric_GameVramPeak), Culture) ?? nameof(Compare_Metric_GameVramPeak);
public static string Compare_Metric_GpuCoreClock => ResourceManager.GetString(nameof(Compare_Metric_GpuCoreClock), Culture) ?? nameof(Compare_Metric_GpuCoreClock);
public static string Compare_Metric_MaxCpuTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxCpuTemp), Culture) ?? nameof(Compare_Metric_MaxCpuTemp);
public static string Compare_Metric_MaxGpuMemTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxGpuMemTemp), Culture) ?? nameof(Compare_Metric_MaxGpuMemTemp);
public static string Compare_Metric_MaxGpuTemp => ResourceManager.GetString(nameof(Compare_Metric_MaxGpuTemp), Culture) ?? nameof(Compare_Metric_MaxGpuTemp);
public static string Compare_Metric_Median => ResourceManager.GetString(nameof(Compare_Metric_Median), Culture) ?? nameof(Compare_Metric_Median);
@@ -1273,10 +1337,20 @@ public static class Strings
public static string Compare_Metric_P1Low => ResourceManager.GetString(nameof(Compare_Metric_P1Low), Culture) ?? nameof(Compare_Metric_P1Low);
public static string Compare_Metric_PowerLimit => ResourceManager.GetString(nameof(Compare_Metric_PowerLimit), Culture) ?? nameof(Compare_Metric_PowerLimit);
public static string Compare_Metric_Presented => ResourceManager.GetString(nameof(Compare_Metric_Presented), Culture) ?? nameof(Compare_Metric_Presented);
public static string Compare_Metric_RenderScale => ResourceManager.GetString(nameof(Compare_Metric_RenderScale), Culture) ?? nameof(Compare_Metric_RenderScale);
public static string Compare_Metric_StutterPct => ResourceManager.GetString(nameof(Compare_Metric_StutterPct), Culture) ?? nameof(Compare_Metric_StutterPct);
public static string Compare_Metric_TimeBelow60 => ResourceManager.GetString(nameof(Compare_Metric_TimeBelow60), Culture) ?? nameof(Compare_Metric_TimeBelow60);
public static string Compare_Metric_TimeBelowRefresh => ResourceManager.GetString(nameof(Compare_Metric_TimeBelowRefresh), Culture) ?? nameof(Compare_Metric_TimeBelowRefresh);
public static string Compare_Metric_Vsync => ResourceManager.GetString(nameof(Compare_Metric_Vsync), Culture) ?? nameof(Compare_Metric_Vsync);
public static string Compare_Metric_Window => ResourceManager.GetString(nameof(Compare_Metric_Window), Culture) ?? nameof(Compare_Metric_Window);
public static string Compare_Mixed_Body => ResourceManager.GetString(nameof(Compare_Mixed_Body), Culture) ?? nameof(Compare_Mixed_Body);
@@ -1689,12 +1763,16 @@ public static class Strings
public static string Format_Duration_MinutesSeconds_Format => ResourceManager.GetString(nameof(Format_Duration_MinutesSeconds_Format), Culture) ?? nameof(Format_Duration_MinutesSeconds_Format);
public static string Format_FramesPerJoule_Format => ResourceManager.GetString(nameof(Format_FramesPerJoule_Format), Culture) ?? nameof(Format_FramesPerJoule_Format);
public static string Format_Frequency_Format => ResourceManager.GetString(nameof(Format_Frequency_Format), Culture) ?? nameof(Format_Frequency_Format);
public static string Format_Memory_Gb_Format => ResourceManager.GetString(nameof(Format_Memory_Gb_Format), Culture) ?? nameof(Format_Memory_Gb_Format);
public static string Format_Memory_Mb_Format => ResourceManager.GetString(nameof(Format_Memory_Mb_Format), Culture) ?? nameof(Format_Memory_Mb_Format);
public static string Format_Milliseconds_Format => ResourceManager.GetString(nameof(Format_Milliseconds_Format), Culture) ?? nameof(Format_Milliseconds_Format);
public static string Format_Playtime_Hours_Format => ResourceManager.GetString(nameof(Format_Playtime_Hours_Format), Culture) ?? nameof(Format_Playtime_Hours_Format);
public static string Format_Playtime_Minutes_Format => ResourceManager.GetString(nameof(Format_Playtime_Minutes_Format), Culture) ?? nameof(Format_Playtime_Minutes_Format);
@@ -2295,10 +2373,20 @@ public static class Strings
public static string Sensors_Axis_Gb => ResourceManager.GetString(nameof(Sensors_Axis_Gb), Culture) ?? nameof(Sensors_Axis_Gb);
public static string Sensors_Axis_Mhz => ResourceManager.GetString(nameof(Sensors_Axis_Mhz), Culture) ?? nameof(Sensors_Axis_Mhz);
public static string Sensors_Axis_Rpm => ResourceManager.GetString(nameof(Sensors_Axis_Rpm), Culture) ?? nameof(Sensors_Axis_Rpm);
public static string Sensors_Axis_Watts => ResourceManager.GetString(nameof(Sensors_Axis_Watts), Culture) ?? nameof(Sensors_Axis_Watts);
public static string Sensors_Clocks_Header => ResourceManager.GetString(nameof(Sensors_Clocks_Header), Culture) ?? nameof(Sensors_Clocks_Header);
public static string Sensors_Empty => ResourceManager.GetString(nameof(Sensors_Empty), Culture) ?? nameof(Sensors_Empty);
public static string Sensors_Limit_Power => ResourceManager.GetString(nameof(Sensors_Limit_Power), Culture) ?? nameof(Sensors_Limit_Power);
public static string Sensors_Limit_Thermal => ResourceManager.GetString(nameof(Sensors_Limit_Thermal), Culture) ?? nameof(Sensors_Limit_Thermal);
public static string Sensors_Ram_Header => ResourceManager.GetString(nameof(Sensors_Ram_Header), Culture) ?? nameof(Sensors_Ram_Header);
public static string Sensors_Series_CpuLoad => ResourceManager.GetString(nameof(Sensors_Series_CpuLoad), Culture) ?? nameof(Sensors_Series_CpuLoad);
@@ -2647,6 +2735,8 @@ public static class Strings
public static string Summary_Open => ResourceManager.GetString(nameof(Summary_Open), Culture) ?? nameof(Summary_Open);
public static string Summary_RenderScale_Header => ResourceManager.GetString(nameof(Summary_RenderScale_Header), Culture) ?? nameof(Summary_RenderScale_Header);
public static string Summary_Save => ResourceManager.GetString(nameof(Summary_Save), Culture) ?? nameof(Summary_Save);
public static string Summary_Saved => ResourceManager.GetString(nameof(Summary_Saved), Culture) ?? nameof(Summary_Saved);
@@ -2657,12 +2747,36 @@ public static class Strings
public static string Summary_Stat_Avg => ResourceManager.GetString(nameof(Summary_Stat_Avg), Culture) ?? nameof(Summary_Stat_Avg);
public static string Summary_Stat_Below30_Format => ResourceManager.GetString(nameof(Summary_Stat_Below30_Format), Culture) ?? nameof(Summary_Stat_Below30_Format);
public static string Summary_Stat_BelowRefresh_Format => ResourceManager.GetString(nameof(Summary_Stat_BelowRefresh_Format), Culture) ?? nameof(Summary_Stat_BelowRefresh_Format);
public static string Summary_Stat_Capture => ResourceManager.GetString(nameof(Summary_Stat_Capture), Culture) ?? nameof(Summary_Stat_Capture);
public static string Summary_Stat_Capture_Format => ResourceManager.GetString(nameof(Summary_Stat_Capture_Format), Culture) ?? nameof(Summary_Stat_Capture_Format);
public static string Summary_Stat_Clocks_Format => ResourceManager.GetString(nameof(Summary_Stat_Clocks_Format), Culture) ?? nameof(Summary_Stat_Clocks_Format);
public static string Summary_Stat_Cpu => ResourceManager.GetString(nameof(Summary_Stat_Cpu), Culture) ?? nameof(Summary_Stat_Cpu);
public static string Summary_Stat_Display => ResourceManager.GetString(nameof(Summary_Stat_Display), Culture) ?? nameof(Summary_Stat_Display);
public static string Summary_Stat_DisplayedLow_Format => ResourceManager.GetString(nameof(Summary_Stat_DisplayedLow_Format), Culture) ?? nameof(Summary_Stat_DisplayedLow_Format);
public static string Summary_Stat_Duration => ResourceManager.GetString(nameof(Summary_Stat_Duration), Culture) ?? nameof(Summary_Stat_Duration);
public static string Summary_Stat_Efficiency => ResourceManager.GetString(nameof(Summary_Stat_Efficiency), Culture) ?? nameof(Summary_Stat_Efficiency);
public static string Summary_Stat_Efficiency_Note => ResourceManager.GetString(nameof(Summary_Stat_Efficiency_Note), Culture) ?? nameof(Summary_Stat_Efficiency_Note);
public static string Summary_Stat_FanMemTemp_Format => ResourceManager.GetString(nameof(Summary_Stat_FanMemTemp_Format), Culture) ?? nameof(Summary_Stat_FanMemTemp_Format);
public static string Summary_Stat_Focus => ResourceManager.GetString(nameof(Summary_Stat_Focus), Culture) ?? nameof(Summary_Stat_Focus);
public static string Summary_Stat_Focus_Format => ResourceManager.GetString(nameof(Summary_Stat_Focus_Format), Culture) ?? nameof(Summary_Stat_Focus_Format);
public static string Summary_Stat_FrameToFrame => ResourceManager.GetString(nameof(Summary_Stat_FrameToFrame), Culture) ?? nameof(Summary_Stat_FrameToFrame);
public static string Summary_Stat_GameRam => ResourceManager.GetString(nameof(Summary_Stat_GameRam), Culture) ?? nameof(Summary_Stat_GameRam);
public static string Summary_Stat_GameRam_Suffix_Format => ResourceManager.GetString(nameof(Summary_Stat_GameRam_Suffix_Format), Culture) ?? nameof(Summary_Stat_GameRam_Suffix_Format);
@@ -2677,6 +2791,12 @@ public static class Strings
public static string Summary_Stat_Gpu => ResourceManager.GetString(nameof(Summary_Stat_Gpu), Culture) ?? nameof(Summary_Stat_Gpu);
public static string Summary_Stat_GpuClocks => ResourceManager.GetString(nameof(Summary_Stat_GpuClocks), Culture) ?? nameof(Summary_Stat_GpuClocks);
public static string Summary_Stat_GpuLimits => ResourceManager.GetString(nameof(Summary_Stat_GpuLimits), Culture) ?? nameof(Summary_Stat_GpuLimits);
public static string Summary_Stat_Limits_Format => ResourceManager.GetString(nameof(Summary_Stat_Limits_Format), Culture) ?? nameof(Summary_Stat_Limits_Format);
public static string Summary_Stat_LoadTemp_Format => ResourceManager.GetString(nameof(Summary_Stat_LoadTemp_Format), Culture) ?? nameof(Summary_Stat_LoadTemp_Format);
public static string Summary_Stat_Median => ResourceManager.GetString(nameof(Summary_Stat_Median), Culture) ?? nameof(Summary_Stat_Median);
@@ -2685,10 +2805,16 @@ public static class Strings
public static string Summary_Stat_MinMax_Format => ResourceManager.GetString(nameof(Summary_Stat_MinMax_Format), Culture) ?? nameof(Summary_Stat_MinMax_Format);
public static string Summary_Stat_OfFrames_Format => ResourceManager.GetString(nameof(Summary_Stat_OfFrames_Format), Culture) ?? nameof(Summary_Stat_OfFrames_Format);
public static string Summary_Stat_P01Low => ResourceManager.GetString(nameof(Summary_Stat_P01Low), Culture) ?? nameof(Summary_Stat_P01Low);
public static string Summary_Stat_P1Low => ResourceManager.GetString(nameof(Summary_Stat_P1Low), Culture) ?? nameof(Summary_Stat_P1Low);
public static string Summary_Stat_RaysPerPixel_Format => ResourceManager.GetString(nameof(Summary_Stat_RaysPerPixel_Format), Culture) ?? nameof(Summary_Stat_RaysPerPixel_Format);
public static string Summary_Stat_RayTracing => ResourceManager.GetString(nameof(Summary_Stat_RayTracing), Culture) ?? nameof(Summary_Stat_RayTracing);
public static string Summary_Stat_StdDev => ResourceManager.GetString(nameof(Summary_Stat_StdDev), Culture) ?? nameof(Summary_Stat_StdDev);
public static string Summary_Stat_StdDev_Format => ResourceManager.GetString(nameof(Summary_Stat_StdDev_Format), Culture) ?? nameof(Summary_Stat_StdDev_Format);
@@ -2697,6 +2823,12 @@ public static class Strings
public static string Summary_Stat_Stutter_Format => ResourceManager.GetString(nameof(Summary_Stat_Stutter_Format), Culture) ?? nameof(Summary_Stat_Stutter_Format);
public static string Summary_Stat_Tearing_Format => ResourceManager.GetString(nameof(Summary_Stat_Tearing_Format), Culture) ?? nameof(Summary_Stat_Tearing_Format);
public static string Summary_Stat_TimeBelow60 => ResourceManager.GetString(nameof(Summary_Stat_TimeBelow60), Culture) ?? nameof(Summary_Stat_TimeBelow60);
public static string Summary_Stat_Vsync => ResourceManager.GetString(nameof(Summary_Stat_Vsync), Culture) ?? nameof(Summary_Stat_Vsync);
public static string Summary_Tags_Placeholder => ResourceManager.GetString(nameof(Summary_Tags_Placeholder), Culture) ?? nameof(Summary_Tags_Placeholder);
public static string Summary_Tier2_Body => ResourceManager.GetString(nameof(Summary_Tier2_Body), Culture) ?? nameof(Summary_Tier2_Body);
@@ -2825,8 +2957,12 @@ public static class Strings
public static string Trend_Metric_DisplayWindowed => ResourceManager.GetString(nameof(Trend_Metric_DisplayWindowed), Culture) ?? nameof(Trend_Metric_DisplayWindowed);
public static string Trend_Metric_Efficiency => ResourceManager.GetString(nameof(Trend_Metric_Efficiency), Culture) ?? nameof(Trend_Metric_Efficiency);
public static string Trend_Metric_FgFactor => ResourceManager.GetString(nameof(Trend_Metric_FgFactor), Culture) ?? nameof(Trend_Metric_FgFactor);
public static string Trend_Metric_FrameToFrame => ResourceManager.GetString(nameof(Trend_Metric_FrameToFrame), Culture) ?? nameof(Trend_Metric_FrameToFrame);
public static string Trend_Metric_GameRamMedian => ResourceManager.GetString(nameof(Trend_Metric_GameRamMedian), Culture) ?? nameof(Trend_Metric_GameRamMedian);
public static string Trend_Metric_GameRamPeak => ResourceManager.GetString(nameof(Trend_Metric_GameRamPeak), Culture) ?? nameof(Trend_Metric_GameRamPeak);
@@ -2835,10 +2971,14 @@ public static class Strings
public static string Trend_Metric_GameVramPeak => ResourceManager.GetString(nameof(Trend_Metric_GameVramPeak), Culture) ?? nameof(Trend_Metric_GameVramPeak);
public static string Trend_Metric_GpuCoreClock => ResourceManager.GetString(nameof(Trend_Metric_GpuCoreClock), Culture) ?? nameof(Trend_Metric_GpuCoreClock);
public static string Trend_Metric_Label => ResourceManager.GetString(nameof(Trend_Metric_Label), Culture) ?? nameof(Trend_Metric_Label);
public static string Trend_Metric_MaxCpuTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxCpuTemp), Culture) ?? nameof(Trend_Metric_MaxCpuTemp);
public static string Trend_Metric_MaxGpuMemTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxGpuMemTemp), Culture) ?? nameof(Trend_Metric_MaxGpuMemTemp);
public static string Trend_Metric_MaxGpuTemp => ResourceManager.GetString(nameof(Trend_Metric_MaxGpuTemp), Culture) ?? nameof(Trend_Metric_MaxGpuTemp);
public static string Trend_Metric_NativeFps => ResourceManager.GetString(nameof(Trend_Metric_NativeFps), Culture) ?? nameof(Trend_Metric_NativeFps);
@@ -2847,8 +2987,18 @@ public static class Strings
public static string Trend_Metric_P1Low => ResourceManager.GetString(nameof(Trend_Metric_P1Low), Culture) ?? nameof(Trend_Metric_P1Low);
public static string Trend_Metric_PowerLimitShare => ResourceManager.GetString(nameof(Trend_Metric_PowerLimitShare), Culture) ?? nameof(Trend_Metric_PowerLimitShare);
public static string Trend_Metric_PresentedFps => ResourceManager.GetString(nameof(Trend_Metric_PresentedFps), Culture) ?? nameof(Trend_Metric_PresentedFps);
public static string Trend_Metric_RenderScale => ResourceManager.GetString(nameof(Trend_Metric_RenderScale), Culture) ?? nameof(Trend_Metric_RenderScale);
public static string Trend_Metric_TimeBelow60 => ResourceManager.GetString(nameof(Trend_Metric_TimeBelow60), Culture) ?? nameof(Trend_Metric_TimeBelow60);
public static string Trend_Metric_TimeBelowRefresh => ResourceManager.GetString(nameof(Trend_Metric_TimeBelowRefresh), Culture) ?? nameof(Trend_Metric_TimeBelowRefresh);
public static string Trend_Metric_VsyncShare => ResourceManager.GetString(nameof(Trend_Metric_VsyncShare), Culture) ?? nameof(Trend_Metric_VsyncShare);
public static string Trend_Partial_Note => ResourceManager.GetString(nameof(Trend_Partial_Note), Culture) ?? nameof(Trend_Partial_Note);
public static string Trend_Unit_Celsius => ResourceManager.GetString(nameof(Trend_Unit_Celsius), Culture) ?? nameof(Trend_Unit_Celsius);
@@ -2857,8 +3007,14 @@ public static class Strings
public static string Trend_Unit_Fps => ResourceManager.GetString(nameof(Trend_Unit_Fps), Culture) ?? nameof(Trend_Unit_Fps);
public static string Trend_Unit_FpsPerWatt => ResourceManager.GetString(nameof(Trend_Unit_FpsPerWatt), Culture) ?? nameof(Trend_Unit_FpsPerWatt);
public static string Trend_Unit_Gigabytes => ResourceManager.GetString(nameof(Trend_Unit_Gigabytes), Culture) ?? nameof(Trend_Unit_Gigabytes);
public static string Trend_Unit_Mhz => ResourceManager.GetString(nameof(Trend_Unit_Mhz), Culture) ?? nameof(Trend_Unit_Mhz);
public static string Trend_Unit_Ms => ResourceManager.GetString(nameof(Trend_Unit_Ms), Culture) ?? nameof(Trend_Unit_Ms);
public static string Trend_Unit_Percent => ResourceManager.GetString(nameof(Trend_Unit_Percent), Culture) ?? nameof(Trend_Unit_Percent);
public static string Trend_Unit_Watts => ResourceManager.GetString(nameof(Trend_Unit_Watts), Culture) ?? nameof(Trend_Unit_Watts);
+208
View File
@@ -3897,4 +3897,212 @@
<value>{0:N0} RPM</value>
<comment>review</comment>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
<comment>review</comment>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>30 未満: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>表示 {0} Hz 未満: {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>フレームの {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>ティアリング許可: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>レイトレーシング</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>1 ピクセルあたり {0:0.00} レイ</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>ゲームがアクティブ</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>時間の {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>記録の品質</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>欠落 {0:N0} · 消失 {1:N0} · 障害 {2:N0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>表示: {0}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>GPU クロック</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>コア {0} · メモリ {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>ファン {0} · メモリ {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU の制限</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>電力 {0} · 温度 {1}</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>ゲーム自身のフレーム・GPU 電力のみ</value>
<comment>review</comment>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>レンダースケール</value>
<comment>review</comment>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>レンダースケール %</value>
<comment>review</comment>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>このセッションではレンダー解像度を測定していません。</value>
<comment>review</comment>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>クロックとファン</value>
<comment>review</comment>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
<comment>review</comment>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>RPM</value>
<comment>review</comment>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>電力制限</value>
<comment>review</comment>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>温度制限</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>リフレッシュレート未満の表示 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動 ms</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>レンダースケール %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>VSync の割合 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>平均GPUコアクロック MHz</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>GPU メモリ最高 °C</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>電力制限の割合 %</value>
<comment>review</comment>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
<comment>review</comment>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>60 FPS 未満の時間</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>リフレッシュレート未満の表示</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>フレーム間の変動</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>VSync の割合</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>レンダースケール</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>平均GPUコアクロック</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>GPU メモリ最高 °C</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>電力制限の割合</value>
<comment>review</comment>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>ワットあたりのフレーム</value>
<comment>review</comment>
</data>
</root>
+156
View File
@@ -2933,4 +2933,160 @@ The documents below are the full terms; this summary does not replace them.</val
<data name="Format_Rpm_Format" xml:space="preserve">
<value>{0:N0} RPM</value>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS</value>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>below 30: {0}</value>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>display under {0} Hz: {1}</value>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>Frame to frame</value>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>{0} of frames</value>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>tearing allowed: {0}</value>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>Ray tracing</value>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>{0:0.00} rays per pixel</value>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>Game in focus</value>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>{0} of the time</value>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>Capture quality</value>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>{0:N0} gaps · {1:N0} lost · {2:N0} faults</value>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>displayed: {0}</value>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>GPU clocks</value>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>{0} core · {1} memory</value>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>fan {0} · memory {1}</value>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU held back</value>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>power {0} · heat {1}</value>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>the game's own frames, GPU power only</value>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>Render scale</value>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>Render scale %</value>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>The render resolution was not measured in this session.</value>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>Clocks and fan</value>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>RPM</value>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>held back by its power limit</value>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>held back by heat</value>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS %</value>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Display under refresh rate %</value>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>Frame to frame ms</value>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>Render scale %</value>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>VSync share %</value>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>Avg GPU core clock MHz</value>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Max GPU memory °C</value>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>Held back by power limit %</value>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>Time below 60 FPS</value>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Display under refresh rate</value>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>Frame to frame</value>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>VSync share</value>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>Render scale</value>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>Avg GPU core clock</value>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Max GPU memory °C</value>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>Held back by power limit</value>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>Frames per watt</value>
</data>
</root>
+156
View File
@@ -2928,4 +2928,160 @@ Các văn bản bên dưới là điều khoản đầy đủ; bản tóm tắt
<data name="Format_Rpm_Format" xml:space="preserve">
<value>{0:N0} vòng/phút</value>
</data>
<data name="Format_Milliseconds_Format" xml:space="preserve">
<value>{0:0.00} ms</value>
</data>
<data name="Format_FramesPerJoule_Format" xml:space="preserve">
<value>{0:0.00} FPS/W</value>
</data>
<data name="Summary_Stat_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS</value>
</data>
<data name="Summary_Stat_Below30_Format" xml:space="preserve">
<value>dưới 30: {0}</value>
</data>
<data name="Summary_Stat_BelowRefresh_Format" xml:space="preserve">
<value>màn hình dưới {0} Hz: {1}</value>
</data>
<data name="Summary_Stat_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame</value>
</data>
<data name="Summary_Stat_Vsync" xml:space="preserve">
<value>VSync</value>
</data>
<data name="Summary_Stat_OfFrames_Format" xml:space="preserve">
<value>{0} số frame</value>
</data>
<data name="Summary_Stat_Tearing_Format" xml:space="preserve">
<value>cho phép xé hình: {0}</value>
</data>
<data name="Summary_Stat_RayTracing" xml:space="preserve">
<value>Ray tracing</value>
</data>
<data name="Summary_Stat_RaysPerPixel_Format" xml:space="preserve">
<value>{0:0.00} tia mỗi điểm ảnh</value>
</data>
<data name="Summary_Stat_Focus" xml:space="preserve">
<value>Game đang được chọn</value>
</data>
<data name="Summary_Stat_Focus_Format" xml:space="preserve">
<value>{0} thời gian</value>
</data>
<data name="Summary_Stat_Capture" xml:space="preserve">
<value>Chất lượng ghi</value>
</data>
<data name="Summary_Stat_Capture_Format" xml:space="preserve">
<value>{0:N0} khoảng trống · {1:N0} bị mất · {2:N0} lỗi</value>
</data>
<data name="Summary_Stat_DisplayedLow_Format" xml:space="preserve">
<value>hiển thị: {0}</value>
</data>
<data name="Summary_Stat_GpuClocks" xml:space="preserve">
<value>Xung nhịp GPU</value>
</data>
<data name="Summary_Stat_Clocks_Format" xml:space="preserve">
<value>{0} lõi · {1} bộ nhớ</value>
</data>
<data name="Summary_Stat_FanMemTemp_Format" xml:space="preserve">
<value>quạt {0} · bộ nhớ {1}</value>
</data>
<data name="Summary_Stat_GpuLimits" xml:space="preserve">
<value>GPU bị giới hạn</value>
</data>
<data name="Summary_Stat_Limits_Format" xml:space="preserve">
<value>công suất {0} · nhiệt {1}</value>
</data>
<data name="Summary_Stat_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
<data name="Summary_Stat_Efficiency_Note" xml:space="preserve">
<value>chỉ frame của game, chỉ công suất GPU</value>
</data>
<data name="Summary_RenderScale_Header" xml:space="preserve">
<value>Tỉ lệ render</value>
</data>
<data name="Chart_Axis_RenderScale" xml:space="preserve">
<value>Tỉ lệ render %</value>
</data>
<data name="Chart_RenderScale_NotMeasured" xml:space="preserve">
<value>Phiên này không đo được độ phân giải render.</value>
</data>
<data name="Sensors_Clocks_Header" xml:space="preserve">
<value>Xung nhịp và quạt</value>
</data>
<data name="Sensors_Axis_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Sensors_Axis_Rpm" xml:space="preserve">
<value>vòng/phút</value>
</data>
<data name="Sensors_Limit_Power" xml:space="preserve">
<value>bị giới hạn công suất</value>
</data>
<data name="Sensors_Limit_Thermal" xml:space="preserve">
<value>bị giới hạn do nhiệt</value>
</data>
<data name="Trend_Metric_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS %</value>
</data>
<data name="Trend_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Màn hình dưới tần số quét %</value>
</data>
<data name="Trend_Metric_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame ms</value>
</data>
<data name="Trend_Metric_RenderScale" xml:space="preserve">
<value>Tỉ lệ render %</value>
</data>
<data name="Trend_Metric_VsyncShare" xml:space="preserve">
<value>Tỉ lệ VSync %</value>
</data>
<data name="Trend_Metric_GpuCoreClock" xml:space="preserve">
<value>Xung nhịp lõi GPU TB MHz</value>
</data>
<data name="Trend_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Bộ nhớ GPU tối đa °C</value>
</data>
<data name="Trend_Metric_PowerLimitShare" xml:space="preserve">
<value>Bị giới hạn công suất %</value>
</data>
<data name="Trend_Metric_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
<data name="Trend_Unit_Ms" xml:space="preserve">
<value>ms</value>
</data>
<data name="Trend_Unit_Mhz" xml:space="preserve">
<value>MHz</value>
</data>
<data name="Trend_Unit_FpsPerWatt" xml:space="preserve">
<value>FPS/W</value>
</data>
<data name="Compare_Metric_TimeBelow60" xml:space="preserve">
<value>Thời gian dưới 60 FPS</value>
</data>
<data name="Compare_Metric_TimeBelowRefresh" xml:space="preserve">
<value>Màn hình dưới tần số quét</value>
</data>
<data name="Compare_Metric_FrameToFrame" xml:space="preserve">
<value>Chênh lệch giữa các frame</value>
</data>
<data name="Compare_Metric_Vsync" xml:space="preserve">
<value>Tỉ lệ VSync</value>
</data>
<data name="Compare_Metric_RenderScale" xml:space="preserve">
<value>Tỉ lệ render</value>
</data>
<data name="Compare_Metric_GpuCoreClock" xml:space="preserve">
<value>Xung nhịp lõi GPU TB</value>
</data>
<data name="Compare_Metric_MaxGpuMemTemp" xml:space="preserve">
<value>Bộ nhớ GPU tối đa °C</value>
</data>
<data name="Compare_Metric_PowerLimit" xml:space="preserve">
<value>Bị giới hạn công suất</value>
</data>
<data name="Compare_Metric_Efficiency" xml:space="preserve">
<value>Frame mỗi watt</value>
</data>
</root>
@@ -22,4 +22,7 @@
<Color x:Key="Chart_Histogram">#CC4CC2FF</Color>
<!-- Not a second gold beside Chart_SensorSecondary (beta.8): the Sensors tab draws both. -->
<Color x:Key="Chart_Percentile">#FFFF79C6</Color>
<!-- beta.14: the seventh line on the temperatures plot (the card's memory temperature) — no colour above is 60 apart
from all six beside it. -->
<Color x:Key="Chart_SensorTertiary">#FFE6E6E6</Color>
</ResourceDictionary>
@@ -18,4 +18,6 @@
<Color x:Key="Chart_Histogram">#CC0A6FB3</Color>
<!-- Not Chart_SensorSecondary's gold (beta.8): the Sensors tab draws both, and in this theme they were one colour. -->
<Color x:Key="Chart_Percentile">#FF795548</Color>
<!-- beta.14: the seventh line on the temperatures plot (the card's memory temperature). -->
<Color x:Key="Chart_SensorTertiary">#FFBE008C</Color>
</ResourceDictionary>
@@ -182,13 +182,45 @@ public sealed partial class CompareViewModel : ObservableObject
{
Rows.Clear();
SessionRow[] rows = [.. picked.Select(static c => c.Row)];
AddFrameRows(rows);
AddMachineRows(rows);
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Duration, [.. rows.Select(static r => new CompareCell(Formats.Duration(r.DurationSeconds), false))]));
// beta.10: how each session was shown, both tiers. Facts, not scores: no mode is better than another, so none is best.
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Display, [.. rows.Select(static r => new CompareCell(DisplayText.Shares(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Window, [.. rows.Select(static r => new CompareCell(DisplayText.Window(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Monitor, [.. rows.Select(static r => new CompareCell(DisplayText.Monitor(DisplayText.Of(r)), false))]));
}
/// <summary>
/// The frame rate's rows, hooked sessions only. A statistic a present-only session has over its presents is labelled
/// <c>(presented)</c> in its cell (beta.14, rule 6) — beside a session whose same statistic is over the game's own frames,
/// an unlabelled number would compare two different things as one.
/// </summary>
private void AddFrameRows(SessionRow[] rows)
{
Rows.Add(Row(Strings.Compare_Metric_Native, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Generated or FpsReadoutKind.None } m ? m.Native : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Displayed, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Generated } m ? m.Displayed : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Presented, rows, static r => FpsPresentation.FromRow(r) is { Kind: FpsReadoutKind.Presented or FpsReadoutKind.IdentifiedUncounted } m ? m.Presented : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_Median, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.MedianFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_P1Low, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.P1LowFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_P01Low, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.P01LowFps : null, Formats.Fps, higherIsBetter: true));
Rows.Add(Row(Strings.Compare_Metric_StutterPct, rows, static r => r.Tier == Domain.Sessions.CaptureTier.Hooked ? r.StutterTimePct : null, static v => v is double d ? d.ToString("0.0", CultureInfo.CurrentCulture) + "%" : Strings.Common_NotAvailable, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_Median, rows, static r => Hooked(r, r.MedianFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_P1Low, rows, static r => Hooked(r, r.P1LowFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_P01Low, rows, static r => Hooked(r, r.P01LowFps), Formats.Fps, higherIsBetter: true, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_StutterPct, rows, static r => Hooked(r, r.StutterTimePct), Formats.Share, higherIsBetter: false, PresentedLabel));
// beta.14 (D49): pacing — less time below 60 and less change from frame to frame is better; the refresh share is the
// display's, over presents, generated frames included, and is named for it rather than labelled presented.
Rows.Add(Row(Strings.Compare_Metric_TimeBelow60, rows, static r => Hooked(r, r.TimeBelow60Pct), Formats.Share, higherIsBetter: false, PresentedLabel));
Rows.Add(Row(Strings.Compare_Metric_TimeBelowRefresh, rows, static r => Hooked(r, r.TimeBelowRefreshPct), Formats.Share, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_FrameToFrame, rows, static r => Hooked(r, r.FrametimeDeltaMeanMs), Formats.Milliseconds, higherIsBetter: false, PresentedLabel));
// What the presents asked for, and the render scale: settings, not scores — no best.
Rows.Add(Row(Strings.Compare_Metric_Vsync, rows, static r => Hooked(r, r.VsyncPresentPct), Formats.Share, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_RenderScale, rows, static r => r.UpscaleRatio is > 0 ? 100.0 / r.UpscaleRatio.Value : null, Formats.Share, higherIsBetter: null));
}
/// <summary>The machine's rows, both tiers.</summary>
private void AddMachineRows(SessionRow[] rows)
{
Rows.Add(Row(Strings.Compare_Metric_MaxGpuTemp, rows, static r => r.MaxGpuTemp, Formats.Temperature, higherIsBetter: false));
// A load is neither better high nor low (beta.8): a GPU at 99 % may be the bottleneck or simply busy, so neither row
// names a best.
@@ -202,20 +234,28 @@ public sealed partial class CompareViewModel : ObservableObject
Rows.Add(Row(Strings.Compare_Metric_GameVramPeak, rows, static r => r.GameVramDedicatedMaxMb, Formats.Memory, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_GameRamMedian, rows, static r => r.GameRamPrivateMedianMb, Formats.Memory, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_GameRamPeak, rows, static r => r.GameRamPrivateMaxMb, Formats.Memory, higherIsBetter: null));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Duration, [.. rows.Select(static r => new CompareCell(Formats.Duration(r.DurationSeconds), false))]));
// beta.10: how each session was shown, both tiers. Facts, not scores: no mode is better than another, so none is best.
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Display, [.. rows.Select(static r => new CompareCell(DisplayText.Shares(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Window, [.. rows.Select(static r => new CompareCell(DisplayText.Window(DisplayText.Of(r)), false))]));
Rows.Add(new CompareRowViewModel(Strings.Compare_Metric_Monitor, [.. rows.Select(static r => new CompareCell(DisplayText.Monitor(DisplayText.Of(r)), false))]));
// beta.14 (D49): the card. A clock and a power limit are facts about the card, not scores; a cooler memory and more
// of the game's own frames per watt are better.
Rows.Add(Row(Strings.Compare_Metric_GpuCoreClock, rows, static r => r.AvgGpuCoreClockMhz, Formats.Frequency, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_MaxGpuMemTemp, rows, static r => r.MaxGpuMemTemp, Formats.Temperature, higherIsBetter: false));
Rows.Add(Row(Strings.Compare_Metric_PowerLimit, rows, static r => r.PowerLimitPct, Formats.Share, higherIsBetter: null));
Rows.Add(Row(Strings.Compare_Metric_Efficiency, rows, static r => r.AppFramesPerJoule, Formats.FramesPerJoule, higherIsBetter: true));
}
private static double? Hooked(SessionRow row, double? value) => row.Tier == Domain.Sessions.CaptureTier.Hooked ? value : null;
/// <summary>The <c>(presented)</c> label for a hooked session whose statistics are over presents; null otherwise.</summary>
private static string? PresentedLabel(SessionRow row) =>
row.Tier == Domain.Sessions.CaptureTier.Hooked && FpsPresentation.FromRow(row).Kind == FpsReadoutKind.Presented ? Strings.Summary_Lows_Presented : null;
/// <summary>
/// One row: the value per session, the best (never an N/A) flagged; a row where nothing has a value is all N/A and nothing
/// is best, and a row that ranks nothing (<paramref name="higherIsBetter"/> null) flags none. Since beta.8 the best is the
/// best as SHOWN: two sessions that both read "62" are both best — 62.4 against 62.3 is not a difference the reader sees.
/// </summary>
internal static CompareRowViewModel Row(string metric, IReadOnlyList<SessionRow> rows, Func<SessionRow, double?> value, Func<double?, string> text, bool? higherIsBetter)
internal static CompareRowViewModel Row(string metric, IReadOnlyList<SessionRow> rows, Func<SessionRow, double?> value, Func<double?, string> text, bool? higherIsBetter,
Func<SessionRow, string?>? label = null)
{
double?[] values = [.. rows.Select(value)];
double? best = higherIsBetter switch
@@ -225,9 +265,15 @@ public sealed partial class CompareViewModel : ObservableObject
null => null,
};
string? bestText = best.HasValue ? text(best) : null;
return new CompareRowViewModel(metric, [.. values.Select(v => new CompareCell(text(v), bestText is not null && v.HasValue && string.Equals(text(v), bestText, StringComparison.Ordinal)))]);
// The best is decided on the number as shown; a label beside it (beta.14) says what the number is over, not how good.
return new CompareRowViewModel(metric, [.. values.Select((v, i) => new CompareCell(
Labelled(text(v), v.HasValue ? label?.Invoke(rows[i]) : null),
bestText is not null && v.HasValue && string.Equals(text(v), bestText, StringComparison.Ordinal)))]);
}
private static string Labelled(string text, string? label) => label is null ? text : text + " " + label;
private void OnCandidateChanged(object? sender, PropertyChangedEventArgs e)
{
if (string.Equals(e.PropertyName, nameof(CompareCandidateViewModel.IsSelected), StringComparison.Ordinal))
@@ -191,6 +191,13 @@ public sealed partial class GameDetailViewModel : ObservableObject
[ObservableProperty]
private bool _hasLatency;
/// <summary>
/// beta.14: any of the game's sessions measured PC latency, so the Latency tab is shown. Nothing measures Reflex today
/// (<c>sessions.reflex_active</c> is null on every row), and a tab that can only ever say "no data" was noise.
/// </summary>
[ObservableProperty]
private bool _anyLatency;
[ObservableProperty]
private TrendMetric _trendMetric = TrendMetric.PresentedFps;
@@ -344,6 +351,15 @@ public sealed partial class GameDetailViewModel : ObservableObject
new(TrendMetric.DisplayExclusiveShare, Strings.Trend_Metric_DisplayExclusive),
new(TrendMetric.DisplayBorderlessShare, Strings.Trend_Metric_DisplayBorderless),
new(TrendMetric.DisplayWindowedShare, Strings.Trend_Metric_DisplayWindowed),
new(TrendMetric.TimeBelow60, Strings.Trend_Metric_TimeBelow60),
new(TrendMetric.TimeBelowRefresh, Strings.Trend_Metric_TimeBelowRefresh),
new(TrendMetric.FrameToFrame, Strings.Trend_Metric_FrameToFrame),
new(TrendMetric.RenderScale, Strings.Trend_Metric_RenderScale),
new(TrendMetric.VsyncShare, Strings.Trend_Metric_VsyncShare),
new(TrendMetric.GpuCoreClock, Strings.Trend_Metric_GpuCoreClock),
new(TrendMetric.MaxGpuMemTemp, Strings.Trend_Metric_MaxGpuMemTemp),
new(TrendMetric.PowerLimitShare, Strings.Trend_Metric_PowerLimitShare),
new(TrendMetric.Efficiency, Strings.Trend_Metric_Efficiency),
];
/// <summary>The selected session's decoded series (null: none selected, Tier 2, or swept).</summary>
@@ -424,6 +440,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
}
Present(detail);
AnyLatency = detail.Sessions.Any(static s => s.ReflexActive == true);
ChooseDefaultMetric(detail);
await RebuildTrendAsync(ct).ConfigureAwait(true);
}
@@ -168,6 +168,8 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
public static string DistributionHeader => Strings.Summary_Distribution_Header;
public static string RenderScaleHeader => Strings.Summary_RenderScale_Header;
public static string SensorsHeader => Strings.GameDetail_Tab_Sensors;
public static string SensorStatsHeader => Strings.SensorStats_Header;
@@ -395,9 +397,32 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
IReadOnlyDictionary<string, Application.Recording.SensorSeriesStats> stats = Application.Recording.SensorSeriesStats.Parse(row.SensorStatsJson);
string? presented = IsHooked && FpsPresentation.FromRow(row).Kind == FpsReadoutKind.Presented ? Strings.Summary_Lows_Presented : null;
Stats.Clear();
AddFrameCards(row, presented);
AddPacingCards(row, presented);
AddMachineCards(row, stats);
// The table reads what finalize stored; a session from before beta.12 says so rather than computing it here.
SensorStats.Clear();
foreach (SensorStatRowModel line in SensorStatsTable.Rows(stats))
{
SensorStats.Add(line);
}
HasSensorStats = SensorStats.Count > 0;
SensorStatsMissing = !HasSensorStats && (HasSensorCharts || row.AvgGpuLoad is not null || row.MaxGpuTemp is not null) ? Strings.SensorStats_NotStored : null;
}
/// <summary>The frame rate's cards; <paramref name="presented"/> labels the statistics a present-only session has over presents.</summary>
private void AddFrameCards(SessionRow row, string? presented)
{
// CLAUDE.md rule 6 (beta.14): where frames were generated the 1% low is the game's own frames', and the presents' —
// what the display received — stands beside it, never instead of it.
string? displayedLow = IsHooked && Readout.Kind == FpsReadoutKind.Generated && row.DisplayedP1LowFps is double shown
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_DisplayedLow_Format, Formats.Fps(shown))
: null;
Stats.Add(new StatCardModel(Strings.Summary_Stat_Avg, Readout.Line));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Median, IsHooked ? Formats.Fps(row.MedianFps) : Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P1Low, IsHooked ? Formats.Fps(row.P1LowFps) : Strings.Common_NotAvailable, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P1Low, IsHooked ? Formats.Fps(row.P1LowFps) : Strings.Common_NotAvailable, presented ?? displayedLow));
Stats.Add(new StatCardModel(Strings.Summary_Stat_P01Low, IsHooked ? Formats.Fps(row.P01LowFps) : Strings.Common_NotAvailable, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_MinMax, IsHooked ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_MinMax_Format, Formats.Fps(row.MinFps), Formats.Fps(row.MaxFps)) : Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_StdDev, IsHooked && row.FrametimeStdDevMs is double sd ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_StdDev_Format, sd) : Strings.Common_NotAvailable));
@@ -410,8 +435,55 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
string window = DisplayText.Window(display);
Stats.Add(new StatCardModel(Strings.Summary_Stat_Display, DisplayText.Headline(display),
string.Equals(window, Strings.Common_NotAvailable, StringComparison.Ordinal) ? null : window));
}
// The machine, both tiers: telemetry is what a not-hooked session still has. Load is the average, temperature the peak.
/// <summary>
/// beta.14 (D49), hooked sessions: how the frames were paced, what the presents asked for, ray tracing where it was
/// measured, focus, and how complete the record is. A session recorded before beta.14 reads N/A on the new ones.
/// </summary>
private void AddPacingCards(SessionRow row, string? presented)
{
string na = Strings.Common_NotAvailable;
var below = new List<string>(3);
if (IsHooked && row.TimeBelow30Pct is double below30)
{
below.Add(string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Below30_Format, Formats.Share(below30)));
}
// The refresh share is over what the display received — generated frames included — so it is named for the display.
if (IsHooked && row.TimeBelowRefreshPct is double belowRefresh && row.DisplayMonitorHz is int hz)
{
below.Add(string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_BelowRefresh_Format, hz, Formats.Share(belowRefresh)));
}
if (presented is not null)
{
below.Add(presented);
}
Stats.Add(new StatCardModel(Strings.Summary_Stat_TimeBelow60, IsHooked ? Formats.Share(row.TimeBelow60Pct) : na, below.Count == 0 ? null : string.Join(" · ", below)));
Stats.Add(new StatCardModel(Strings.Summary_Stat_FrameToFrame, IsHooked ? Formats.Milliseconds(row.FrametimeDeltaMeanMs) : na, presented));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Vsync,
IsHooked && row.VsyncPresentPct is double vsync ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_OfFrames_Format, Formats.Share(vsync)) : na,
IsHooked && row.TearingAllowedPct is double tearing ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Tearing_Format, Formats.Share(tearing)) : null));
if (IsHooked && row.RtFramePct is double rt)
{
Stats.Add(new StatCardModel(Strings.Summary_Stat_RayTracing, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_OfFrames_Format, Formats.Share(rt)),
row.RaysPerPixel is double rays ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_RaysPerPixel_Format, rays) : null));
}
Stats.Add(new StatCardModel(Strings.Summary_Stat_Focus,
IsHooked && row.DrainTicks is > 0 && row.ForegroundTicks is long focused
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Focus_Format, Formats.Share(focused * 100.0 / row.DrainTicks.Value))
: na));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Capture,
IsHooked ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Capture_Format, row.GapCount, row.DroppedRecords, row.FaultCount) : na));
}
/// <summary>The machine, both tiers: telemetry is what a not-hooked session still has.</summary>
private void AddMachineCards(SessionRow row, IReadOnlyDictionary<string, Application.Recording.SensorSeriesStats> stats)
{
// Load is the average, temperature the peak.
Stats.Add(new StatCardModel(Strings.Summary_Stat_Gpu, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_LoadTemp_Format, Formats.Percent(row.AvgGpuLoad), Formats.Temperature(row.MaxGpuTemp))));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Cpu, string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_LoadTemp_Format, Formats.Percent(row.AvgCpuLoad), Formats.Temperature(row.MaxCpuTemp))));
@@ -419,15 +491,18 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
Stats.Add(GameMemoryText.VramCard(row));
Stats.Add(GameMemoryText.RamCard(row, stats));
// The table reads what finalize stored; a session from before beta.12 says so rather than computing it here.
SensorStats.Clear();
foreach (SensorStatRowModel line in SensorStatsTable.Rows(stats))
{
SensorStats.Add(line);
}
HasSensorStats = SensorStats.Count > 0;
SensorStatsMissing = !HasSensorStats && (HasSensorCharts || row.AvgGpuLoad is not null || row.MaxGpuTemp is not null) ? Strings.SensorStats_NotStored : null;
// beta.14 (D49): the card's clocks, fan and memory temperature, what held it back (NVIDIA only), and frames per watt.
bool clocks = row.AvgGpuCoreClockMhz is not null || row.AvgGpuMemClockMhz is not null;
bool fan = row.AvgGpuFanRpm is not null || row.MaxGpuMemTemp is not null;
Stats.Add(new StatCardModel(Strings.Summary_Stat_GpuClocks,
clocks ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Clocks_Format, Formats.Frequency(row.AvgGpuCoreClockMhz), Formats.Frequency(row.AvgGpuMemClockMhz)) : Strings.Common_NotAvailable,
fan ? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_FanMemTemp_Format, Formats.Rpm(row.AvgGpuFanRpm), Formats.Temperature(row.MaxGpuMemTemp)) : null));
Stats.Add(new StatCardModel(Strings.Summary_Stat_GpuLimits,
row.PowerLimitPct is not null || row.ThermalLimitPct is not null
? string.Format(CultureInfo.CurrentCulture, Strings.Summary_Stat_Limits_Format, Formats.Share(row.PowerLimitPct), Formats.Share(row.ThermalLimitPct))
: Strings.Common_NotAvailable));
Stats.Add(new StatCardModel(Strings.Summary_Stat_Efficiency, Formats.FramesPerJoule(row.AppFramesPerJoule),
row.AppFramesPerJoule is null ? null : Strings.Summary_Stat_Efficiency_Note));
}
/// <summary>
@@ -115,6 +115,9 @@
<charts:FrametimeChart x:Name="Frametime" Margin="0,6,0,0" Height="300" />
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.DistributionHeader}" />
<charts:DistributionChart x:Name="Distribution" Margin="0,6,0,0" Height="260" />
<!-- beta.14 (D49): the render scale over the session -->
<ui:TextBlock Margin="0,16,0,0" FontTypography="Subtitle" Text="{x:Static vm:SessionSummaryViewModel.RenderScaleHeader}" />
<charts:RenderScaleChart x:Name="RenderScale" Margin="0,6,0,0" Height="200" />
</StackPanel>
<!-- sensors, in either tier (beta.8): a session that was not hooked has nothing else to chart -->
@@ -63,6 +63,7 @@ public partial class SessionSummaryWindow : FluentWindow
{
Frametime.Show(ViewModel.Series, ViewModel.ShowDisplayed, ViewModel.ShowSensors);
Distribution.Show(ViewModel.Series);
RenderScale.Show(ViewModel.Series, ViewModel.Row);
Sensors.Show(ViewModel.SensorSeries);
}
@@ -107,7 +107,12 @@ public sealed class ChartMathTests
{
Dictionary<string, (int R, int G, int B)> palette = Palette(file);
foreach (string[] plot in new[] { SensorsChart.TempsPlot.Select(static s => s.PaletteKey).ToArray(), SensorsChart.VideoMemoryPlot.Select(static s => s.PaletteKey).ToArray(), SensorsChart.SystemMemoryPlot.Select(static s => s.PaletteKey).ToArray() })
// beta.14: the temperatures plot has a seventh line (the card's memory), and the clocks plot is a fourth plot.
foreach (string[] plot in new[]
{
SensorsChart.TempsPlot.Select(static s => s.PaletteKey).ToArray(), SensorsChart.VideoMemoryPlot.Select(static s => s.PaletteKey).ToArray(),
SensorsChart.SystemMemoryPlot.Select(static s => s.PaletteKey).ToArray(), SensorsChart.ClocksPlot.Select(static s => s.PaletteKey).ToArray(),
})
{
for (int i = 0; i < plot.Length; i++)
{
@@ -168,4 +168,50 @@ public sealed class CompareViewModelTests
CompareViewModel.Row("t", close, static r => r.MedianFps, static v => Formats.FpsNumber(v!.Value, twoDecimals: false), higherIsBetter: true)
.Cells.Select(static c => c.IsBest).Should().Equal([true, true, false], "both are shown as 62");
}
/// <summary>
/// beta.14 (D49): the new rows, and the <c>(presented)</c> label — a session whose frame statistics are over its presents
/// says so in its cell, beside one whose statistics are over the game's own frames (rule 6). The best is decided on the
/// number: less time below 60 is better, more frames per watt is better, and a VSync share ranks nothing.
/// </summary>
[Fact]
public async Task APresentOnlySessionsStatisticsAreLabelledAndTheNewRowsRankAsTheySay()
{
CultureInfo? previous = Strings.Culture;
CultureInfo previousCulture = CultureInfo.CurrentCulture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en");
try
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow a = await s.GameAsync("Alpha");
await s.SessionAsync(a.Id, DateTimeOffset.UtcNow.AddHours(-2), fgMode: "na", native: null, presented: 72, qualifier: "fg_runtime_loaded",
shape: static r => r with { TimeBelow60Pct = 20, VsyncPresentPct = 100, AppFramesPerJoule = null, UpscaleRatio = 1.5 });
await s.SessionAsync(a.Id, DateTimeOffset.UtcNow.AddHours(-1),
shape: static r => r with { TimeBelow60Pct = 5, VsyncPresentPct = 0, AppFramesPerJoule = 0.31, UpscaleRatio = 2 });
CompareViewModel vm = await BuildAsync(s, new ScriptedMixed(answer: true));
foreach (CompareCandidateViewModel c in vm.Candidates)
{
c.IsSelected = true;
}
vm.CompareCommand.Execute(null);
Task pending = vm.Pending;
await pending;
CompareRowViewModel RowOf(string metric) => vm.Rows.Single(r => string.Equals(r.Metric, metric, StringComparison.Ordinal));
// Newest first: the counted-none session, then the present-only one.
RowOf("1% Low").Cells.Select(static c => c.Text).Should().Equal("48", "48 (presented)");
CompareRowViewModel below = RowOf("Time below 60 FPS");
below.Cells.Select(static c => c.Text).Should().Equal("5.0%", "20.0% (presented)");
below.Cells.Select(static c => c.IsBest).Should().Equal(true, false);
RowOf("Frames per watt").Cells.Select(static c => (c.Text, c.IsBest)).Should().Equal(("0.31 FPS/W", true), ("N/A", false));
RowOf("VSync share").Cells.Should().OnlyContain(static c => !c.IsBest, "a setting, not a score");
RowOf("Render scale").Cells.Select(static c => c.Text).Should().Equal("50.0%", "66.7%");
}
finally
{
Strings.Culture = previous;
CultureInfo.CurrentCulture = previousCulture;
}
}
}
@@ -31,6 +31,16 @@ public sealed class FormatsTests
}
}
/// <summary>beta.14 (D49): a share to one decimal, a frame-time difference in ms, frames per joule as FPS/W; N/A, never 0.</summary>
[Fact]
public void SharesMillisecondsAndFramesPerWatt()
{
InEnglish(static () => (Formats.Share(9.62), Formats.Share(0.04), Formats.Share(null))).Should().Be(("9.6%", "0.0%", "N/A"));
InEnglish(static () => (Formats.Milliseconds(0.875), Formats.Milliseconds(null))).Should().Be(("0.88 ms", "N/A"));
InEnglish(static () => (Formats.FramesPerJoule(0.3125), Formats.FramesPerJoule(null))).Should().Be(("0.31 FPS/W", "N/A"));
InEnglish(static () => (Formats.Frequency(2655.4), Formats.Rpm(1450.4))).Should().Be(("2,655 MHz", "1,450 RPM"));
}
[Fact]
public void DurationsAndPlaytime()
{
@@ -940,4 +940,17 @@ public sealed class GameDetailViewModelTests
GameDetailViewModel.CapabilityNames("not json").Should().BeEmpty();
GameDetailViewModel.CapabilityNames(null).Should().BeEmpty();
}
/// <summary>beta.14: the Latency tab shows only when one of the game's sessions measured PC latency — nothing measures it today.</summary>
[Fact]
public async Task TheLatencyTabIsShownOnlyWhereASessionMeasuredLatency()
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow without = await s.GameAsync("Without");
await s.SessionAsync(without.Id, DateTimeOffset.UtcNow);
GameRow with = await s.GameAsync("With");
await s.SessionAsync(with.Id, DateTimeOffset.UtcNow, shape: static r => r with { ReflexActive = true, LatencyAvgUs = 21_000, LatencyP95Us = 30_000 });
(await BuildAsync(s, without.Id)).Vm.AnyLatency.Should().BeFalse();
(await BuildAsync(s, with.Id)).Vm.AnyLatency.Should().BeTrue();
}
}
@@ -0,0 +1,119 @@
// SPDX-License-Identifier: GPL-3.0-only
// Copyright (C) 2026 poli0981 - additional terms under GPLv3 section 7: see NOTICE
using FluentAssertions;
using FrameLedger.App.Charts;
using FrameLedger.Application.Persistence;
using FrameLedger.Application.Recording;
using FrameLedger.Domain.Sessions;
namespace FrameLedger.App.Tests;
/// <summary>
/// beta.14 (D49), the charts' half: the render scale over a session, and the card's clocks with the time its limits held it
/// back. The arithmetic is pure and pinned here; the two charts are drawn on the STA thread to show they draw it.
/// </summary>
public sealed class RenderScaleAndClocksTests
{
private static readonly SessionRow _row = new()
{
SessionGuid = Guid.NewGuid(),
GameId = 1,
SnapshotId = 1,
StartedAt = DateTimeOffset.UnixEpoch,
EndedAt = DateTimeOffset.UnixEpoch.AddMinutes(1),
QpcEpoch = 0,
QpcFrequency = 1,
Tier = CaptureTier.Hooked,
Mode = CaptureMode.Launch,
ExitStatus = ExitStatus.Normal,
RenderW = 1707,
RenderH = 960,
OutputW = 2560,
OutputH = 1440,
};
/// <summary>Presents 0.1 s apart; <paramref name="renderRes"/> is the blob's four values per present, or none.</summary>
private static SessionSeries Frames(int presents, ushort[]? renderRes = null) => new()
{
TimesS = [.. Enumerable.Range(0, presents).Select(static i => i * 0.1)],
FrameTimesMs = new float[presents],
Generated = new bool[presents],
Gap = new bool[presents],
RenderRes = renderRes,
AppTimesS = [],
AppFrameTimesMs = [],
AppPresentIndex = [],
Segments = [],
Sensors = [],
};
[Fact]
public void TheScaleIsThePerAxisShareOfTheOutput()
{
RenderScaleSeries.Scale(1707, 960, 2560, 1440)!.Value.Should().BeApproximately(66.67, 0.01, "DLSS Quality");
RenderScaleSeries.Scale(2560, 1440, 2560, 1440).Should().Be(100, "DLAA renders at the output");
RenderScaleSeries.Scale(0, 960, 2560, 1440).Should().BeNull("0 is the writer's unknown");
}
[Fact]
public void ABlobIsDrawnWhereTheScaleChangesAndToTheEnd()
{
// Quality for three presents, Performance for two, Quality again for three: three steps and the closing point.
ushort[] quality = [1707, 960, 2560, 1440];
ushort[] performance = [1280, 720, 2560, 1440];
ushort[] blob = [.. quality, .. quality, .. quality, .. performance, .. performance, .. quality, .. quality, .. quality];
(double[] xs, double[] ys) = RenderScaleSeries.Of(Frames(8, blob), _row);
xs.Should().Equal(0, 0.30000000000000004, 0.5, 0.7000000000000001);
ys.Select(static y => Math.Round(y, 1)).Should().Equal(66.7, 50, 66.7, 66.7);
}
[Fact]
public void WithoutABlobTheRowsExtentIsAFlatLineAndWithoutEitherNothing()
{
(double[] xs, double[] ys) = RenderScaleSeries.Of(Frames(11), _row);
xs.Should().Equal(0, 1.0);
ys.Should().AllSatisfy(static y => y.Should().BeApproximately(66.67, 0.01));
RenderScaleSeries.Of(Frames(11), _row with { RenderW = null }).Xs.Should().BeEmpty("the upscaler's parameters were never measured");
RenderScaleSeries.Of(null, _row).Xs.Should().BeEmpty("a session that was not hooked has no frames");
}
[Fact]
public void ALimitIsShadedFromItsFirstTickToTheNextTickThatWasNot()
{
var limit = new SensorSeries(SensorSeriesCatalog.GpuPowerLimit, [0, 1, 2, 3, 4, 5], [0, 100, 100, 0, 100, 100]);
SensorsChart.LimitRuns(limit).Should().Equal((1.0, 3.0), (4.0, 6.0));
SensorsChart.LimitRuns(new SensorSeries(SensorSeriesCatalog.GpuPowerLimit, [0, 1], [0, 0])).Should().BeEmpty();
}
[Fact]
public async Task TheClocksPlotAndTheRenderScaleChartDrawWhatTheSessionHas()
{
SessionSeries sensors = SessionSeries.SensorsOnly(
[
new SensorSeries(SensorSeriesCatalog.GpuCoreClock, [0, 1, 2], [2600, 2650, 2700]),
new SensorSeries(SensorSeriesCatalog.GpuFan, [0, 1, 2], [1400, 1450, 1500]),
new SensorSeries(SensorSeriesCatalog.GpuPowerLimit, [0, 1, 2], [100, 0, 100]),
]);
(int lines, int spans, int scalePoints, int notMeasured) = await PagesLoadTests.OnStaAsync(() =>
{
var chart = new SensorsChart();
chart.Show(sensors);
var scale = new RenderScaleChart();
scale.Show(Frames(11), _row);
int drawn = scale.DrawnPoints;
scale.Show(Frames(11), _row with { RenderW = null });
return (chart.DrawnSeries, chart.LimitSpansDrawn, drawn, scale.DrawnPoints);
});
lines.Should().Be(2, "the core clock and the fan; this session stored no memory clock and no temperature");
spans.Should().Be(2);
scalePoints.Should().Be(2, "a flat line from the row's extent");
notMeasured.Should().Be(0, "and nothing where it was never measured");
}
}
@@ -61,7 +61,8 @@ public sealed class SessionSummaryViewModelTests
vm.NotFound.Should().BeFalse();
vm.IsHooked.Should().BeTrue();
vm.Series.Should().NotBeNull();
vm.Stats.Should().HaveCount(13, "eight frame statistics, the display mode (beta.10), the machine: GPU and CPU (2026-09-21), then the game's own memory (beta.12)");
vm.Stats.Should().HaveCount(21, "eight frame statistics, the display mode (beta.10), pacing, VSync, focus and capture quality (beta.14), "
+ "the machine: GPU and CPU (2026-09-21), the game's own memory (beta.12), then the card's clocks, its limits and frames per watt (beta.14)");
vm.Stats.Single(c => string.Equals(c.Label, "CPU", StringComparison.Ordinal)).Value.Should().Be("N/A avg · N/A max", "this row carries no CPU reading: N/A, never 0%");
vm.Stats.Single(c => string.Equals(c.Label, "Median", StringComparison.Ordinal)).Value.Should().Be("60");
vm.Stats.Single(c => string.Equals(c.Label, "1% Low", StringComparison.Ordinal)).Value.Should().Be("48");
@@ -99,6 +100,96 @@ public sealed class SessionSummaryViewModelTests
}
}
/// <summary>
/// beta.14 (D49): the new cards read the stored row — pacing with the display's own share named for the display, VSync and
/// tearing, ray tracing where it was measured, focus, capture quality, the card's clocks and limits, frames per watt — and
/// where frames were generated the displayed 1% low stands beside the game's own (rule 6), never instead of it.
/// </summary>
[Fact]
public async Task TheBetaFourteenCardsReadTheStoredRowAndTheDisplayedLowStandsBesideTheGamesOwn()
{
CultureInfo? previous = Strings.Culture;
CultureInfo previousCulture = CultureInfo.CurrentCulture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en");
try
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow game = await s.GameAsync("Beta");
long id = await s.SessionAsync(game.Id, DateTimeOffset.UtcNow, fgMode: "dlssg", native: 60, displayed: 118, factor: 1.97, shape: static r => r with
{
FgFactorScope = "session",
DisplayedP1LowFps = 101,
TimeBelow30Pct = 1.25,
TimeBelow60Pct = 9.62,
TimeBelowRefreshPct = 3.5,
DisplayMonitorHz = 144,
FrametimeDeltaMeanMs = 0.875,
VsyncPresentPct = 100,
TearingAllowedPct = 0,
RtFramePct = 45.5,
RaysPerPixel = 0.82,
DrainTicks = 1000,
ForegroundTicks = 950,
GapCount = 2,
AvgGpuCoreClockMhz = 2655.4,
AvgGpuMemClockMhz = 15001,
AvgGpuFanRpm = 1450.4,
MaxGpuMemTemp = 78,
PowerLimitPct = 33.3,
ThermalLimitPct = 0,
AppFramesPerJoule = 0.3125,
});
SessionSummaryViewModel vm = Build(s);
await vm.LoadAsync(id, Ct);
StatCardModel Card(string label) => vm.Stats.Single(c => string.Equals(c.Label, label, StringComparison.Ordinal));
vm.Readout.Kind.Should().Be(FpsReadoutKind.Generated);
Card("1% Low").Suffix.Should().Be("displayed: 101", "rule 6: the presents' low beside the game's own, never instead");
Card("Time below 60 FPS").Should().Be(new StatCardModel("Time below 60 FPS", "9.6%", "below 30: 1.3% · display under 144 Hz: 3.5%"));
Card("Frame to frame").Value.Should().Be("0.88 ms");
Card("VSync").Should().Be(new StatCardModel("VSync", "100.0% of frames", "tearing allowed: 0.0%"));
Card("Ray tracing").Should().Be(new StatCardModel("Ray tracing", "45.5% of frames", "0.82 rays per pixel"));
Card("Game in focus").Value.Should().Be("95.0% of the time");
Card("Capture quality").Value.Should().Be("2 gaps · 0 lost · 0 faults");
Card("GPU clocks").Should().Be(new StatCardModel("GPU clocks", "2,655 MHz core · 15,001 MHz memory", "fan 1,450 RPM · memory 78 °C"));
Card("GPU held back").Value.Should().Be("power 33.3% · heat 0.0%");
Card("Frames per watt").Should().Be(new StatCardModel("Frames per watt", "0.31 FPS/W", "the game's own frames, GPU power only"));
}
finally
{
Strings.Culture = previous;
CultureInfo.CurrentCulture = previousCulture;
}
}
/// <summary>A session recorded before beta.14 has none of schema 0019's values: every new card reads N/A, never a zero.</summary>
[Fact]
public async Task ARowRecordedBeforeBetaFourteenReadsNotAvailableOnTheNewCards()
{
CultureInfo? previous = Strings.Culture;
Strings.Culture = CultureInfo.GetCultureInfo("en");
try
{
await using ScratchLedger s = await ScratchLedger.OpenAsync();
GameRow game = await s.GameAsync("Old");
SessionSummaryViewModel vm = Build(s);
await vm.LoadAsync(await s.SessionAsync(game.Id, DateTimeOffset.UtcNow), Ct);
foreach (string label in new[] { "Time below 60 FPS", "Frame to frame", "VSync", "Game in focus", "GPU clocks", "GPU held back", "Frames per watt" })
{
vm.Stats.Single(c => string.Equals(c.Label, label, StringComparison.Ordinal)).Value.Should().Be("N/A", label + " was not recorded before beta.14");
}
vm.Stats.Should().NotContain(c => string.Equals(c.Label, "Ray tracing", StringComparison.Ordinal), "the card appears only where ray tracing was measured");
}
finally
{
Strings.Culture = previous;
}
}
/// <summary>A session recorded before beta.12 has its sensors and no stored statistics: N/A cards and one sentence, nothing computed here.</summary>
[Fact]
public async Task ASessionRecordedBeforeBetaTwelveSaysItsStatisticsWereNotStored()
@@ -243,4 +243,42 @@ public sealed class TrendSeriesBuilderTests
TrendSeriesBuilder.ValueOf(Shown(3, hooked: true, new() { NoWindowMs = 9_000 }), TrendMetric.DisplayWindowedShare)
.Should().BeNull("no window was ever read, so there is no share of anything");
}
/// <summary>
/// beta.14 (D49): the nine new metrics are schema 0019's columns in their own units. Pacing and efficiency are the hooks',
/// so a Tier-2 session has no point there even with a value; the card's clock, memory temperature and power limit are
/// telemetry, every session's; a session recorded before beta.14 has no point at all.
/// </summary>
[Fact]
public void TheBetaFourteenMetricsAreTheRowsColumnsInTheirOwnUnits()
{
SessionRow hooked = Row(1, 1) with
{
TimeBelow60Pct = 9.6,
TimeBelowRefreshPct = 3.5,
FrametimeDeltaMeanMs = 0.9,
UpscaleRatio = 1.5,
VsyncPresentPct = 100,
AvgGpuCoreClockMhz = 2655,
MaxGpuMemTemp = 78,
PowerLimitPct = 33,
AppFramesPerJoule = 0.31,
};
SessionRow tier2 = Row(2, 1, hooked: false) with { TimeBelow60Pct = 50, AvgGpuCoreClockMhz = 2400, MaxGpuMemTemp = 70, PowerLimitPct = 10 };
SessionRow[] rows = [hooked, tier2, Row(3, 1)];
TrendSeriesBuilder.Points(rows, TrendMetric.TimeBelow60, false).Select(static p => p.Value).Should().Equal(9.6);
TrendSeriesBuilder.Points(rows, TrendMetric.GpuCoreClock, false).Select(static p => p.Value).Should().Equal(2655, 2400);
TrendSeriesBuilder.Points(rows, TrendMetric.MaxGpuMemTemp, false).Select(static p => p.Value).Should().Equal(78, 70);
TrendSeriesBuilder.Points(rows, TrendMetric.PowerLimitShare, false).Select(static p => p.Value).Should().Equal(33, 10);
TrendSeriesBuilder.Points(rows, TrendMetric.RenderScale, false).Single().Value.Should().BeApproximately(66.67, 0.01, "100 / upscale_ratio");
TrendSeriesBuilder.Points(rows, TrendMetric.Efficiency, false).Select(static p => p.Value).Should().Equal(0.31);
TrendSeriesBuilder.Points(rows, TrendMetric.VsyncShare, false).Select(static p => p.Value).Should().Equal(100);
TrendSeriesBuilder.Points(rows, TrendMetric.FrameToFrame, false).Select(static p => p.Value).Should().Equal(0.9);
TrendSeriesBuilder.Points(rows, TrendMetric.TimeBelowRefresh, false).Select(static p => p.Value).Should().Equal(3.5);
(TrendSeriesBuilder.UnitOf(TrendMetric.FrameToFrame), TrendSeriesBuilder.UnitOf(TrendMetric.GpuCoreClock), TrendSeriesBuilder.UnitOf(TrendMetric.Efficiency))
.Should().Be((Strings.Trend_Unit_Ms, Strings.Trend_Unit_Mhz, Strings.Trend_Unit_FpsPerWatt));
(TrendSeriesBuilder.UnitOf(TrendMetric.MaxGpuMemTemp), TrendSeriesBuilder.UnitOf(TrendMetric.TimeBelow60), TrendSeriesBuilder.UnitOf(TrendMetric.RenderScale))
.Should().Be((Strings.Trend_Unit_Celsius, Strings.Trend_Unit_Percent, Strings.Trend_Unit_Percent));
}
}