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.