diff --git a/runtime/cfg.c b/runtime/cfg.c index 53f2bb98..bcd40fc1 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -111,7 +111,7 @@ static const CfgMeta metas[] = { {"PERF_OVERLAY", "off", "off|fps|full", LIVE}, {"OUTPUT_RES", "1920x1080", NULL, RESTART}, {"RENDER_SCALE", "game", "game|50|67|75|100|125|150|200", RESTART}, {"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE}, - {"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance", RESTART}, {"FXAA", "1", "0|1", LIVE}, + {"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance", LIVE}, {"FXAA", "1", "0|1", LIVE}, {"ASPECT", "fit", "fit|stretch", LIVE}, {"FOV", "100", "70..140", LIVE}, {"ANISO", "game", "game|2|4|8|16", RESTART}, // vk_texture.c sampler_features // colour adjustment (vk_color.c); the preset is the menu's, the four values are what the present uses diff --git a/runtime/host.h b/runtime/host.h index 5766ee4c..5b3070f8 100644 --- a/runtime/host.h +++ b/runtime/host.h @@ -262,6 +262,9 @@ int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n); // void res_heapdef_served(void); // romfs.c serves the grown table void res_init(void); // after rt_patches_init: the patch page and the sets float res_dlss_lod_bias(void); // TOTK_DLSS upscaling: texture LOD bias (<= 0) +int res_dlss_mode(const char *mode); // TOTK_DLSS changed while running: new scene size +void res_fn_hit(uint64_t addr, uint64_t x0); // main.c fnprof_hit: catches the renderer at start +void res_present(Cpu *c); // nvnQueuePresentTexture: applies a pending scene size void res_sizes(unsigned out[2], unsigned scene[2]); // the output and scene sizes in effect (the game's own // until res_init switched the sets on) int res_is_16x9(unsigned w, unsigned h); // within 1% of 16:9 (the test res_init and romfs.c share) diff --git a/runtime/main.c b/runtime/main.c index e6ced76e..86962041 100644 --- a/runtime/main.c +++ b/runtime/main.c @@ -153,8 +153,8 @@ static RtConfig cfg; const RtConfig *rt_config(void) { return &cfg; } // ---- runtime services the generated code calls (cpu.h) -volatile int g_fnprof = 0; -void fnprof_hit(uint64_t addr, uint64_t lr, uint64_t x0) { (void)addr, (void)lr, (void)x0; } +volatile int g_fnprof = 0; // resolution.c switches it on until the game sets its render size (res_fn_hit) +void fnprof_hit(uint64_t addr, uint64_t lr, uint64_t x0) { (void)lr, res_fn_hit(addr, x0); } void rt_brk(Cpu *c, uint32_t imm, uint64_t pc) { char at[128], lr[128]; diff --git a/runtime/nvn_api_obj.c b/runtime/nvn_api_obj.c index ffe0648a..bca459ac 100644 --- a/runtime/nvn_api_obj.c +++ b/runtime/nvn_api_obj.c @@ -699,6 +699,7 @@ NVN_API(nvnQueuePresentTexture) { win_t *o = arg_p(c, 1); int idx = (int)arg_x(c, 2); movie_tick(c); // ov_movie.c: hand over decoded movie frames that are due; needs the core, so before the wait + res_present(c); // resolution.c: a DLSS mode change sets the game's render size again, between frames NVN_BLOCKING(); if (o->magic != NVN_WIN_MAGIC || idx < 0 || idx >= o->ntex || idx >= 4 || !o->tex[idx]) rt_fatal("nvn: QueuePresentTexture of image %d on window %p", idx, (void *)o); diff --git a/runtime/resolution.c b/runtime/resolution.c index cd93a74c..feb2e043 100644 --- a/runtime/resolution.c +++ b/runtime/resolution.c @@ -54,6 +54,8 @@ static struct { int on; // res_init switched the patch sets on unsigned shadow; // fixed sun shadow map size (TOTK_SHADOW_RES), 0: the game's own double dlss_k; // TOTK_DLSS quality/balanced/performance: the scene's share of the output, else 0 + double base_k; // the scene's share without a DLSS mode (render_scale, or the game's 5/6) + unsigned hw, hh; // the largest scene a DLSS mode change can ask for: the heap is sized for it } R; // The scene size is decided before the device exists, so NGX cannot be asked yet. NGX loads DLSS from nvngx_dlss.dll @@ -72,6 +74,36 @@ static int dlss_dll(void) { #endif } +// The scene size for a share k of the output, within SCENE_MAX per side. +static void scene_for(double k, unsigned *w, unsigned *h) { + double sw = R.ow * k, sh = R.oh * k; + double fit = fmin(1.0, fmin(SCENE_MAX / sw, SCENE_MAX / sh)); + *w = (unsigned)(sw * fit + 0.5); + *h = (unsigned)(sh * fit + 0.5); +} + +// The scene's share of the output for a TOTK_DLSS mode; 0 for dlaa (the scene keeps base_k), while DLSS/DLAA is off +// (the mode the menu still holds would shrink the scene for the plain upscaler) and where DLSS cannot run (dlss_dll). +static double dlss_share(const char *m) { + static const struct { const char *name; double k; } dlss[] = { + {"quality", 2.0 / 3.0}, {"balanced", 0.58}, {"performance", 0.5}}; + static int dll = -1; + if (!cfg_bool("TOTK_DLAA")) return 0; + for (int i = 0; i < 3; i++) + if (!strcmp(m, dlss[i].name)) { + if (dll < 0 && !(dll = dlss_dll())) { +#ifdef _WIN32 + rt_log("resolution: DLSS %s needs nvngx_dlss.dll next to totk.exe, which is missing: the scene follows " + "render_scale", m); +#else + rt_log("resolution: DLSS %s runs on Windows only: the scene follows render_scale", m); +#endif + } + return dll ? dlss[i].k : 0; + } + return 0; +} + static void decide(void) { if (R.decided) return; R.decided = 1; @@ -88,26 +120,7 @@ static void decide(void) { } const char *s = cfg_value("TOTK_RENDER_SCALE"); double k = 5.0 / 6.0; - // a DLSS mode other than dlaa sets the scene size, only while DLSS/DLAA is on: switched off, the mode the menu - // still holds would shrink the scene for the plain upscaler - const char *m = cfg_value("TOTK_DLSS"); - static const struct { const char *name; double k; } dlss[] = { - {"quality", 2.0 / 3.0}, {"balanced", 0.58}, {"performance", 0.5}}; - for (int i = 0; cfg_bool("TOTK_DLAA") && i < 3; i++) - if (!strcmp(m, dlss[i].name)) R.dlss_k = dlss[i].k; - if (R.dlss_k && !dlss_dll()) { -#ifdef _WIN32 - rt_log("resolution: DLSS %s needs nvngx_dlss.dll next to totk.exe, which is missing: the scene follows render_scale", m); -#else - rt_log("resolution: DLSS %s runs on Windows only: the scene follows render_scale", m); -#endif - R.dlss_k = 0; - } - if (R.dlss_k) { - k = R.dlss_k; - R.scene_set = 1; - rt_log("resolution: DLSS %s: the scene at %.0f %% of the output (render_scale ignored)", m, k * 100); - } else if (strcmp(s, "game")) { + if (strcmp(s, "game")) { char *end; double pct = strtod(s, &end); if (end != s && !*end && pct >= 25 && pct <= 400) { @@ -117,11 +130,15 @@ static void decide(void) { rt_log("resolution: TOTK_RENDER_SCALE=%s is not game or a percentage 25..400; game", s); } } - double sw = R.ow * k, sh = R.oh * k; - double fit = fmin(1.0, fmin(SCENE_MAX / sw, SCENE_MAX / sh)); - if (fit < 1.0) R.scene_set = 1; - R.sw = (unsigned)(sw * fit + 0.5); - R.sh = (unsigned)(sh * fit + 0.5); + // A DLSS mode other than dlaa sets the scene size instead, and can change while the game runs (res_dlss_mode): the + // scene patch is always on, and the heap is sized for the largest scene the modes ask for. + R.base_k = k; + R.scene_set = 1; + const char *m = cfg_value("TOTK_DLSS"); + R.dlss_k = dlss_share(m); + if (R.dlss_k) rt_log("resolution: DLSS %s: the scene at %.0f %% of the output (render_scale ignored)", m, R.dlss_k * 100); + scene_for(R.dlss_k ? R.dlss_k : k, &R.sw, &R.sh); + scene_for(fmax(k, 2.0 / 3.0), &R.hw, &R.hh); const char *sr = cfg_value("TOTK_SHADOW_RES"); if (strcmp(sr, "game")) { unsigned n = (unsigned)atoi(sr); @@ -144,7 +161,7 @@ static int bigger(void) { uint64_t res_heap_extra_kib(void) { if (!bigger()) return 0; double grow = fmax(0.0, (double)R.ow * R.oh / (BASE_W * BASE_H) - 1.0) + - fmax(0.0, (double)R.sw * R.sh / (SCENE_W * SCENE_H) - 1.0); + fmax(0.0, (double)R.hw * R.hh / (SCENE_W * SCENE_H) - 1.0); uint64_t kib = grow > 0 ? (uint64_t)ceil(DTA_KIB * (1.0 + grow) / 1024.0) * 1024 - DTA_KIB : 0; return kib + ((shadow_kib() + 1023) & ~1023ull); // whole MiB } @@ -309,6 +326,7 @@ void res_init(void) { rt_patch_switch(output, R.ow != BASE_W || R.oh != BASE_H); rt_patch_switch(scene, scene_on); R.on = 1; + if (RT_V143) g_fnprof = 1; // until the game sets its render size: res_fn_hit // Another shape than 16:9 (more than 1% off): the camera takes the output's ratio (recomp/patches-v121.txt and // patches-v143.txt, set aspect), so a 21:9 output shows more of the world at the sides instead of a stretched 16:9 view. The HUD's layouts // for that shape come from romfs-patches-x (romfs.c overlay_init, tools/make_romfs_patches.py --aspect). @@ -379,6 +397,55 @@ void res_wanted(unsigned out[2]) { out[0] = R.ow, out[1] = R.oh; } +// A TOTK_DLSS change while the game runs (vk_dlaa.c, at a present): the new scene size goes to the patch page, where +// the game reads it when it sets its render size (main+0x585e48). 1.4.3 does that once, at start: its renderer setup +// (main+0x7000e67028) calls main+0x585bd0(renderer, force), which picks the console mode's sizes and flags the render +// targets for re-creation. The setup call is caught through the function-entry hook (res_fn_hit, on only until then), +// and the next nvnQueuePresentTexture on the game's thread calls it again with force set (res_present), between frames +// as at start. The heap was sized for the largest scene a mode asks for. 1 when the size changed. +#define SET_RENDER_SIZE 0x7000585bd0ull +static uint64_t renderer; // x0 of the game's own call of SET_RENDER_SIZE +static volatile int size_pending; // the page holds a size the game has not set yet + +void res_fn_hit(uint64_t addr, uint64_t x0) { + if (addr != SET_RENDER_SIZE) return; + renderer = x0; + g_fnprof = 0; + rt_log("resolution: renderer at %#llx; the scene size can change while the game runs", (unsigned long long)x0); +} + +void res_present(Cpu *c) { + if (!size_pending || !renderer) return; + size_pending = 0; + Cpu keep = *c; // the guest's registers as at the present call: the setup runs as if it never happened + rt_call(c, SET_RENDER_SIZE, 2, (uint64_t)renderer, (uint64_t)1); + memcpy(c->x, keep.x, sizeof c->x); + memcpy(c->v, keep.v, sizeof c->v); + c->nzcv = keep.nzcv, c->fpsr = keep.fpsr; + rt_log("resolution: the game set the scene size %ux%u", R.sw, R.sh); +} + +int res_dlss_mode(const char *m) { + decide(); + double k = dlss_share(m); + if (k == R.dlss_k || !R.on) return 0; + if (!RT_V143 || !renderer) { + rt_log("resolution: DLSS %s takes effect at the next start (the game set its render size already)", m); + return 0; + } + R.dlss_k = k; + unsigned w, h; + scene_for(k ? k : R.base_k, &w, &h); + if (w == R.sw && h == R.sh) return 0; + double s = RT_V143 ? (double)R.ow / BASE_W : 1.0; + float sc[2] = {(float)(w / s), (float)(h / s)}; + memcpy((uint8_t *)rt_patch_page() + 16, sc, sizeof sc); + R.sw = w, R.sh = h; + size_pending = 1; + rt_log("resolution: DLSS %s: scene %ux%u", m, w, h); + return 1; +} + void res_sizes(unsigned out[2], unsigned scene[2]) { decide(); out[0] = R.on ? R.ow : BASE_W, out[1] = R.on ? R.oh : BASE_H; diff --git a/runtime/vk.h b/runtime/vk.h index 8119ca59..9965dfa5 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -390,6 +390,7 @@ uint32_t vk_texture_slots_gen(void); // its storage address is created, dropped, released or taken back into use. Unlocked; read it before the lookup it // guards (a lookup may create an entry). 0 when the slot was never registered: nothing is kept under 0. uint64_t vk_texture_slot_token(int id); +void vk_sampler_dlss_bias(float bias); // texture LOD bias added for DLSS upscaling (material samplers) uint32_t vk_sampler_gen(void); // changes whenever a sampler slot is registered void vk_texture_gpu_written(const tex_t *t); // rendered or copied into by the GPU: no re-upload from storage void vk_texture_storage_bound_locked(const VkTexImage *img); // bound as a storage image in the recording submission diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 4872dd32..0d85a03d 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -231,7 +231,7 @@ static struct { VkImageView out_view, mv_view; NgxHandle *feat; uint64_t used; // evals count when it last ran - } sizes[3], *last; // last: the one the previous DLAA frame ran with + } sizes[5], *last; // last: the one the previous DLAA frame ran with VkImage last_color; // the target DLAA ran on last frame: another one means a new history NgxParam *params; int failed, reset; @@ -299,7 +299,7 @@ static void free_size(struct Size *e) { // goes for a new one. static struct Size *size_for(VkCommandBuffer cb, uint32_t w, uint32_t h, uint32_t ow, uint32_t oh) { struct Size *e = NULL, *lru = &D.sizes[0]; - for (int i = 0; i < 3; i++) { + for (int i = 0; i < 5; i++) { if (D.sizes[i].w == w && D.sizes[i].h == h && D.sizes[i].ow == ow && D.sizes[i].oh == oh) return &D.sizes[i]; if (!D.sizes[i].out && !e) e = &D.sizes[i]; if (D.sizes[i].used < lru->used) lru = &D.sizes[i]; @@ -613,7 +613,23 @@ void vk_dlaa_pass(VkExec *ex) { } } +// TOTK_DLSS, read at each present (the menu switches it live): the scene size of the mode (resolution.c) and the +// texture bias that goes with it while DLSS runs. +static void dlss_mode(void) { + static char mode[16]; + static int bias_on = -1; + const char *m = cfg_value("TOTK_DLSS"); + if (strcmp(m, mode)) { + snprintf(mode, sizeof mode, "%s", m); + res_dlss_mode(m); + bias_on = -1; + } + int b = dl_active(); + if (b != bias_on) bias_on = b, vk_sampler_dlss_bias(b ? res_dlss_lod_bias() : 0.0f); +} + void vk_dlaa_frame(void) { + dlss_mode(); int on = N.available && cfg_bool("TOTK_DLAA"); if (on != D.on) { rt_log("dlaa: %s", on ? "on" : "off"); diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index 46abe06f..0a63a3bb 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -1679,15 +1679,8 @@ static VkSampler make_sampler(VkCtx *c, const samp_par *d) { si.maxLod = d->lod_max > 1000 ? VK_LOD_CLAMP_NONE : d->lod_max; if (mf <= NVN_MIN_FILTER_LINEAR) si.maxLod = si.minLod + 0.25f; // not mipmapped: stay on the base level if (si.maxLod < si.minLod) si.maxLod = si.minLod; - float lim = c->props.limits.maxSamplerLodBias, bias = d->lod_bias; - // DLSS upscaling (resolution.c): the scene's material textures, the filtered mipmapped ones that repeat, are - // sampled for the output's resolution; clamped ones (post effects, LUTs, the UI) keep the game's bias. Without DLSS - // running (dlaa = 0, or NGX without DLSS) nothing accumulates the extra detail, and the sharper mips only shimmer. - if (vk_dlaa_available() && !d->cmp_mode && mf == NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR && - (si.addressModeU == VK_SAMPLER_ADDRESS_MODE_REPEAT || si.addressModeU == VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT || - si.addressModeV == VK_SAMPLER_ADDRESS_MODE_REPEAT || si.addressModeV == VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT)) - bias += res_dlss_lod_bias(); - si.mipLodBias = fmaxf(-lim, fminf(lim, bias)); + float lim = c->props.limits.maxSamplerLodBias; + si.mipLodBias = fmaxf(-lim, fminf(lim, d->lod_bias)); // TOTK_ANISO raises the level for filtered, mipmapped colour samplers that repeat on U and V: the surface textures, // which tile, so ground and walls seen at a shallow angle stay sharp into the distance. Depth-compare (shadow) // samplers, nearest or unmipmapped ones (data maps, LUTs) and clamped ones keep the game's level: clamped samplers @@ -1755,11 +1748,32 @@ void vk_sampler_register(int id, const samp_par *s) { unlock(); } +// DLSS upscaling (vk_sampler_dlss_bias): the scene's material textures, the filtered mipmapped ones that repeat, are +// sampled for the output's resolution; clamped ones (post effects, LUTs, the UI) keep the game's bias. +static float dlss_bias; + +static int dlss_biased(const samp_par *k) { + int rep_s = k->ws == NVN_WRAP_MODE_REPEAT || k->ws == NVN_WRAP_MODE_MIRRORED_REPEAT; + int rep_t = k->wt == NVN_WRAP_MODE_REPEAT || k->wt == NVN_WRAP_MODE_MIRRORED_REPEAT; + return !k->cmp_mode && k->minf == NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR && (rep_s || rep_t); +} + +void vk_sampler_dlss_bias(float b) { + lock(); + if (b != dlss_bias) { + dlss_bias = b; + for (int i = 0; i < nsslots; i++) sslots[i].s = sslots[i].sp = VK_NULL_HANDLE; // looked up again (the key moves) + samp_gen++; + } + unlock(); +} + // Caller holds the lock. static VkSampler sampler_for(VkCtx *c, const samp_par *s) { samp_par k; memset(&k, 0, sizeof k); k = *s; + if (dlss_bias != 0 && dlss_biased(&k)) k.lod_bias += dlss_bias; // part of the key: samplers live until shutdown VkSampler v = (VkSampler)nvn_hm_get(&samplers, &k); if (!v) { v = make_sampler(c, &k);