From bfb49335312bc80452731ca70edf80191e703e52 Mon Sep 17 00:00:00 2001 From: itaskaev2 <165683571+itaskaev2@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:47:47 +0100 Subject: [PATCH 01/12] Add shadow map resolution and anisotropic filtering settings TotK draws its sun cascades into a 960x960 DEPTH16 array of 4 layers, and its static shadows into 1440x1440 and 720x720 arrays of 2, whatever the output resolution, and shrinks the cascades under load. shadow_scale (1 to 4, default 1) creates those images that many times larger on each side: passes into them scale the game's viewports, scissors and support-buffer viewport size, and copies scale their regions, so the game is unaware of it. Images the CPU writes or that alias pool memory keep their size. When the maps are enlarged, depth-compare samplers filter linearly, because the game's few nearest taps are spaced for its own texels and leave hard, stepped edges otherwise. aniso (game, 2, 4, 8, 16; default 16) raises anisotropic filtering of linear mipmapped colour samplers; depth-compare, nearest and unmipmapped samplers keep the game's setting. Both are in totk.ini.example and on the Screen tab of the settings menu (English and Russian). Co-Authored-By: Claude Opus 5.5 --- runtime/cfg.c | 7 +++--- runtime/ui/menu.cpp | 15 +++++++++++++ runtime/ui_text.c | 14 ++++++++++++ runtime/ui_text.h | 2 ++ runtime/vk.h | 3 +++ runtime/vk_exec.c | 11 +++++++--- runtime/vk_exec.h | 3 +++ runtime/vk_exec_draw.c | 10 ++++++--- runtime/vk_exec_xfer.c | 11 +++++++--- runtime/vk_texture.c | 50 +++++++++++++++++++++++++++++++++++++++--- totk.ini.example | 7 ++++++ 11 files changed, 118 insertions(+), 15 deletions(-) diff --git a/runtime/cfg.c b/runtime/cfg.c index 84abed08..11cebb4a 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -30,7 +30,7 @@ static int save_ok = 1; // the last cfg_save_to wrote (o // Every name the runtime reads (and the patch sets in generated/), without the prefix. A file key outside this list is // logged as unknown. A new variable goes here too, or its ini key logs a harmless "unknown key" line. static const char *const known[] = { - "AB", "APP_POOL", "ASSUME_FOCUS", "ASTC", "ASTC_TIME", "ASYNC_PREEMPT", "AUDIO", "AUDIO_OFF", "AUDIO_PREFILL_MS", + "AB", "ANISO", "APP_POOL", "ASSUME_FOCUS", "ASTC", "ASTC_TIME", "ASYNC_PREEMPT", "AUDIO", "AUDIO_OFF", "AUDIO_PREFILL_MS", "BACKGROUND_WINDOW", "BIND_A", "BIND_B", "BIND_DOWN", "BIND_L", "BIND_LCLICK", "BIND_LEFT", "BIND_LSTICK_DOWN", "BIND_LSTICK_LEFT", "BIND_LSTICK_RIGHT", "BIND_LSTICK_UP", "BIND_MINUS", "BIND_PLUS", "BIND_R", "BIND_RCLICK", "BIND_RIGHT", "BIND_RSTICK_DOWN", "BIND_RSTICK_LEFT", "BIND_RSTICK_RIGHT", "BIND_RSTICK_UP", @@ -47,7 +47,7 @@ static const char *const known[] = { "RENDER_SCALE", "REPLAY_ASYNC", "REPLAY_CHECK", "RESOLVE_CHECK", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES", "ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SHADER_CACHE", - "SHADER_MEMO", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR", "SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "SWKBD_ANSWER", + "SHADER_MEMO", "SHADOW_SCALE", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR", "SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "SWKBD_ANSWER", "SWKBD_TEST", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_MEMO", "TIMER_1MS", "TRACE", "UBO_SNAPSHOT", "UPSCALER", "VK_DYN_VERTEX", "VK_NO_FLOAT64", "VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_PROCS", "ZSTD_CHECK", "ZSTD_NATIVE", @@ -59,7 +59,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, + {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -93,6 +93,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}, + {"ANISO", "16", "game|2|4|8|16", RESTART}, {"SHADOW_SCALE", "1", "1..4", RESTART}, // Game {"FPS_LIMIT", "60", "30|60|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index 64c3c4c0..a9ee648f 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -438,6 +438,19 @@ static void row_render_scale(void) { opt_choice_list("TOTK_RENDER_SCALE", UI_MENU_RENDER_SCALE, vals, names, N, UI_MENU_RENDER_SCALE_DESC); } +static void row_aniso(void) { + static const char *const vals[] = {"game", "2", "4", "8", "16"}; + static const char *names[] = {NULL, "2x", "4x", "8x", "16x"}; + names[0] = menu_text(UI_MENU_ANISO_GAME); + opt_choice_list("TOTK_ANISO", UI_MENU_ANISO, vals, names, 5, UI_MENU_ANISO_DESC); +} + +static void row_shadow_scale(void) { + static const char *const vals[] = {"1", "2", "3", "4"}; + static const char *const names[] = {"960 (1x)", "1920 (2x)", "2880 (3x)", "3840 (4x)"}; + opt_choice_list("TOTK_SHADOW_SCALE", UI_MENU_SHADOW_SCALE, vals, names, 4, UI_MENU_SHADOW_SCALE_DESC); +} + static void row_gpu(void) { const char *vals[MAX_GPUS + 1], *names[MAX_GPUS + 1]; char idx[MAX_GPUS][4]; @@ -528,6 +541,8 @@ static void tab_screen(float scale) { static const UiTextId up[] = {UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR}; opt_choice("TOTK_UPSCALER", UI_MENU_UPSCALER, up, 2, UI_MENU_UPSCALER_DESC); opt_slider("TOTK_SHARPNESS", UI_MENU_SHARPNESS, 0, 100, UI_MENU_SHARPNESS_DESC, 5, "%.0f %%"); + row_aniso(); + row_shadow_scale(); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index f93107ae..aa31587e 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -63,6 +63,13 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Bilinear", [UI_MENU_SHARPNESS] = "FSR sharpness", [UI_MENU_SHARPNESS_DESC] = "Sharpening after FSR scaling; 0 turns it off.", + [UI_MENU_ANISO] = "Anisotropic filtering", + [UI_MENU_ANISO_DESC] = "Keeps ground and walls seen at a steep angle sharp. The game's own level is the Switch's; " + "16x costs little on a desktop GPU.", + [UI_MENU_ANISO_GAME] = "The game's", + [UI_MENU_SHADOW_SCALE] = "Shadow resolution", + [UI_MENU_SHADOW_SCALE_DESC] = "Draws the sun's shadow maps this many times larger on each side than the game's 960x960: " + "sharper shadow edges and leaf shadows. Takes effect at the next start.", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " @@ -281,6 +288,13 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Билинейное", [UI_MENU_SHARPNESS] = "Резкость FSR", [UI_MENU_SHARPNESS_DESC] = "Повышение резкости после масштабирования FSR; 0 выключает его.", + [UI_MENU_ANISO] = "Анизотропная фильтрация", + [UI_MENU_ANISO_DESC] = "Сохраняет чёткость земли и стен под острым углом. Уровень самой игры — как на Switch; " + "16x почти ничего не стоит настольной видеокарте.", + [UI_MENU_ANISO_GAME] = "Как в игре", + [UI_MENU_SHADOW_SCALE] = "Разрешение теней", + [UI_MENU_SHADOW_SCALE_DESC] = "Карты теней от солнца рисуются во столько раз больше по каждой стороне, чем 960x960 " + "самой игры: края теней и тени листвы чётче. Действует после перезапуска.", [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 6eb805cf..680e9cfe 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -36,6 +36,8 @@ typedef enum { UI_MENU_RENDER_SCALE, UI_MENU_RENDER_SCALE_DESC, UI_MENU_RENDER_SCALE_GAME, UI_MENU_UPSCALER, UI_MENU_UPSCALER_DESC, UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR, UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, + UI_MENU_ANISO, UI_MENU_ANISO_DESC, UI_MENU_ANISO_GAME, + UI_MENU_SHADOW_SCALE, UI_MENU_SHADOW_SCALE_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, diff --git a/runtime/vk.h b/runtime/vk.h index 961f2f35..fdfaf319 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -268,6 +268,9 @@ typedef struct { uint8_t fb_usage; // created with ATTACHMENT_FEEDBACK_LOOP usage (VK_FEEDBACK_LAYOUT, attachable images) uint8_t fb_learned; // a draw sampled it while it was a written attachment of the open pass: its passes // attach it in ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT (vk_exec.c vk_exec_pass_begin) + uint8_t scale; // 1, or TOTK_SHADOW_SCALE for a shadow map made larger than the game's (vk_texture.c + // shadow_scale_of): width and height above are the larger ones, the game's regions + // are multiplied by it } VkTexImage; const VkTexImage *vk_texture_get(const tex_t *t); // created and made current; NULL for BUFFER or unmapped formats // A texture slot; a slot whose texture was finalized follows the live texture at the same storage (hle_nvn.c). diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index d82c0574..0abd2b63 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -192,6 +192,7 @@ static void resolve_target(const tex_t *t, const view_t *v, int has_v, int depth } o->image = img->image; o->img = img; + o->scale = img->scale ? img->scale : 1; o->format = fmt; o->view_type = layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D; o->aspect = depth_slot ? img->aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) @@ -227,7 +228,7 @@ static void resolve_rt(VkExec *ex) { ex->rt_resolved = 1; const p_set_rt *r = &ex->rt; int n = r->n < 0 ? 0 : r->n > 8 ? 8 : r->n; - uint32_t w = UINT32_MAX, h = UINT32_MAX, layers = UINT32_MAX, samples = 0; + uint32_t w = UINT32_MAX, h = UINT32_MAX, layers = UINT32_MAX, samples = 0, scale = 1; for (int i = 0; i < 8; i++) { VkExecTarget *t = &ex->color[i]; resolve_target(i < n ? r->color[i] : NULL, &r->cview[i], i < n && r->has_cview[i], 0, t); @@ -238,6 +239,7 @@ static void resolve_rt(VkExec *ex) { if (t->height < h) h = t->height; if (t->layers < layers) layers = t->layers; if (!samples) samples = t->samples; + if (t->scale > scale) scale = t->scale; } VkExecTarget *d = &ex->depth; resolve_target(r->depth, &r->dview, r->has_dview, 1, d); @@ -249,6 +251,7 @@ static void resolve_rt(VkExec *ex) { if (d->height < h) h = d->height; if (d->layers < layers) layers = d->layers; if (!samples) samples = d->samples; + if (d->scale > scale) scale = d->scale; } ex->pass_noatt = w == UINT32_MAX; if (ex->pass_noatt) { @@ -260,6 +263,7 @@ static void resolve_rt(VkExec *ex) { ex->vp[0][1], ex->vp[0][2], ex->vp[0][3]); } ex->pass_w = w, ex->pass_h = h, ex->pass_layers = layers; + ex->pass_scale = ex->pass_noatt ? 1 : scale; ex->pass_ncolor = (uint32_t)n; ex->pass_samples = samples ? samples : 1; ex->pipe.samples = (uint8_t)ex->pass_samples; @@ -511,8 +515,9 @@ VkBuffer vk_exec_inline_buffer(VkDeviceSize size) { VkRect2D vk_exec_scissor(const VkExec *ex) { int64_t w = ex->pass_w, h = ex->pass_h; if (!ex->has_scissor) return (VkRect2D){{0, 0}, {(uint32_t)w, (uint32_t)h}}; - int64_t x0 = ex->scissor.x, y0 = ex->scissor.y; - int64_t x1 = x0 + ex->scissor.w, y1 = y0 + ex->scissor.h; + int64_t k = ex->pass_scale > 1 ? ex->pass_scale : 1; + int64_t x0 = ex->scissor.x * k, y0 = ex->scissor.y * k; + int64_t x1 = x0 + (int64_t)ex->scissor.w * k, y1 = y0 + (int64_t)ex->scissor.h * k; if (x0 < 0) x0 = 0; if (y0 < 0) y0 = 0; if (x1 > w) x1 = w; diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index c81d5c61..b0095f63 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -35,6 +35,7 @@ typedef struct { uint32_t width, height, samples; // extent of that level; with blocks, in blocks int32_t nvn_format; // NVNformat of the view (VkPipeState.color_fmt / depth_fmt) const VkTexImage *img; // the image (fb_usage, fb_learned) + uint8_t scale; // VkTexImage.scale } VkExecTarget; // The replay state. One instance lives for the run: NVN state is queue state and carries over from one submission to @@ -52,6 +53,8 @@ typedef struct VkExec { int rt_resolved; // color[] and depth hold this command buffer's images for rt VkExecTarget color[8], depth; // resolved targets uint32_t pass_w, pass_h, pass_layers; // render area and layer count of the open (or next) pass + uint32_t pass_scale; // its targets' VkTexImage.scale: game viewports and scissors + // are multiplied by it int pass_noatt; // the pass has no attachment: its size follows the draws (vk_exec_noatt_dims) VkFormat pass_color[8], pass_depth, pass_stencil; // attachment formats of the pass (VkPipelineRenderingCreateInfo); // VK_FORMAT_UNDEFINED: none diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index e9326df5..e23741e9 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -1240,8 +1240,9 @@ static VkDescriptorSet alloc_set(VkExec *ex, VkDescriptorSetLayout layout) { } static void support_in(const VkExec *ex, float in[3]) { // what support_fill reads: viewport size, point size - in[0] = ex->in_pass && ex->has_vp ? ex->vp[0][2] : (float)ex->pass_w; - in[1] = ex->in_pass && ex->has_vp ? ex->vp[0][3] : (float)ex->pass_h; + float k = ex->pass_scale > 1 ? (float)ex->pass_scale : 1.0f; + in[0] = ex->in_pass && ex->has_vp ? ex->vp[0][2] * k : (float)ex->pass_w; + in[1] = ex->in_pass && ex->has_vp ? ex->vp[0][3] * k : (float)ex->pass_h; in[2] = ex->point_size > 0 ? ex->point_size : 1.0f; } @@ -1670,7 +1671,10 @@ static void record_fixed(VkExec *ex) { VkCommandBuffer cb = ex->cb; if (ex->dirty & VK_EXEC_DIRTY_VIEWPORT) { float x = 0, y = 0, w = (float)ex->pass_w, h = (float)ex->pass_h; - if (ex->has_vp) x = ex->vp[0][0], y = ex->vp[0][1], w = ex->vp[0][2], h = ex->vp[0][3]; + if (ex->has_vp) { + float k = ex->pass_scale > 1 ? (float)ex->pass_scale : 1.0f; + x = ex->vp[0][0] * k, y = ex->vp[0][1] * k, w = ex->vp[0][2] * k, h = ex->vp[0][3] * k; + } if (w < 1) w = 1; if (h < 1) h = 1; VkViewport v = {x, y + h, w, -h, ex->depth_range[0], ex->depth_range[1]}; // the y flip: negative height diff --git a/runtime/vk_exec_xfer.c b/runtime/vk_exec_xfer.c index 34548153..ffb3b420 100644 --- a/runtime/vk_exec_xfer.c +++ b/runtime/vk_exec_xfer.c @@ -352,10 +352,11 @@ static int sub_resolve(const tex_t *t, const view_t *v, int has_v, const NVNcopy s->level = has_v && v->set_levels ? v->base_level : 0; s->layer0 = has_v && v->set_layers ? v->min_layer : 0; uint32_t lw = max1(img->width >> s->level), lh = max1(img->height >> s->level); - s->x = r->xoffset, s->y = r->yoffset, s->z = r->zoffset; + int k = img->scale > 1 ? img->scale : 1; // a larger shadow map: the game's region in its texels + s->x = r->xoffset * k, s->y = r->yoffset * k, s->z = r->zoffset; s->nz = r->depth > 0 ? (uint32_t)r->depth : 1; - s->w = r->width > 0 ? (uint32_t)r->width : defaults_to_level ? (s->x < (int32_t)lw ? lw - (uint32_t)s->x : 0) : 0; - s->h = r->height > 0 ? (uint32_t)r->height : defaults_to_level ? (s->y < (int32_t)lh ? lh - (uint32_t)s->y : 0) : 0; + s->w = r->width > 0 ? (uint32_t)r->width * k : defaults_to_level ? (s->x < (int32_t)lw ? lw - (uint32_t)s->x : 0) : 0; + s->h = r->height > 0 ? (uint32_t)r->height * k : defaults_to_level ? (s->y < (int32_t)lh ? lh - (uint32_t)s->y : 0) : 0; int is3d = img->type == VK_IMAGE_TYPE_3D; uint32_t layers = is3d ? 1 : (uint32_t)s->z + s->nz, first = is3d ? 0 : s->layer0; if (s->level >= img->levels || s->x < 0 || s->y < 0 || s->z < 0 || !s->w || !s->h || @@ -411,6 +412,10 @@ static int buffer_side(const VkExec *ex, const Sub *s, uint64_t addr, uint64_t * static void copy_buffer_image(VkExec *ex, const p_copy_b2t *p, int to_image) { Sub s; if (!sub_resolve(p->tex, &p->view, p->has_view, &p->r, 1, &s)) return; + if (s.img->scale > 1) { // the buffer holds the game's texel count, the image more + warn_once(W_REGION, "buffer copy of a shadow map enlarged by TOTK_SHADOW_SCALE: skipped"); + return; + } uint64_t size; VkBufferImageCopy c; VkMemSpan m; diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index b65f21e7..e2fda908 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -273,6 +273,33 @@ static void init_image(Tex *e, VkCommandBuffer cb) { } } +// TOTK_SHADOW_SCALE (1 to 4): the game's shadow maps are made this many times larger on each side. TotK renders its +// sun cascades into a 960x960 DEPTH16 2D array of 4 layers and its static shadows into 1440x1440 and 720x720 arrays of 2, +// whatever the output resolution, and shrinks the cascades under load (872, 848, 800, 480 and so on). Those are made +// larger here: render passes into them scale the game's viewports and scissors (vk_exec.c resolve_rt, pass_scale), +// copies scale their regions (vk_exec_xfer.c sub_resolve), and shaders sample them with normalised coordinates, so the +// game sees nothing of it. A map whose storage the CPU writes (mirrored) or that aliases pool memory keeps its size, +// as its texels must match the guest layout. +static int shadow_scale(void) { + static int scale = -1; + if (scale < 0) { + int s = cfg_int("TOTK_SHADOW_SCALE"); + s = s < 1 ? 1 : s > 4 ? 4 : s; + rt_log("vk: shadow map scale %d", s); + scale = s; + } + return scale; +} + +static int shadow_scale_of(const nvn_texdesc *d, const TexVkFormat *f, uint32_t samples, int mirrored) { + int scale = shadow_scale(); + if (scale == 1 || mirrored || samples > 1 || d->format != NVN_FORMAT_DEPTH16 || !f->depth) return 1; + if (d->target != NVN_TEXTURE_TARGET_2D_ARRAY || d->width != d->height || d->width < 256 || d->depth < 2 || d->depth > 4) + return 1; + uint32_t most = vk_ctx()->props.limits.maxImageDimension2D; + return d->width * (uint32_t)scale <= most ? scale : 1; +} + // defer_init: the caller records the image's first transition (init_image or alias_copy). static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { static volatile long n_unmapped, n_unsupported, n_failed, n_unbound; @@ -300,6 +327,8 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { case NVN_TEXTURE_TARGET_CUBEMAP: case NVN_TEXTURE_TARGET_CUBEMAP_ARRAY: layers = L.layers; break; default: break; } + int scale = shadow_scale_of(d, &f, d->samples > 1 ? (uint32_t)d->samples : 1, tex_mirrored(t)); + w *= (uint32_t)scale, h *= (uint32_t)scale; uint32_t levels = umax(d->levels, 1), most = 1; for (uint32_t s = umax(umax(w, h), depth); s > 1; s >>= 1) most++; if (levels > most) levels = most; @@ -342,7 +371,7 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { e->f = f; e->pub.addr = k->addr; VkImage img = VK_NULL_HANDLE; - if (nvn_gpu_only(k->addr)) { // storage in a physical or virtual pool: alias the pool memory (section 3.2) + if (scale == 1 && nvn_gpu_only(k->addr)) { // storage in a physical or virtual pool: alias the pool memory (section 3.2) if (vkCreateImage(c->device, &ci, NULL, &img) == VK_SUCCESS && !bind_pool_memory(c, e, img)) { vkDestroyImage(c->device, img, NULL); img = VK_NULL_HANDLE; @@ -384,6 +413,7 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { p->bound = e->bound_to != NULL; p->block_views = (uint8_t)block_views; p->fb_usage = (uint8_t)fb_usage; + p->scale = (uint8_t)scale; if (!defer_init) { init_image(e, vk_upload_begin()); @@ -1421,6 +1451,7 @@ static VkCompareOp compare_op(uint32_t f) { } static struct { int init, mirror_clamp_edge, minmax, border_no_format; } sf; +static float aniso_force; // TOTK_ANISO: 0 = the game's level, else the least level of mipmapped colour samplers static void sampler_features(VkCtx *c) { if (sf.init) return; @@ -1432,6 +1463,9 @@ static void sampler_features(VkCtx *c) { sf.mirror_clamp_edge = f12.samplerMirrorClampToEdge; sf.minmax = f12.samplerFilterMinmax; sf.border_no_format = c->has_custom_border_color && cbf.customBorderColors && cbf.customBorderColorWithoutFormat; + const char *an = cfg_value("TOTK_ANISO"); + aniso_force = strcmp(an, "game") ? (float)atoi(an) : 0; + rt_log("vk: anisotropic filtering: %s", aniso_force > 1 ? an : "the game's"); sf.init = 1; } @@ -1466,13 +1500,23 @@ static VkSampler make_sampler(VkCtx *c, const samp_par *d) { if (si.maxLod < si.minLod) si.maxLod = si.minLod; float lim = c->props.limits.maxSamplerLodBias; si.mipLodBias = fmaxf(-lim, fminf(lim, d->lod_bias)); - if (d->aniso > 1) { + float aniso = d->aniso; + // TOTK_ANISO raises the level for filtered, mipmapped colour samplers only: depth-compare (shadow) samplers and + // nearest or unmipmapped ones (data maps, LUTs) keep what the game set. + if (aniso_force > 1 && !d->cmp_mode && si.magFilter == VK_FILTER_LINEAR && si.minFilter == VK_FILTER_LINEAR && + (mf == NVN_MIN_FILTER_LINEAR_MIPMAP_NEAREST || mf == NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR) && aniso < aniso_force) + aniso = aniso_force; + if (aniso > 1) { si.anisotropyEnable = VK_TRUE; - si.maxAnisotropy = fminf(d->aniso, c->props.limits.maxSamplerAnisotropy); + si.maxAnisotropy = fminf(aniso, c->props.limits.maxSamplerAnisotropy); } if (d->cmp_mode) { si.compareEnable = VK_TRUE; si.compareOp = compare_op(d->cmp_func); + // A depth-compare sampler set to nearest returns 0 or 1 per tap, and the game's shaders smooth shadow edges by + // a few taps spaced for its own shadow map texels. With TOTK_SHADOW_SCALE those taps cover a fraction of the + // area and the edges turn hard and stepped; linear filtering makes every tap a 2x2 PCF instead. + if (shadow_scale() > 1) si.magFilter = si.minFilter = VK_FILTER_LINEAR; } VkSamplerCustomBorderColorCreateInfoEXT cb = {.sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT}; VkSamplerReductionModeCreateInfo rm = {.sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO}; diff --git a/totk.ini.example b/totk.ini.example index f8213a99..68e9f306 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -115,6 +115,13 @@ # from 0 (off) to 100. Changes while the game runs take effect at once. # upscaler = fsr # sharpness = 80 +# Anisotropic filtering of mipmapped textures: game (the level the game asks for, as on the Switch) or 2, 4, 8, 16. +# Keeps ground and walls seen at a steep angle sharp. Depth-compare (shadow) and nearest-filtered samplers keep the +# game's setting. Read at start. +# aniso = 16 +# Shadow map resolution: the game's sun cascades are 960x960 (and its static shadow maps 1440 and 720) whatever the game +# resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. Read at start. +# shadow_scale = 1 [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale. From 386e70453b4f5be8eed1ff4704c05ff249bd894f Mon Sep 17 00:00:00 2001 From: itaskaev2 <165683571+itaskaev2@users.noreply.github.com> Date: Fri, 30 Oct 2026 15:06:58 +0100 Subject: [PATCH 02/12] Add a shadow cascade range setting for 1.4.3 The sun's shadow cascades end at 20, 40, 80 and 160 m: the depth shadow parameter object (main+0x6fa3c0) registers depth_shadow_near_0_1..3 and depth_shadow_far_0 as immediates, and the field's .bgsdw files do not override them. The new cascade patch set reads the four distances from patch page +64..+76 instead, and shadow_range (percent, 50 to 400, default 100) writes them there at start, so the visible steps where shadows turn softer move away from the player. It spreads the shadow map over more ground, which shadow_scale pays back. Only patches-v143.txt has the set; on 1.2.1 the setting logs that and does nothing. The setting is in totk.ini.example and on the Screen tab of the menu (English and Russian). Co-Authored-By: Claude Opus 5.5 --- recomp/patches-v143.txt | 9 +++++++++ runtime/cfg.c | 5 +++-- runtime/resolution.c | 18 ++++++++++++++++++ runtime/ui/menu.cpp | 7 +++++++ runtime/ui_text.c | 8 ++++++++ runtime/ui_text.h | 1 + totk.ini.example | 3 +++ 7 files changed, 49 insertions(+), 2 deletions(-) diff --git a/recomp/patches-v143.txt b/recomp/patches-v143.txt index 16189169..dd47fea5 100644 --- a/recomp/patches-v143.txt +++ b/recomp/patches-v143.txt @@ -10,6 +10,7 @@ set cloth TOTK_CLOTH_REALTIME 1 set bounce TOTK_HIGHFPS_FIX 1 set output TOTK_PATCH_OUTPUT 0 set scene TOTK_PATCH_SCENE 0 +set cascade TOTK_PATCH_CASCADE 0 # 60 fps: the adaptive present-interval controller (main+0x2db174, 1.2.1 0x8f26c8) gets the minimum interval 1. site fps60 main 2db204 6b08015f 7100055f # clamp: cmp w10, #1 (was cmp w10, w8 = minimum) @@ -936,3 +937,11 @@ spin subsdk0 1c4e54 1c4e60 # 4 instructions; loads spin sdk 2d3654 2d3668 # 6 instructions; loads spin sdk 443864 443884 # 9 instructions; loads spin sdk 541e54 541f98 # 32 instructions; loads + +# Sun shadow cascade distances (runtime/resolution.c res_shadow_range switches the set on). The depth shadow parameter +# object (main+0x6fa3c0) registers depth_shadow_near_0_1..3 = 20, 40, 80 m and depth_shadow_far_0 = 160 m as +# immediates, and the field's .bgsdw files do not override them; with the set on they come from page +64..+76. +site cascade main 6fabb8 52a83408 @page:x8 b9404108 # mov w8, #20.0 -> ldr w8, [page+64] +site cascade main 6fac40 52a84408 @page:x8 b9404508 # mov w8, #40.0 -> ldr w8, [page+68] +site cascade main 6facc8 52a85408 @page:x8 b9404908 # mov w8, #80.0 -> ldr w8, [page+72] +site cascade main 6fad4c 52a86408 @page:x8 b9404d08 # mov w8, #160.0 -> ldr w8, [page+76] diff --git a/runtime/cfg.c b/runtime/cfg.c index 11cebb4a..bfd87294 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -47,7 +47,7 @@ static const char *const known[] = { "RENDER_SCALE", "REPLAY_ASYNC", "REPLAY_CHECK", "RESOLVE_CHECK", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES", "ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SHADER_CACHE", - "SHADER_MEMO", "SHADOW_SCALE", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR", "SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "SWKBD_ANSWER", + "SHADER_MEMO", "SHADOW_RANGE", "SHADOW_SCALE", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR", "SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "SWKBD_ANSWER", "SWKBD_TEST", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_MEMO", "TIMER_1MS", "TRACE", "UBO_SNAPSHOT", "UPSCALER", "VK_DYN_VERTEX", "VK_NO_FLOAT64", "VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_PROCS", "ZSTD_CHECK", "ZSTD_NATIVE", @@ -59,7 +59,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, + {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -94,6 +94,7 @@ static const CfgMeta metas[] = { {"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}, {"ANISO", "16", "game|2|4|8|16", RESTART}, {"SHADOW_SCALE", "1", "1..4", RESTART}, + {"SHADOW_RANGE", "100", "50..400", RESTART}, // Game {"FPS_LIMIT", "60", "30|60|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, diff --git a/runtime/resolution.c b/runtime/resolution.c index 2e4b1d7c..fc8d5524 100644 --- a/runtime/resolution.c +++ b/runtime/resolution.c @@ -191,7 +191,25 @@ void res_heapdef_served(void) { R.heapdef_ok = 1; } // ---- start: the patch page and the sets static uint64_t pack(unsigned w, unsigned h) { return (uint64_t)h << 32 | w; } +// TOTK_SHADOW_RANGE (percent, 50 to 400; 100 = the game's): the sun's shadow cascades end at 20, 40, 80 and 160 m. +// Other values multiply those distances through the cascade patch set (recomp/patches-v143.txt), so the sharp first +// cascade reaches further and the visible steps between cascades move away from the player, at the cost of shadow +// texels per metre (TOTK_SHADOW_SCALE pays that back). +static void res_shadow_range(void) { + int pct = cfg_int("TOTK_SHADOW_RANGE"), set = rt_patch_set("cascade"); + if (pct == 100) return; + if (set < 0) { + rt_log("resolution: the generated C has no cascade patch set; shadow_range stays 100"); + return; + } + float k = (float)(pct < 50 ? 50 : pct > 400 ? 400 : pct) / 100.0f, d[4] = {20 * k, 40 * k, 80 * k, 160 * k}; + memcpy((uint8_t *)rt_patch_page() + 64, d, sizeof d); + rt_patch_switch(set, 1); + rt_log("resolution: shadow cascades end at %g, %g, %g and %g m", d[0], d[1], d[2], d[3]); +} + void res_init(void) { + res_shadow_range(); if (!bigger()) { rt_log("resolution: the game's own (output 1920x1080, scene 1600x900)"); return; diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index a9ee648f..d3eb04f9 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -451,6 +451,12 @@ static void row_shadow_scale(void) { opt_choice_list("TOTK_SHADOW_SCALE", UI_MENU_SHADOW_SCALE, vals, names, 4, UI_MENU_SHADOW_SCALE_DESC); } +static void row_shadow_range(void) { + static const char *const vals[] = {"100", "150", "200", "300"}; + static const char *const names[] = {"160 m (1x)", "240 m (1.5x)", "320 m (2x)", "480 m (3x)"}; + opt_choice_list("TOTK_SHADOW_RANGE", UI_MENU_SHADOW_RANGE, vals, names, 4, UI_MENU_SHADOW_RANGE_DESC); +} + static void row_gpu(void) { const char *vals[MAX_GPUS + 1], *names[MAX_GPUS + 1]; char idx[MAX_GPUS][4]; @@ -543,6 +549,7 @@ static void tab_screen(float scale) { opt_slider("TOTK_SHARPNESS", UI_MENU_SHARPNESS, 0, 100, UI_MENU_SHARPNESS_DESC, 5, "%.0f %%"); row_aniso(); row_shadow_scale(); + row_shadow_range(); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index aa31587e..d279674a 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -70,6 +70,10 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Shadow resolution", [UI_MENU_SHADOW_SCALE_DESC] = "Draws the sun's shadow maps this many times larger on each side than the game's 960x960: " "sharper shadow edges and leaf shadows. Takes effect at the next start.", + [UI_MENU_SHADOW_RANGE] = "Shadow cascade range", + [UI_MENU_SHADOW_RANGE_DESC] = "Moves the steps where shadows turn softer (the game's 20, 40, 80 and 160 m) further " + "away. Spreads the shadow map over more ground: raise Shadow resolution with it. " + "Takes effect at the next start.", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " @@ -295,6 +299,10 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Разрешение теней", [UI_MENU_SHADOW_SCALE_DESC] = "Карты теней от солнца рисуются во столько раз больше по каждой стороне, чем 960x960 " "самой игры: края теней и тени листвы чётче. Действует после перезапуска.", + [UI_MENU_SHADOW_RANGE] = "Дальность каскадов теней", + [UI_MENU_SHADOW_RANGE_DESC] = "Отодвигает границы, за которыми тени становятся мягче (в игре 20, 40, 80 и 160 м). " + "Карта теней растягивается на большую площадь, поэтому вместе с этим поднимайте " + "разрешение теней. Действует после перезапуска.", [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 680e9cfe..7462a703 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -38,6 +38,7 @@ typedef enum { UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, UI_MENU_ANISO, UI_MENU_ANISO_DESC, UI_MENU_ANISO_GAME, UI_MENU_SHADOW_SCALE, UI_MENU_SHADOW_SCALE_DESC, + UI_MENU_SHADOW_RANGE, UI_MENU_SHADOW_RANGE_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, diff --git a/totk.ini.example b/totk.ini.example index 68e9f306..d8744e73 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -122,6 +122,9 @@ # Shadow map resolution: the game's sun cascades are 960x960 (and its static shadow maps 1440 and 720) whatever the game # resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. Read at start. # shadow_scale = 1 +# Sun shadow cascade range in percent of the game's (its cascades end at 20, 40, 80 and 160 m), 50 to 400: higher moves +# the steps where shadows turn softer further away, and spreads the shadow map over more ground. Read at start. +# shadow_range = 100 [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale. From 4af60604de5d96da5bdafb4c6653df1f80a52bac Mon Sep 17 00:00:00 2001 From: itaskaev2 <165683571+itaskaev2@users.noreply.github.com> Date: Fri, 30 Oct 2026 15:29:53 +0100 Subject: [PATCH 03/12] Add screen-space contact shadows TotK fills a full-resolution G-buffer with a B10G11R11 scene colour, an R32F linear depth and a D32F depth, lights it in half resolution, and composites the lighting into the scene colour in one pass whose only target is that colour, with a D16 class depth. vk_contact.c recognises both passes, and when the pass after the composite begins (or a dispatch or copy comes first) runtime/shaders/contact_shadow.comp marches each pixel 16 steps toward the sun through the linear depth and darkens the scene colour where nearby geometry blocks the ray: the small shadows at feet, under stones and in grass that the shadow maps miss. Transparent surfaces, the sky and post-processing come after. The projection, far plane and sun direction come from the fragment stage's 0x940-byte camera block (c4): c4[7].x, c4[8].y, c4[14].y, and the first cascade's depth row c4[44].xyz, whose negation points toward the sun. Scene colour images get STORAGE usage while the setting is on. contact_shadows (percent strength, default 0) is in totk.ini.example and on the Screen tab of the menu (English and Russian). TOTK_CONTACT_DEBUG=1 shows the shadow factor in grey instead of the frame. It costs about 0.45 ms per frame at a 3840x2160 scene on an RTX 4080 SUPER. Co-Authored-By: Claude Opus 5.5 --- runtime/cfg.c | 6 +- runtime/contact_shadow_spv.h | 156 +++++++++++++++++++++++ runtime/gfx_window.c | 1 + runtime/shaders/contact_shadow.comp | 67 ++++++++++ runtime/ui/menu.cpp | 1 + runtime/ui_text.c | 6 + runtime/ui_text.h | 1 + runtime/vk.h | 3 + runtime/vk_contact.c | 188 ++++++++++++++++++++++++++++ runtime/vk_exec.c | 1 + runtime/vk_exec.h | 3 + runtime/vk_exec_draw.c | 1 + runtime/vk_exec_xfer.c | 1 + runtime/vk_texture.c | 4 + totk.ini.example | 4 + 15 files changed, 440 insertions(+), 3 deletions(-) create mode 100644 runtime/contact_shadow_spv.h create mode 100644 runtime/shaders/contact_shadow.comp create mode 100644 runtime/vk_contact.c diff --git a/runtime/cfg.c b/runtime/cfg.c index bfd87294..2372ad1b 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -35,7 +35,7 @@ static const char *const known[] = { "BIND_LSTICK_RIGHT", "BIND_LSTICK_UP", "BIND_MINUS", "BIND_PLUS", "BIND_R", "BIND_RCLICK", "BIND_RIGHT", "BIND_RSTICK_DOWN", "BIND_RSTICK_LEFT", "BIND_RSTICK_RIGHT", "BIND_RSTICK_UP", "BIND_SKIP", "BIND_STATS", "BIND_UP", "BIND_X", "BIND_Y", - "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", + "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CONTACT_DEBUG", "CONTACT_SHADOWS", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "EXEFS", "FEEDBACK", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES", "FULLSCREEN", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", @@ -59,7 +59,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, + {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"CONTACT_SHADOWS", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -94,7 +94,7 @@ static const CfgMeta metas[] = { {"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}, {"ANISO", "16", "game|2|4|8|16", RESTART}, {"SHADOW_SCALE", "1", "1..4", RESTART}, - {"SHADOW_RANGE", "100", "50..400", RESTART}, + {"SHADOW_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART}, // Game {"FPS_LIMIT", "60", "30|60|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, diff --git a/runtime/contact_shadow_spv.h b/runtime/contact_shadow_spv.h new file mode 100644 index 00000000..7d506c8f --- /dev/null +++ b/runtime/contact_shadow_spv.h @@ -0,0 +1,156 @@ +// Generated by tools/build_shaders.py from runtime/shaders/contact_shadow.comp; do not edit. +// source sha256 b452a1920e59c4d83b2c994b0c6573cc1e479f7032a1310a7432d11c5c2e9908 +#pragma once +#include +static const uint32_t contact_shadow_spv[] = { + 0x07230203, 0x00010300, 0x000d000b, 0x000001b1, 0x00000000, 0x00020011, 0x00000001, 0x00020011, + 0x00000031, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, + 0x00000000, 0x00000001, 0x0006000f, 0x00000005, 0x00000004, 0x6e69616d, 0x00000000, 0x00000069, + 0x00060010, 0x00000004, 0x00000011, 0x00000008, 0x00000008, 0x00000001, 0x00030047, 0x00000027, + 0x00000002, 0x00050048, 0x00000027, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000027, + 0x00000001, 0x00000023, 0x00000010, 0x00050048, 0x00000027, 0x00000002, 0x00000023, 0x00000020, + 0x00050048, 0x00000027, 0x00000003, 0x00000023, 0x00000030, 0x00040047, 0x00000069, 0x0000000b, + 0x0000001c, 0x00040047, 0x00000088, 0x00000021, 0x00000000, 0x00040047, 0x00000088, 0x00000022, + 0x00000000, 0x00040047, 0x0000013f, 0x00000021, 0x00000001, 0x00040047, 0x0000013f, 0x00000022, + 0x00000000, 0x00040047, 0x0000015c, 0x0000000b, 0x00000019, 0x00020013, 0x00000002, 0x00030021, + 0x00000003, 0x00000002, 0x00030016, 0x00000006, 0x00000020, 0x00040017, 0x00000007, 0x00000006, + 0x00000002, 0x00040017, 0x0000000a, 0x00000006, 0x00000003, 0x0004002b, 0x00000006, 0x0000001b, + 0x40000000, 0x0004002b, 0x00000006, 0x0000001d, 0x3f800000, 0x00040015, 0x00000020, 0x00000020, + 0x00000000, 0x0004002b, 0x00000020, 0x00000021, 0x00000000, 0x00040017, 0x00000026, 0x00000006, + 0x00000004, 0x0006001e, 0x00000027, 0x00000026, 0x00000026, 0x00000026, 0x00000026, 0x00040020, + 0x00000028, 0x00000009, 0x00000027, 0x0004003b, 0x00000028, 0x00000029, 0x00000009, 0x00040015, + 0x0000002a, 0x00000020, 0x00000001, 0x0004002b, 0x0000002a, 0x0000002b, 0x00000000, 0x00040020, + 0x0000002c, 0x00000009, 0x00000006, 0x0004002b, 0x00000020, 0x00000030, 0x00000001, 0x0004002b, + 0x00000020, 0x0000003f, 0x00000002, 0x0004002b, 0x00000006, 0x00000043, 0x3f000000, 0x0004002b, + 0x00000006, 0x00000059, 0x4253ee82, 0x0004002b, 0x00000006, 0x0000005b, 0x3d897143, 0x0004002b, + 0x00000006, 0x0000005c, 0x3bbf4590, 0x0005002c, 0x00000007, 0x0000005d, 0x0000005b, 0x0000005c, + 0x00040017, 0x00000064, 0x0000002a, 0x00000002, 0x00040017, 0x00000067, 0x00000020, 0x00000003, + 0x00040020, 0x00000068, 0x00000001, 0x00000067, 0x0004003b, 0x00000068, 0x00000069, 0x00000001, + 0x00040017, 0x0000006a, 0x00000020, 0x00000002, 0x00020014, 0x0000006e, 0x0004002b, 0x0000002a, + 0x00000072, 0x00000002, 0x00090019, 0x00000085, 0x00000006, 0x00000001, 0x00000000, 0x00000000, + 0x00000000, 0x00000001, 0x00000000, 0x0003001b, 0x00000086, 0x00000085, 0x00040020, 0x00000087, + 0x00000000, 0x00000086, 0x0004003b, 0x00000087, 0x00000088, 0x00000000, 0x0004002b, 0x00000006, + 0x0000008f, 0x00000000, 0x0004002b, 0x00000006, 0x00000092, 0x3f7fbe77, 0x0004002b, 0x00000006, + 0x0000009e, 0x42a00000, 0x00040020, 0x000000a8, 0x00000009, 0x00000026, 0x0004002b, 0x0000002a, + 0x000000b4, 0x00000001, 0x0004002b, 0x00000020, 0x000000b5, 0x00000003, 0x0004002b, 0x00000006, + 0x000000bb, 0x3ecccccd, 0x0004002b, 0x00000006, 0x000000bc, 0x40400000, 0x0004002b, 0x00000006, + 0x000000c0, 0x3e19999a, 0x0004002b, 0x00000006, 0x000000c2, 0x3c23d70a, 0x0004002b, 0x00000006, + 0x000000cb, 0x3e800000, 0x0004002b, 0x0000002a, 0x000000da, 0x00000010, 0x0004002b, 0x00000006, + 0x000000e6, 0xbd4ccccd, 0x0005002c, 0x00000007, 0x000000f0, 0x0000008f, 0x0000008f, 0x00040017, + 0x000000f1, 0x0000006e, 0x00000002, 0x0005002c, 0x00000007, 0x000000f8, 0x0000001d, 0x0000001d, + 0x0004002b, 0x00000006, 0x00000114, 0x3ca3d70a, 0x0004002b, 0x00000006, 0x00000116, 0x3b03126f, + 0x0004002b, 0x00000006, 0x0000012b, 0x42200000, 0x0004002b, 0x0000002a, 0x00000137, 0x00000003, + 0x00090019, 0x0000013d, 0x00000006, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000002, + 0x00000008, 0x00040020, 0x0000013e, 0x00000000, 0x0000013d, 0x0004003b, 0x0000013e, 0x0000013f, + 0x00000000, 0x0004002b, 0x00000020, 0x0000015b, 0x00000008, 0x0006002c, 0x00000067, 0x0000015c, + 0x0000015b, 0x0000015b, 0x00000030, 0x0005002c, 0x00000007, 0x000001ad, 0x00000043, 0x00000043, + 0x0004002b, 0x00000006, 0x000001af, 0x3dcccccd, 0x0004002b, 0x00000006, 0x000001b0, 0x3d800000, + 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x000300f7, + 0x0000015d, 0x00000000, 0x000300fb, 0x00000021, 0x0000015e, 0x000200f8, 0x0000015e, 0x0004003d, + 0x00000067, 0x0000006b, 0x00000069, 0x0007004f, 0x0000006a, 0x0000006c, 0x0000006b, 0x0000006b, + 0x00000000, 0x00000001, 0x0004007c, 0x00000064, 0x0000006d, 0x0000006c, 0x00050051, 0x0000002a, + 0x00000071, 0x0000006d, 0x00000000, 0x00060041, 0x0000002c, 0x00000073, 0x00000029, 0x00000072, + 0x00000021, 0x0004003d, 0x00000006, 0x00000074, 0x00000073, 0x0004006e, 0x0000002a, 0x00000075, + 0x00000074, 0x000500af, 0x0000006e, 0x00000076, 0x00000071, 0x00000075, 0x000400a8, 0x0000006e, + 0x00000077, 0x00000076, 0x000300f7, 0x00000079, 0x00000000, 0x000400fa, 0x00000077, 0x00000078, + 0x00000079, 0x000200f8, 0x00000078, 0x00050051, 0x0000002a, 0x0000007b, 0x0000006d, 0x00000001, + 0x00060041, 0x0000002c, 0x0000007c, 0x00000029, 0x00000072, 0x00000030, 0x0004003d, 0x00000006, + 0x0000007d, 0x0000007c, 0x0004006e, 0x0000002a, 0x0000007e, 0x0000007d, 0x000500af, 0x0000006e, + 0x0000007f, 0x0000007b, 0x0000007e, 0x000200f9, 0x00000079, 0x000200f8, 0x00000079, 0x000700f5, + 0x0000006e, 0x00000080, 0x00000076, 0x0000015e, 0x0000007f, 0x00000078, 0x000300f7, 0x00000082, + 0x00000000, 0x000400fa, 0x00000080, 0x00000081, 0x00000082, 0x000200f8, 0x00000081, 0x000200f9, + 0x0000015d, 0x000200f8, 0x00000082, 0x0004003d, 0x00000086, 0x00000089, 0x00000088, 0x00040064, + 0x00000085, 0x0000008b, 0x00000089, 0x0007005f, 0x00000026, 0x0000008c, 0x0000008b, 0x0000006d, + 0x00000002, 0x0000002b, 0x00050051, 0x00000006, 0x0000008d, 0x0000008c, 0x00000000, 0x000500bc, + 0x0000006e, 0x00000090, 0x0000008d, 0x0000008f, 0x000500be, 0x0000006e, 0x00000093, 0x0000008d, + 0x00000092, 0x000500a6, 0x0000006e, 0x00000094, 0x00000090, 0x00000093, 0x000300f7, 0x00000096, + 0x00000000, 0x000400fa, 0x00000094, 0x00000095, 0x00000096, 0x000200f8, 0x00000095, 0x000200f9, + 0x0000015d, 0x000200f8, 0x00000096, 0x00060041, 0x0000002c, 0x0000009a, 0x00000029, 0x0000002b, + 0x0000003f, 0x0004003d, 0x00000006, 0x0000009b, 0x0000009a, 0x00050085, 0x00000006, 0x0000009c, + 0x0000008d, 0x0000009b, 0x000500ba, 0x0000006e, 0x0000009f, 0x0000009c, 0x0000009e, 0x000300f7, + 0x000000a1, 0x00000000, 0x000400fa, 0x0000009f, 0x000000a0, 0x000000a1, 0x000200f8, 0x000000a0, + 0x000200f9, 0x0000015d, 0x000200f8, 0x000000a1, 0x0004006f, 0x00000007, 0x000000a5, 0x0000006d, + 0x00050081, 0x00000007, 0x000000a7, 0x000000a5, 0x000001ad, 0x00050041, 0x000000a8, 0x000000a9, + 0x00000029, 0x00000072, 0x0004003d, 0x00000026, 0x000000aa, 0x000000a9, 0x0007004f, 0x00000007, + 0x000000ab, 0x000000aa, 0x000000aa, 0x00000002, 0x00000003, 0x00050085, 0x00000007, 0x000000ac, + 0x000000a7, 0x000000ab, 0x0005008e, 0x00000007, 0x00000167, 0x000000ac, 0x0000001b, 0x00050083, + 0x00000007, 0x00000169, 0x00000167, 0x000000f8, 0x00050051, 0x00000006, 0x0000016b, 0x00000169, + 0x00000000, 0x00050085, 0x00000006, 0x0000016d, 0x0000016b, 0x0000009c, 0x00060041, 0x0000002c, + 0x0000016e, 0x00000029, 0x0000002b, 0x00000021, 0x0004003d, 0x00000006, 0x0000016f, 0x0000016e, + 0x00050088, 0x00000006, 0x00000170, 0x0000016d, 0x0000016f, 0x00050051, 0x00000006, 0x00000172, + 0x00000169, 0x00000001, 0x0004007f, 0x00000006, 0x00000173, 0x00000172, 0x00050085, 0x00000006, + 0x00000175, 0x00000173, 0x0000009c, 0x00060041, 0x0000002c, 0x00000176, 0x00000029, 0x0000002b, + 0x00000030, 0x0004003d, 0x00000006, 0x00000177, 0x00000176, 0x00050088, 0x00000006, 0x00000178, + 0x00000175, 0x00000177, 0x0004007f, 0x00000006, 0x0000017a, 0x0000009c, 0x00060050, 0x0000000a, + 0x0000017b, 0x00000170, 0x00000178, 0x0000017a, 0x00060041, 0x0000002c, 0x000000b6, 0x00000029, + 0x000000b4, 0x000000b5, 0x0004003d, 0x00000006, 0x000000b7, 0x000000b6, 0x00050085, 0x00000006, + 0x000000ba, 0x0000009c, 0x000001af, 0x0008000c, 0x00000006, 0x000000bd, 0x00000001, 0x0000002b, + 0x000000ba, 0x000000bb, 0x000000bc, 0x00050085, 0x00000006, 0x000000be, 0x000000b7, 0x000000bd, + 0x00050085, 0x00000006, 0x000000c3, 0x0000009c, 0x000000c2, 0x00050081, 0x00000006, 0x000000c4, + 0x000000c0, 0x000000c3, 0x00050085, 0x00000006, 0x000000c8, 0x000000be, 0x000001b0, 0x00050094, + 0x00000006, 0x0000017f, 0x000000a5, 0x0000005d, 0x0006000c, 0x00000006, 0x00000180, 0x00000001, + 0x0000000a, 0x0000017f, 0x00050085, 0x00000006, 0x00000181, 0x00000059, 0x00000180, 0x0006000c, + 0x00000006, 0x00000182, 0x00000001, 0x0000000a, 0x00000181, 0x00050081, 0x00000006, 0x000000d0, + 0x000000cb, 0x00000182, 0x00050085, 0x00000006, 0x000000d1, 0x000000c8, 0x000000d0, 0x000200f9, + 0x000000d4, 0x000200f8, 0x000000d4, 0x000700f5, 0x00000006, 0x000001a7, 0x000000d1, 0x000000a1, + 0x00000129, 0x000000d7, 0x000700f5, 0x0000002a, 0x000001a6, 0x0000002b, 0x000000a1, 0x00000126, + 0x000000d7, 0x000500b1, 0x0000006e, 0x000000db, 0x000001a6, 0x000000da, 0x000400f6, 0x000000d6, + 0x000000d7, 0x00000000, 0x000400fa, 0x000000db, 0x000000d5, 0x000000d6, 0x000200f8, 0x000000d5, + 0x00050041, 0x000000a8, 0x000000de, 0x00000029, 0x000000b4, 0x0004003d, 0x00000026, 0x000000df, + 0x000000de, 0x0008004f, 0x0000000a, 0x000000e0, 0x000000df, 0x000000df, 0x00000000, 0x00000001, + 0x00000002, 0x0005008e, 0x0000000a, 0x000000e2, 0x000000e0, 0x000001a7, 0x00050081, 0x0000000a, + 0x000000e3, 0x0000017b, 0x000000e2, 0x00050051, 0x00000006, 0x000000e5, 0x000000e3, 0x00000002, + 0x000500be, 0x0000006e, 0x000000e7, 0x000000e5, 0x000000e6, 0x000300f7, 0x000000e9, 0x00000000, + 0x000400fa, 0x000000e7, 0x000000e8, 0x000000e9, 0x000200f8, 0x000000e8, 0x000200f9, 0x000000d6, + 0x000200f8, 0x000000e9, 0x0004007f, 0x00000006, 0x00000188, 0x000000e5, 0x00050051, 0x00000006, + 0x0000018a, 0x000000e3, 0x00000000, 0x00050085, 0x00000006, 0x0000018b, 0x00000043, 0x0000018a, + 0x00050085, 0x00000006, 0x0000018e, 0x0000018b, 0x0000016f, 0x00050088, 0x00000006, 0x00000190, + 0x0000018e, 0x00000188, 0x00050081, 0x00000006, 0x00000191, 0x00000043, 0x00000190, 0x00050051, + 0x00000006, 0x00000193, 0x000000e3, 0x00000001, 0x00050085, 0x00000006, 0x00000194, 0x00000043, + 0x00000193, 0x00050085, 0x00000006, 0x00000197, 0x00000194, 0x00000177, 0x00050088, 0x00000006, + 0x00000199, 0x00000197, 0x00000188, 0x00050083, 0x00000006, 0x0000019a, 0x00000043, 0x00000199, + 0x00050050, 0x00000007, 0x0000019b, 0x00000191, 0x0000019a, 0x000500b8, 0x000000f1, 0x000000f2, + 0x0000019b, 0x000000f0, 0x0004009a, 0x0000006e, 0x000000f3, 0x000000f2, 0x000400a8, 0x0000006e, + 0x000000f4, 0x000000f3, 0x000300f7, 0x000000f6, 0x00000000, 0x000400fa, 0x000000f4, 0x000000f5, + 0x000000f6, 0x000200f8, 0x000000f5, 0x000500ba, 0x000000f1, 0x000000f9, 0x0000019b, 0x000000f8, + 0x0004009a, 0x0000006e, 0x000000fa, 0x000000f9, 0x000200f9, 0x000000f6, 0x000200f8, 0x000000f6, + 0x000700f5, 0x0000006e, 0x000000fb, 0x000000f3, 0x000000e9, 0x000000fa, 0x000000f5, 0x000300f7, + 0x000000fd, 0x00000000, 0x000400fa, 0x000000fb, 0x000000fc, 0x000000fd, 0x000200f8, 0x000000fc, + 0x000200f9, 0x000000d6, 0x000200f8, 0x000000fd, 0x0004003d, 0x00000086, 0x00000100, 0x00000088, + 0x0007004f, 0x00000007, 0x00000104, 0x000000aa, 0x000000aa, 0x00000000, 0x00000001, 0x00050085, + 0x00000007, 0x00000105, 0x0000019b, 0x00000104, 0x0004006e, 0x00000064, 0x00000106, 0x00000105, + 0x00040064, 0x00000085, 0x00000107, 0x00000100, 0x0007005f, 0x00000026, 0x00000108, 0x00000107, + 0x00000106, 0x00000002, 0x0000002b, 0x00050051, 0x00000006, 0x00000109, 0x00000108, 0x00000000, + 0x00050085, 0x00000006, 0x0000010c, 0x00000109, 0x0000009b, 0x00050083, 0x00000006, 0x00000112, + 0x00000188, 0x0000010c, 0x00050085, 0x00000006, 0x00000117, 0x0000009c, 0x00000116, 0x00050081, + 0x00000006, 0x00000118, 0x00000114, 0x00000117, 0x000500ba, 0x0000006e, 0x00000119, 0x00000112, + 0x00000118, 0x000500b8, 0x0000006e, 0x0000011c, 0x00000112, 0x000000c4, 0x000500a7, 0x0000006e, + 0x0000011d, 0x00000119, 0x0000011c, 0x000300f7, 0x0000011f, 0x00000000, 0x000400fa, 0x0000011d, + 0x0000011e, 0x0000011f, 0x000200f8, 0x0000011e, 0x0004006f, 0x00000006, 0x00000121, 0x000001a6, + 0x00050085, 0x00000006, 0x00000122, 0x00000121, 0x000001b0, 0x00050083, 0x00000006, 0x00000123, + 0x0000001d, 0x00000122, 0x000200f9, 0x000000d6, 0x000200f8, 0x0000011f, 0x000200f9, 0x000000d7, + 0x000200f8, 0x000000d7, 0x00050080, 0x0000002a, 0x00000126, 0x000001a6, 0x000000b4, 0x00050081, + 0x00000006, 0x00000129, 0x000001a7, 0x000000c8, 0x000200f9, 0x000000d4, 0x000200f8, 0x000000d6, + 0x000b00f5, 0x00000006, 0x000001aa, 0x0000008f, 0x000000d4, 0x0000008f, 0x000000e8, 0x0000008f, + 0x000000fc, 0x00000123, 0x0000011e, 0x0008000c, 0x00000006, 0x0000012d, 0x00000001, 0x00000031, + 0x0000012b, 0x0000009e, 0x0000009c, 0x00050083, 0x00000006, 0x0000012e, 0x0000001d, 0x0000012d, + 0x00060041, 0x0000002c, 0x00000130, 0x00000029, 0x0000002b, 0x000000b5, 0x0004003d, 0x00000006, + 0x00000131, 0x00000130, 0x00050085, 0x00000006, 0x00000133, 0x00000131, 0x000001aa, 0x00050085, + 0x00000006, 0x00000135, 0x00000133, 0x0000012e, 0x00050083, 0x00000006, 0x00000136, 0x0000001d, + 0x00000135, 0x00060041, 0x0000002c, 0x00000138, 0x00000029, 0x00000137, 0x00000021, 0x0004003d, + 0x00000006, 0x00000139, 0x00000138, 0x000500ba, 0x0000006e, 0x0000013a, 0x00000139, 0x00000043, + 0x000300f7, 0x0000013c, 0x00000000, 0x000400fa, 0x0000013a, 0x0000013b, 0x0000013c, 0x000200f8, + 0x0000013b, 0x0004003d, 0x0000013d, 0x00000140, 0x0000013f, 0x00070050, 0x00000026, 0x00000143, + 0x00000136, 0x00000136, 0x00000136, 0x0000001d, 0x00040063, 0x00000140, 0x0000006d, 0x00000143, + 0x000200f9, 0x0000015d, 0x000200f8, 0x0000013c, 0x000500be, 0x0000006e, 0x00000146, 0x00000136, + 0x00000092, 0x000300f7, 0x00000148, 0x00000000, 0x000400fa, 0x00000146, 0x00000147, 0x00000148, + 0x000200f8, 0x00000147, 0x000200f9, 0x0000015d, 0x000200f8, 0x00000148, 0x0004003d, 0x0000013d, + 0x0000014c, 0x0000013f, 0x00050062, 0x00000026, 0x0000014e, 0x0000014c, 0x0000006d, 0x0004003d, + 0x0000013d, 0x0000014f, 0x0000013f, 0x0008004f, 0x0000000a, 0x00000152, 0x0000014e, 0x0000014e, + 0x00000000, 0x00000001, 0x00000002, 0x0005008e, 0x0000000a, 0x00000154, 0x00000152, 0x00000136, + 0x00050051, 0x00000006, 0x00000156, 0x0000014e, 0x00000003, 0x00050051, 0x00000006, 0x00000157, + 0x00000154, 0x00000000, 0x00050051, 0x00000006, 0x00000158, 0x00000154, 0x00000001, 0x00050051, + 0x00000006, 0x00000159, 0x00000154, 0x00000002, 0x00070050, 0x00000026, 0x0000015a, 0x00000157, + 0x00000158, 0x00000159, 0x00000156, 0x00040063, 0x0000014f, 0x0000006d, 0x0000015a, 0x000200f9, + 0x0000015d, 0x000200f8, 0x0000015d, 0x000100fd, 0x00010038, +}; diff --git a/runtime/gfx_window.c b/runtime/gfx_window.c index f62de225..38f6476f 100644 --- a/runtime/gfx_window.c +++ b/runtime/gfx_window.c @@ -920,6 +920,7 @@ void gfx_window_release_vk(void) { g_flip_on = 0; // its blit is done (device idle); the swapchain goes away unpresented menu_vk_release(); vk_fsr_release(); + vk_contact_release(); free_capture(); free_thumbs(); for (int i = 0; i < FRAMES; i++) { diff --git a/runtime/shaders/contact_shadow.comp b/runtime/shaders/contact_shadow.comp new file mode 100644 index 00000000..78828bb4 --- /dev/null +++ b/runtime/shaders/contact_shadow.comp @@ -0,0 +1,67 @@ +#version 450 +// Screen-space contact shadows (runtime/vk_contact.c). Each pixel of the game's lit scene colour marches a short way +// toward the sun through the linear depth target; when the ray passes behind something close in front of it, the pixel +// is in a contact shadow the shadow maps are too coarse to show, and its colour is darkened. +layout(local_size_x = 8, local_size_y = 8) in; + +layout(binding = 0) uniform sampler2D lin_depth; // the game's linear depth: view distance / far +layout(binding = 1, r11f_g11f_b10f) uniform image2D scene; // the lit scene colour, darkened in place + +layout(push_constant) uniform Params { + vec4 proj; // projection x scale, y scale, far plane, strength (0..1) + vec4 light; // view-space direction toward the sun (xyz), march length in metres at 10 m (w) + vec4 size; // width, height, 1/width, 1/height + vec4 opt; // x: debug (1: write the shadow factor as grey) +} pc; + +vec3 view_pos(vec2 uv, float z) { // z: distance in front of the camera + vec2 ndc = uv * 2.0 - 1.0; + return vec3(ndc.x * z / pc.proj.x, -ndc.y * z / pc.proj.y, -z); +} + +vec2 to_uv(vec3 p) { + float z = -p.z; + return vec2(0.5 + 0.5 * p.x * pc.proj.x / z, 0.5 - 0.5 * p.y * pc.proj.y / z); +} + +float ign(vec2 px) { // interleaved gradient noise: a per-pixel start offset that hides the step pattern + return fract(52.9829189 * fract(dot(px, vec2(0.06711056, 0.00583715)))); +} + +void main() { + ivec2 px = ivec2(gl_GlobalInvocationID.xy); + if (px.x >= int(pc.size.x) || px.y >= int(pc.size.y)) return; + float d = texelFetch(lin_depth, px, 0).x; + if (d <= 0.0 || d >= 0.999) return; // nothing drawn, or the sky + float z = d * pc.proj.z; + if (z > 80.0) return; + vec2 uv = (vec2(px) + 0.5) * pc.size.zw; + vec3 p = view_pos(uv, z); + // the march grows with distance, as one pixel covers more ground; thickness keeps thin blades from hiding the sky + float len = pc.light.w * clamp(z / 10.0, 0.4, 3.0); + float thick = 0.15 + z * 0.01; + const int STEPS = 16; + float step_len = len / float(STEPS), t = step_len * (0.25 + ign(vec2(px))); + float occ = 0.0; + for (int i = 0; i < STEPS; i++, t += step_len) { + vec3 q = p + pc.light.xyz * t; + if (q.z >= -0.05) break; + vec2 quv = to_uv(q); + if (any(lessThan(quv, vec2(0.0))) || any(greaterThan(quv, vec2(1.0)))) break; + float sz = texelFetch(lin_depth, ivec2(quv * pc.size.xy), 0).x * pc.proj.z; + float delta = -q.z - sz; // how far the scene at that pixel is in front of the ray point + if (delta > 0.02 + z * 0.002 && delta < thick) { + occ = 1.0 - float(i) / float(STEPS); // a hit close to the pixel shadows more than one at the end + break; + } + } + float fade = 1.0 - smoothstep(40.0, 80.0, z); + float k = 1.0 - pc.proj.w * occ * fade; + if (pc.opt.x > 0.5) { + imageStore(scene, px, vec4(k, k, k, 1.0)); + return; + } + if (k >= 0.999) return; + vec4 c = imageLoad(scene, px); + imageStore(scene, px, vec4(c.rgb * k, c.a)); +} diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index d3eb04f9..b82f9f2a 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -550,6 +550,7 @@ static void tab_screen(float scale) { row_aniso(); row_shadow_scale(); row_shadow_range(); + opt_slider("TOTK_CONTACT_SHADOWS", UI_MENU_CONTACT_SHADOWS, 0, 100, UI_MENU_CONTACT_SHADOWS_DESC, 10, "%.0f %%"); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index d279674a..91228692 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -70,6 +70,9 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Shadow resolution", [UI_MENU_SHADOW_SCALE_DESC] = "Draws the sun's shadow maps this many times larger on each side than the game's 960x960: " "sharper shadow edges and leaf shadows. Takes effect at the next start.", + [UI_MENU_CONTACT_SHADOWS] = "Contact shadows", + [UI_MENU_CONTACT_SHADOWS_DESC] = "Small sun shadows the shadow maps miss: at feet, under stones, in grass and creases. " + "Traced on the screen after lighting. Takes effect at the next start.", [UI_MENU_SHADOW_RANGE] = "Shadow cascade range", [UI_MENU_SHADOW_RANGE_DESC] = "Moves the steps where shadows turn softer (the game's 20, 40, 80 and 160 m) further " "away. Spreads the shadow map over more ground: raise Shadow resolution with it. " @@ -299,6 +302,9 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Разрешение теней", [UI_MENU_SHADOW_SCALE_DESC] = "Карты теней от солнца рисуются во столько раз больше по каждой стороне, чем 960x960 " "самой игры: края теней и тени листвы чётче. Действует после перезапуска.", + [UI_MENU_CONTACT_SHADOWS] = "Контактные тени", + [UI_MENU_CONTACT_SHADOWS_DESC] = "Мелкие тени от солнца, которых нет на картах теней: у ног, под камнями, в траве и " + "складках. Считаются по экрану после освещения. Действует после перезапуска.", [UI_MENU_SHADOW_RANGE] = "Дальность каскадов теней", [UI_MENU_SHADOW_RANGE_DESC] = "Отодвигает границы, за которыми тени становятся мягче (в игре 20, 40, 80 и 160 м). " "Карта теней растягивается на большую площадь, поэтому вместе с этим поднимайте " diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 7462a703..eb0e09cf 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -39,6 +39,7 @@ typedef enum { UI_MENU_ANISO, UI_MENU_ANISO_DESC, UI_MENU_ANISO_GAME, UI_MENU_SHADOW_SCALE, UI_MENU_SHADOW_SCALE_DESC, UI_MENU_SHADOW_RANGE, UI_MENU_SHADOW_RANGE_DESC, + UI_MENU_CONTACT_SHADOWS, UI_MENU_CONTACT_SHADOWS_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, diff --git a/runtime/vk.h b/runtime/vk.h index fdfaf319..94c2b62c 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -87,6 +87,9 @@ void vk_present_blit(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int int vk_fsr_record(VkCommandBuffer cb, unsigned slot, VkImage src, VkFormat fmt, int sw, int sh, const int crop[4], VkImage dst, uint32_t dw, uint32_t dh); void vk_fsr_release(void); // before the device goes away +// vk_contact.c: screen-space contact shadows on the game's composed scene colour (TOTK_CONTACT_SHADOWS) +int vk_contact_strength(void); // percent, 0 = off +void vk_contact_release(void); // before the device goes away void vk_present_flip(void); // Every submission to ctx->gfx_queue (and xfer_queue when shared) takes this lock; vk_present_image and the swapchain // rebuild do. Recursive. diff --git a/runtime/vk_contact.c b/runtime/vk_contact.c new file mode 100644 index 00000000..74eae718 --- /dev/null +++ b/runtime/vk_contact.c @@ -0,0 +1,188 @@ +// Screen-space contact shadows (TOTK_CONTACT_SHADOWS, percent strength, 0 = off). TotK fills a full-resolution +// G-buffer whose targets include a B10G11R11 scene colour, an R32F linear depth (view distance / far) and a D32F depth +// (is_gbuffer), lights it in half resolution, and then composites the lighting into that scene colour in one pass +// whose only target is the scene colour, with a D16 depth that sorts pixels into material classes (is_composite). +// When the pass after the composite begins, or a dispatch or copy comes first, runtime/shaders/contact_shadow.comp +// marches each pixel a short way toward the sun through the linear depth and darkens the scene colour where the ray +// passes behind nearby geometry: the small shadows at feet, under stones and in grass that the shadow maps are too +// coarse for. Transparent surfaces, the sky and post-processing come after, untouched. +// +// Inputs from the game, read from the fragment stage's uniform block c4 bound in the composite pass (guest memory, +// so it may be one frame newer than the replay): the projection scales c4[7].x and c4[8].y, the far plane c4[14].y, +// and the first sun cascade's depth row c4[44].xyz, whose negated direction points from a view-space position toward +// the sun (the G-buffer shaders compare dot(c4[44].xyz, pos) + c4[44].w with the cascade map). The scene colour images +// get STORAGE usage when the setting is on (vk_texture.c create_tex). +#include "vk.h" + +#include +#include + +#include "cfg.h" +#include "contact_shadow_spv.h" +#include "host.h" +#include "vk_exec.h" + +static struct { + int tried, ok, strength, debug, logged; + PFN_vkCmdPushDescriptorSetKHR push; + VkDescriptorSetLayout dsl; + VkPipelineLayout layout; + VkPipeline pipe; + VkSampler sampler; + const VkTexImage *scene, *depth; // the last G-buffer's scene colour and linear depth + uint32_t w, h; + int pending; // the composite into scene ran; the march waits for the next pass + uint64_t c4; +} C; + +int vk_contact_strength(void) { + if (!C.tried) { + int s = cfg_int("TOTK_CONTACT_SHADOWS"); + C.strength = s < 0 ? 0 : s > 100 ? 100 : s; + } + return C.strength; +} + +static int init(VkCtx *c) { + C.tried = 1; + vk_contact_strength(); + if (!C.strength) return 0; + const char *e = cfg_get("TOTK_CONTACT_DEBUG"); // 1: the frame shows the contact shadow factor in grey + C.debug = e && *e && strcmp(e, "0"); + C.push = (PFN_vkCmdPushDescriptorSetKHR)vkGetDeviceProcAddr(c->device, "vkCmdPushDescriptorSetKHR"); + VkDescriptorSetLayoutBinding b[2] = { + {.binding = 0, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorCount = 1, + .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT}, + {.binding = 1, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 1, + .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT}}; + VkDescriptorSetLayoutCreateInfo dci = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + .bindingCount = 2, .pBindings = b}; + VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 64}; + VkPipelineLayoutCreateInfo li = {.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .setLayoutCount = 1, + .pSetLayouts = &C.dsl, .pushConstantRangeCount = 1, .pPushConstantRanges = &pr}; + VkSamplerCreateInfo si = {.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, .magFilter = VK_FILTER_NEAREST, + .minFilter = VK_FILTER_NEAREST, .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, .maxLod = 0}; + VkShaderModuleCreateInfo mi = {.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + .codeSize = sizeof contact_shadow_spv, .pCode = contact_shadow_spv}; + VkShaderModule m = VK_NULL_HANDLE; + if (!C.push || vkCreateDescriptorSetLayout(c->device, &dci, NULL, &C.dsl) != VK_SUCCESS || + vkCreatePipelineLayout(c->device, &li, NULL, &C.layout) != VK_SUCCESS || + vkCreateSampler(c->device, &si, NULL, &C.sampler) != VK_SUCCESS || + vkCreateShaderModule(c->device, &mi, NULL, &m) != VK_SUCCESS) { + rt_log("vk: contact shadows off: their pipeline could not be created"); + return 0; + } + VkComputePipelineCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + .stage = {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_COMPUTE_BIT, .module = m, .pName = "main"}, + .layout = C.layout}; + VkResult r = vkCreateComputePipelines(c->device, VK_NULL_HANDLE, 1, &ci, NULL, &C.pipe); + vkDestroyShaderModule(c->device, m, NULL); + if (r != VK_SUCCESS) { + rt_log("vk: contact shadows off: their pipeline could not be created"); + return 0; + } + rt_log("vk: contact shadows on, strength %d%%%s", C.strength, C.debug ? " (debug view)" : ""); + return C.ok = 1; +} + +// A G-buffer pass: a B10G11R11 scene colour, an R32F linear depth and a D32F depth, all one size, at least 640 wide. +static int is_gbuffer(const VkExec *ex, const VkTexImage **scene, const VkTexImage **depth) { + *scene = *depth = NULL; + if (ex->pass_noatt || ex->pass_w < 640 || ex->depth.format != VK_FORMAT_D32_SFLOAT || ex->depth.level) return 0; + for (uint32_t i = 0; i < ex->pass_ncolor && i < 8; i++) { + const VkExecTarget *t = &ex->color[i]; + if (!t->image || t->level || t->width != ex->pass_w || t->height != ex->pass_h) continue; + if (t->format == VK_FORMAT_B10G11R11_UFLOAT_PACK32 && !*scene) *scene = t->img; + if (t->format == VK_FORMAT_R32_SFLOAT && !*depth) *depth = t->img; + } + return *scene && *depth && ((*scene)->usage & VK_IMAGE_USAGE_STORAGE_BIT); +} + +static void mem_barrier(VkCommandBuffer cb) { + VkMemoryBarrier2 mb = {.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + .srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT, + .dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .dstAccessMask = VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT}; + VkDependencyInfo d = {.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = 1, .pMemoryBarriers = &mb}; + vkCmdPipelineBarrier2(cb, &d); +} + +void vk_contact_flush(VkExec *ex) { + if (!C.pending) return; + C.pending = 0; + if (ex->in_pass) return; + const float *u = (const float *)(uintptr_t)C.c4; + float lx = -u[44 * 4 + 0], ly = -u[44 * 4 + 1], lz = -u[44 * 4 + 2], ll = sqrtf(lx * lx + ly * ly + lz * lz); + float px = u[7 * 4 + 0], py = u[8 * 4 + 1], zfar = u[14 * 4 + 1]; + if (!(ll > 1e-6f) || !(px > 0) || !(py > 0) || !(zfar > 1)) return; + VkImageView in = vk_exec_target_view(C.depth, VK_FORMAT_R32_SFLOAT, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, + 0, 0, 1, 0); + VkImageView out = vk_exec_target_view(C.scene, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_IMAGE_VIEW_TYPE_2D, + VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1, 0); + if (!in || !out) return; + VkCommandBuffer cb = ex->cb; + float pcv[16] = {px, py, zfar, (float)C.strength / 100.0f, + lx / ll, ly / ll, lz / ll, 0.6f, + (float)C.w, (float)C.h, 1.0f / (float)C.w, 1.0f / (float)C.h, + (float)C.debug, 0, 0, 0}; + if (!C.logged) { + C.logged = 1; + rt_log("vk: contact shadows on a %ux%u scene, sun toward %.3f %.3f %.3f (view space), far %g", C.w, C.h, + pcv[4], pcv[5], pcv[6], zfar); + } + mem_barrier(cb); // the compose passes' writes, before the march reads and writes them + VkDescriptorImageInfo ii = {C.sampler, in, VK_IMAGE_LAYOUT_GENERAL}, oi = {VK_NULL_HANDLE, out, VK_IMAGE_LAYOUT_GENERAL}; + VkWriteDescriptorSet w[2] = { + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 0, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &ii}, + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 1, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &oi}}; + vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, C.pipe); + rec_push(C.push, cb, VK_PIPELINE_BIND_POINT_COMPUTE, C.layout, 0, 2, w); + vkCmdPushConstants(cb, C.layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof pcv, pcv); + vkCmdDispatch(cb, (C.w + 7) / 8, (C.h + 7) / 8, 1); + mem_barrier(cb); // and what follows sees the darkened colour + ex->recorded += 6; + vk_exec_draw_new_cb(); // the game's bound compute pipeline and descriptors were replaced: bind them again +} + +// The lighting composite: the remembered scene colour as the only target, with a D16 depth of its size. +static int is_composite(const VkExec *ex) { + return C.scene && ex->pass_ncolor >= 1 && ex->color[0].img == C.scene && !ex->color[0].level && + ex->depth.format == VK_FORMAT_D16_UNORM && ex->pass_w == C.w && ex->pass_h == C.h; +} + +void vk_contact_pass_begin(VkExec *ex) { + if (!C.tried && !init(vk_ctx())) return; + if (!C.ok) return; + const VkTexImage *scene, *depth; + // The camera block: c4 of the fragment stage, 0x940 bytes. The composite binds it only after its pass begins, so + // the newest one seen at any pass start serves. + const p_bind_buf *b = &ex->ubo[1][1]; + if (b->addr && b->size == 0x940) C.c4 = b->addr; + if (is_gbuffer(ex, &scene, &depth)) { + C.pending = 0; + C.scene = scene, C.depth = depth, C.w = ex->pass_w, C.h = ex->pass_h; + return; + } + if (is_composite(ex)) { + C.pending = C.c4 != 0; + return; + } + vk_contact_flush(ex); +} + +void vk_contact_release(void) { + VkCtx *c = vk_ctx(); + if (!c || !C.tried) return; + if (C.pipe) vkDestroyPipeline(c->device, C.pipe, NULL); + if (C.sampler) vkDestroySampler(c->device, C.sampler, NULL); + if (C.layout) vkDestroyPipelineLayout(c->device, C.layout, NULL); + if (C.dsl) vkDestroyDescriptorSetLayout(c->device, C.dsl, NULL); + memset(&C, 0, sizeof C); +} diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index 0abd2b63..fb227f01 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -422,6 +422,7 @@ void vk_exec_barrier(VkExec *ex) { barrier_to(ex, NULL, NULL, 0); } void vk_exec_pass_begin(VkExec *ex) { if (ex->in_pass) return; resolve_rt(ex); + vk_contact_pass_begin(ex); // Learned targets (VkTexImage.fb_learned) are attached in the feedback layout VkImage want[9]; VkImageAspectFlags wasp[9]; diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index b0095f63..c4f9182e 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -176,6 +176,9 @@ VkImageView vk_exec_target_view(const VkTexImage *img, VkFormat format, VkImageV // vk_exec_xfer.c: OP_COPY_B2B, OP_COPY_B2T, OP_COPY_T2B, OP_COPY_T2T, OP_CLEAR_TEX, OP_SIGNAL_EVENT, OP_REPORT_COUNTER, // OP_RESET_COUNTER, OP_RENDER_ENABLE, OP_RENDER_COND, OP_CLEAR_BUF. void vk_exec_op_xfer(VkExec *ex, uint32_t op, const void *payload); +// vk_contact.c: a pass about to begin (its targets resolved, no pass open), and a dispatch or copy about to be recorded +void vk_contact_pass_begin(VkExec *ex); +void vk_contact_flush(VkExec *ex); // vk_exec_xfer.c, samples-passed counting: a draw about to be recorded in the open pass (begins an occlusion query // when counting and none is active), and the open pass about to end (ends the active query). void vk_exec_oq_draw(VkExec *ex); diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index e23741e9..124ebbc8 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -2069,6 +2069,7 @@ static void op_draw_idx_ind(VkExec *ex, const p_draw_idx_ind *d) { static void op_dispatch(VkExec *ex, const p_dispatch *d) { if (d->x <= 0 || d->y <= 0 || d->z <= 0) return; if (!ex->prog) return warn_once(W_PROGRAM, "a dispatch without a bound program is skipped"); + vk_contact_flush(ex); cb_res(ex); dummies_init(); int present; diff --git a/runtime/vk_exec_xfer.c b/runtime/vk_exec_xfer.c index ffb3b420..06602742 100644 --- a/runtime/vk_exec_xfer.c +++ b/runtime/vk_exec_xfer.c @@ -592,6 +592,7 @@ static void clear_tex(VkExec *ex, const p_clear_tex *p) { } void vk_exec_op_xfer(VkExec *ex, uint32_t op, const void *payload) { + if (op != OP_RENDER_ENABLE && op != OP_SIGNAL_EVENT) vk_contact_flush(ex); switch (op) { case OP_COPY_B2B: copy_b2b(ex, payload); break; case OP_COPY_B2T: copy_buffer_image(ex, payload, 1); break; diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index e2fda908..ce7619f7 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -341,6 +341,10 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { if (!ds && (ff & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; if ((d->flags & NVN_TEXTURE_FLAGS_IMAGE) && (ff & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && samples == 1) usage |= VK_IMAGE_USAGE_STORAGE_BIT; + // contact shadows (vk_contact.c) darken the game's B10G11R11 scene colour in place from a compute shader + if (f.vk == VK_FORMAT_B10G11R11_UFLOAT_PACK32 && (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && samples == 1 && + (ff & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && w >= 640 && vk_contact_strength()) + usage |= VK_IMAGE_USAGE_STORAGE_BIT; VkImageCreateFlags flags = ds ? 0 : VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; // format-reinterpreting views if (type == VK_IMAGE_TYPE_2D && layers >= 6 && w == h && samples == 1) flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; // NVN renders into a 3D texture slice by slice (a view's min layer is the depth plane, nvn_mtl.m), e.g. the diff --git a/totk.ini.example b/totk.ini.example index d8744e73..07042f86 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -125,6 +125,10 @@ # Sun shadow cascade range in percent of the game's (its cascades end at 20, 40, 80 and 160 m), 50 to 400: higher moves # the steps where shadows turn softer further away, and spreads the shadow map over more ground. Read at start. # shadow_range = 100 +# Screen-space contact shadows, strength in percent (0 = off): after the game lights its scene, each pixel traces a +# short way toward the sun through the depth buffer and darkens where something close blocks it, adding the small +# shadows at feet, under stones and in grass that the shadow maps miss. Read at start. +# contact_shadows = 0 [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale. From 24571ec0b0f7b09c9a31f9eaf45f74ce9710c77d Mon Sep 17 00:00:00 2001 From: itaskaev2 <165683571+itaskaev2@users.noreply.github.com> Date: Fri, 30 Oct 2026 16:00:23 +0100 Subject: [PATCH 04/12] Add soft sun shadows (PCSS) through a translator patch The deferred lighting shaders take the sun shadow as four explicit-LOD compares on the cascade array. Translator patch 0010 turns every explicit-LOD compare on a 2D array texture into a PCSS lookup when the support buffer's new pcss field has x above 0: eight raw depth fetches within pcss.w find the blockers, (receiver - blocker) * pcss.x gives the penumbra width clamped to pcss.y..pcss.z, and eight compares on a disc of that radius average to the result. With x at 0 the original single compare runs behind a branch. Radii are in UV, so they hold at any shadow_scale. The support buffer grows to 1424 bytes; support_fill writes the field from pcss (percent of the default width, 0 to 200, default 0; TOTK_PCSS_K overrides the factor at 100 percent, default 0.5). build_xlate.py expects ten patches. The setting is in totk.ini.example and on the Screen tab of the menu (English and Russian). Co-Authored-By: Claude Opus 5.5 --- runtime/cfg.c | 5 +- runtime/ui/menu.cpp | 1 + runtime/ui_text.c | 6 + runtime/ui_text.h | 1 + runtime/vk_exec_draw.c | 22 ++- tools/build_xlate.py | 6 +- .../0010-pcss-for-cascade-compares.patch | 135 ++++++++++++++++++ totk.ini.example | 4 + 8 files changed, 174 insertions(+), 6 deletions(-) create mode 100644 tools/xlate/patches/0010-pcss-for-cascade-compares.patch diff --git a/runtime/cfg.c b/runtime/cfg.c index 2372ad1b..bc7da7dd 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -41,7 +41,7 @@ static const char *const known[] = { "GPU_INDEX", "GPU_NAME", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", "LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "MEMORY", "MENU_LANG", "MENU_TEST", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MOTION", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE", - "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PATCH_OUTPUT", "PATCH_SCENE", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", + "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PATCH_OUTPUT", "PATCH_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES", "PROFILE_MAIN", "PROFILE_RENDER", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REEXEC", "RENDER_SCALE", "REPLAY_ASYNC", @@ -59,7 +59,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"CONTACT_SHADOWS", "display"}, + {"SHARPNESS", "display"}, {"ANISO", "display"}, {"SHADOW_SCALE", "display"}, {"SHADOW_RANGE", "display"}, {"CONTACT_SHADOWS", "display"}, {"PCSS", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -95,6 +95,7 @@ static const CfgMeta metas[] = { {"UPSCALER", "fsr", "fsr|bilinear", LIVE}, {"SHARPNESS", "80", "0..100", LIVE}, {"ANISO", "16", "game|2|4|8|16", RESTART}, {"SHADOW_SCALE", "1", "1..4", RESTART}, {"SHADOW_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART}, + {"PCSS", "0", "0..200", RESTART}, // Game {"FPS_LIMIT", "60", "30|60|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index b82f9f2a..3553f058 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -550,6 +550,7 @@ static void tab_screen(float scale) { row_aniso(); row_shadow_scale(); row_shadow_range(); + opt_slider("TOTK_PCSS", UI_MENU_PCSS, 0, 200, UI_MENU_PCSS_DESC, 10, "%.0f %%"); opt_slider("TOTK_CONTACT_SHADOWS", UI_MENU_CONTACT_SHADOWS, 0, 100, UI_MENU_CONTACT_SHADOWS_DESC, 10, "%.0f %%"); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index 91228692..056c0e4d 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -70,6 +70,9 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Shadow resolution", [UI_MENU_SHADOW_SCALE_DESC] = "Draws the sun's shadow maps this many times larger on each side than the game's 960x960: " "sharper shadow edges and leaf shadows. Takes effect at the next start.", + [UI_MENU_PCSS] = "Soft shadows", + [UI_MENU_PCSS_DESC] = "Sun shadows sharp where an object meets the ground and softer the further the shadow falls " + "(PCSS). 0 keeps the game's filter. Takes effect at the next start.", [UI_MENU_CONTACT_SHADOWS] = "Contact shadows", [UI_MENU_CONTACT_SHADOWS_DESC] = "Small sun shadows the shadow maps miss: at feet, under stones, in grass and creases. " "Traced on the screen after lighting. Takes effect at the next start.", @@ -302,6 +305,9 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_SHADOW_SCALE] = "Разрешение теней", [UI_MENU_SHADOW_SCALE_DESC] = "Карты теней от солнца рисуются во столько раз больше по каждой стороне, чем 960x960 " "самой игры: края теней и тени листвы чётче. Действует после перезапуска.", + [UI_MENU_PCSS] = "Мягкие тени", + [UI_MENU_PCSS_DESC] = "Тени от солнца резкие там, где предмет касается земли, и мягче, чем дальше падает тень " + "(PCSS). 0 оставляет фильтр игры. Действует после перезапуска.", [UI_MENU_CONTACT_SHADOWS] = "Контактные тени", [UI_MENU_CONTACT_SHADOWS_DESC] = "Мелкие тени от солнца, которых нет на картах теней: у ног, под камнями, в траве и " "складках. Считаются по экрану после освещения. Действует после перезапуска.", diff --git a/runtime/ui_text.h b/runtime/ui_text.h index eb0e09cf..599cd34a 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -40,6 +40,7 @@ typedef enum { UI_MENU_SHADOW_SCALE, UI_MENU_SHADOW_SCALE_DESC, UI_MENU_SHADOW_RANGE, UI_MENU_SHADOW_RANGE_DESC, UI_MENU_CONTACT_SHADOWS, UI_MENU_CONTACT_SHADOWS_DESC, + UI_MENU_PCSS, UI_MENU_PCSS_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_120, UI_MENU_FPS_144, diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 124ebbc8..4f7276d0 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -32,7 +32,7 @@ #define MAX_DESC 1024 #define CHUNK_BYTES (4u << 20) #define ZERO_BYTES 65536u -#define SUPPORT_BYTES 1408u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... +#define SUPPORT_BYTES 1424u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... #define NVN_STAGE_VS 0 #define NVN_STAGE_FS 1 #define NVN_STAGE_CS 5 @@ -1246,6 +1246,25 @@ static void support_in(const VkExec *ex, float in[3]) { // what support_fill r in[2] = ex->point_size > 0 ? ex->point_size : 1.0f; } +// TOTK_PCSS (percent, 0 = off): the pcss field of the support buffer, which translator patch 0010 reads in every +// explicit-LOD compare on a 2D array texture (the sun cascades). x: penumbra width in UV per unit of light-space depth +// between receiver and blocker (0 keeps the game's single compare), y and z: the narrowest and widest disc radius, +// w: the blocker search radius, all in UV of the cascade map. Radii are in UV, so they hold at any TOTK_SHADOW_SCALE. +// TOTK_PCSS_K overrides the depth-to-penumbra factor at 100 percent, for tuning. +static const float *pcss_params(void) { + static float p[4] = {-1, 0, 0, 0}; + if (p[0] < 0) { + int pct = cfg_int("TOTK_PCSS"); + pct = pct < 0 ? 0 : pct > 200 ? 200 : pct; + const char *k = cfg_get("TOTK_PCSS_K"); + float k100 = k && *k ? (float)atof(k) : 0.5f; + p[0] = k100 * (float)pct / 100.0f; + p[1] = 0.35f / 960.0f, p[2] = 5.0f / 960.0f, p[3] = 4.0f / 960.0f; + if (pct) rt_log("vk: soft shadows (PCSS) at %d%% (depth factor %g)", pct, p[0]); + } + return p; +} + static void support_fill(uint8_t *b, float w, float h, float point_size) { memset(b, 0, SUPPORT_BYTES); float inv[4] = {w > 0 ? 2.0f / w : 0, h > 0 ? 2.0f / h : 0, 0, 0}, size[4] = {w, h, 0, 0}; @@ -1253,6 +1272,7 @@ static void support_fill(uint8_t *b, float w, float h, float point_size) { memcpy(b + 160, size, 16); const float one = 1.0f; memcpy(b + 1392, &point_size, 4); // point_size (translator patch 0008): vertex shaders that write none output it + memcpy(b + 1408, pcss_params(), 16); // pcss (translator patch 0010): soft sun shadows in the cascade compares for (int i = 0; i < 73; i++) memcpy(b + 192 + 16 * i, &one, 4); // render scale 1: the host renders at guest size } diff --git a/tools/build_xlate.py b/tools/build_xlate.py index eb455ab4..ef0d08bc 100644 --- a/tools/build_xlate.py +++ b/tools/build_xlate.py @@ -1,7 +1,7 @@ """Build the shader translator: build/xlate/totk_xlate.exe (Ryujinx 1.3.2 + patches, NativeAOT, SPIR-V for Vulkan). Copies tools/vendor/ryujinx to build/xlate/ryujinx, applies tools/xlate/patches/*.patch there (tools/vendor stays -byte-identical; 0001-0004 are MNG's, 0005-0009 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build +byte-identical; 0001-0004 are MNG's, 0005-0010 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build tools and vswhere.exe (docs/building.md). Run with .venv. Next to the exe it writes totk_xlate.id: the translator identity, a sha256 over everything the build reads (this script, @@ -96,8 +96,8 @@ def prepare_sources() -> Path: for junk in list(src.glob("src/*/obj")) + list(src.glob("src/*/bin")): shutil.rmtree(junk) patches = sorted((XLATE / "patches").glob("*.patch")) - if len(patches) != 9: - sys.exit(f"expected 9 patches, found {len(patches)}") + if len(patches) != 10: + sys.exit(f"expected 10 patches, found {len(patches)}") for patch in patches: # git apply works outside a repository when given a directory; --check first so a failure names the patch. for extra in (["--check"], []): diff --git a/tools/xlate/patches/0010-pcss-for-cascade-compares.patch b/tools/xlate/patches/0010-pcss-for-cascade-compares.patch new file mode 100644 index 00000000..4f41aaae --- /dev/null +++ b/tools/xlate/patches/0010-pcss-for-cascade-compares.patch @@ -0,0 +1,135 @@ +--- a/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs ++++ b/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs +@@ -1456,7 +1456,11 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv + } + else if (isShadow) + { +- if (hasLodLevel) ++ if (hasLodLevel && isArray && coordsCount == 2 && operandsMask == ImageOperandsMask.Lod) ++ { ++ result = GeneratePcssSample(context, declaration, image, pCoords, dRef, lod); ++ } ++ else if (hasLodLevel) + { + result = context.ImageSampleDrefExplicitLod(resultType, image, pCoords, dRef, operandsMask, operands); + } +@@ -1486,6 +1490,92 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv + return new OperationResult(swizzledResultType, result); + } + ++ // TOTK: percentage-closer soft shadows for the sun. The deferred lighting shaders take the shadow as four ++ // explicit-LOD compares on a 2D array (the cascades) around the receiver; each of those becomes a PCSS lookup ++ // when the support buffer's pcss.x is above 0 (runtime/vk_exec_draw.c support_fill, TOTK_PCSS): a blocker ++ // search reads the raw depths at eight points within pcss.w (UV), the average depth of those nearer the light ++ // than the receiver gives the penumbra width (receiver - blocker) * pcss.x, clamped to pcss.y..pcss.z (UV), and ++ // eight compares on a disc of that radius average to the result. With pcss.x at 0 the original single compare ++ // runs. The cascades are orthographic, so the depth difference is a distance along the light. ++ private static readonly float[] PcssSearch = [-0.7f, -0.7f, 0.7f, -0.7f, -0.7f, 0.7f, 0.7f, 0.7f, 0f, -1f, 0f, 1f, -1f, 0f, 1f, 0f]; ++ private static readonly float[] PcssDisk = ++ [ ++ -0.9420f, -0.3991f, 0.9456f, -0.7689f, -0.0942f, -0.9294f, 0.3450f, 0.2939f, ++ -0.9159f, 0.4577f, -0.8154f, -0.8791f, -0.3828f, 0.2768f, 0.9748f, 0.7565f, ++ ]; ++ ++ private static SpvInstruction GeneratePcssSample(CodeGenContext context, SamplerDeclaration declaration, SpvInstruction image, ++ SpvInstruction pCoords, SpvInstruction dRef, SpvInstruction lod) ++ { ++ SpvInstruction f32 = context.TypeFP32(), s32 = context.TypeS32(), b = context.TypeBool(); ++ SpvInstruction v2 = context.TypeVector(f32, 2), v3 = context.TypeVector(f32, 3), v4 = context.TypeVector(f32, 4); ++ SpvInstruction iv2 = context.TypeVector(s32, 2), iv3 = context.TypeVector(s32, 3); ++ SpvInstruction zero = context.Constant(f32, 0f), one = context.Constant(f32, 1f); ++ ++ SpvInstruction prmPtr = context.AccessChain(context.TypePointer(StorageClass.Uniform, v4), context.ConstantBuffers[SupportBuffer.Binding], ++ context.Constant(s32, (int)SupportBufferField.Pcss)); ++ SpvInstruction prm = context.Load(v4, prmPtr); ++ SpvInstruction lightSize = context.CompositeExtract(f32, prm, 0); ++ SpvInstruction minR = context.CompositeExtract(f32, prm, 1); ++ SpvInstruction maxR = context.CompositeExtract(f32, prm, 2); ++ SpvInstruction searchR = context.CompositeExtract(f32, prm, 3); ++ ++ SpvInstruction pcssLabel = context.Label(), plainLabel = context.Label(), mergeLabel = context.Label(); ++ SpvInstruction enabled = context.FOrdGreaterThan(b, lightSize, zero); // before the merge: it must precede the branch ++ context.SelectionMerge(mergeLabel, SelectionControlMask.MaskNone); ++ context.BranchConditional(enabled, pcssLabel, plainLabel); ++ ++ context.AddLabel(plainLabel); ++ SpvInstruction plain = context.ImageSampleDrefExplicitLod(f32, image, pCoords, dRef, ImageOperandsMask.Lod, lod); ++ context.Branch(mergeLabel); ++ ++ context.AddLabel(pcssLabel); ++ SpvInstruction raw = context.Image(declaration.ImageType, image); ++ SpvInstruction size3 = context.ImageQuerySizeLod(iv3, raw, context.Constant(s32, 0)); ++ SpvInstruction sizeI = context.VectorShuffle(iv2, size3, size3, 0, 1); ++ SpvInstruction sizeF = context.ConvertSToF(v2, sizeI); ++ SpvInstruction maxI = context.ISub(iv2, sizeI, context.ConstantComposite(iv2, context.Constant(s32, 1), context.Constant(s32, 1))); ++ SpvInstruction zeroI = context.ConstantComposite(iv2, context.Constant(s32, 0), context.Constant(s32, 0)); ++ SpvInstruction uv = context.VectorShuffle(v2, pCoords, pCoords, 0, 1); ++ SpvInstruction layerF = context.CompositeExtract(f32, pCoords, 2); ++ SpvInstruction layerI = context.ConvertFToS(s32, layerF); ++ SpvInstruction searchV = context.CompositeConstruct(v2, searchR, searchR); ++ ++ SpvInstruction sum = zero, count = zero; ++ for (int i = 0; i < PcssSearch.Length; i += 2) ++ { ++ SpvInstruction off = context.ConstantComposite(v2, context.Constant(f32, PcssSearch[i]), context.Constant(f32, PcssSearch[i + 1])); ++ SpvInstruction p = context.FAdd(v2, uv, context.FMul(v2, off, searchV)); ++ SpvInstruction t = context.GlslSClamp(iv2, context.ConvertFToS(iv2, context.FMul(v2, p, sizeF)), zeroI, maxI); ++ SpvInstruction c = context.CompositeConstruct(iv3, context.CompositeExtract(s32, t, 0), context.CompositeExtract(s32, t, 1), layerI); ++ SpvInstruction d = context.CompositeExtract(f32, context.ImageFetch(v4, raw, c, ImageOperandsMask.Lod, context.Constant(s32, 0)), 0); ++ SpvInstruction blocker = context.FOrdLessThan(b, d, dRef); ++ sum = context.FAdd(f32, sum, context.Select(f32, blocker, d, zero)); ++ count = context.FAdd(f32, count, context.Select(f32, blocker, one, zero)); ++ } ++ ++ SpvInstruction avg = context.FDiv(f32, sum, context.GlslFMax(f32, count, one)); ++ SpvInstruction penumbra = context.Select(f32, context.FOrdGreaterThan(b, count, zero), ++ context.FMul(f32, context.FSub(f32, dRef, avg), lightSize), zero); ++ SpvInstruction radius = context.GlslFClamp(f32, penumbra, minR, maxR); ++ SpvInstruction radiusV = context.CompositeConstruct(v2, radius, radius); ++ ++ SpvInstruction acc = zero; ++ for (int i = 0; i < PcssDisk.Length; i += 2) ++ { ++ SpvInstruction off = context.ConstantComposite(v2, context.Constant(f32, PcssDisk[i]), context.Constant(f32, PcssDisk[i + 1])); ++ SpvInstruction p = context.FAdd(v2, uv, context.FMul(v2, off, radiusV)); ++ SpvInstruction c = context.CompositeConstruct(v3, context.CompositeExtract(f32, p, 0), context.CompositeExtract(f32, p, 1), layerF); ++ acc = context.FAdd(f32, acc, context.ImageSampleDrefExplicitLod(f32, image, c, dRef, ImageOperandsMask.Lod, lod)); ++ } ++ ++ SpvInstruction pcss = context.FMul(f32, acc, context.Constant(f32, 2f / PcssDisk.Length)); ++ context.Branch(mergeLabel); ++ ++ context.AddLabel(mergeLabel); ++ return context.Phi(f32, pcss, pcssLabel, plain, plainLabel); ++ } ++ + private static OperationResult GenerateTextureQuerySamples(CodeGenContext context, AstOperation operation) + { + AstTextureOperation texOp = (AstTextureOperation)operation; +--- a/src/Ryujinx.Graphics.Shader/SupportBuffer.cs ++++ b/src/Ryujinx.Graphics.Shader/SupportBuffer.cs +@@ -25,6 +25,7 @@ namespace Ryujinx.Graphics.Shader + TfeOffset, + TfeVertexCount, + PointSize, ++ Pcss, + } + + public struct SupportBuffer +@@ -82,7 +83,8 @@ namespace Ryujinx.Graphics.Shader + new StructureField(AggregateType.Array | AggregateType.FP32, "render_scale", RenderScaleMaxCount), + new StructureField(AggregateType.Vector4 | AggregateType.S32, "tfe_offset"), + new StructureField(AggregateType.S32, "tfe_vertex_count"), +- new StructureField(AggregateType.FP32, "point_size") ++ new StructureField(AggregateType.FP32, "point_size"), ++ new StructureField(AggregateType.Vector4 | AggregateType.FP32, "pcss") + ]); + } + +@@ -98,5 +100,6 @@ namespace Ryujinx.Graphics.Shader + public Vector4 TfeOffset; + public Vector4 TfeVertexCount; + public Vector4 PointSize; ++ public Vector4 Pcss; + } + } diff --git a/totk.ini.example b/totk.ini.example index 07042f86..352f19c3 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -129,6 +129,10 @@ # short way toward the sun through the depth buffer and darkens where something close blocks it, adding the small # shadows at feet, under stones and in grass that the shadow maps miss. Read at start. # contact_shadows = 0 +# Soft sun shadows (PCSS), percent of the default penumbra width (0 to 200; 0 = the game's own four-tap filter): sharp +# where an object meets the ground and softer the further its shadow falls. Done in the translated shaders (translator +# patch 0010), so the shader cache is rebuilt once after an update. Read at start. +# pcss = 0 [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale. From 1512d9ed65a9ab898ce816a6b6131b36333ce58d Mon Sep 17 00:00:00 2001 From: TotK local Date: Sat, 31 Oct 2026 03:34:55 +0800 Subject: [PATCH 05/12] Add NVIDIA DLAA and a switch for the game's FXAA DLAA runs DLSS at the scene's own size on the R11G11B10F light target, right before the bloom chain's first pass, so bloom, post and HUD read the anti-aliased picture. NGX is loaded from the driver's NGX core at run time; no NVIDIA SDK code is compiled in, and nvngx_dlss.dll goes next to totk.exe. The scene's draws get a Halton(2,3) viewport jitter that steps after each DLAA run; camera motion vectors come from the scene depth reprojected through this and last frame's view-projection of the scene camera block (c4), read from the uniform snapshot. One DLSS feature per scene size keeps dynamic resolution from stalling. dlaa and fxaa switch live from the settings menu; fxaa skips the draw of the game's FXAA pass. Co-Authored-By: Claude Opus 5.5 --- docs/architecture.md | 5 + runtime/cfg.c | 7 +- runtime/dlaa_mv_spv.h | 119 +++++++ runtime/shaders/dlaa_mv.comp | 40 +++ runtime/ui/menu.cpp | 2 + runtime/ui_text.c | 10 + runtime/ui_text.h | 1 + runtime/vk_backend.c | 2 + runtime/vk_device.c | 9 +- runtime/vk_dlaa.c | 624 +++++++++++++++++++++++++++++++++++ runtime/vk_dlaa.h | 22 ++ runtime/vk_exec.c | 2 + runtime/vk_exec_draw.c | 4 + totk.ini.example | 7 + 14 files changed, 848 insertions(+), 6 deletions(-) create mode 100644 runtime/dlaa_mv_spv.h create mode 100644 runtime/shaders/dlaa_mv.comp create mode 100644 runtime/vk_dlaa.c create mode 100644 runtime/vk_dlaa.h diff --git a/docs/architecture.md b/docs/architecture.md index af1c6605..50154d80 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -94,6 +94,11 @@ Every guest thread is a host thread. TotK assumes Horizon's scheduler: three app (MacNativeGames' sites); `resolution.c` sets them from `output_res` and `render_scale` and grows the texture heap and the application pool to match. When the window is larger than the output, `vk_fsr.c` runs AMD FSR 1 (EASU, RCAS) on the present. +- DLAA (`vk_dlaa.c`, `dlaa`, off by default). NVIDIA DLSS at the scene's own size, through the driver's NGX core loaded + at run time (no SDK code compiled in). It runs on the R11G11B10F light target right before the bloom chain's first + pass, so post effects and the HUD read the anti-aliased picture. The scene's draws get a sub-pixel Halton viewport + jitter; motion vectors are camera-only, reprojected from the scene depth through this and last frame's + view-projection of the scene camera block (constant bank c4). `fxaa` switches the game's own FXAA pass. - Occlusion queries never block the CPU; a result that is not ready counts as visible. - ASTC textures are uploaded as they are where the device reports `textureCompressionASTC_LDR`, and decoded by a compute shader everywhere else (`vk_astc.c`, `TOTK_ASTC`). The CPU decoder (`tex_astc*.c`) is the fallback and the test oracle. - Draw state. A draw whose program, bound state and textures repeat reuses the previous draw's shaders and skips rebuilding its descriptor sets; descriptor sets are written through update templates (`vk_exec_draw.c`, `vk_pipeline.c`). diff --git a/runtime/cfg.c b/runtime/cfg.c index 31eb9213..4fed7c46 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -35,9 +35,9 @@ static const char *const known[] = { "BIND_LSTICK_RIGHT", "BIND_LSTICK_UP", "BIND_MINUS", "BIND_PLUS", "BIND_R", "BIND_RCLICK", "BIND_RIGHT", "BIND_RSTICK_DOWN", "BIND_RSTICK_LEFT", "BIND_RSTICK_RIGHT", "BIND_RSTICK_UP", "BIND_SKIP", "BIND_STATS", "BIND_UP", "BIND_X", "BIND_Y", - "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", + "BIND_ZL", "BIND_ZR", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DLAA", "DLAA_JITTER", "DLAA_MV", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "EXEFS", "FEEDBACK", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", - "FLIGHT_THUMBS", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES", "FULLSCREEN", "GPL", "GPL_DRAW_BUILD", "GPU", + "FLIGHT_THUMBS", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES", "FULLSCREEN", "FXAA", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", "LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "MEMORY", "MENU_LANG", "MENU_TEST", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MOTION", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE", @@ -59,7 +59,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, + {"SHARPNESS", "display"}, {"DLAA", "display"}, {"FXAA", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -94,6 +94,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", LIVE}, {"FXAA", "1", "0|1", LIVE}, // Game {"FPS_LIMIT", "60", "30|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, {"REALTIME", "1", "0|1", RESTART}, {"CLOTH_REALTIME", "1", "0|1", RESTART}, diff --git a/runtime/dlaa_mv_spv.h b/runtime/dlaa_mv_spv.h new file mode 100644 index 00000000..e1b31e6c --- /dev/null +++ b/runtime/dlaa_mv_spv.h @@ -0,0 +1,119 @@ +// Generated by tools/build_shaders.py from runtime/shaders/dlaa_mv.comp; do not edit. +// source sha256 bfa9b6d9e0f9d5cfd4382fa5080fa46f007a1a4e2b886b8fecd9adba11767686 +#pragma once +#include +static const uint32_t dlaa_mv_spv[] = { + 0x07230203, 0x00010600, 0x0008000b, 0x00000131, 0x00000000, 0x00020011, 0x00000001, 0x00020011, + 0x00000031, 0x0006000b, 0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, + 0x00000000, 0x00000001, 0x000b000f, 0x00000005, 0x00000004, 0x6e69616d, 0x00000000, 0x00000036, + 0x00000043, 0x0000005d, 0x00000089, 0x000000a0, 0x000000e7, 0x00060010, 0x00000004, 0x00000011, + 0x00000008, 0x00000008, 0x00000001, 0x00030003, 0x00000002, 0x000001c2, 0x00040005, 0x00000004, + 0x6e69616d, 0x00000000, 0x00080005, 0x00000036, 0x475f6c67, 0x61626f6c, 0x766e496c, 0x7461636f, + 0x496e6f69, 0x00000044, 0x00030005, 0x00000041, 0x00000050, 0x00050006, 0x00000041, 0x00000000, + 0x657a6973, 0x00000000, 0x00050006, 0x00000041, 0x00000001, 0x7474696a, 0x00007265, 0x00030005, + 0x00000043, 0x00006370, 0x00050005, 0x0000005d, 0x74706564, 0x65745f68, 0x00000078, 0x00030005, + 0x00000087, 0x00727543, 0x00040006, 0x00000087, 0x00000000, 0x00000072, 0x00030005, 0x00000089, + 0x00727563, 0x00040005, 0x0000009e, 0x76657250, 0x00000000, 0x00040006, 0x0000009e, 0x00000000, + 0x00000072, 0x00040005, 0x000000a0, 0x76657270, 0x00000000, 0x00040005, 0x000000e7, 0x6f5f766d, + 0x00007475, 0x00040047, 0x00000036, 0x0000000b, 0x0000001c, 0x00030047, 0x00000041, 0x00000002, + 0x00050048, 0x00000041, 0x00000000, 0x00000023, 0x00000000, 0x00050048, 0x00000041, 0x00000001, + 0x00000023, 0x00000008, 0x00040047, 0x0000005d, 0x00000021, 0x00000000, 0x00040047, 0x0000005d, + 0x00000022, 0x00000000, 0x00040047, 0x00000086, 0x00000006, 0x00000010, 0x00030047, 0x00000087, + 0x00000002, 0x00050048, 0x00000087, 0x00000000, 0x00000023, 0x00000000, 0x00040047, 0x00000089, + 0x00000021, 0x00000002, 0x00040047, 0x00000089, 0x00000022, 0x00000000, 0x00040047, 0x0000009d, + 0x00000006, 0x00000010, 0x00030047, 0x0000009e, 0x00000002, 0x00050048, 0x0000009e, 0x00000000, + 0x00000023, 0x00000000, 0x00040047, 0x000000a0, 0x00000021, 0x00000003, 0x00040047, 0x000000a0, + 0x00000022, 0x00000000, 0x00030047, 0x000000e7, 0x00000019, 0x00040047, 0x000000e7, 0x00000021, + 0x00000001, 0x00040047, 0x000000e7, 0x00000022, 0x00000000, 0x00020013, 0x00000002, 0x00030021, + 0x00000003, 0x00000002, 0x00030016, 0x00000006, 0x00000020, 0x00040017, 0x00000007, 0x00000006, + 0x00000004, 0x00040018, 0x00000009, 0x00000007, 0x00000004, 0x0004002b, 0x00000006, 0x00000015, + 0x3f800000, 0x0004002b, 0x00000006, 0x00000016, 0x00000000, 0x00040015, 0x0000002f, 0x00000020, + 0x00000001, 0x00040017, 0x00000030, 0x0000002f, 0x00000002, 0x00040015, 0x00000033, 0x00000020, + 0x00000000, 0x00040017, 0x00000034, 0x00000033, 0x00000003, 0x00040020, 0x00000035, 0x00000001, + 0x00000034, 0x0004003b, 0x00000035, 0x00000036, 0x00000001, 0x00040017, 0x00000037, 0x00000033, + 0x00000002, 0x00020014, 0x0000003b, 0x0004002b, 0x00000033, 0x0000003c, 0x00000000, 0x00040017, + 0x00000040, 0x00000006, 0x00000002, 0x0004001e, 0x00000041, 0x00000040, 0x00000040, 0x00040020, + 0x00000042, 0x00000009, 0x00000041, 0x0004003b, 0x00000042, 0x00000043, 0x00000009, 0x0004002b, + 0x0000002f, 0x00000044, 0x00000000, 0x00040020, 0x00000045, 0x00000009, 0x00000006, 0x0004002b, + 0x00000033, 0x0000004d, 0x00000001, 0x00090019, 0x0000005a, 0x00000006, 0x00000001, 0x00000000, + 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x0003001b, 0x0000005b, 0x0000005a, 0x00040020, + 0x0000005c, 0x00000000, 0x0000005b, 0x0004003b, 0x0000005c, 0x0000005d, 0x00000000, 0x0004002b, + 0x00000006, 0x00000067, 0x3f000000, 0x0004002b, 0x0000002f, 0x0000006a, 0x00000001, 0x00040020, + 0x0000006b, 0x00000009, 0x00000040, 0x0004002b, 0x00000006, 0x00000075, 0x40000000, 0x0004002b, + 0x00000033, 0x00000085, 0x00000010, 0x0004001c, 0x00000086, 0x00000007, 0x00000085, 0x0003001e, + 0x00000087, 0x00000086, 0x00040020, 0x00000088, 0x00000002, 0x00000087, 0x0004003b, 0x00000088, + 0x00000089, 0x00000002, 0x0004002b, 0x0000002f, 0x0000008a, 0x00000003, 0x0004002b, 0x0000002f, + 0x0000008b, 0x00000004, 0x0004002b, 0x0000002f, 0x0000008c, 0x00000005, 0x0004002b, 0x0000002f, + 0x0000008d, 0x00000006, 0x00040020, 0x0000008f, 0x00000002, 0x00000007, 0x0004001c, 0x0000009d, + 0x00000007, 0x00000085, 0x0003001e, 0x0000009e, 0x0000009d, 0x00040020, 0x0000009f, 0x00000002, + 0x0000009e, 0x0004003b, 0x0000009f, 0x000000a0, 0x00000002, 0x0005002c, 0x00000040, 0x000000b4, + 0x00000016, 0x00000016, 0x0004002b, 0x00000006, 0x000000b9, 0x2b8cbccc, 0x0004002b, 0x00000006, + 0x000000c7, 0x358637bd, 0x00090019, 0x000000e5, 0x00000006, 0x00000001, 0x00000000, 0x00000000, + 0x00000000, 0x00000002, 0x00000007, 0x00040020, 0x000000e6, 0x00000000, 0x000000e5, 0x0004003b, + 0x000000e6, 0x000000e7, 0x00000000, 0x0005002c, 0x00000040, 0x00000130, 0x00000067, 0x00000067, + 0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x000300f7, + 0x000000f0, 0x00000000, 0x000300fb, 0x0000003c, 0x000000f1, 0x000200f8, 0x000000f1, 0x0004003d, + 0x00000034, 0x00000038, 0x00000036, 0x0007004f, 0x00000037, 0x00000039, 0x00000038, 0x00000038, + 0x00000000, 0x00000001, 0x0004007c, 0x00000030, 0x0000003a, 0x00000039, 0x00050051, 0x0000002f, + 0x0000003f, 0x0000003a, 0x00000000, 0x00060041, 0x00000045, 0x00000046, 0x00000043, 0x00000044, + 0x0000003c, 0x0004003d, 0x00000006, 0x00000047, 0x00000046, 0x0004006e, 0x0000002f, 0x00000048, + 0x00000047, 0x000500af, 0x0000003b, 0x00000049, 0x0000003f, 0x00000048, 0x000400a8, 0x0000003b, + 0x0000004a, 0x00000049, 0x000300f7, 0x0000004c, 0x00000000, 0x000400fa, 0x0000004a, 0x0000004b, + 0x0000004c, 0x000200f8, 0x0000004b, 0x00050051, 0x0000002f, 0x0000004f, 0x0000003a, 0x00000001, + 0x00060041, 0x00000045, 0x00000050, 0x00000043, 0x00000044, 0x0000004d, 0x0004003d, 0x00000006, + 0x00000051, 0x00000050, 0x0004006e, 0x0000002f, 0x00000052, 0x00000051, 0x000500af, 0x0000003b, + 0x00000053, 0x0000004f, 0x00000052, 0x000200f9, 0x0000004c, 0x000200f8, 0x0000004c, 0x000700f5, + 0x0000003b, 0x00000054, 0x00000049, 0x000000f1, 0x00000053, 0x0000004b, 0x000300f7, 0x00000056, + 0x00000000, 0x000400fa, 0x00000054, 0x00000055, 0x00000056, 0x000200f8, 0x00000055, 0x000200f9, + 0x000000f0, 0x000200f8, 0x00000056, 0x0004003d, 0x0000005b, 0x0000005e, 0x0000005d, 0x00040064, + 0x0000005a, 0x00000060, 0x0000005e, 0x0007005f, 0x00000007, 0x00000061, 0x00000060, 0x0000003a, + 0x00000002, 0x00000044, 0x00050051, 0x00000006, 0x00000062, 0x00000061, 0x00000000, 0x0004006f, + 0x00000040, 0x00000066, 0x0000003a, 0x00050081, 0x00000040, 0x00000069, 0x00000066, 0x00000130, + 0x00050041, 0x0000006b, 0x0000006c, 0x00000043, 0x0000006a, 0x0004003d, 0x00000040, 0x0000006d, + 0x0000006c, 0x00050083, 0x00000040, 0x0000006e, 0x00000069, 0x0000006d, 0x00050051, 0x00000006, + 0x00000071, 0x0000006e, 0x00000000, 0x00050088, 0x00000006, 0x00000074, 0x00000071, 0x00000047, + 0x00050085, 0x00000006, 0x00000076, 0x00000074, 0x00000075, 0x00050083, 0x00000006, 0x00000077, + 0x00000076, 0x00000015, 0x00050051, 0x00000006, 0x00000079, 0x0000006e, 0x00000001, 0x00060041, + 0x00000045, 0x0000007a, 0x00000043, 0x00000044, 0x0000004d, 0x0004003d, 0x00000006, 0x0000007b, + 0x0000007a, 0x00050088, 0x00000006, 0x0000007c, 0x00000079, 0x0000007b, 0x00050085, 0x00000006, + 0x0000007d, 0x0000007c, 0x00000075, 0x00050083, 0x00000006, 0x0000007e, 0x00000015, 0x0000007d, + 0x00050085, 0x00000006, 0x00000080, 0x00000062, 0x00000075, 0x00050083, 0x00000006, 0x00000081, + 0x00000080, 0x00000015, 0x00070050, 0x00000007, 0x00000082, 0x00000077, 0x0000007e, 0x00000081, + 0x00000015, 0x00060041, 0x0000008f, 0x00000090, 0x00000089, 0x00000044, 0x0000008a, 0x0004003d, + 0x00000007, 0x00000091, 0x00000090, 0x00060041, 0x0000008f, 0x00000093, 0x00000089, 0x00000044, + 0x0000008b, 0x0004003d, 0x00000007, 0x00000094, 0x00000093, 0x00060041, 0x0000008f, 0x00000096, + 0x00000089, 0x00000044, 0x0000008c, 0x0004003d, 0x00000007, 0x00000097, 0x00000096, 0x00060041, + 0x0000008f, 0x00000099, 0x00000089, 0x00000044, 0x0000008d, 0x0004003d, 0x00000007, 0x0000009a, + 0x00000099, 0x00070050, 0x00000009, 0x00000110, 0x00000091, 0x00000094, 0x00000097, 0x0000009a, + 0x00040054, 0x00000009, 0x00000111, 0x00000110, 0x00060041, 0x0000008f, 0x000000a2, 0x000000a0, + 0x00000044, 0x0000008a, 0x0004003d, 0x00000007, 0x000000a3, 0x000000a2, 0x00060041, 0x0000008f, + 0x000000a5, 0x000000a0, 0x00000044, 0x0000008b, 0x0004003d, 0x00000007, 0x000000a6, 0x000000a5, + 0x00060041, 0x0000008f, 0x000000a8, 0x000000a0, 0x00000044, 0x0000008c, 0x0004003d, 0x00000007, + 0x000000a9, 0x000000a8, 0x00060041, 0x0000008f, 0x000000ab, 0x000000a0, 0x00000044, 0x0000008d, + 0x0004003d, 0x00000007, 0x000000ac, 0x000000ab, 0x00070050, 0x00000009, 0x0000012c, 0x000000a3, + 0x000000a6, 0x000000a9, 0x000000ac, 0x00040054, 0x00000009, 0x0000012d, 0x0000012c, 0x0006000c, + 0x00000009, 0x000000b0, 0x00000001, 0x00000022, 0x00000111, 0x00050091, 0x00000007, 0x000000b2, + 0x000000b0, 0x00000082, 0x00050051, 0x00000006, 0x000000b7, 0x000000b2, 0x00000003, 0x0006000c, + 0x00000006, 0x000000b8, 0x00000001, 0x00000004, 0x000000b7, 0x000500ba, 0x0000003b, 0x000000ba, + 0x000000b8, 0x000000b9, 0x000300f7, 0x000000bc, 0x00000000, 0x000400fa, 0x000000ba, 0x000000bb, + 0x000000bc, 0x000200f8, 0x000000bb, 0x00070050, 0x00000007, 0x000000c2, 0x000000b7, 0x000000b7, + 0x000000b7, 0x000000b7, 0x00050088, 0x00000007, 0x000000c3, 0x000000b2, 0x000000c2, 0x00050091, + 0x00000007, 0x000000c4, 0x0000012d, 0x000000c3, 0x00050051, 0x00000006, 0x000000c6, 0x000000c4, + 0x00000003, 0x000500ba, 0x0000003b, 0x000000c8, 0x000000c6, 0x000000c7, 0x000300f7, 0x000000ca, + 0x00000000, 0x000400fa, 0x000000c8, 0x000000c9, 0x000000ca, 0x000200f8, 0x000000c9, 0x0007004f, + 0x00000040, 0x000000cd, 0x000000c4, 0x000000c4, 0x00000000, 0x00000001, 0x00050050, 0x00000040, + 0x000000d0, 0x000000c6, 0x000000c6, 0x00050088, 0x00000040, 0x000000d1, 0x000000cd, 0x000000d0, + 0x00050051, 0x00000006, 0x000000d4, 0x000000d1, 0x00000000, 0x00050085, 0x00000006, 0x000000d5, + 0x000000d4, 0x00000067, 0x00050081, 0x00000006, 0x000000d6, 0x000000d5, 0x00000067, 0x00050085, + 0x00000006, 0x000000d9, 0x000000d6, 0x00000047, 0x00050051, 0x00000006, 0x000000db, 0x000000d1, + 0x00000001, 0x00050085, 0x00000006, 0x000000dc, 0x000000db, 0x00000067, 0x00050083, 0x00000006, + 0x000000dd, 0x00000067, 0x000000dc, 0x00050085, 0x00000006, 0x000000e0, 0x000000dd, 0x0000007b, + 0x00050050, 0x00000040, 0x000000e1, 0x000000d9, 0x000000e0, 0x00050083, 0x00000040, 0x000000e4, + 0x000000e1, 0x0000006e, 0x000200f9, 0x000000ca, 0x000200f8, 0x000000ca, 0x000700f5, 0x00000040, + 0x0000012f, 0x000000b4, 0x000000bb, 0x000000e4, 0x000000c9, 0x000200f9, 0x000000bc, 0x000200f8, + 0x000000bc, 0x000700f5, 0x00000040, 0x0000012e, 0x000000b4, 0x00000056, 0x0000012f, 0x000000ca, + 0x0004003d, 0x000000e5, 0x000000e8, 0x000000e7, 0x00050051, 0x00000006, 0x000000eb, 0x0000012e, + 0x00000000, 0x00050051, 0x00000006, 0x000000ec, 0x0000012e, 0x00000001, 0x00070050, 0x00000007, + 0x000000ed, 0x000000eb, 0x000000ec, 0x00000016, 0x00000016, 0x00040063, 0x000000e8, 0x0000003a, + 0x000000ed, 0x000200f9, 0x000000f0, 0x000200f8, 0x000000f0, 0x000100fd, 0x00010038, +}; diff --git a/runtime/shaders/dlaa_mv.comp b/runtime/shaders/dlaa_mv.comp new file mode 100644 index 00000000..f7ced22c --- /dev/null +++ b/runtime/shaders/dlaa_mv.comp @@ -0,0 +1,40 @@ +#version 450 +// Camera motion vectors for DLAA (vk_dlaa.c mv_pass): each pixel's depth is taken back to the world through this +// frame's view-projection and forward through last frame's; the vector is last frame's window position minus this +// frame's, in render pixels, without the jitter (DLSS's default convention). Objects that move on their own get only +// the camera's motion. +// The camera block is TotK's scene uniform block (bound as c4 in the scene's vertex shaders): vec4 rows 3-6 are the +// view-projection, rows of a row-major 4x4 with OpenGL clip depth (-w..w). The replay's viewports have negative +// heights, so window y grows downwards from ndc y = +1, and depth is z_ndc * 0.5 + 0.5. +layout(local_size_x = 8, local_size_y = 8) in; +layout(binding = 0) uniform sampler2D depth_tex; +layout(binding = 1, rg16f) uniform writeonly image2D mv_out; +layout(binding = 2, std140) uniform Cur { vec4 r[16]; } cur; +layout(binding = 3, std140) uniform Prev { vec4 r[16]; } prev; +layout(push_constant) uniform P { + vec2 size; // render size in pixels + vec2 jitter; // this frame's jitter, pixels, as the scene was drawn (window x right, y down) +} pc; + +mat4 vp(vec4 a, vec4 b, vec4 c, vec4 d) { return transpose(mat4(a, b, c, d)); } + +void main() { + ivec2 p = ivec2(gl_GlobalInvocationID.xy); + if (p.x >= int(pc.size.x) || p.y >= int(pc.size.y)) return; + float d = texelFetch(depth_tex, p, 0).r; + vec2 win = vec2(p) + 0.5 - pc.jitter; // where this pixel's surface sits without the jitter + vec4 ndc = vec4(win.x / pc.size.x * 2.0 - 1.0, 1.0 - win.y / pc.size.y * 2.0, d * 2.0 - 1.0, 1.0); + mat4 c = vp(cur.r[3], cur.r[4], cur.r[5], cur.r[6]); + mat4 q = vp(prev.r[3], prev.r[4], prev.r[5], prev.r[6]); + vec4 world = inverse(c) * ndc; + vec2 mv = vec2(0.0); + if (abs(world.w) > 1e-12) { + vec4 clip = q * (world / world.w); + if (clip.w > 1e-6) { + vec2 pn = clip.xy / clip.w; + vec2 pwin = vec2((pn.x * 0.5 + 0.5) * pc.size.x, (0.5 - pn.y * 0.5) * pc.size.y); + mv = pwin - win; + } + } + imageStore(mv_out, p, vec4(mv, 0.0, 0.0)); +} diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index 7d52baa9..035631b4 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -534,6 +534,8 @@ static void tab_screen(float scale) { static const UiTextId up[] = {UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR}; opt_choice("TOTK_UPSCALER", UI_MENU_UPSCALER, up, 2, UI_MENU_UPSCALER_DESC); opt_slider("TOTK_SHARPNESS", UI_MENU_SHARPNESS, 0, 100, UI_MENU_SHARPNESS_DESC, 5, "%.0f %%"); + opt_toggle("TOTK_DLAA", UI_MENU_DLAA, UI_MENU_DLAA_DESC); + opt_toggle("TOTK_FXAA", UI_MENU_FXAA, UI_MENU_FXAA_DESC); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index 0de0818f..3bd8c2f3 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -63,6 +63,11 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Bilinear", [UI_MENU_SHARPNESS] = "FSR sharpness", [UI_MENU_SHARPNESS_DESC] = "Sharpening after FSR scaling; 0 turns it off.", + [UI_MENU_DLAA] = "NVIDIA DLAA", + [UI_MENU_DLAA_DESC] = "DLSS anti-aliasing of the 3D scene at its own resolution (NVIDIA RTX GPUs; nvngx_dlss.dll next to " + "totk.exe). Smoother edges and less shimmer for about 3 ms a frame.", + [UI_MENU_FXAA] = "Game anti-aliasing (FXAA)", + [UI_MENU_FXAA_DESC] = "The game's own FXAA edge smoothing. It blurs fine detail a little; with DLAA on it is not needed.", [UI_MENU_FPS_LIMIT] = "Frame rate limit", [UI_MENU_FPS_LIMIT_DESC] = "The most frames per second the game draws. Above 60 is experimental and needs Game speed " @@ -282,6 +287,11 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_UPSCALER_FSR] = "AMD FSR 1", [UI_MENU_UPSCALER_BILINEAR] = "Билинейное", [UI_MENU_SHARPNESS] = "Резкость FSR", [UI_MENU_SHARPNESS_DESC] = "Повышение резкости после масштабирования FSR; 0 выключает его.", + [UI_MENU_DLAA] = "NVIDIA DLAA", + [UI_MENU_DLAA_DESC] = "Сглаживание 3D-сцены через DLSS в её собственном разрешении (видеокарты NVIDIA RTX; nvngx_dlss.dll " + "рядом с totk.exe). Ровнее края и меньше мерцания, около 3 мс на кадр.", + [UI_MENU_FXAA] = "Сглаживание игры (FXAA)", + [UI_MENU_FXAA_DESC] = "Собственное сглаживание FXAA. Слегка размывает мелкие детали; с DLAA оно не нужно.", [UI_MENU_FPS_LIMIT] = "Ограничение частоты кадров", [UI_MENU_FPS_LIMIT_DESC] = "Наибольшее число кадров в секунду. Выше 60 — экспериментальный режим, нужна «Скорость " diff --git a/runtime/ui_text.h b/runtime/ui_text.h index 96e10618..7d95c8be 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -36,6 +36,7 @@ typedef enum { UI_MENU_RENDER_SCALE, UI_MENU_RENDER_SCALE_DESC, UI_MENU_RENDER_SCALE_GAME, UI_MENU_UPSCALER, UI_MENU_UPSCALER_DESC, UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR, UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, + UI_MENU_DLAA, UI_MENU_DLAA_DESC, UI_MENU_FXAA, UI_MENU_FXAA_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_90, UI_MENU_FPS_120, diff --git a/runtime/vk_backend.c b/runtime/vk_backend.c index a260aa69..86388618 100644 --- a/runtime/vk_backend.c +++ b/runtime/vk_backend.c @@ -29,6 +29,7 @@ #include "nvn_api.h" #include "vk.h" #include "vk_exec.h" +#include "vk_dlaa.h" #define WEAK __attribute__((weak)) @@ -104,6 +105,7 @@ static void present_image(const tex_t *t, const int crop[4], uint64_t at_ns, uin uint64_t value) { static volatile long n_skipped; vk_exec_frame_log(t, frame); + vk_dlaa_frame(); vk_mem_census(frame); if (vk_dump_armed) vk_dump_present(frame); __atomic_store_n(&gfx_counters.validation_errors, (uint64_t)vk_validation_errors_total(), __ATOMIC_RELAXED); diff --git a/runtime/vk_device.c b/runtime/vk_device.c index 98fb84f9..8df3eab0 100644 --- a/runtime/vk_device.c +++ b/runtime/vk_device.c @@ -10,6 +10,7 @@ #include "cfg.h" #include "host.h" #include "vk.h" +#include "vk_dlaa.h" static VkCtx g_vk; static int g_ready; @@ -42,7 +43,7 @@ static int layer_present(const char *name) { } static int create_instance(void) { - const char *ext[4] = {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME}; + const char *ext[12] = {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME}; uint32_t n_ext = 2; const char *layers[] = {"VK_LAYER_KHRONOS_validation"}; int validate = cfg_bool("TOTK_VK_VALIDATION"); @@ -51,6 +52,7 @@ static int create_instance(void) { validate = 0; } if (validate) ext[n_ext++] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME; + vk_dlaa_instance_exts(ext, &n_ext, 12); VkApplicationInfo app = {.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pApplicationName = "TotK Recomp", .pEngineName = "TotK Recomp", .apiVersion = VK_API_VERSION_1_3}; VkInstanceCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .pApplicationInfo = &app, @@ -195,7 +197,7 @@ static int create_device(void) { vkEnumerateDeviceExtensionProperties(g_vk.phys, NULL, &ne, NULL); VkExtensionProperties *ep = calloc(ne ? ne : 1, sizeof *ep); vkEnumerateDeviceExtensionProperties(g_vk.phys, NULL, &ne, ep); - const char *ext[28]; + const char *ext[40]; uint32_t n_ext = 0; for (size_t i = 0; i < sizeof k_required_ext / sizeof *k_required_ext; i++) ext[n_ext++] = k_required_ext[i]; @@ -232,6 +234,7 @@ static int create_device(void) { CHAIN(fbl, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT); CHAIN(lr, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR); } + vk_dlaa_device_exts(ep, ne, ext, &n_ext, 34); // NGX's; the six slots after it stay for the ones below if (has_ext(ep, ne, VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) { g_vk.has_memory_budget = 1; ext[n_ext++] = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME; } // GPU breadcrumbs for a lost device (vk_crumbs.c): AMD's drivers and RADV report it. if (has_ext(ep, ne, VK_AMD_BUFFER_MARKER_EXTENSION_NAME)) { g_vk.has_buffer_marker = 1; ext[n_ext++] = VK_AMD_BUFFER_MARKER_EXTENSION_NAME; } @@ -354,7 +357,7 @@ int vk_init(void) { AcquireSRWLockExclusive(&g_lock); if (!g_ready) { memset(&g_vk, 0, sizeof g_vk); - if (create_instance() && pick_device() && create_device()) g_ready = 1, vk_headroom_start(); + if (create_instance() && pick_device() && create_device()) g_ready = 1, vk_headroom_start(), vk_dlaa_init(); else destroy_all(); } int ok = g_ready; diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c new file mode 100644 index 00000000..9de36e8a --- /dev/null +++ b/runtime/vk_dlaa.c @@ -0,0 +1,624 @@ +// DLAA: NVIDIA DLSS at the scene's own size (TOTK_DLAA, totk.ini dlaa). NGX is loaded at run time from the driver's +// NGX core (_nvngx.dll, found through HKLM\SOFTWARE\NVIDIA Corporation\Global\NGXCore); the DLSS model +// (nvngx_dlss.dll) is loaded by NGX from the folder of totk.exe. No NVIDIA SDK code or header is compiled in: the few +// NGX types used are declared here from the SDK's documented ABI, the way the Metroid Dread recomp's dlss.c reaches +// the core (read for behaviour only). +// +// The core's parameter object is a C++ class whose virtual functions are called through the MSVC vtable: the Set +// overloads in slots 0-7 and the Get overloads in 8-15, each group in reverse declaration order. vtable_ok checks that +// layout with a set-then-get round trip before anything relies on it. +// +// Where DLAA runs in the frame, the jitter and the motion vectors: see the sections below. +#include +#include +#include +#include +#include +#include + +#include "cfg.h" +#include "host.h" +#include "vk.h" +#include "vk_dlaa.h" +#include "vk_exec.h" +#include "vk_rec.h" +#include "dlaa_mv_spv.h" + +typedef int NgxResult; // NVSDK_NGX_Result: 1 success, 0xBAD00000 | n failures +#define NGX_OK(r) (((unsigned)(r) & 0xFFF00000u) != 0xBAD00000u) +#define NGX_VERSION_API 0x15 +#define NGX_FEATURE_SUPERSAMPLING 1 +#define NGX_PERFQ_DLAA 5 +typedef struct NgxParam NgxParam; +typedef struct NgxHandle NgxHandle; +typedef struct { void *slot[17]; } NgxParamVtbl; +struct NgxParam { const NgxParamVtbl *vt; }; +typedef struct { // NVSDK_NGX_ImageViewInfo_VK + VkImageView view; + VkImage image; + VkImageSubresourceRange range; + VkFormat format; + unsigned width, height; +} NgxImageView; +typedef struct { // NVSDK_NGX_Resource_VK + union { NgxImageView img; struct { VkBuffer buffer; unsigned bytes; } buf; } r; + int type; // 0 image view, 1 buffer + _Bool rw; +} NgxResourceVK; + +typedef NgxResult (*PFN_Init)(unsigned long long app, const wchar_t *path, VkInstance, VkPhysicalDevice, VkDevice, + PFN_vkGetInstanceProcAddr, PFN_vkGetDeviceProcAddr, int version, const void *info); +typedef NgxResult (*PFN_ReqExt)(unsigned *ni, const char ***ie, unsigned *nd, const char ***de); +typedef NgxResult (*PFN_Params)(NgxParam **); +typedef NgxResult (*PFN_DestroyParams)(NgxParam *); +typedef NgxResult (*PFN_Create)(VkCommandBuffer, int feature, NgxParam *, NgxHandle **); +typedef NgxResult (*PFN_Evaluate)(VkCommandBuffer, const NgxHandle *, const NgxParam *, void *callback); +typedef NgxResult (*PFN_Release)(NgxHandle *); + +static struct { + HMODULE core; + PFN_Init init; + PFN_ReqExt req_ext; + PFN_Params caps, alloc_params; + PFN_DestroyParams destroy_params; + PFN_Create create; + PFN_Evaluate evaluate; + PFN_Release release; + int tried, loaded, available; + int wanted; // -1 not read yet +} N = {.wanted = -1}; + +typedef void (*SetI)(NgxParam *, const char *, int); +typedef void (*SetU)(NgxParam *, const char *, unsigned); +typedef void (*SetF)(NgxParam *, const char *, float); +typedef void (*SetP)(NgxParam *, const char *, void *); +typedef NgxResult (*GetI)(const NgxParam *, const char *, int *); +typedef NgxResult (*GetU)(const NgxParam *, const char *, unsigned *); +typedef NgxResult (*GetF)(const NgxParam *, const char *, float *); +typedef NgxResult (*GetP)(const NgxParam *, const char *, void **); +enum { S_P = 0, S_D12, S_D11, S_I, S_U32, S_D, S_F, S_U64, G_P, G_D12, G_D11, G_I, G_U32, G_D, G_F, G_U64 }; +static void p_seti(NgxParam *p, const char *n, int v) { ((SetI)p->vt->slot[S_I])(p, n, v); } +static void p_setu(NgxParam *p, const char *n, unsigned v) { ((SetU)p->vt->slot[S_U32])(p, n, v); } +static void p_setf(NgxParam *p, const char *n, float v) { ((SetF)p->vt->slot[S_F])(p, n, v); } +static void p_setp(NgxParam *p, const char *n, void *v) { ((SetP)p->vt->slot[S_P])(p, n, v); } +static int p_geti(const NgxParam *p, const char *n, int *v) { return NGX_OK(((GetI)p->vt->slot[G_I])(p, n, v)); } +static int p_getu(const NgxParam *p, const char *n, unsigned *v) { return NGX_OK(((GetU)p->vt->slot[G_U32])(p, n, v)); } +static int p_getf(const NgxParam *p, const char *n, float *v) { return NGX_OK(((GetF)p->vt->slot[G_F])(p, n, v)); } +static int p_getp(const NgxParam *p, const char *n, void **v) { return NGX_OK(((GetP)p->vt->slot[G_P])(p, n, v)); } + +// NGX is brought up whenever the driver has it, whatever the setting, so dlaa can be switched on while the game runs +// (its device extensions can only be asked for at device creation). Switched off, nothing else of DLAA runs. +int vk_dlaa_wanted(void) { return 1; } + +static int core_load(void) { + if (N.tried) return N.loaded; + N.tried = 1; + char dir[MAX_PATH] = {0}, path[MAX_PATH + 32]; + DWORD n = sizeof dir; + if (RegGetValueA(HKEY_LOCAL_MACHINE, "SOFTWARE\\NVIDIA Corporation\\Global\\NGXCore", "FullPath", RRF_RT_REG_SZ, + NULL, dir, &n) != ERROR_SUCCESS) { + rt_log("dlaa: the driver has no NGX core (registry NGXCore missing): DLAA off"); + return 0; + } + snprintf(path, sizeof path, "%s\\_nvngx.dll", dir); + N.core = LoadLibraryA(path); + if (!N.core) { + rt_log("dlaa: cannot load %s (error %lu): DLAA off", path, GetLastError()); + return 0; + } +#define FN(f, name) N.f = (void *)GetProcAddress(N.core, name) + FN(init, "NVSDK_NGX_VULKAN_Init_Ext2"); + FN(req_ext, "NVSDK_NGX_VULKAN_RequiredExtensions"); + FN(caps, "NVSDK_NGX_VULKAN_GetCapabilityParameters"); + FN(alloc_params, "NVSDK_NGX_VULKAN_AllocateParameters"); + FN(destroy_params, "NVSDK_NGX_VULKAN_DestroyParameters"); + FN(create, "NVSDK_NGX_VULKAN_CreateFeature"); + FN(evaluate, "NVSDK_NGX_VULKAN_EvaluateFeature"); + FN(release, "NVSDK_NGX_VULKAN_ReleaseFeature"); +#undef FN + if (!N.init || !N.req_ext || !N.caps || !N.alloc_params || !N.create || !N.evaluate || !N.release) { + rt_log("dlaa: the NGX core %s lacks Vulkan entry points: DLAA off", path); + return 0; + } + N.loaded = 1; + rt_log("dlaa: NGX core %s", path); + return 1; +} + +static int listed(const char *const *list, uint32_t n, const char *s) { + for (uint32_t i = 0; i < n; i++) + if (!strcmp(list[i], s)) return 1; + return 0; +} + +void vk_dlaa_instance_exts(const char **ext, uint32_t *n, uint32_t max) { + unsigned ni = 0, nd = 0; + const char **ie = NULL, **de = NULL; + if (!vk_dlaa_wanted() || !core_load() || !NGX_OK(N.req_ext(&ni, &ie, &nd, &de))) return; + for (unsigned i = 0; i < ni; i++) + if (!listed(ext, *n, ie[i]) && *n < max) ext[(*n)++] = ie[i]; +} + +void vk_dlaa_device_exts(const VkExtensionProperties *have, uint32_t nhave, const char **ext, uint32_t *n, + uint32_t max) { + unsigned ni = 0, nd = 0; + const char **ie = NULL, **de = NULL; + if (!vk_dlaa_wanted() || !core_load() || !NGX_OK(N.req_ext(&ni, &ie, &nd, &de))) return; + for (unsigned i = 0; i < nd; i++) { + int ok = 0; + for (uint32_t k = 0; k < nhave && !ok; k++) ok = !strcmp(have[k].extensionName, de[i]); + if (!ok) rt_log("dlaa: the device lacks %s, which NGX asks for", de[i]); + else if (!listed(ext, *n, de[i]) && *n < max) ext[(*n)++] = de[i]; + } +} + +static int vtable_ok(void) { + NgxParam *p = NULL; + if (!NGX_OK(N.alloc_params(&p)) || !p) return 0; + int i = 0; + unsigned u = 0; + float f = 0; + void *v = NULL; + p_seti(p, "TotK.Test.I", -12345); + p_setu(p, "TotK.Test.U", 4000000000u); + p_setf(p, "TotK.Test.F", 1.25f); + p_setp(p, "TotK.Test.P", (void *)p); + int ok = p_geti(p, "TotK.Test.I", &i) && i == -12345 && p_getu(p, "TotK.Test.U", &u) && u == 4000000000u && + p_getf(p, "TotK.Test.F", &f) && f == 1.25f && p_getp(p, "TotK.Test.P", &v) && v == (void *)p; + if (N.destroy_params) N.destroy_params(p); + if (!ok) rt_log("dlaa: NGX parameter layout check failed (i=%d u=%u f=%g p=%p): DLAA off", i, u, f, v); + return ok; +} + +void vk_dlaa_init(void) { + if (!vk_dlaa_wanted() || !core_load()) return; + wchar_t wdir[MAX_PATH]; + DWORD len = GetModuleFileNameW(NULL, wdir, MAX_PATH); + while (len && wdir[len - 1] != L'\\') len--; + wdir[len] = 0; + // 231313132: the application id NVIDIA's DLSS samples use for builds without an NVIDIA-issued id + const VkCtx *c = vk_ctx(); + NgxResult r = N.init(231313132ull, wdir, c->instance, c->phys, c->device, vkGetInstanceProcAddr, + vkGetDeviceProcAddr, NGX_VERSION_API, NULL); + if (!NGX_OK(r)) { + rt_log("dlaa: NGX init failed (%08x): DLAA off", (unsigned)r); + return; + } + if (!vtable_ok()) return; + NgxParam *caps = NULL; + int avail = 0, driver = 0; + if (NGX_OK(N.caps(&caps)) && caps) { + p_geti(caps, "SuperSampling.Available", &avail); + p_geti(caps, "SuperSampling.NeedsUpdatedDriver", &driver); + } + N.available = avail != 0; + rt_log("dlaa: NGX up; DLSS %s%s", avail ? "available" : "NOT available (is nvngx_dlss.dll next to totk.exe?)", + driver ? "; the driver needs an update" : ""); +} + +// ---------------------------------------------------------------- where DLAA runs in TotK's frame +// Measured (TOTK_DUMP, frame 2100 at Lookout Landing, 2560x1440 scene): the G-buffer passes draw into five targets with +// the scene depth (d32f at the scene size), one of them the R11G11B10F light target; lighting and the transparents +// then draw into that light target alone, the last time with the scene depth attached; the first pass narrower than a +// quarter of the scene starts the bloom chain, which reads it. After the bloom come the tonemap and post passes, then +// the HUD is drawn into the same target and a last pass copies it to the 8-bit output. +// So: after the G-buffer, a pass at the scene size with exactly one colour target (R11G11B10F or RGBA16F) and the D32F +// depth arms the frame with that pair; the next pass at most a quarter as wide runs DLAA on the armed target first. +// Bloom, tonemap, post and HUD then all work on the anti-aliased picture. +static struct { + VkExecTarget color, depth; // the armed pair, valid in the frame it was armed + int armed, done, gbuf; // this frame: armed on the light target, DLAA ran, the G-buffer was drawn + struct Size { // a DLSS feature and its work images per scene size (dynamic resolution flips it) + uint32_t w, h; + VkImage out, mv; + VmaAllocation out_mem, mv_mem; + 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 + VkImage last_color; // the target DLAA ran on last frame: another one means a new history + NgxParam *params; + int failed, reset; + uint64_t evals, frames_missed; + // jitter (vk_dlaa_viewport) + VkImage jdepth; // the scene depth of the last frame DLAA ran on: passes drawing with it are jittered + float jx, jy; // the offset the next scene draws take, render pixels (window x right, y down) + float ux, uy; // the offset this frame's scene draws took (DLSS and the motion vectors get these) + uint32_t jframe; + int jit_ok, jit_used, hold; // jitter allowed this frame / a draw used it / frames left without it + uint64_t holds; + // camera (vk_dlaa_draw) and motion vectors (mv_pass) + uint64_t cam_addr; // this frame's scene camera block (c4 of a scene draw's vertex stage), 0: none seen + VkBuffer camb; // two 256-byte slots: this frame's block and last frame's + VmaAllocation camb_mem; + int cam_slot, cam_prev_ok; // the slot this frame writes / the other slot holds last frame's camera + VkDescriptorSetLayout mv_dsl; + VkPipelineLayout mv_layout; + VkPipeline mv_pipe; + VkSampler mv_samp; + int mv_ok; // -1 not built, 0 failed, 1 ready + uint64_t mv_frames, mv_none; + uint64_t why[3]; // history resets: scene size changed, no camera, scene target changed + int on; // the dlaa setting, read at each present (the menu switches it live) +} D = {.mv_ok = -1}; + +static int dl_active(void) { return N.available && !D.failed && D.on; } + +static void dl_fail(const char *what, NgxResult r) { + rt_log("dlaa: %s failed (%08x): DLAA off for this run", what, (unsigned)r); + D.failed = 1; +} + +static int image2d(uint32_t w, uint32_t h, VkFormat f, VkImageUsageFlags usage, VkImage *img, VmaAllocation *mem, + VkImageView *view) { + const VkCtx *c = vk_ctx(); + VkImageCreateInfo ii = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .imageType = VK_IMAGE_TYPE_2D, .format = f, + .extent = {w, h, 1}, .mipLevels = 1, .arrayLayers = 1, .samples = VK_SAMPLE_COUNT_1_BIT, + .tiling = VK_IMAGE_TILING_OPTIMAL, .usage = usage, + .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED}; + VmaAllocationCreateInfo ai = {.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE}; + if (vmaCreateImage(c->vma, &ii, &ai, img, mem, NULL) != VK_SUCCESS) return 0; + VkImageViewCreateInfo vi = {.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .image = *img, + .viewType = VK_IMAGE_VIEW_TYPE_2D, .format = f, + .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; + return vkCreateImageView(c->device, &vi, NULL, view) == VK_SUCCESS; +} + +static void free_size(struct Size *e) { + const VkCtx *c = vk_ctx(); + vkDeviceWaitIdle(c->device); // a third scene size: the evicted images may still be in flight + if (e->out_view) vkDestroyImageView(c->device, e->out_view, NULL); + if (e->mv_view) vkDestroyImageView(c->device, e->mv_view, NULL); + if (e->out) vmaDestroyImage(c->vma, e->out, e->out_mem); + if (e->mv) vmaDestroyImage(c->vma, e->mv, e->mv_mem); + if (e->feat) N.release(e->feat); + memset(e, 0, sizeof *e); +} + +// The entry for a scene size: its output (RGBA16F, written by DLSS, then blitted back into the scene target) and +// motion vectors (RG16F, render pixels), both kept in GENERAL like every image of the back end. TotK's dynamic +// resolution switches between a few sizes; each keeps its feature, the least recently used goes for a new one. +static struct Size *size_for(VkCommandBuffer cb, uint32_t w, uint32_t h) { + struct Size *e = NULL, *lru = &D.sizes[0]; + for (int i = 0; i < 3; i++) { + if (D.sizes[i].w == w && D.sizes[i].h == h) 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]; + } + if (!e) { + if (D.last == lru) D.last = NULL; + free_size(e = lru); + } + VkImageUsageFlags u = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | + VK_IMAGE_USAGE_TRANSFER_DST_BIT; + if (!image2d(w, h, VK_FORMAT_R16G16B16A16_SFLOAT, u, &e->out, &e->out_mem, &e->out_view) || + !image2d(w, h, VK_FORMAT_R16G16_SFLOAT, u, &e->mv, &e->mv_mem, &e->mv_view)) + return NULL; + VkImageMemoryBarrier2 ib[2]; + VkImage im[2] = {e->out, e->mv}; + for (int i = 0; i < 2; i++) + ib[i] = (VkImageMemoryBarrier2){.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + .srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .dstAccessMask = VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT, + .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_GENERAL, + .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, + .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = im[i], + .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; + VkDependencyInfo di = {.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .imageMemoryBarrierCount = 2, + .pImageMemoryBarriers = ib}; + vkCmdPipelineBarrier2(cb, &di); + e->w = w, e->h = h; + return e; +} + +static void full_barrier(VkCommandBuffer cb) { + VkMemoryBarrier2 mb = {.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + .srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT, + .dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + .dstAccessMask = VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT}; + VkDependencyInfo di = {.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = 1, .pMemoryBarriers = &mb}; + vkCmdPipelineBarrier2(cb, &di); +} + +static NgxResourceVK res_image(VkImageView v, VkImage img, VkFormat f, uint32_t w, uint32_t h, VkImageAspectFlags a, + int rw) { + NgxResourceVK r; + memset(&r, 0, sizeof r); + r.r.img = (NgxImageView){v, img, {a, 0, 1, 0, 1}, f, w, h}; + r.type = 0; + r.rw = rw; + return r; +} + +// ---------------------------------------------------------------- motion vectors +// Camera motion only (runtime/shaders/dlaa_mv.comp): this frame's scene camera block is copied out of the replay's +// uniform snapshot (vk_usnap.c, as of the submit call) into one slot of camb, last frame's stays in the other, and the +// compute pass reprojects every pixel's depth through both. Characters and anything else that moves on its own get +// the camera's motion only, which DLSS mostly copes with by rejecting their history. +#define CAM_BYTES 256u // vec4 rows 0-15: view, view-projection (3-6), projection, inverse view + +static int mv_init(void) { + if (D.mv_ok >= 0) return D.mv_ok; + D.mv_ok = 0; + const VkCtx *c = vk_ctx(); + VkDescriptorSetLayoutBinding b[4] = { + {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}, + {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}, + {2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}, + {3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}}; + VkDescriptorSetLayoutCreateInfo dci = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + .bindingCount = 4, .pBindings = b}; + VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 16}; + VkSamplerCreateInfo si = {.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, .magFilter = VK_FILTER_NEAREST, + .minFilter = VK_FILTER_NEAREST, .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST, + .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE}; + VkShaderModuleCreateInfo mi = {.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, .codeSize = sizeof dlaa_mv_spv, + .pCode = dlaa_mv_spv}; + VkShaderModule m = VK_NULL_HANDLE; + VkBufferCreateInfo bi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = 2 * CAM_BYTES, + .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT}; + VmaAllocationCreateInfo ai = {.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE}; + if (vkCreateDescriptorSetLayout(c->device, &dci, NULL, &D.mv_dsl) != VK_SUCCESS) goto fail; + VkPipelineLayoutCreateInfo li = {.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .setLayoutCount = 1, + .pSetLayouts = &D.mv_dsl, .pushConstantRangeCount = 1, .pPushConstantRanges = &pr}; + if (vkCreatePipelineLayout(c->device, &li, NULL, &D.mv_layout) != VK_SUCCESS || + vkCreateSampler(c->device, &si, NULL, &D.mv_samp) != VK_SUCCESS || + vkCreateShaderModule(c->device, &mi, NULL, &m) != VK_SUCCESS || + vmaCreateBuffer(c->vma, &bi, &ai, &D.camb, &D.camb_mem, NULL) != VK_SUCCESS) + goto fail; + VkComputePipelineCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + .stage = {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + .stage = VK_SHADER_STAGE_COMPUTE_BIT, .module = m, .pName = "main"}, + .layout = D.mv_layout}; + VkResult r = vkCreateComputePipelines(c->device, VK_NULL_HANDLE, 1, &ci, NULL, &D.mv_pipe); + vkDestroyShaderModule(c->device, m, NULL); + if (r != VK_SUCCESS) goto fail; + return D.mv_ok = 1; +fail: + rt_log("dlaa: the motion-vector pass could not be set up: DLAA runs with zero motion"); + return 0; +} + +// The pass, recorded through the recorder like the replay's own commands. 0: no camera this frame (the vectors stay +// zero and DLSS starts a new history). +static int mv_pass(VkCommandBuffer cb, const struct Size *e, VkImageView zv, float jx, float jy) { + uint32_t w = e->w, h = e->h; + VkDescriptorBufferInfo cam; + if (!mv_init() || !D.cam_addr || !vk_usnap_find(D.cam_addr, CAM_BYTES, 4, &cam)) { + D.mv_none++; + D.cam_prev_ok = 0; + return 0; + } + int s = D.cam_slot, had_prev = D.cam_prev_ok; + VkBufferCopy bc = {cam.offset, (VkDeviceSize)s * CAM_BYTES, CAM_BYTES}; + vkCmdCopyBuffer(cb, cam.buffer, D.camb, 1, &bc); + full_barrier(cb); + D.cam_slot ^= 1, D.cam_prev_ok = 1; + if (!had_prev) return 0; // nothing to reproject into: zero motion, new history + VkDescriptorImageInfo zi = {D.mv_samp, zv, VK_IMAGE_LAYOUT_GENERAL}; + VkDescriptorImageInfo oi = {VK_NULL_HANDLE, e->mv_view, VK_IMAGE_LAYOUT_GENERAL}; + VkDescriptorBufferInfo cur = {D.camb, (VkDeviceSize)s * CAM_BYTES, CAM_BYTES}; + VkDescriptorBufferInfo prev = {D.camb, (VkDeviceSize)(s ^ 1) * CAM_BYTES, CAM_BYTES}; + VkWriteDescriptorSet wr[4] = { + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 0, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &zi}, + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 1, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &oi}, + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 2, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .pBufferInfo = &cur}, + {.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 3, .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .pBufferInfo = &prev}}; + vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, D.mv_pipe); + rec_push(vk_pipeline_push_fn(), cb, VK_PIPELINE_BIND_POINT_COMPUTE, D.mv_layout, 0, 4, wr); + float pc[4] = {(float)w, (float)h, jx, jy}; + vkCmdPushConstants(cb, D.mv_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof pc, pc); + vkCmdDispatch(cb, (w + 7) / 8, (h + 7) / 8, 1); + full_barrier(cb); + D.mv_frames++; + return 1; +} + +// ---------------------------------------------------------------- jitter +// The scene's draws (every pass drawing with the scene depth, until the DLAA point) have their viewport moved by a +// sub-pixel Halton(2,3) offset, which shifts what they rasterise as a jittered projection would; full-screen passes +// that shade by window position are unaffected. Jitter only follows a frame DLSS ran on: a jittered frame that DLSS +// does not resolve shakes on screen, so a missed DLAA point stops the jitter for a second. +static float halton(uint32_t i, uint32_t b) { + float f = 1, r = 0; + for (; i; i /= b) f /= (float)b, r += f * (float)(i % b); + return r; +} + +void vk_dlaa_viewport(VkExec *ex, VkViewport *v) { + if (!D.jit_ok || D.done || !ex->depth.image || ex->depth.image != D.jdepth) return; + v->x += D.jx, v->y += D.jy; + D.ux = D.jx, D.uy = D.jy, D.jit_used = 1; +} + +void vk_dlaa_draw(VkExec *ex) { + if (!dl_active() || D.done) return; + const p_bind_buf *b = &ex->ubo[0][1]; // constant bank c4: the replay keeps user banks from c3 on + const VkExecTarget *z = &ex->depth; + if (b->size == 0x940 && b->addr && z->image && z->width >= 640 && z->format == VK_FORMAT_D32_SFLOAT && + (!D.jdepth || z->image == D.jdepth)) + D.cam_addr = b->addr; +} + +// The jitter moves on right after DLAA ran, not at the present: the replay can record the next frame's scene before +// the present of this one is handled, and a step taken there landed in the middle of a frame (worse after an off/on +// switch, which shifted that order). Jitter needs a frame DLSS ran on; a frame without the DLAA point stops it. +static void next_jitter(void) { + static int nj = -1; + if (nj < 0) nj = !rt_knob("DLAA_JITTER", "1"); // TOTK_DLAA_JITTER=0: no jitter (test) + uint32_t i = D.jframe++ % 16 + 1; + D.jx = halton(i, 2) - 0.5f, D.jy = halton(i, 3) - 0.5f; + D.jit_ok = !D.hold && !nj; +} + +static void evaluate(VkExec *ex) { + const VkExecTarget *t = &D.color, *z = &D.depth; + uint32_t w = t->width, h = t->height; + VkCommandBuffer cb = ex->cb; + vk_exec_barrier(ex); // what drew the scene is done (no pass is open here) + struct Size *e = size_for(cb, w, h); + if (!e) return dl_fail("work image creation", 0); + if (e != D.last) D.reset = 1, D.why[0]++; // another size's history is from another moment + if (!D.params && !NGX_OK(N.alloc_params(&D.params))) return dl_fail("parameter allocation", 0); + NgxParam *p = D.params; + VkImageView zv = vk_exec_target_view(z->img, z->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_DEPTH_BIT, z->level, + z->base_layer, 1, 0); + float jx = D.jit_used ? D.ux : 0.0f, jy = D.jit_used ? D.uy : 0.0f; + static int no_mv = -1; + if (no_mv < 0) no_mv = !rt_knob("DLAA_MV", "1"); // TOTK_DLAA_MV=0: zero motion (test) + if (no_mv || !mv_pass(cb, e, zv, jx, jy)) { + VkClearColorValue zero = {{0, 0, 0, 0}}; + VkImageSubresourceRange all = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + vkCmdClearColorImage(cb, e->mv, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &all); + full_barrier(cb); + if (!no_mv) D.reset = 1, D.why[1]++; // no camera: the history cannot be moved along + } + rec_drain(); // NGX records into the command buffer itself: the recorder thread must have made every call so far + if (!e->feat) { + p_setu(p, "CreationNodeMask", 1); + p_setu(p, "VisibilityNodeMask", 1); + p_setu(p, "Width", w); + p_setu(p, "Height", h); + p_setu(p, "OutWidth", w); + p_setu(p, "OutHeight", h); + p_seti(p, "PerfQualityValue", NGX_PERFQ_DLAA); + // IsHDR | MVLowRes | AutoExposure: linear scene light, motion vectors at the render size, no exposure texture + p_seti(p, "DLSS.Feature.Create.Flags", (1 << 0) | (1 << 1) | (1 << 6)); + p_seti(p, "DLSS.Enable.Output.Subrects", 0); + NgxResult r = N.create(cb, NGX_FEATURE_SUPERSAMPLING, p, &e->feat); + if (!NGX_OK(r) || !e->feat) return dl_fail("DLSS feature creation", r); + D.reset = 1; + rt_log("dlaa: DLSS feature created at %ux%u (scene format %d, depth format %d)", w, h, (int)t->format, + (int)z->format); + } + if (D.last_color != t->image) D.reset = 1, D.why[2]++, D.last_color = t->image; + VkImageView cv = vk_exec_target_view(t->img, t->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, t->level, + t->base_layer, 1, 0); + NgxResourceVK rc = res_image(cv, t->image, t->format, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0); + NgxResourceVK ro = res_image(e->out_view, e->out, VK_FORMAT_R16G16B16A16_SFLOAT, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 1); + NgxResourceVK rz = res_image(zv, z->image, z->format, w, h, VK_IMAGE_ASPECT_DEPTH_BIT, 0); + NgxResourceVK rm = res_image(e->mv_view, e->mv, VK_FORMAT_R16G16_SFLOAT, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0); + p_setp(p, "Color", &rc); + p_setp(p, "Output", &ro); + p_setp(p, "Depth", &rz); + p_setp(p, "MotionVectors", &rm); + p_setf(p, "Jitter.Offset.X", jx); + p_setf(p, "Jitter.Offset.Y", jy); + p_setf(p, "Sharpness", 0.0f); + p_seti(p, "Reset", D.reset); + p_setf(p, "MV.Scale.X", 1.0f); + p_setf(p, "MV.Scale.Y", 1.0f); + p_setu(p, "DLSS.Render.Subrect.Dimensions.Width", w); + p_setu(p, "DLSS.Render.Subrect.Dimensions.Height", h); + p_setf(p, "DLSS.Pre.Exposure", 1.0f); + p_setf(p, "DLSS.Exposure.Scale", 1.0f); + p_setf(p, "FrameTimeDeltaInMsec", 16.67f); + NgxResult r = N.evaluate(cb, e->feat, p, NULL); + if (!NGX_OK(r)) return dl_fail("DLSS evaluation", r); + D.reset = 0; + D.last = e, e->used = D.evals + 1; + full_barrier(cb); + // the result back into the scene target, which the bloom, the post passes and the HUD read and draw over + VkImageBlit b = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, + .srcOffsets = {{0, 0, 0}, {(int32_t)w, (int32_t)h, 1}}, + .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, t->level, t->base_layer, 1}, + .dstOffsets = {{0, 0, 0}, {(int32_t)w, (int32_t)h, 1}}}; + vkCmdBlitImage(cb, e->out, VK_IMAGE_LAYOUT_GENERAL, t->image, VK_IMAGE_LAYOUT_GENERAL, 1, &b, VK_FILTER_NEAREST); + full_barrier(cb); + ex->recorded += 4; + vk_exec_draw_new_cb(); // NGX bound pipelines and descriptor sets of its own: the next draw binds everything again + D.jdepth = z->image; + next_jitter(); + if (++D.evals == 1 || D.evals % 3600 == 0) + rt_log("dlaa: %llu frames anti-aliased (scene %ux%u; %llu frames without the DLAA point, %llu with camera " + "motion, %llu without a camera, %llu jitter holds; resets: %llu size, %llu camera, %llu target)", + (unsigned long long)D.evals, w, h, (unsigned long long)D.frames_missed, + (unsigned long long)D.mv_frames, (unsigned long long)D.mv_none, (unsigned long long)D.holds, + (unsigned long long)D.why[0], (unsigned long long)D.why[1], (unsigned long long)D.why[2]); +} + +static int scene_color(VkFormat f) { + return f == VK_FORMAT_B10G11R11_UFLOAT_PACK32 || f == VK_FORMAT_R16G16B16A16_SFLOAT; +} + +void vk_dlaa_pass(VkExec *ex) { + const VkExecTarget *c = &ex->color[0], *z = &ex->depth; + if (!dl_active() || D.done) return; + // The G-buffer: several colour targets with a D32F depth of at least 640 wide. Only the light target drawn after it + // arms the frame; at night the game draws into the light target alone with the scene depth before the G-buffer too, + // and DLAA then ran at a small pass ahead of the whole scene, which reached the screen jittered. + if (ex->pass_ncolor >= 3 && z->image && z->format == VK_FORMAT_D32_SFLOAT && z->width >= 640) { + D.gbuf = 1, D.armed = 0; + return; + } + // the scene depth is D32F; a D16 target of the scene size also serves one composite pass before the transparents + if (D.gbuf && ex->pass_ncolor == 1 && c->image && scene_color(c->format) && z->image && z->format == VK_FORMAT_D32_SFLOAT && + c->width == z->width && c->height == z->height && c->width >= 640 && + c->samples <= 1 && !c->is3d) { + D.color = *c, D.depth = *z, D.armed = 1; + return; + } + if (!D.armed) return; + if (!ex->pass_w || ex->pass_w * 4 > D.color.width) return; + D.done = 1; + evaluate(ex); +} + +void vk_dlaa_frame(void) { + int on = N.available && cfg_bool("TOTK_DLAA"); + if (on != D.on) { + rt_log("dlaa: %s", on ? "on" : "off"); + D.on = on; + // either way the next DLAA frame starts a new history from an unjittered frame + D.reset = 1, D.cam_prev_ok = 0, D.jit_ok = D.jit_used = D.armed = D.done = D.gbuf = 0, D.hold = 0; + return; + } + if (!dl_active()) return; + if (!D.done) D.frames_missed++; + if (D.jit_used && !D.done) D.hold = 60, D.holds++; // jittered but not resolved: that frame shook + else if (D.hold) D.hold--; + if (!D.done) D.jit_ok = 0; + D.armed = D.done = D.jit_used = D.gbuf = 0; + D.cam_addr = 0; +} + +// ---------------------------------------------------------------- the game's FXAA (TOTK_FXAA, live) +// TotK's FXAA is two full-screen passes after the bloom, just before the HUD: one copies the scene target into a +// scratch target, the other draws the anti-aliased result back over the scene (found by diffing frame dumps with the +// game's own switch, ModelSceneExtensionParam EnableFXAA, on and off). With fxaa = 0 the draws of that second pass's +// fragment shader are skipped, so the scene reaches the HUD as it was. Shaders are known by the FNV-1a hash of their +// SPIR-V, as vk_dump.c names them; a translator change gives new hashes and the switch then does nothing. +#define FXAA_FS 0xf450003ebeb3dc52ull + +static uint64_t spirv_hash(const GfxShader *s) { + static struct { const GfxShader *s; uint64_t h; } tab[8192]; + uintptr_t k = ((uintptr_t)s >> 4) * 0x9E3779B97F4A7C15ull; + for (uint32_t i = 0, j = (uint32_t)(k >> 51); i < 8192; i++, j = (j + 1) & 8191) { + if (tab[j].s == s) return tab[j].h; + if (!tab[j].s) { + uint64_t words = 0, h = 0xcbf29ce484222325ull; + const uint8_t *b = (const uint8_t *)gfx_shader_spirv(s, &words); + for (uint64_t n = 0; b && n < words * 4; n++) h = (h ^ b[n]) * 0x100000001b3ull; + tab[j].s = s, tab[j].h = h; + return h; + } + } + return 0; // table full: no skip +} + +int vk_dlaa_skip_draw(const GfxShader *fs) { + static uint64_t frame_read = ~0ull; + static int fxaa = 1; + uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); + if (f != frame_read) frame_read = f, fxaa = cfg_bool("TOTK_FXAA"); // once a frame: the menu switches it live + return !fxaa && fs && spirv_hash(fs) == FXAA_FS; +} diff --git a/runtime/vk_dlaa.h b/runtime/vk_dlaa.h new file mode 100644 index 00000000..4eb7ff3d --- /dev/null +++ b/runtime/vk_dlaa.h @@ -0,0 +1,22 @@ +// DLAA (vk_dlaa.c): NVIDIA DLSS at the scene's own size, behind TOTK_DLAA (totk.ini dlaa = 1). +#pragma once +#include "vk.h" + +int vk_dlaa_wanted(void); // the setting is on (the device may still lack DLSS) +// vk_device.c: NGX's instance and device extensions join the lists (room for max names); vk_dlaa_init after the +// device exists brings NGX up and checks that DLSS is available. +void vk_dlaa_instance_exts(const char **ext, uint32_t *n, uint32_t max); +void vk_dlaa_device_exts(const VkExtensionProperties *have, uint32_t nhave, const char **ext, uint32_t *n, uint32_t max); +void vk_dlaa_init(void); +// vk_exec.c vk_exec_pass_begin, once the pass's targets are resolved and before its barrier: arms the frame on the +// scene's light target or, at the first quarter-width pass after it, runs DLAA on that target. Each present ends the +// frame (vk_dlaa_frame). +typedef struct VkExec VkExec; +void vk_dlaa_pass(VkExec *ex); +void vk_dlaa_frame(void); +// vk_exec_draw.c, each draw before its fixed state is recorded: notes the scene camera block (vk_dlaa_draw), and moves +// the viewport of the scene's draws by the frame's jitter (vk_dlaa_viewport, when the viewport is recorded). +void vk_dlaa_draw(VkExec *ex); +void vk_dlaa_viewport(VkExec *ex, VkViewport *v); +// vk_exec_draw.c, once a draw's fragment shader is known: 1 skips the draw (the game's FXAA while TOTK_FXAA is 0). +int vk_dlaa_skip_draw(const GfxShader *fs); diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index d82c0574..572a9760 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -26,6 +26,7 @@ #include "tex.h" #include "vk.h" #include "vk_exec.h" +#include "vk_dlaa.h" #define WEAK __attribute__((weak)) #define CALL_DEPTH 8 @@ -418,6 +419,7 @@ void vk_exec_barrier(VkExec *ex) { barrier_to(ex, NULL, NULL, 0); } void vk_exec_pass_begin(VkExec *ex) { if (ex->in_pass) return; resolve_rt(ex); + vk_dlaa_pass(ex); // DLAA runs before the bloom chain's first pass (vk_dlaa.c) // Learned targets (VkTexImage.fb_learned) are attached in the feedback layout VkImage want[9]; VkImageAspectFlags wasp[9]; diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 59ff9cbb..0f2fc2ec 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -27,6 +27,7 @@ #include "nvn_hmap.h" #include "vk.h" #include "vk_exec.h" +#include "vk_dlaa.h" #define MAX_BINDINGS 128 #define MAX_DESC 1024 @@ -1850,6 +1851,7 @@ static void record_fixed(VkExec *ex) { if (w < 1) w = 1; if (h < 1) h = 1; VkViewport v = {x, y + h, w, -h, ex->depth_range[0], ex->depth_range[1]}; // the y flip: negative height + vk_dlaa_viewport(ex, &v); // the scene's draws move by the DLAA jitter vkCmdSetViewportWithCount(cb, 1, &v); ex->recorded++; } @@ -2038,6 +2040,7 @@ static int prepare_draw(VkExec *ex, int prim, int32_t count, int restart) { if (fs_wait) fs = shader_for(ex, NVN_STAGE_FS, &has_fs, NULL, 1); } if (!vs || (has_fs && !fs)) return 0; + if (vk_dlaa_skip_draw(fs)) return 0; // the game's FXAA, switched off (vk_dlaa.c) uint32_t fbl = feedback_prepare(ex, fs); VkPipeState s = ex->pipe; s.vs = vs, s.fs = fs; @@ -2108,6 +2111,7 @@ static int prepare_draw(VkExec *ex, int prim, int32_t count, int restart) { ex->recorded++; B.st = s, B.st_valid = 1; } + vk_dlaa_draw(ex); record_fixed(ex); repeat_stats(ex, info); bind_resources(ex, info); diff --git a/totk.ini.example b/totk.ini.example index 30c3a2af..cb9e952f 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -118,6 +118,13 @@ # from 0 (off) to 100. Changes while the game runs take effect at once. # upscaler = fsr # sharpness = 80 +# NVIDIA DLAA: DLSS anti-aliasing of the 3D scene at its own resolution, on NVIDIA RTX GPUs with nvngx_dlss.dll (from +# NVIDIA's DLSS SDK) next to totk.exe; elsewhere the setting does nothing. Changes while the game runs take effect at +# once. +# dlaa = 0 +# The game's own FXAA after the post effects; with DLAA on it is not needed. Changes while the game runs take effect at +# once. +# fxaa = 1 [language] # Language: a Windows locale such as de-DE, or a Switch code (en-US, ja, zh-Hant, ...). Default: the Windows locale. From bc5eb0cb15ceea409d1dc447e73036e73b16f557 Mon Sep 17 00:00:00 2001 From: applezra Date: Fri, 30 Oct 2026 21:10:27 -0700 Subject: [PATCH 06/12] Narrow the sun shadow filter by the shadow map scale The deferred lighting shaders soften the sun shadow with four compares around the receiver, offset by element 56 .xy of their lighting block. The offset is in UV and the game sized it for its own 960x960 cascades, so with shadow_scale above 1 it spans that many more texels and the near cascade shows four separate copies of each edge. Translator patch 0011 multiplies those reads by the support buffer's new shadow_spread field in fragment shaders that sample a 2D array shadow texture, leaving fp_c4 (the cascade matrices) alone. support_fill writes 1 / shadow_scale there, so the spacing stays the game's in texels; at shadow_scale 1 the shaders behave as before. The support buffer grows to 1440 bytes and build_xlate.py expects eleven patches. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_exec_draw.c | 19 ++++- tools/build_xlate.py | 6 +- .../patches/0011-shadow-filter-spread.patch | 82 +++++++++++++++++++ totk.ini.example | 4 +- 4 files changed, 106 insertions(+), 5 deletions(-) create mode 100644 tools/xlate/patches/0011-shadow-filter-spread.patch diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 4f7276d0..4323d05d 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -32,7 +32,7 @@ #define MAX_DESC 1024 #define CHUNK_BYTES (4u << 20) #define ZERO_BYTES 65536u -#define SUPPORT_BYTES 1424u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... +#define SUPPORT_BYTES 1440u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... #define NVN_STAGE_VS 0 #define NVN_STAGE_FS 1 #define NVN_STAGE_CS 5 @@ -1265,6 +1265,22 @@ static const float *pcss_params(void) { return p; } +// The shadow_spread field of the support buffer: the factor translator patch 0011 applies to the lighting shaders' sun +// shadow filter offset (element 56 .xy of their lighting block), 1 / TOTK_SHADOW_SCALE. The game spaces its four +// compares for its own shadow map texels; with maps TOTK_SHADOW_SCALE times larger, the same offset in UV spans that +// many more texels and the near cascade shows four separate copies of each edge. Dividing by the scale keeps the game's +// spacing in texels. The offset is in UV of the shadow map, so the output resolution plays no part. The scale is read +// once, as vk_texture.c shadow_scale reads it: the maps keep the size they were made with. +static const float *shadow_spread_params(void) { + static float p[4] = {0, 0, 0, 0}; + if (p[0] == 0) { + int scale = cfg_int("TOTK_SHADOW_SCALE"); + scale = scale < 1 ? 1 : scale > 4 ? 4 : scale; + p[0] = 1.0f / (float)scale; + } + return p; +} + static void support_fill(uint8_t *b, float w, float h, float point_size) { memset(b, 0, SUPPORT_BYTES); float inv[4] = {w > 0 ? 2.0f / w : 0, h > 0 ? 2.0f / h : 0, 0, 0}, size[4] = {w, h, 0, 0}; @@ -1273,6 +1289,7 @@ static void support_fill(uint8_t *b, float w, float h, float point_size) { const float one = 1.0f; memcpy(b + 1392, &point_size, 4); // point_size (translator patch 0008): vertex shaders that write none output it memcpy(b + 1408, pcss_params(), 16); // pcss (translator patch 0010): soft sun shadows in the cascade compares + memcpy(b + 1424, shadow_spread_params(), 16); // shadow_spread (translator patch 0011): sun shadow filter width for (int i = 0; i < 73; i++) memcpy(b + 192 + 16 * i, &one, 4); // render scale 1: the host renders at guest size } diff --git a/tools/build_xlate.py b/tools/build_xlate.py index ef0d08bc..d721a8ed 100644 --- a/tools/build_xlate.py +++ b/tools/build_xlate.py @@ -1,7 +1,7 @@ """Build the shader translator: build/xlate/totk_xlate.exe (Ryujinx 1.3.2 + patches, NativeAOT, SPIR-V for Vulkan). Copies tools/vendor/ryujinx to build/xlate/ryujinx, applies tools/xlate/patches/*.patch there (tools/vendor stays -byte-identical; 0001-0004 are MNG's, 0005-0010 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build +byte-identical; 0001-0004 are MNG's, 0005-0011 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build tools and vswhere.exe (docs/building.md). Run with .venv. Next to the exe it writes totk_xlate.id: the translator identity, a sha256 over everything the build reads (this script, @@ -96,8 +96,8 @@ def prepare_sources() -> Path: for junk in list(src.glob("src/*/obj")) + list(src.glob("src/*/bin")): shutil.rmtree(junk) patches = sorted((XLATE / "patches").glob("*.patch")) - if len(patches) != 10: - sys.exit(f"expected 10 patches, found {len(patches)}") + if len(patches) != 11: + sys.exit(f"expected 11 patches, found {len(patches)}") for patch in patches: # git apply works outside a repository when given a directory; --check first so a failure names the patch. for extra in (["--check"], []): diff --git a/tools/xlate/patches/0011-shadow-filter-spread.patch b/tools/xlate/patches/0011-shadow-filter-spread.patch new file mode 100644 index 00000000..cd952174 --- /dev/null +++ b/tools/xlate/patches/0011-shadow-filter-spread.patch @@ -0,0 +1,82 @@ +--- a/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs ++++ b/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs +@@ -853,7 +853,51 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv + + private static OperationResult GenerateLoad(CodeGenContext context, AstOperation operation) + { +- return GenerateLoadOrStore(context, operation, isStore: false); ++ OperationResult result = GenerateLoadOrStore(context, operation, isStore: false); ++ if (result.Type == AggregateType.FP32 && IsShadowSpread(context, operation)) ++ { ++ SpvInstruction f32 = context.TypeFP32(), v4 = context.TypeVector(f32, 4); ++ SpvInstruction prmPtr = context.AccessChain(context.TypePointer(StorageClass.Uniform, v4), context.ConstantBuffers[SupportBuffer.Binding], ++ context.Constant(context.TypeS32(), (int)SupportBufferField.ShadowSpread)); ++ SpvInstruction factor = context.CompositeExtract(f32, context.Load(v4, prmPtr), 0); ++ result = new OperationResult(AggregateType.FP32, context.FMul(f32, result.Value, factor)); ++ } ++ ++ return result; ++ } ++ ++ // TOTK: the spread of the sun shadow filter. The deferred lighting shaders take the sun shadow as four compares ++ // at the receiver ± h on the cascade map, h = 0.5 * c[56].xy (UV) of their lighting block (fp_c9, or fp_c5 in ++ // some), the same in every cascade. In the near cascade the map is sharp enough that the four copies of an edge ++ // show apart. In a fragment shader that has a 2D array shadow sampler, reads of element 56 .x and .y from any ++ // constant buffer but fp_c4 (which holds the cascade matrices, row 56 being cascade 3's depth row) are multiplied ++ // by the support buffer's shadow_spread.x (runtime/vk_exec_draw.c support_fill, TOTK_SHADOW_SPREAD; 1 keeps the ++ // game's spread). ++ private static bool IsShadowSpread(CodeGenContext context, AstOperation load) ++ { ++ if (context.Definitions.Stage != ShaderStage.Fragment || ++ load.StorageKind != StorageKind.ConstantBuffer || ++ load.SourcesCount != 4 || ++ load.GetSource(0) is not AstOperand { Type: OperandType.Constant } binding || ++ load.GetSource(1) is not AstOperand { Type: OperandType.Constant, Value: 0 } || ++ load.GetSource(2) is not AstOperand { Type: OperandType.Constant, Value: 56 } || ++ load.GetSource(3) is not AstOperand { Type: OperandType.Constant, Value: < 2 } || ++ !context.Properties.ConstantBuffers.TryGetValue(binding.Value, out BufferDefinition buffer) || ++ buffer.Name == "fp_c4") ++ { ++ return false; ++ } ++ ++ foreach (TextureDefinition texture in context.Properties.Textures.Values) ++ { ++ if ((texture.Type & (SamplerType.Mask | SamplerType.Array | SamplerType.Shadow)) == ++ (SamplerType.Texture2D | SamplerType.Array | SamplerType.Shadow)) ++ { ++ return true; ++ } ++ } ++ ++ return false; + } + + private static OperationResult GenerateLod(CodeGenContext context, AstOperation operation) +--- a/src/Ryujinx.Graphics.Shader/SupportBuffer.cs ++++ b/src/Ryujinx.Graphics.Shader/SupportBuffer.cs +@@ -26,6 +26,7 @@ namespace Ryujinx.Graphics.Shader + TfeVertexCount, + PointSize, + Pcss, ++ ShadowSpread, + } + + public struct SupportBuffer +@@ -84,7 +85,8 @@ namespace Ryujinx.Graphics.Shader + new StructureField(AggregateType.Vector4 | AggregateType.S32, "tfe_offset"), + new StructureField(AggregateType.S32, "tfe_vertex_count"), + new StructureField(AggregateType.FP32, "point_size"), +- new StructureField(AggregateType.Vector4 | AggregateType.FP32, "pcss") ++ new StructureField(AggregateType.Vector4 | AggregateType.FP32, "pcss"), ++ new StructureField(AggregateType.Vector4 | AggregateType.FP32, "shadow_spread") + ]); + } + +@@ -101,5 +103,6 @@ namespace Ryujinx.Graphics.Shader + public Vector4 TfeVertexCount; + public Vector4 PointSize; + public Vector4 Pcss; ++ public Vector4 ShadowSpread; + } + } diff --git a/totk.ini.example b/totk.ini.example index 352f19c3..5722f8d1 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -120,7 +120,9 @@ # game's setting. Read at start. # aniso = 16 # Shadow map resolution: the game's sun cascades are 960x960 (and its static shadow maps 1440 and 720) whatever the game -# resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. Read at start. +# resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. The game's +# shadow edge filter is narrowed by the same factor (translator patch 0011), so close shadow edges don't look doubled. +# Read at start. # shadow_scale = 1 # Sun shadow cascade range in percent of the game's (its cascades end at 20, 40, 80 and 160 m), 50 to 400: higher moves # the steps where shadows turn softer further away, and spreads the shadow map over more ground. Read at start. From 45f24a72e391b8e77e2957355d2a7545fb0a56ba Mon Sep 17 00:00:00 2001 From: applezra Date: Fri, 30 Oct 2026 21:10:35 -0700 Subject: [PATCH 07/12] Let TOTK_DUMP_UBO set how many vec4 of each uniform block are printed The value is now a count (1 still means 16, capped at 4096), so blocks such as the deferred lighting shaders' camera block, whose shadow cascade matrices sit at vec4 42 to 58, can be read from a frame dump. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_dump.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/runtime/vk_dump.c b/runtime/vk_dump.c index 151f39f3..f80dce4b 100644 --- a/runtime/vk_dump.c +++ b/runtime/vk_dump.c @@ -18,8 +18,8 @@ // as x/2+1/2, UNORM and sRGB bytes written as stored. Caps: MAX_PASSES passes copied, PNG_CAP bytes of PNGs. // TOTK_DUMP_TEX=|x[,...]: those texture slots, or 2D textures of that size, are copied where first sampled, // whatever their format. -// TOTK_DUMP_UBO=1: each listed pipeline also prints the first 16 vec4 of its user uniform blocks (c3 and up), read from -// guest memory when the entry is listed. A block the submission rewrites with UpdateUniformBuffer shows its value from +// TOTK_DUMP_UBO=: each listed pipeline also prints the first n vec4 of its user uniform blocks (c3 and up; 1 means 16, +// the cap is 4096), read from guest memory when the entry is listed. A block the submission rewrites with UpdateUniformBuffer shows its value from // before the submission (vk_exec_draw.c upd_note). // TOTK_DUMP_SKIP_RUNS=1: a render pass with the same targets as the render pass before it is logged but not copied // (the terrain decals draw one pass each into the G-buffer and would use up both caps). @@ -48,7 +48,7 @@ static uint64_t dump_frame, log_from; // log_from: TOTK_DUMP_LOG, first frame static char dir[400]; static FILE *passes_f, *images_f; static int seq, finished, copied; // copied: passes and dispatches of the dump frame whose images were copied -static int skip_runs, dump_ubo; // TOTK_DUMP_SKIP_RUNS, TOTK_DUMP_UBO +static int skip_runs, dump_ubo; // TOTK_DUMP_SKIP_RUNS, TOTK_DUMP_UBO (vec4 per block, 0 for none) static uint32_t want_tex[16][2]; // TOTK_DUMP_TEX: slot id and 0, or width and height static int nwant_tex; static uint64_t last_targets; // targets_sig of the last render pass; 0 after a dispatch @@ -576,7 +576,7 @@ static void describe_bindings(Str *b, const VkExec *ex, const VkPipeInfo *info) if (u->addr && vk_mem_resolve(u->addr, 1, &ms)) { uint64_t n = u->size && u->size < ms.avail ? u->size : ms.avail; const float *f = (const float *)(uintptr_t)u->addr; - for (uint64_t k = 0; k < 16 && (k + 1) * 16 <= n; k++) + for (uint64_t k = 0; k < (uint64_t)dump_ubo && (k + 1) * 16 <= n; k++) sp(b, "%s[%llu] %g %g %g %g", k % 4 ? " " : "\n ", (unsigned long long)k, f[4 * k], f[4 * k + 1], f[4 * k + 2], f[4 * k + 3]); } else { @@ -879,7 +879,10 @@ void vk_dump_init(void) { const char *sr = cfg_get("TOTK_DUMP_SKIP_RUNS"); skip_runs = sr && *sr && *sr != '0'; const char *du = cfg_get("TOTK_DUMP_UBO"); - dump_ubo = du && *du && *du != '0'; + dump_ubo = du && *du ? atoi(du) : 0; + if (dump_ubo == 1) dump_ubo = 16; + if (dump_ubo > 4096) dump_ubo = 4096; + if (dump_ubo < 0) dump_ubo = 0; const char *wt = cfg_get("TOTK_DUMP_TEX"); for (char *q = (char *)wt; q && *q && nwant_tex < 16; q += *q == ',') { uint32_t *w = want_tex[nwant_tex++]; From 5dcac19982a8ee4a69ab6cc16c26f0f38659f254 Mon Sep 17 00:00:00 2001 From: applezra Date: Fri, 30 Oct 2026 22:56:47 -0700 Subject: [PATCH 08/12] Force anisotropic filtering only on samplers that tile The aniso setting raised every filtered, mipmapped colour sampler to the chosen level. Some of those read screen-sized buffers, among them the ones the inventory's character preview is drawn from. Their coordinates stretch steeply at the model's edges, so the anisotropic taps reach across the edge and leave a speckled fringe around the character. The level is now raised only for samplers that repeat on U and V, which the surface textures it is meant for do; clamped samplers keep the game's level. Distant ground stays as sharp as before. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_texture.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index ce7619f7..14d11067 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -1505,9 +1505,14 @@ static VkSampler make_sampler(VkCtx *c, const samp_par *d) { float lim = c->props.limits.maxSamplerLodBias; si.mipLodBias = fmaxf(-lim, fminf(lim, d->lod_bias)); float aniso = d->aniso; - // TOTK_ANISO raises the level for filtered, mipmapped colour samplers only: depth-compare (shadow) samplers and - // nearest or unmipmapped ones (data maps, LUTs) keep what the game set. - if (aniso_force > 1 && !d->cmp_mode && si.magFilter == VK_FILTER_LINEAR && si.minFilter == VK_FILTER_LINEAR && + // TOTK_ANISO raises the level for filtered, mipmapped colour samplers that repeat on U and V only: the surface + // textures it is for tile. Depth-compare (shadow) samplers, nearest or unmipmapped ones (data maps, LUTs) and clamped + // ones keep what the game set. Clamped samplers read screen-sized buffers, whose coordinates can stretch steeply at + // an object's edge; there anisotropic taps reach across the edge and leave a speckled fringe (the inventory's + // character preview). + int tiled = (modes[0] == VK_SAMPLER_ADDRESS_MODE_REPEAT || modes[0] == VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT) && + (modes[1] == VK_SAMPLER_ADDRESS_MODE_REPEAT || modes[1] == VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT); + if (aniso_force > 1 && tiled && !d->cmp_mode && si.magFilter == VK_FILTER_LINEAR && si.minFilter == VK_FILTER_LINEAR && (mf == NVN_MIN_FILTER_LINEAR_MIPMAP_NEAREST || mf == NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR) && aniso < aniso_force) aniso = aniso_force; if (aniso > 1) { From 2e8b4ff1b1f3becd4ddc505b1a0ffba895f45fdb Mon Sep 17 00:00:00 2001 From: DizzyMan1337 Date: Sat, 31 Oct 2026 14:39:20 +0800 Subject: [PATCH 09/12] DLSS upscaling: quality, balanced and performance modes TOTK_DLSS (dlaa|quality|balanced|performance, read at start) sets the scene to 67, 58 or 50 % of the output. DLSS then runs at the begin of the game's scaling pass (the FXAA shader drawing the light target into the output-sized target, before the HUD) and its result replaces that draw; the HUD is drawn afterwards and never jittered or passed through DLSS. The jitter now ends where the scene ends (the bloom), separately from where DLSS runs. Scaled modes add a mip bias of log2(scale) to repeating, mipmapped material samplers. With a scene smaller than the output, fxaa = 0 no longer skips the game's scaling draw (it left the 3D picture out). Co-Authored-By: Claude Opus 5.5 --- runtime/cfg.c | 6 +-- runtime/host.h | 1 + runtime/resolution.c | 19 ++++++- runtime/ui/menu.cpp | 3 ++ runtime/ui_text.c | 24 ++++++--- runtime/ui_text.h | 3 +- runtime/vk_dlaa.c | 114 ++++++++++++++++++++++++++++------------- runtime/vk_dlaa.h | 5 +- runtime/vk_exec_draw.c | 2 +- runtime/vk_texture.c | 10 +++- totk.ini.example | 10 ++-- 11 files changed, 141 insertions(+), 56 deletions(-) diff --git a/runtime/cfg.c b/runtime/cfg.c index 46af3931..d495c1fb 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -36,7 +36,7 @@ static const char *const known[] = { "BIND_PLUS", "BIND_R", "BIND_RCLICK", "BIND_RIGHT", "BIND_RSTICK_DOWN", "BIND_RSTICK_LEFT", "BIND_RSTICK_RIGHT", "BIND_RSTICK_UP", "BIND_SKIP", "BIND_STATS", "BIND_UP", "BIND_X", "BIND_Y", "BIND_ZL", "BIND_ZR", "BLOCK_VIEWS_3D", "CLOTH_REALTIME", "CORE_DIAG", "CRIT", "CRIT_OUT", "DESC_TEMPLATE", "DLAA", - "DLAA_JITTER", "DLAA_MV", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", + "DLAA_JITTER", "DLAA_MV", "DLSS", "DUMP", "DUMP_BUF", "DUMP_DIR", "DUMP_LOG", "EXEFS", "FEEDBACK", "FIX_C0", "FIX_ZERO", "FLIGHT", "FLIGHT_AT", "FLIGHT_DIR", "FLIGHT_FRAMES", "FLIGHT_SPIKE_MS", "FLIGHT_THUMBS", "FPS60", "FPS_LIMIT", "FREEZE_IDLE", "FREE_CORES", "FULLSCREEN", "FXAA", "GPL", "GPL_DRAW_BUILD", "GPU", "GPU_INDEX", "GPU_NAME", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", @@ -60,7 +60,7 @@ static const struct { const char *key, *section; } sections[] = { {"REALTIME", "frame rate"}, {"CLOTH_REALTIME", "frame rate"}, {"HIGHFPS_FIX", "frame rate"}, {"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"}, {"GPU_INDEX", "display"}, {"OUTPUT_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"}, - {"SHARPNESS", "display"}, {"ASPECT", "display"}, {"DLAA", "display"}, {"FXAA", "display"}, + {"SHARPNESS", "display"}, {"ASPECT", "display"}, {"DLAA", "display"}, {"DLSS", "display"}, {"FXAA", "display"}, {"MENU_LANG", "language"}, {"LANG", "language"}, {"OPERATION_MODE", "language"}, {"VOLUME", "audio"}, {"MOTION", "input"}, {"RUMBLE_STRENGTH", "input"}, {"RUMBLE_CURVE", "input"}, {"RUMBLE_TRIGGERS", "input"}, @@ -95,7 +95,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", LIVE}, {"FXAA", "1", "0|1", LIVE}, + {"DLAA", "0", "0|1", LIVE}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance", RESTART}, {"FXAA", "1", "0|1", LIVE}, {"ASPECT", "fit", "fit|stretch", LIVE}, // Game {"FPS_LIMIT", "60", "30|60|90|120|144|display", LIVE}, {"FPS60", "1", "0|1", LIVE}, diff --git a/runtime/host.h b/runtime/host.h index 7e4a1939..5f427bde 100644 --- a/runtime/host.h +++ b/runtime/host.h @@ -240,6 +240,7 @@ int res_heapdef_build(const void *in, size_t n, void **out, size_t *out_n); // // the grown heaps, malloc'd; 0 = cannot (logged) 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) 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/resolution.c b/runtime/resolution.c index 514b3e6e..ca2e9aee 100644 --- a/runtime/resolution.c +++ b/runtime/resolution.c @@ -49,6 +49,7 @@ static struct { int scene_set; // the scene differs from the game's 5/6 of the output int heapdef_ok; // romfs.c serves the grown HeapDef int on; // res_init switched the patch sets on + double dlss_k; // TOTK_DLSS quality/balanced/performance: the scene's share of the output, else 0 } R; static void decide(void) { @@ -67,7 +68,16 @@ static void decide(void) { } const char *s = cfg_value("TOTK_RENDER_SCALE"); double k = 5.0 / 6.0; - if (strcmp(s, "game")) { + const char *m = cfg_value("TOTK_DLSS"); // a DLSS mode other than dlaa sets the scene size + static const struct { const char *name; double k; } dlss[] = { + {"quality", 2.0 / 3.0}, {"balanced", 0.58}, {"performance", 0.5}}; + for (int i = 0; i < 3; i++) + if (!strcmp(m, dlss[i].name)) R.dlss_k = dlss[i].k; + 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")) { char *end; double pct = strtod(s, &end); if (end != s && !*end && pct >= 25 && pct <= 400) { @@ -241,6 +251,13 @@ void res_init(void) { scene_on ? "" : " (the game's own 5/6 of the output)", (unsigned long long)res_heap_extra_kib()); } +// DLSS upscaling: textures are sampled for the output's resolution, not the scene's (NVIDIA's DLSS guide: a mip bias +// of log2(render / output)), so their detail survives the scaling. 0 without a DLSS mode. +float res_dlss_lod_bias(void) { + decide(); + return R.dlss_k ? (float)log2(R.dlss_k) : 0.0f; +} + // 16:9 within 1% (1366x768 counts): the shape the game's own layouts and camera are made for. int res_is_16x9(unsigned w, unsigned h) { double rel = ((double)w / h) / ((double)BASE_W / BASE_H); diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index 7b7a83e2..ba8f8b1d 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -542,6 +542,9 @@ static void tab_screen(float scale) { static const UiTextId aspect[] = {UI_MENU_ASPECT_FIT, UI_MENU_ASPECT_STRETCH}; opt_choice("TOTK_ASPECT", UI_MENU_ASPECT, aspect, 2, UI_MENU_ASPECT_DESC); opt_toggle("TOTK_DLAA", UI_MENU_DLAA, UI_MENU_DLAA_DESC); + static const UiTextId dlss[] = {UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, UI_MENU_DLSS_BALANCED, + UI_MENU_DLSS_PERFORMANCE}; + opt_choice("TOTK_DLSS", UI_MENU_DLSS, dlss, 4, UI_MENU_DLSS_DESC); opt_toggle("TOTK_FXAA", UI_MENU_FXAA, UI_MENU_FXAA_DESC); opt_end(); } diff --git a/runtime/ui_text.c b/runtime/ui_text.c index 87daf846..11358991 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -68,9 +68,15 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_ASPECT_FIT] = "Black bars", [UI_MENU_ASPECT_STRETCH] = "Stretch", [UI_MENU_SHARPNESS] = "FSR sharpness", [UI_MENU_SHARPNESS_DESC] = "Sharpening after FSR scaling; 0 turns it off.", - [UI_MENU_DLAA] = "NVIDIA DLAA", - [UI_MENU_DLAA_DESC] = "DLSS anti-aliasing of the 3D scene at its own resolution (NVIDIA RTX GPUs; nvngx_dlss.dll next to " - "totk.exe). Smoother edges and less shimmer for about 3 ms a frame.", + [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", + [UI_MENU_DLAA_DESC] = "NVIDIA DLSS for the 3D scene (NVIDIA RTX GPUs; nvngx_dlss.dll next to totk.exe): smoother edges " + "and less shimmer. The HUD is not touched. The mode below sets the resolution it works from.", + [UI_MENU_DLSS] = "DLSS mode", + [UI_MENU_DLSS_DESC] = "DLAA draws the 3D scene at full resolution. Quality, Balanced and Performance draw it at 67, 58 " + "and 50 % and let DLSS scale it up, for more frames per second; they replace the 3D render " + "scale. Takes effect after a restart.", + [UI_MENU_DLSS_DLAA] = "DLAA (native)", [UI_MENU_DLSS_QUALITY] = "Quality", [UI_MENU_DLSS_BALANCED] = "Balanced", + [UI_MENU_DLSS_PERFORMANCE] = "Performance", [UI_MENU_FXAA] = "Game anti-aliasing (FXAA)", [UI_MENU_FXAA_DESC] = "The game's own FXAA edge smoothing. It blurs fine detail a little; with DLAA on it is not needed.", @@ -308,9 +314,15 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_ASPECT_FIT] = "Чёрные полосы", [UI_MENU_ASPECT_STRETCH] = "Растянуть", [UI_MENU_SHARPNESS] = "Резкость FSR", [UI_MENU_SHARPNESS_DESC] = "Повышение резкости после масштабирования FSR; 0 выключает его.", - [UI_MENU_DLAA] = "NVIDIA DLAA", - [UI_MENU_DLAA_DESC] = "Сглаживание 3D-сцены через DLSS в её собственном разрешении (видеокарты NVIDIA RTX; nvngx_dlss.dll " - "рядом с totk.exe). Ровнее края и меньше мерцания, около 3 мс на кадр.", + [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", + [UI_MENU_DLAA_DESC] = "NVIDIA DLSS для 3D-сцены (видеокарты NVIDIA RTX; nvngx_dlss.dll рядом с totk.exe): ровнее края и " + "меньше мерцания. Интерфейс не затрагивается. Режим ниже задаёт разрешение, с которым он работает.", + [UI_MENU_DLSS] = "Режим DLSS", + [UI_MENU_DLSS_DESC] = "DLAA рисует 3D-сцену в полном разрешении. «Качество», «Баланс» и «Производительность» рисуют её " + "в 67, 58 и 50 % и масштабируют через DLSS ради большего числа кадров; они заменяют масштаб " + "3D-отрисовки. Действует после перезапуска.", + [UI_MENU_DLSS_DLAA] = "DLAA (родное)", [UI_MENU_DLSS_QUALITY] = "Качество", [UI_MENU_DLSS_BALANCED] = "Баланс", + [UI_MENU_DLSS_PERFORMANCE] = "Производительность", [UI_MENU_FXAA] = "Сглаживание игры (FXAA)", [UI_MENU_FXAA_DESC] = "Собственное сглаживание FXAA. Слегка размывает мелкие детали; с DLAA оно не нужно.", diff --git a/runtime/ui_text.h b/runtime/ui_text.h index e1e55dba..66b45db6 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -37,7 +37,8 @@ typedef enum { UI_MENU_UPSCALER, UI_MENU_UPSCALER_DESC, UI_MENU_UPSCALER_FSR, UI_MENU_UPSCALER_BILINEAR, UI_MENU_ASPECT, UI_MENU_ASPECT_DESC, UI_MENU_ASPECT_FIT, UI_MENU_ASPECT_STRETCH, UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, - UI_MENU_DLAA, UI_MENU_DLAA_DESC, UI_MENU_FXAA, UI_MENU_FXAA_DESC, + UI_MENU_DLAA, UI_MENU_DLAA_DESC, UI_MENU_DLSS, UI_MENU_DLSS_DESC, UI_MENU_DLSS_DLAA, UI_MENU_DLSS_QUALITY, + UI_MENU_DLSS_BALANCED, UI_MENU_DLSS_PERFORMANCE, UI_MENU_FXAA, UI_MENU_FXAA_DESC, // Game UI_MENU_FPS_LIMIT, UI_MENU_FPS_LIMIT_DESC, UI_MENU_FPS_30, UI_MENU_FPS_60, UI_MENU_FPS_90, UI_MENU_FPS_120, diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 9de36e8a..41de947d 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -28,7 +28,7 @@ typedef int NgxResult; // NVSDK_NGX_Result: 1 success, 0xBAD00000 | n failures #define NGX_OK(r) (((unsigned)(r) & 0xFFF00000u) != 0xBAD00000u) #define NGX_VERSION_API 0x15 #define NGX_FEATURE_SUPERSAMPLING 1 -#define NGX_PERFQ_DLAA 5 +#define NGX_PERFQ_DLAA 5 // NVSDK_NGX_PerfQuality_Value: 0 performance, 1 balanced, 2 quality, 3 ultra performance typedef struct NgxParam NgxParam; typedef struct NgxHandle NgxHandle; typedef struct { void *slot[17]; } NgxParamVtbl; @@ -203,13 +203,21 @@ void vk_dlaa_init(void) { // quarter of the scene starts the bloom chain, which reads it. After the bloom come the tonemap and post passes, then // the HUD is drawn into the same target and a last pass copies it to the 8-bit output. // So: after the G-buffer, a pass at the scene size with exactly one colour target (R11G11B10F or RGBA16F) and the D32F -// depth arms the frame with that pair; the next pass at most a quarter as wide runs DLAA on the armed target first. -// Bloom, tonemap, post and HUD then all work on the anti-aliased picture. +// depth arms the frame with that pair; the next pass at most a quarter as wide ends the scene (no jitter after it) and, +// when the scene is as wide as the output, runs DLAA on the armed target first. Bloom, tonemap, post and HUD then all +// work on the anti-aliased picture. +// Upscaling (a scene smaller than the output: TOTK_DLSS quality/balanced/performance, or the game's own 5/6): measured +// at a 960x536 scene, 1920x1080 output, the bloom and its composite write back into the light target at the scene size, +// then one full-screen draw (the FXAA shader below, which also scales) reads it into an output-sized R11G11B10F target +// with no depth, and the HUD is drawn over that target at the output size. DLSS runs at the begin of that pass: it +// reads the light target and its result is blitted into the pass's target, whose scaling draw is then skipped. The +// HUD, drawn afterwards into the same target, is never jittered nor passed through DLSS. static struct { VkExecTarget color, depth; // the armed pair, valid in the frame it was armed int armed, done, gbuf; // this frame: armed on the light target, DLAA ran, the G-buffer was drawn + int ended, up; // this frame: the scene is drawn (jitter over), DLSS wrote the scaled output struct Size { // a DLSS feature and its work images per scene size (dynamic resolution flips it) - uint32_t w, h; + uint32_t w, h, ow, oh; // render size, output size VkImage out, mv; VmaAllocation out_mem, mv_mem; VkImageView out_view, mv_view; @@ -275,13 +283,14 @@ static void free_size(struct Size *e) { memset(e, 0, sizeof *e); } -// The entry for a scene size: its output (RGBA16F, written by DLSS, then blitted back into the scene target) and -// motion vectors (RG16F, render pixels), both kept in GENERAL like every image of the back end. TotK's dynamic -// resolution switches between a few sizes; each keeps its feature, the least recently used goes for a new one. -static struct Size *size_for(VkCommandBuffer cb, uint32_t w, uint32_t h) { +// The entry for a scene and output size: its output (RGBA16F at the output size, written by DLSS, then blitted into +// the target) and motion vectors (RG16F at the scene size, render pixels), both kept in GENERAL like every image of the +// back end. TotK's dynamic resolution switches between a few sizes; each keeps its feature, the least recently used +// 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++) { - if (D.sizes[i].w == w && D.sizes[i].h == h) return &D.sizes[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]; } @@ -291,7 +300,7 @@ static struct Size *size_for(VkCommandBuffer cb, uint32_t w, uint32_t h) { } VkImageUsageFlags u = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; - if (!image2d(w, h, VK_FORMAT_R16G16B16A16_SFLOAT, u, &e->out, &e->out_mem, &e->out_view) || + if (!image2d(ow, oh, VK_FORMAT_R16G16B16A16_SFLOAT, u, &e->out, &e->out_mem, &e->out_view) || !image2d(w, h, VK_FORMAT_R16G16_SFLOAT, u, &e->mv, &e->mv_mem, &e->mv_view)) return NULL; VkImageMemoryBarrier2 ib[2]; @@ -308,7 +317,7 @@ static struct Size *size_for(VkCommandBuffer cb, uint32_t w, uint32_t h) { VkDependencyInfo di = {.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .imageMemoryBarrierCount = 2, .pImageMemoryBarriers = ib}; vkCmdPipelineBarrier2(cb, &di); - e->w = w, e->h = h; + e->w = w, e->h = h, e->ow = ow, e->oh = oh; return e; } @@ -435,13 +444,13 @@ static float halton(uint32_t i, uint32_t b) { } void vk_dlaa_viewport(VkExec *ex, VkViewport *v) { - if (!D.jit_ok || D.done || !ex->depth.image || ex->depth.image != D.jdepth) return; + if (!D.jit_ok || D.ended || !ex->depth.image || ex->depth.image != D.jdepth) return; v->x += D.jx, v->y += D.jy; D.ux = D.jx, D.uy = D.jy, D.jit_used = 1; } void vk_dlaa_draw(VkExec *ex) { - if (!dl_active() || D.done) return; + if (!dl_active() || D.ended) return; const p_bind_buf *b = &ex->ubo[0][1]; // constant bank c4: the replay keeps user banks from c3 on const VkExecTarget *z = &ex->depth; if (b->size == 0x940 && b->addr && z->image && z->width >= 640 && z->format == VK_FORMAT_D32_SFLOAT && @@ -460,12 +469,21 @@ static void next_jitter(void) { D.jit_ok = !D.hold && !nj; } -static void evaluate(VkExec *ex) { +// The quality setting DLSS is created with, from the scene's share of the output width. +static int perf_quality(uint32_t w, uint32_t ow) { + if (w >= ow) return NGX_PERFQ_DLAA; + double k = (double)w / ow; + return k >= 0.66 ? 2 : k >= 0.57 ? 1 : k >= 0.49 ? 0 : 3; +} + +// dst: the target DLSS's picture goes to, NULL for the light target itself (DLAA in place). +static void evaluate(VkExec *ex, const VkExecTarget *dst) { const VkExecTarget *t = &D.color, *z = &D.depth; - uint32_t w = t->width, h = t->height; + if (!dst) dst = t; + uint32_t w = t->width, h = t->height, ow = dst->width, oh = dst->height; VkCommandBuffer cb = ex->cb; vk_exec_barrier(ex); // what drew the scene is done (no pass is open here) - struct Size *e = size_for(cb, w, h); + struct Size *e = size_for(cb, w, h, ow, oh); if (!e) return dl_fail("work image creation", 0); if (e != D.last) D.reset = 1, D.why[0]++; // another size's history is from another moment if (!D.params && !NGX_OK(N.alloc_params(&D.params))) return dl_fail("parameter allocation", 0); @@ -488,23 +506,23 @@ static void evaluate(VkExec *ex) { p_setu(p, "VisibilityNodeMask", 1); p_setu(p, "Width", w); p_setu(p, "Height", h); - p_setu(p, "OutWidth", w); - p_setu(p, "OutHeight", h); - p_seti(p, "PerfQualityValue", NGX_PERFQ_DLAA); + p_setu(p, "OutWidth", ow); + p_setu(p, "OutHeight", oh); + p_seti(p, "PerfQualityValue", perf_quality(w, ow)); // IsHDR | MVLowRes | AutoExposure: linear scene light, motion vectors at the render size, no exposure texture p_seti(p, "DLSS.Feature.Create.Flags", (1 << 0) | (1 << 1) | (1 << 6)); p_seti(p, "DLSS.Enable.Output.Subrects", 0); NgxResult r = N.create(cb, NGX_FEATURE_SUPERSAMPLING, p, &e->feat); if (!NGX_OK(r) || !e->feat) return dl_fail("DLSS feature creation", r); D.reset = 1; - rt_log("dlaa: DLSS feature created at %ux%u (scene format %d, depth format %d)", w, h, (int)t->format, - (int)z->format); + rt_log("dlaa: DLSS feature created at %ux%u -> %ux%u, quality value %d (scene format %d, depth format %d)", w, + h, ow, oh, perf_quality(w, ow), (int)t->format, (int)z->format); } if (D.last_color != t->image) D.reset = 1, D.why[2]++, D.last_color = t->image; VkImageView cv = vk_exec_target_view(t->img, t->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, t->level, t->base_layer, 1, 0); NgxResourceVK rc = res_image(cv, t->image, t->format, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0); - NgxResourceVK ro = res_image(e->out_view, e->out, VK_FORMAT_R16G16B16A16_SFLOAT, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 1); + NgxResourceVK ro = res_image(e->out_view, e->out, VK_FORMAT_R16G16B16A16_SFLOAT, ow, oh, VK_IMAGE_ASPECT_COLOR_BIT, 1); NgxResourceVK rz = res_image(zv, z->image, z->format, w, h, VK_IMAGE_ASPECT_DEPTH_BIT, 0); NgxResourceVK rm = res_image(e->mv_view, e->mv, VK_FORMAT_R16G16_SFLOAT, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0); p_setp(p, "Color", &rc); @@ -527,21 +545,22 @@ static void evaluate(VkExec *ex) { D.reset = 0; D.last = e, e->used = D.evals + 1; full_barrier(cb); - // the result back into the scene target, which the bloom, the post passes and the HUD read and draw over + // the result into the scene target (DLAA: the bloom, the post passes and the HUD read it and draw over it) or into + // the scaling pass's target (the HUD draws over it) VkImageBlit b = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, - .srcOffsets = {{0, 0, 0}, {(int32_t)w, (int32_t)h, 1}}, - .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, t->level, t->base_layer, 1}, - .dstOffsets = {{0, 0, 0}, {(int32_t)w, (int32_t)h, 1}}}; - vkCmdBlitImage(cb, e->out, VK_IMAGE_LAYOUT_GENERAL, t->image, VK_IMAGE_LAYOUT_GENERAL, 1, &b, VK_FILTER_NEAREST); + .srcOffsets = {{0, 0, 0}, {(int32_t)ow, (int32_t)oh, 1}}, + .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, dst->level, dst->base_layer, 1}, + .dstOffsets = {{0, 0, 0}, {(int32_t)ow, (int32_t)oh, 1}}}; + vkCmdBlitImage(cb, e->out, VK_IMAGE_LAYOUT_GENERAL, dst->image, VK_IMAGE_LAYOUT_GENERAL, 1, &b, VK_FILTER_NEAREST); full_barrier(cb); ex->recorded += 4; vk_exec_draw_new_cb(); // NGX bound pipelines and descriptor sets of its own: the next draw binds everything again D.jdepth = z->image; next_jitter(); if (++D.evals == 1 || D.evals % 3600 == 0) - rt_log("dlaa: %llu frames anti-aliased (scene %ux%u; %llu frames without the DLAA point, %llu with camera " + rt_log("dlaa: %llu frames anti-aliased (scene %ux%u, output %ux%u; %llu frames without the DLAA point, %llu with camera " "motion, %llu without a camera, %llu jitter holds; resets: %llu size, %llu camera, %llu target)", - (unsigned long long)D.evals, w, h, (unsigned long long)D.frames_missed, + (unsigned long long)D.evals, w, h, ow, oh, (unsigned long long)D.frames_missed, (unsigned long long)D.mv_frames, (unsigned long long)D.mv_none, (unsigned long long)D.holds, (unsigned long long)D.why[0], (unsigned long long)D.why[1], (unsigned long long)D.why[2]); } @@ -568,9 +587,20 @@ void vk_dlaa_pass(VkExec *ex) { return; } if (!D.armed) return; - if (!ex->pass_w || ex->pass_w * 4 > D.color.width) return; - D.done = 1; - evaluate(ex); + if (!D.ended) { + if (!ex->pass_w || ex->pass_w * 4 > D.color.width) return; + D.ended = 1; + unsigned o[2], s[2]; + res_sizes(o, s); + if (D.color.width >= o[0]) D.done = 1, evaluate(ex, NULL); // DLAA in place; else wait for the scaling pass + return; + } + // the game's scaling pass: one colour target wider than the scene, no depth + if (ex->pass_ncolor == 1 && c->image && !z->image && scene_color(c->format) && c->width > D.color.width && + c->samples <= 1 && !c->is3d) { + D.done = D.up = 1; + evaluate(ex, c); + } } void vk_dlaa_frame(void) { @@ -579,7 +609,8 @@ void vk_dlaa_frame(void) { rt_log("dlaa: %s", on ? "on" : "off"); D.on = on; // either way the next DLAA frame starts a new history from an unjittered frame - D.reset = 1, D.cam_prev_ok = 0, D.jit_ok = D.jit_used = D.armed = D.done = D.gbuf = 0, D.hold = 0; + D.reset = 1, D.cam_prev_ok = 0, D.jit_ok = D.jit_used = D.armed = D.done = D.gbuf = D.ended = D.up = 0; + D.hold = 0; return; } if (!dl_active()) return; @@ -587,7 +618,7 @@ void vk_dlaa_frame(void) { if (D.jit_used && !D.done) D.hold = 60, D.holds++; // jittered but not resolved: that frame shook else if (D.hold) D.hold--; if (!D.done) D.jit_ok = 0; - D.armed = D.done = D.jit_used = D.gbuf = 0; + D.armed = D.done = D.jit_used = D.gbuf = D.ended = D.up = 0; D.cam_addr = 0; } @@ -597,7 +628,12 @@ void vk_dlaa_frame(void) { // game's own switch, ModelSceneExtensionParam EnableFXAA, on and off). With fxaa = 0 the draws of that second pass's // fragment shader are skipped, so the scene reaches the HUD as it was. Shaders are known by the FNV-1a hash of their // SPIR-V, as vk_dump.c names them; a translator change gives new hashes and the switch then does nothing. -#define FXAA_FS 0xf450003ebeb3dc52ull +// With a scene smaller than the output (the game's own 5/6 render scale, or a DLSS mode) the same shader draws the +// scaled picture into the output-sized target, in a pass without the depth attachment the in-place FXAA has: there it +// is always drawn, whatever fxaa says (skipping it would leave the 3D picture out), unless DLSS already wrote that +// target this frame. +// The stock translator's hash, and the one with tools/xlate patch 0010 (PCSS, PR #89) applied. +static const uint64_t FXAA_FS[] = {0xf450003ebeb3dc52ull, 0x0a12f4bc2a9a4fbeull}; static uint64_t spirv_hash(const GfxShader *s) { static struct { const GfxShader *s; uint64_t h; } tab[8192]; @@ -615,10 +651,14 @@ static uint64_t spirv_hash(const GfxShader *s) { return 0; // table full: no skip } -int vk_dlaa_skip_draw(const GfxShader *fs) { +int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { static uint64_t frame_read = ~0ull; static int fxaa = 1; uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); if (f != frame_read) frame_read = f, fxaa = cfg_bool("TOTK_FXAA"); // once a frame: the menu switches it live - return !fxaa && fs && spirv_hash(fs) == FXAA_FS; + if (!fs) return 0; + uint64_t h = spirv_hash(fs); + if (h != FXAA_FS[0] && h != FXAA_FS[1]) return 0; + if (!ex->depth.image) return D.up; // the scaling pass + return !fxaa; } diff --git a/runtime/vk_dlaa.h b/runtime/vk_dlaa.h index 4eb7ff3d..dc291b10 100644 --- a/runtime/vk_dlaa.h +++ b/runtime/vk_dlaa.h @@ -18,5 +18,6 @@ void vk_dlaa_frame(void); // the viewport of the scene's draws by the frame's jitter (vk_dlaa_viewport, when the viewport is recorded). void vk_dlaa_draw(VkExec *ex); void vk_dlaa_viewport(VkExec *ex, VkViewport *v); -// vk_exec_draw.c, once a draw's fragment shader is known: 1 skips the draw (the game's FXAA while TOTK_FXAA is 0). -int vk_dlaa_skip_draw(const GfxShader *fs); +// vk_exec_draw.c, once a draw's fragment shader is known: 1 skips the draw (the game's FXAA while TOTK_FXAA is 0, its +// scaling draw when DLSS wrote the scaled picture). +int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs); diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index db9f2ef2..bc4aa989 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -2041,7 +2041,7 @@ static int prepare_draw(VkExec *ex, int prim, int32_t count, int restart) { if (fs_wait) fs = shader_for(ex, NVN_STAGE_FS, &has_fs, NULL, 1); } if (!vs || (has_fs && !fs)) return 0; - if (vk_dlaa_skip_draw(fs)) return 0; // the game's FXAA, switched off (vk_dlaa.c) + if (vk_dlaa_skip_draw(ex, fs)) return 0; // the game's FXAA off, or its scaling replaced by DLSS (vk_dlaa.c) uint32_t fbl = feedback_prepare(ex, fs); VkPipeState s = ex->pipe; s.vs = vs, s.fs = fs; diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index 99db3f5c..bf5ab49c 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -1565,8 +1565,14 @@ 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; - si.mipLodBias = fmaxf(-lim, fminf(lim, d->lod_bias)); + 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. + if (!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)); if (d->aniso > 1) { si.anisotropyEnable = VK_TRUE; si.maxAnisotropy = fminf(d->aniso, c->props.limits.maxSamplerAnisotropy); diff --git a/totk.ini.example b/totk.ini.example index 6aa8801c..b9dcc044 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -127,10 +127,14 @@ # window is no longer stretched as it used to be; stretch fills the window. Changes while the game runs take effect at # once. # aspect = fit -# NVIDIA DLAA: DLSS anti-aliasing of the 3D scene at its own resolution, on NVIDIA RTX GPUs with nvngx_dlss.dll (from -# NVIDIA's DLSS SDK) next to totk.exe; elsewhere the setting does nothing. Changes while the game runs take effect at -# once. +# NVIDIA DLSS / DLAA for the 3D scene, on NVIDIA RTX GPUs with nvngx_dlss.dll (from NVIDIA's DLSS SDK) next to +# totk.exe; elsewhere the setting does nothing. The HUD is drawn after it and is not touched. Changes while the game +# runs take effect at once. # dlaa = 0 +# What DLSS works from: dlaa (the 3D scene at full size), quality, balanced or performance (the scene at 67, 58 or +# 50 % of the output, scaled up by DLSS; these replace render_scale and sharpen texture filtering to match). With dlaa +# = 0 the game's own scaling is used at that size. Read at start. +# dlss = dlaa # The game's own FXAA after the post effects; with DLAA on it is not needed. Changes while the game runs take effect at # once. # fxaa = 1 From 54337ce6a4a794fb54639a192cd429fb0b810601 Mon Sep 17 00:00:00 2001 From: DizzyMan1337 Date: Sun, 1 Nov 2026 00:16:47 +0800 Subject: [PATCH 10/12] Let DLAA copy the camera block out of the uniform snapshot buffer mv_pass copies the scene's camera block from the snapshot arena with vkCmdCopyBuffer, which needs VK_BUFFER_USAGE_TRANSFER_SRC_BIT on the source (VUID-vkCmdCopyBuffer-srcBuffer-00118). Reported by Lucas-blip-png in #228 and SchulzCode in #253. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_usnap.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/runtime/vk_usnap.c b/runtime/vk_usnap.c index 056fdf80..8d384afa 100644 --- a/runtime/vk_usnap.c +++ b/runtime/vk_usnap.c @@ -81,7 +81,8 @@ static Arena *arena_get(uint64_t need) { if (!a) rt_fatal("vk_usnap: out of memory"); a->size = need < ARENA_MIN ? ARENA_MIN : (need + (1u << 20) - 1) & ~(uint64_t)((1u << 20) - 1); VkBufferCreateInfo bi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = a->size, - .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT}; + // transfer source: DLAA copies the camera block out (vk_dlaa.c mv_pass) + .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT}; // Device-local through the BAR when the device has it (the GPU reads constants on every draw), else host memory. VmaAllocationCreateInfo ai = {.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | From 90319e6c9a3afd25e253090306f53f4854f8bd4b Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Sun, 1 Nov 2026 11:41:27 +0300 Subject: [PATCH 11/12] Load NGX only with dlaa on at start, and skip the FXAA shader lookup at the defaults vk_dlaa_wanted answered 1 on every machine, so each start on an NVIDIA driver loaded the NGX core and enabled its device extensions with DLAA off; dlaa now applies after a restart. vk_dlaa_skip_draw hashed the fragment shader of every draw through an unlocked 8192-entry table, which 1.4.3's shader variants outgrow; with fxaa on and DLSS not scaling there is nothing to skip, so it returns before the lookup. Also gives the DLSS rows their Brazilian Portuguese and Simplified Chinese text. Co-Authored-By: Claude Opus 5.5 --- runtime/cfg.c | 2 +- runtime/ui_text.c | 32 ++++++++++++++++++++++++++++++-- runtime/vk_dlaa.c | 12 +++++++++--- totk.ini.example | 3 +-- 4 files changed, 41 insertions(+), 8 deletions(-) diff --git a/runtime/cfg.c b/runtime/cfg.c index dbd6a2aa..8c63b839 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -109,7 +109,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", LIVE}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance", RESTART}, {"FXAA", "1", "0|1", LIVE}, + {"DLAA", "0", "0|1", RESTART}, {"DLSS", "dlaa", "dlaa|quality|balanced|performance", RESTART}, {"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/ui_text.c b/runtime/ui_text.c index ced42aa2..87ef14a1 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -123,7 +123,8 @@ static const char *const text_en[UI_TEXT_COUNT] = { "Takes effect at the next start.", [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", [UI_MENU_DLAA_DESC] = "NVIDIA DLSS for the 3D scene (NVIDIA RTX GPUs; nvngx_dlss.dll next to totk.exe): smoother edges " - "and less shimmer. The HUD is not touched. The mode below sets the resolution it works from.", + "and less shimmer. The HUD is not touched. The mode below sets the resolution it works from. Takes effect " + "after a restart.", [UI_MENU_DLSS] = "DLSS mode", [UI_MENU_DLSS_DESC] = "DLAA draws the 3D scene at full resolution. Quality, Balanced and Performance draw it at 67, 58 " "and 50 % and let DLSS scale it up, for more frames per second; they replace the 3D render " @@ -455,7 +456,8 @@ static const char *const text_ru[UI_TEXT_COUNT] = { "разрешение теней. Действует после перезапуска.", [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", [UI_MENU_DLAA_DESC] = "NVIDIA DLSS для 3D-сцены (видеокарты NVIDIA RTX; nvngx_dlss.dll рядом с totk.exe): ровнее края и " - "меньше мерцания. Интерфейс не затрагивается. Режим ниже задаёт разрешение, с которым он работает.", + "меньше мерцания. Интерфейс не затрагивается. Режим ниже задаёт разрешение, с которым он работает. " + "Действует после перезапуска.", [UI_MENU_DLSS] = "Режим DLSS", [UI_MENU_DLSS_DESC] = "DLAA рисует 3D-сцену в полном разрешении. «Качество», «Баланс» и «Производительность» рисуют её " "в 67, 58 и 50 % и масштабируют через DLSS ради большего числа кадров; они заменяют масштаб " @@ -1035,6 +1037,21 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_PCSS] = "Sombras suaves", [UI_MENU_PCSS_DESC] = "Sombras do sol nítidas onde um objeto toca o chão e mais suaves quanto mais longe a sombra " "cai (PCSS). 0 mantém o filtro do jogo. Vale no próximo início.", + [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", + [UI_MENU_DLAA_DESC] = "NVIDIA DLSS para a cena 3D (placas NVIDIA RTX; nvngx_dlss.dll ao lado do totk.exe): bordas " + "mais suaves e menos cintilação. O HUD não é afetado. O modo abaixo define a resolução de " + "onde ele parte. Vale após reiniciar.", + [UI_MENU_DLSS] = "Modo do DLSS", + [UI_MENU_DLSS_DESC] = "DLAA desenha a cena 3D na resolução cheia. Qualidade, Equilibrado e Desempenho a desenham " + "em 67, 58 e 50 % e deixam o DLSS ampliá-la, para mais quadros por segundo; eles substituem " + "a escala 3D. Vale após reiniciar.", + [UI_MENU_DLSS_DLAA] = "DLAA (nativo)", + [UI_MENU_DLSS_QUALITY] = "Qualidade", + [UI_MENU_DLSS_BALANCED] = "Equilibrado", + [UI_MENU_DLSS_PERFORMANCE] = "Desempenho", + [UI_MENU_FXAA] = "Antisserrilhado do jogo (FXAA)", + [UI_MENU_FXAA_DESC] = "A suavização de bordas FXAA do próprio jogo. Borra um pouco os detalhes finos; com o DLAA " + "ligado não é necessária.", }; // Simplified Chinese: this row covers the software keyboard and the whole menu, so the menu and the overlay read Chinese @@ -1494,6 +1511,17 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_CONTACT_SHADOWS_DESC] = "阴影贴图遗漏的细小太阳阴影:脚下、石头下、草丛和褶皱中。在光照之后于屏幕空间追踪。下次启动时生效。", [UI_MENU_PCSS] = "柔和阴影", [UI_MENU_PCSS_DESC] = "物体接触地面处的太阳阴影锐利,阴影投得越远越柔和(PCSS)。0 保留游戏自身的过滤。下次启动时生效。", + [UI_MENU_DLAA] = "NVIDIA DLSS / DLAA", + [UI_MENU_DLAA_DESC] = "用于 3D 场景的 NVIDIA DLSS(NVIDIA RTX 显卡;nvngx_dlss.dll 放在 totk.exe 旁):边缘更平滑,闪烁更少。HUD " + "不受影响。下方的模式决定它的工作分辨率。重启后生效。", + [UI_MENU_DLSS] = "DLSS 模式", + [UI_MENU_DLSS_DESC] = "DLAA 以全分辨率绘制 3D 场景。质量、平衡和性能分别以 67%、58% 和 50% 绘制,再由 DLSS 放大,以获得更高帧率;它们会取代 3D 渲染比例。重启后生效。", + [UI_MENU_DLSS_DLAA] = "DLAA(原生)", + [UI_MENU_DLSS_QUALITY] = "质量", + [UI_MENU_DLSS_BALANCED] = "平衡", + [UI_MENU_DLSS_PERFORMANCE] = "性能", + [UI_MENU_FXAA] = "游戏抗锯齿(FXAA)", + [UI_MENU_FXAA_DESC] = "游戏自身的 FXAA 边缘平滑。会让细节略微模糊;开启 DLAA 时不需要。", }; #define SWKBD_ONLY(name, ...) static const char *const name[UI_TEXT_COUNT] = {SWKBD(__VA_ARGS__)} diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 41de947d..39244b0a 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -86,9 +86,14 @@ static int p_getu(const NgxParam *p, const char *n, unsigned *v) { return NGX_OK static int p_getf(const NgxParam *p, const char *n, float *v) { return NGX_OK(((GetF)p->vt->slot[G_F])(p, n, v)); } static int p_getp(const NgxParam *p, const char *n, void **v) { return NGX_OK(((GetP)p->vt->slot[G_P])(p, n, v)); } -// NGX is brought up whenever the driver has it, whatever the setting, so dlaa can be switched on while the game runs -// (its device extensions can only be asked for at device creation). Switched off, nothing else of DLAA runs. -int vk_dlaa_wanted(void) { return 1; } +// NGX is brought up only when dlaa is on at start: its device extensions can only be asked for at device creation, and +// loading the driver's NGX core on every NVIDIA machine would cost start time and change the device with DLAA off. So +// dlaa applies after a restart; switched off, nothing else of DLAA runs. +int vk_dlaa_wanted(void) { + static int wanted = -1; + if (wanted < 0) wanted = cfg_bool("TOTK_DLAA"); + return wanted; +} static int core_load(void) { if (N.tried) return N.loaded; @@ -656,6 +661,7 @@ int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { static int fxaa = 1; uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED); if (f != frame_read) frame_read = f, fxaa = cfg_bool("TOTK_FXAA"); // once a frame: the menu switches it live + if (fxaa && !D.up) return 0; // nothing to skip: no shader lookup per draw at the defaults if (!fs) return 0; uint64_t h = spirv_hash(fs); if (h != FXAA_FS[0] && h != FXAA_FS[1]) return 0; diff --git a/totk.ini.example b/totk.ini.example index 7a0c0589..d28e2cbc 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -182,8 +182,7 @@ # pcss = 0 # NVIDIA DLSS / DLAA for the 3D scene, on NVIDIA RTX GPUs with nvngx_dlss.dll (from NVIDIA's DLSS SDK) next to -# totk.exe; elsewhere the setting does nothing. The HUD is drawn after it and is not touched. Changes while the game -# runs take effect at once. +# totk.exe; elsewhere the setting does nothing. The HUD is drawn after it and is not touched. Read at start. # dlaa = 0 # What DLSS works from: dlaa (the 3D scene at full size), quality, balanced or performance (the scene at 67, 58 or # 50 % of the output, scaled up by DLSS; these replace render_scale and sharpen texture filtering to match). With dlaa From 0b84f48df23216d2a5817af5fd3aab656f3910bd Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Sun, 1 Nov 2026 11:42:15 +0300 Subject: [PATCH 12/12] Build vk_dlaa.c off Windows as no-op stubs It includes windows.h and loads NGX as a Windows DLL, and build_game.py leaves only *_win.* files out of the Linux build, which then stopped at it. Elsewhere DLAA, the DLSS scaling and the FXAA switch now do nothing. Co-Authored-By: Claude Opus 5.5 --- runtime/vk_dlaa.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index 39244b0a..af926221 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -9,6 +9,7 @@ // layout with a set-then-get round trip before anything relies on it. // // Where DLAA runs in the frame, the jitter and the motion vectors: see the sections below. +#ifdef _WIN32 #include #include #include @@ -668,3 +669,20 @@ int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { if (!ex->depth.image) return D.up; // the scaling pass return !fxaa; } + +#else +// NGX is loaded as a Windows DLL; elsewhere DLAA, the DLSS modes' scaling and the FXAA switch do nothing. +#include "vk_dlaa.h" + +int vk_dlaa_wanted(void) { return 0; } +void vk_dlaa_instance_exts(const char **ext, uint32_t *n, uint32_t max) { (void)ext, (void)n, (void)max; } +void vk_dlaa_device_exts(const VkExtensionProperties *have, uint32_t nhave, const char **ext, uint32_t *n, uint32_t max) { + (void)have, (void)nhave, (void)ext, (void)n, (void)max; +} +void vk_dlaa_init(void) {} +void vk_dlaa_pass(VkExec *ex) { (void)ex; } +void vk_dlaa_frame(void) {} +void vk_dlaa_draw(VkExec *ex) { (void)ex; } +void vk_dlaa_viewport(VkExec *ex, VkViewport *v) { (void)ex, (void)v; } +int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs) { (void)ex, (void)fs; return 0; } +#endif