mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-19 20:25:57 +00:00
With a DLSS mode the game's own scaling draw covered DLSS's picture with the jittered scene. At a 1280x720 scene and 1920x1080 output the scaling is done by the game's tonemap, not by the FXAA shader vk_dlaa_skip_draw looks for, so no hash list could catch it. From DLSS's evaluation to the frame's end, passes larger than the light target now sample DLSS's output in its place (vk_dlaa_swap_img, applied in vk_exec_draw.c tex_info), whichever shader scales. The motion-vector shader inverted the view-projection in 32-bit floats. With a still camera (identical matrices each frame) the rounding still gave a few hundredths of a pixel of motion that changed with every jitter step; DLSS followed it and the whole picture wobbled. mv_pass now makes last frame's view-projection times the inverse of this frame's in double precision from the uniform snapshot (vk_usnap_host), and the shader only applies it. Measured on 1.4.3 indoors, still camera, mean per-pixel change between consecutive frames on static areas: DLSS quality 0.18 -> 0.06, DLAA 0.14 -> 0.05. A camera pan at 10 px per frame shows no ghosting.
751 lines
40 KiB
C
751 lines
40 KiB
C
// 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.
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
|
|
#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 // 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;
|
|
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 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;
|
|
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" : "");
|
|
}
|
|
|
|
int vk_dlaa_available(void) { return vk_dlaa_wanted() && N.available; }
|
|
|
|
// ---------------------------------------------------------------- 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 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.
|
|
// The scaling draw is not always that FXAA shader: at a 1280x720 scene and 1920x1080 output (1.4.3, dlss = quality)
|
|
// the game's tonemap (guest fs 7e114c4330dc212a) reads the light target and writes the output-sized target itself,
|
|
// over DLSS's picture, so the jittered scene reached the screen and the whole picture shook. So from DLSS's evaluation
|
|
// to the frame's end, draws in passes larger than the light target sample DLSS's output in its place
|
|
// (vk_dlaa_swap_img, applied by vk_exec_draw.c tex_info): whichever shader scales, it scales DLSS's 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
|
|
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, ow, oh; // render size, output size
|
|
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
|
|
double cam_prev[16]; // last frame's view-projection (row-major), valid while cam_prev_ok
|
|
int cam_prev_ok;
|
|
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};
|
|
|
|
const VkTexImage *vk_dlaa_swap_img;
|
|
VkImageView vk_dlaa_swap_view;
|
|
|
|
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 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 && 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];
|
|
}
|
|
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(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];
|
|
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, e->ow = ow, e->oh = oh;
|
|
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 read from the replay's uniform
|
|
// snapshot (vk_usnap.c, as of the submit call), and the compute pass takes every pixel through last frame's
|
|
// view-projection times the inverse of this frame's. That matrix is made here in double precision: the shader once
|
|
// inverted the view-projection itself in 32-bit floats, and the rounding gave a still camera a few hundredths of a
|
|
// pixel of motion that changed with every jitter step, which DLSS followed, so the whole picture wobbled. 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
|
|
|
|
// m inverted in place (row-major 4x4, Gauss-Jordan with partial pivoting). 0: singular.
|
|
static int invert4(double m[16]) {
|
|
double a[4][8];
|
|
for (int r = 0; r < 4; r++)
|
|
for (int c = 0; c < 8; c++) a[r][c] = c < 4 ? m[r * 4 + c] : (c - 4 == r);
|
|
for (int c = 0; c < 4; c++) {
|
|
int p = c;
|
|
for (int r = c + 1; r < 4; r++)
|
|
if (fabs(a[r][c]) > fabs(a[p][c])) p = r;
|
|
if (fabs(a[p][c]) < 1e-30) return 0;
|
|
for (int k = 0; k < 8; k++) {
|
|
double t = a[c][k];
|
|
a[c][k] = a[p][k], a[p][k] = t;
|
|
}
|
|
double inv = 1.0 / a[c][c];
|
|
for (int k = 0; k < 8; k++) a[c][k] *= inv;
|
|
for (int r = 0; r < 4; r++) {
|
|
if (r == c || a[r][c] == 0.0) continue;
|
|
double f = a[r][c];
|
|
for (int k = 0; k < 8; k++) a[r][k] -= f * a[c][k];
|
|
}
|
|
}
|
|
for (int r = 0; r < 4; r++)
|
|
for (int c = 0; c < 4; c++) m[r * 4 + c] = a[r][c + 4];
|
|
return 1;
|
|
}
|
|
|
|
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[2] = {
|
|
{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}};
|
|
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, 80};
|
|
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;
|
|
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)
|
|
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;
|
|
const float *cam = D.cam_addr ? vk_usnap_host(D.cam_addr, CAM_BYTES, 4) : NULL;
|
|
if (!mv_init() || !cam) {
|
|
D.mv_none++;
|
|
D.cam_prev_ok = 0;
|
|
return 0;
|
|
}
|
|
double cur[16], prev[16], m[16];
|
|
for (int i = 0; i < 16; i++) cur[i] = cam[12 + i]; // rows 3-6
|
|
int had_prev = D.cam_prev_ok;
|
|
memcpy(prev, D.cam_prev, sizeof prev);
|
|
memcpy(D.cam_prev, cur, sizeof cur), D.cam_prev_ok = 1;
|
|
if (!had_prev || !invert4(cur)) return 0; // nothing to reproject into: zero motion, new history
|
|
for (int r = 0; r < 4; r++)
|
|
for (int c = 0; c < 4; c++) {
|
|
double v = 0;
|
|
for (int k = 0; k < 4; k++) v += prev[r * 4 + k] * cur[k * 4 + c];
|
|
m[r * 4 + c] = v;
|
|
}
|
|
VkDescriptorImageInfo zi = {D.mv_samp, zv, VK_IMAGE_LAYOUT_GENERAL};
|
|
VkDescriptorImageInfo oi = {VK_NULL_HANDLE, e->mv_view, VK_IMAGE_LAYOUT_GENERAL};
|
|
VkWriteDescriptorSet wr[2] = {
|
|
{.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}};
|
|
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, 2, wr);
|
|
float pc[20];
|
|
for (int r = 0; r < 4; r++)
|
|
for (int c = 0; c < 4; c++) pc[c * 4 + r] = (float)m[r * 4 + c]; // GLSL mat4 is column-major
|
|
pc[16] = (float)w, pc[17] = (float)h, pc[18] = jx, pc[19] = 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.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.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 &&
|
|
(!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;
|
|
}
|
|
|
|
// 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;
|
|
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, 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);
|
|
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", 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 -> %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, 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);
|
|
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 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)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);
|
|
if (dst != t) vk_dlaa_swap_img = t->img, vk_dlaa_swap_view = e->out_view; // the scaling draw reads DLSS's picture
|
|
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, 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, 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]);
|
|
}
|
|
|
|
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 (!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) {
|
|
vk_dlaa_swap_img = NULL, vk_dlaa_swap_view = VK_NULL_HANDLE;
|
|
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 = D.ended = D.up = 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 = D.ended = D.up = 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.
|
|
// 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, the one with tools/xlate patch 0010 (PCSS, PR #89) applied, and the one with patches
|
|
// 0010 and 0011 (the shadow filter spread) applied. A scaling draw this list misses still scales DLSS's picture, not
|
|
// the jittered scene: after DLSS ran, passes larger than the light target sample DLSS's output (vk_dlaa_swap_img).
|
|
static const uint64_t FXAA_FS[] = {0xf450003ebeb3dc52ull, 0x0a12f4bc2a9a4fbeull, 0x5c43ae18948d52cbull};
|
|
|
|
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(VkExec *ex, const GfxShader *fs) {
|
|
static uint64_t frame_read = ~0ull;
|
|
static int fxaa = 1;
|
|
// fxaa = 0 reports once whether it found the game's FXAA draw: the first skip, or a minute of frames (3600) with
|
|
// none, which is what a translator change that moves FXAA_FS looks like on every GPU, with or without DLSS
|
|
static uint64_t fx_off_frames;
|
|
static int fx_found, fx_reported;
|
|
uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED);
|
|
if (f != frame_read) { // once a frame: the menu switches it live
|
|
frame_read = f, fxaa = cfg_bool("TOTK_FXAA");
|
|
if (!fxaa && !fx_found && !fx_reported && ++fx_off_frames == 3600) {
|
|
fx_reported = 1;
|
|
rt_log("dlaa: fxaa = 0 found no draw of the game's FXAA in %llu frames (its fragment shader is not in "
|
|
"FXAA_FS): the FXAA stays on", (unsigned long long)fx_off_frames);
|
|
}
|
|
}
|
|
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);
|
|
int known = 0;
|
|
for (size_t i = 0; i < sizeof FXAA_FS / sizeof FXAA_FS[0]; i++) known |= h == FXAA_FS[i];
|
|
if (!known) return 0;
|
|
if (!ex->depth.image) return D.up; // the scaling pass, which DLSS replaced
|
|
if (!fxaa && !fx_found) {
|
|
fx_found = 1;
|
|
rt_log("dlaa: fxaa = 0 skips the game's FXAA (fragment shader %016llx)", (unsigned long long)h);
|
|
}
|
|
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"
|
|
#include "vk_exec.h"
|
|
|
|
const VkTexImage *vk_dlaa_swap_img;
|
|
VkImageView vk_dlaa_swap_view;
|
|
|
|
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) {}
|
|
int vk_dlaa_available(void) { return 0; }
|
|
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
|