Files
Triforce-Source/tests/test_upscaler_rows.py
ruckus7382sfgsgdf 34b3683441 Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 19:32:48 -06:00

128 lines
8.7 KiB
Python

"""The Insert menu's scaling rows: the Upscaler (opts.dlss: the game's own, NVIDIA DLSS and DLAA, AMD FSR 3.1, AMD FSR 4 and
its native AA) and the Render resolution's steps for it (gpu/vk/upscaler_rows.h), their order on the Graphics tab, options
files from before still loading, and their help (why DLSS or FSR 4 is not offered, the Sharpness DLSS wants). No game or GPU
required.
python -I -B tests/test_upscaler_rows.py [--cxx g++]
"""
import argparse
import re
import subprocess
import tempfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def function(source, start):
"""A function's body from its first line to its closing brace at the start of a line"""
at = source.find(start)
if at < 0:
raise SystemExit("%s is missing" % start.rstrip(" {("))
body = source[at:]
return body[:body.index("\n}\n")]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--cxx", default="g++")
args = parser.parse_args()
menu = (ROOT / "gpu" / "vk" / "vk_menu.cpp").read_text(encoding="utf-8")
# the picture's way, top to bottom; Reflex with the frame rows
order = ['"Frame generation", &opts.framegen', '"Frame pacing", &opts.pace', '"NVIDIA Reflex", &opts.reflex',
'"Output resolution", &opts.output_res', '"Upscaler", &opts.dlss', '"DLSS model", &opts.dlss_model',
'"Render resolution", &opts.resolution',
'"Window scaling filter", &opts.upscale', '"Sharpness", &opts.sharpness']
at = [menu.find(row) for row in order]
if -1 in at:
raise SystemExit("vk_menu.cpp: a scaling row is missing: " + order[at.index(-1)])
if at != sorted(at):
raise SystemExit("vk_menu.cpp: the scaling rows are not in the picture's order")
if '"NVIDIA DLSS", &opts.' in menu or '"AMD FSR 4", &opts.' in menu:
raise SystemExit("vk_menu.cpp: DLSS or FSR has a row of its own beside the Upscaler")
# saved options: the renamed rows keep their keys (data, so read from the source)
key = function(menu, "const char* ini_key(const Row& r) {")
for value, name in (("opts.resolution", "resolution"), ("opts.upscale", "upscaling"), ("opts.dlss", "dlss")):
if not re.search(r"&%s\)\s*return\s*\"%s\"" % (re.escape(value), name), key):
raise SystemExit("ini_key: %s is not saved as %s (an options file from before would lose it)" % (value, name))
# the menu's rules are upscaler_rows.h's, checked by behaviour in test_upscaler_rows.cpp: here only that the menu uses them
uses = {
"row_fixed": ("ur::upscaler_fixed(", "ur::resolution_fixed(", "reflex_available()", "ur::model_fixed("),
"row_shown": ("ur::upscaler_shown(dlss_built() || fsr4_built(), fsr3::supported())", "ur::model_shown(dlss_built())"),
"set_row": ("ur::step_upscaler(", "ur::step(", "ur::snap(", "row_fixed("),
}
for name, calls in uses.items():
body = function(menu, "%s %s(" % ("void" if name == "set_row" else "bool", name))
for call in calls:
if call not in body:
raise SystemExit("%s does not use %s (upscaler_rows.h)" % (name, call))
# the help: a row's own, then a line for the value chosen (Row::hint). The Upscaler's says why DLSS is not offered, and
# DLSS's values ask for more Sharpness (it looks softer than the game's own)
upscaler = function(menu, "const char* hn_upscaler(int v, int variant) {")
for why in ("not in this build", "RX_VK_DLSS=0", "NVIDIA RTX GPU", "newer NVIDIA driver", "runtime was not found",
"(int)dlss_why()", "RX_VK_FSR4=0", "AMD's files were not found", "no FSR 4 for this GPU", "(int)fsr4_why()"):
if why not in upscaler:
raise SystemExit("hn_upscaler: the help no longer says why DLSS or FSR is not offered (%s)" % why)
if upscaler.count("Sharpness to") < 2:
raise SystemExit("hn_upscaler: NVIDIA DLSS and DLAA do not say to set Sharpness to around 80%")
resolution = function(menu, "const char* hn_resolution(int v, int variant) {")
if resolution.count("Sharpness to around 80%") < 5 or "upscaler()" not in resolution:
raise SystemExit("hn_resolution: DLSS's modes do not say to set Sharpness to around 80%, or not for the Upscaler shown")
measure = function(menu, "float measure_help(ui::Ctx& c, float width) {")
if "r.hint(v, k)" not in measure:
raise SystemExit("measure_help leaves the values' lines out: the help's room would jump as a value changes")
for row, hint in (('"Upscaler", &opts.dlss', "hn_upscaler"), ('"DLSS model", &opts.dlss_model', "hn_dlss_model"), ('"Render resolution", &opts.resolution', "hn_resolution"),
('"NVIDIA Reflex", &opts.reflex', "hn_reflex"), ('"Window scaling filter", &opts.upscale', "hn_filter")):
entry = menu[menu.index(row):]
if hint not in entry[:entry.index("},")]:
raise SystemExit("vk_menu.cpp: %s has no %s" % (row.split(",")[0], hint))
# the DLSS model row: not the Quality preset's (preset_exempt), no restart, and its preset is what DLSS is made with
model = menu[menu.index('"DLSS model", &opts.dlss_model'):]
if not model[:model.index("},")].rstrip().endswith("hn_dlss_model, false, true"):
raise SystemExit("vk_menu.cpp: the DLSS model row takes a restart or turns the Quality preset to Custom")
# the Window scaling filter's sizes: only from the game's frames. The start-up screen is drawn at the window's size
# (present_image with no source): taken as the picture's, the row read "Not needed" while the output was another size
replay = (ROOT / "gpu" / "vk" / "vk_replay.cpp").read_text(encoding="utf-8")
present = function(replay, "void present_image(")
note = present.index("menu_note_present_sizes(")
if "if (src) {" not in present[:note] or present.rindex("if (src) {", 0, note) < present.rindex("\n }", 0, note):
raise SystemExit("present_image: the start-up screen's frames (no src) count as the game's picture for the filter row")
dlss = (ROOT / "gpu" / "vk" / "vk_dlss.cpp").read_text(encoding="utf-8")
feature = function(dlss, "int prepare(")
if "wanted_preset()" not in feature or "s.feature_preset == preset" not in feature:
raise SystemExit("vk_dlss.cpp: DLSS's feature is not made again for another DLSS model")
if "upscaler_rows::dlss_preset(opts.dlss_model" not in function(dlss, "unsigned wanted_preset() {"):
raise SystemExit("vk_dlss.cpp: the DLSS model row (and RX_VK_DLSS_PRESET over it) is not the preset asked for")
temporal = (ROOT / "gpu" / "vk" / "vk_temporal.cpp").read_text(encoding="utf-8")
mode = function(temporal, "int temporal_mode() {")
if "dlss_why() != DLSS_OK" not in mode or "fsr4_why() != FSR_OK" not in mode:
raise SystemExit("temporal_mode asks for an engine where it cannot run (DLAA or FSR 4's native AA would hold the 3D at "
"full scale for nothing)")
if "std::clamp(" in mode:
raise SystemExit("temporal_mode clamps the row's value: FSR 3.1 (3) would run on the chain")
if "fsr3_wanted()" not in mode:
raise SystemExit("temporal_mode runs DLSS or FSR 4 while FSR 3.1 upscales (two upscalers, two jitters)")
fsr3 = (ROOT / "gpu" / "vk" / "vk_fsr3.cpp").read_text(encoding="utf-8")
if "!temporal_env_chosen()" not in function(fsr3, "bool fsr3_wanted() {"):
raise SystemExit("fsr3_wanted: a saved FSR 3.1 drops RX_VK_DLSS / RX_VK_FSR4, which go over the row")
chosen = function(temporal, "bool temporal_env_chosen() {")
if "dlss_why() == DLSS_OK" not in chosen or "fsr4_why() == FSR_OK" not in chosen:
raise SystemExit("temporal_env_chosen: a switch for an engine that cannot run here leaves the game's own, not the saved FSR 3.1")
# FSR 3.1 and FSR 4 are offered where they run, and the row steps over what does not run here
available = function(menu, "unsigned upscalers_available() {")
if "fsr3::supported()" not in available:
raise SystemExit("upscalers_available does not ask vk_fsr3.cpp whether FSR 3.1 runs here")
if "fsr4_why() == FSR_OK" not in available:
raise SystemExit("upscalers_available does not ask vk_fsr4.cpp whether FSR 4 runs here")
if "upscalers_available()" not in function(menu, "void set_row(") or "upscalers_available()" not in function(menu, "bool row_fixed("):
raise SystemExit("the Upscaler row does not step over (or fix on) what runs here")
with tempfile.TemporaryDirectory(prefix="upscaler-rows-") as tmp:
exe = Path(tmp) / "upscaler-rows"
subprocess.run([args.cxx, "-std=c++20", "-Wall", "-Wextra", "-Werror",
str(ROOT / "tests" / "test_upscaler_rows.cpp"), "-o", str(exe)], check=True)
subprocess.run([str(exe)], check=True)
if __name__ == "__main__":
main()