Files
NX2navi/runtime/vk_dlaa.c
2026-11-09 20:51:06 -05:00

1876 lines
110 KiB
C

// DLAA: NVIDIA DLSS at the scene's own size (NX2NAVI_DLAA, nx2navi.ini dlaa). NGX is loaded at run time from the driver's
// NGX core: on Windows _nvngx.dll, found through HKLM\SOFTWARE\NVIDIA Corporation\Global\NGXCore; on Linux
// libnvidia-ngx.so.1, which the NVIDIA driver installs on the library path. NGX loads the DLSS model from the folder of
// the executable: nvngx_dlss.dll on Windows, libnvidia-ngx-dlss.so.<version> on Linux. No NVIDIA SDK code or header is
// compiled in: the few NGX types used are declared here from the SDK ABI and the Linux core's shutdown interface.
//
// The core's parameter object is a C++ class whose virtual functions are called through its vtable: the Set overloads
// in slots 0-7 and the Get overloads in 8-15. MSVC (the Windows core) lays out each group of overloads in reverse
// declaration order, the Itanium C++ ABI (the Linux core, built with GCC) in declaration order. vtable_ok checks the
// layout with a set-then-get round trip before anything relies on it.
//
// NGX and DLAA's resources live as long as the device: vk_dlaa_init brings NGX up on the new device, and
// vk_dlaa_release (Linux) frees everything DLAA made and shuts NGX down before the device is destroyed.
//
// Where DLAA runs in the frame, the jitter and the motion vectors: see the sections below.
#ifdef _WIN32
#include <windows.h>
#endif
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include "cfg.h"
#include "gfx.h"
#include "host.h"
#include "platform/platform.h"
#include "vk.h"
#include "vk_dlaa.h"
#include "vk_exec.h"
#include "vk_ffx.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 *);
#ifndef _WIN32
// NVSDK_NGX_VULKAN_Shutdown1 as the Linux core exports it: the device and a pointer that receives the devices NGX still
// serves afterwards (vk_dlaa_release).
typedef NgxResult (*PFN_Shutdown1)(VkDevice, unsigned *remaining);
#endif
static struct {
void *core; // the NGX core library (an HMODULE on Windows)
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 ngx_up; // vk_dlaa_init brought NGX up: DLSS serves this run
int wanted; // -1 not read yet
#ifndef _WIN32
// Linux teardown (vk_dlaa_release)
PFN_Shutdown1 shutdown1; // required: core_load leaves DLAA off without it
VkDevice device; // what NGX was initialised with: set while vk_dlaa_release owes it a shutdown
NgxParam *caps_map; // GetCapabilityParameters' map: allocated for the caller, destroyed by vk_dlaa_release
#endif
} 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 **);
// The SDK declares Set(u64), Set(float), Set(double), Set(u32), Set(int), Set(ID3D11Resource *), Set(ID3D12Resource *),
// Set(void *), then the Get overloads in the same order, then Reset.
#ifdef _WIN32
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 };
#else
enum { S_U64 = 0, S_F, S_D, S_U32, S_I, S_D11, S_D12, S_P, G_U64, G_F, G_D, G_U32, G_I, G_D11, G_D12, G_P };
#endif
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)); }
#ifdef _WIN32
#define DLSS_MODEL "nvngx_dlss.dll"
#else
#define DLSS_MODEL "libnvidia-ngx-dlss.so.<version>"
#endif
// NGX is brought up only when DLSS is wanted 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 DLSS applies after a restart. FSR 3.1 (amd_fidelityfx_vk.dll, vk_ffx.cpp) asks nothing of the device: NX2NAVI_TAA
// and dlaa follow the setting at once when NGX is not up, and vk_dlaa_frame loads the library the first time it is used.
int vk_dlaa_wanted(void) {
static int at_start = -1;
if (at_start < 0) at_start = cfg_bool("NX2NAVI_DLAA");
return at_start || (!N.ngx_up && cfg_bool("NX2NAVI_DLAA") && !strcmp(cfg_value("NX2NAVI_TAA"), "fsr3"));
}
// The temporal upscaler behind dlaa: NVIDIA DLSS through NGX, once NGX is up, or else AMD FSR 3.1, which takes the same
// inputs. The DLSS mode setting (NX2NAVI_DLSS) is the render scale for both.
static int fsr3(void) { return !N.ngx_up && !strcmp(cfg_value("NX2NAVI_TAA"), "fsr3"); }
static int fsr_frame; // fsr3() as vk_dlaa_init and then vk_dlaa_frame read it: the upscaler this frame runs with
int vk_dlaa_fsr3(void) { return vk_dlaa_wanted() && fsr3(); }
// The upscaler the menu has set cannot start in this run: DLSS when NGX was never tried (a device made without its
// extensions), FSR 3.1 while NGX is up and serves the run. A DLSS this PC could not bring up is not waiting for a restart.
int vk_dlaa_needs_restart(void) {
if (!cfg_bool("NX2NAVI_DLAA")) return 0;
return strcmp(cfg_value("NX2NAVI_TAA"), "fsr3") ? !N.ngx_up && !N.tried : N.ngx_up;
}
static int core_load(void) {
if (N.tried) return N.loaded;
N.tried = 1;
#ifdef _WIN32
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((HMODULE)N.core, name)
#else
// The driver's NGX core; the dynamic loader finds it where the driver put it (/usr/lib, /usr/lib/x86_64-linux-gnu).
const char *path = "libnvidia-ngx.so.1";
N.core = plat_lib_open(path);
if (!N.core) {
rt_log("dlaa: cannot load %s (not an NVIDIA driver, or one without NGX): DLAA off", path);
return 0;
}
#define FN(f, name) N.f = plat_lib_sym(N.core, name)
#endif
FN(init, "NVSDK_NGX_VULKAN_Init_Ext2");
#ifndef _WIN32
FN(shutdown1, "NVSDK_NGX_VULKAN_Shutdown1"); // Linux: checked below
#endif
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;
}
#ifndef _WIN32
// Without Shutdown1 the device cannot be taken back from NGX (vk_dlaa_release), and the process then segfaults after
// the Vulkan teardown (NVIDIA 615.78.08): DLAA stays off rather than run with a teardown known to crash. The
// parameter maps are destroyed there too.
if (!N.shutdown1 || !N.destroy_params) {
rt_log("dlaa: the NGX core %s lacks NVSDK_NGX_VULKAN_Shutdown1 or DestroyParameters, which its teardown needs: "
"DLAA off", path);
return 0;
}
#endif
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() || fsr3() || !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() || fsr3() || !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, "NX2navi.Test.I", -12345);
p_setu(p, "NX2navi.Test.U", 4000000000u);
p_setf(p, "NX2navi.Test.F", 1.25f);
p_setp(p, "NX2navi.Test.P", (void *)p);
int ok = p_geti(p, "NX2navi.Test.I", &i) && i == -12345 && p_getu(p, "NX2navi.Test.U", &u) && u == 4000000000u &&
p_getf(p, "NX2navi.Test.F", &f) && f == 1.25f && p_getp(p, "NX2navi.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;
}
#ifndef _WIN32
// UTF-8 to UTF-32 wchar_t, without the C library's locale (the runtime never sets one, so mbstowcs would stop at the
// first non-ASCII byte). Returns 0 on malformed input or when out has no room.
static int utf8_to_wide(const char *in, wchar_t *out, size_t cap) {
const unsigned char *u = (const unsigned char *)in;
size_t n = 0;
while (*u) {
unsigned c = *u++, more = c < 0x80 ? 0 : c >= 0xF0 ? 3 : c >= 0xE0 ? 2 : c >= 0xC0 ? 1 : 4;
if (more == 4) return 0;
if (more) c &= 0x3F >> more;
for (unsigned k = 0; k < more; k++, u++) {
if ((*u & 0xC0) != 0x80) return 0;
c = c << 6 | (*u & 0x3F);
}
if (n + 1 >= cap) return 0;
out[n++] = (wchar_t)c;
}
out[n] = 0;
return 1;
}
#endif
void vk_dlaa_init(void) {
if (vk_dlaa_wanted() && fsr3()) {
fsr_frame = 1;
N.available = vk_ffx_load();
rt_log("dlaa: the temporal upscaler is AMD FSR 3.1%s", N.available ? "" : ", which is missing: the game's own scaling");
return;
}
if (!vk_dlaa_wanted() || !core_load()) return;
#ifdef _WIN32
wchar_t wdir[MAX_PATH];
DWORD len = GetModuleFileNameW(NULL, wdir, MAX_PATH);
while (len && wdir[len - 1] != L'\\') len--;
wdir[len] = 0;
#else
// The executable's folder, where NGX looks for libnvidia-ngx-dlss.so and writes its logs, as a wchar_t string:
// 32-bit code points here, as the Linux core expects.
char dir[PLAT_PATH_MAX];
wchar_t wdir[PLAT_PATH_MAX];
char *cut = plat_exe_path(dir, sizeof dir) ? plat_last_sep(dir) : NULL;
if (!cut || !utf8_to_wide((cut[1] = 0, dir), wdir, PLAT_PATH_MAX)) {
rt_log("dlaa: cannot name the executable's folder for NGX: DLAA off");
return;
}
#endif
// 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;
}
#ifndef _WIN32
N.device = c->device; // NGX holds the device from here, also if the layout check below turns DLAA off
#endif
if (!vtable_ok()) return;
NgxParam *caps = NULL;
int avail = 0, driver = 0;
if (NGX_OK(N.caps(&caps)) && caps) {
#ifndef _WIN32
N.caps_map = caps; // allocated for us (the SDK header: free it with DestroyParameters): vk_dlaa_release does
#endif
p_geti(caps, "SuperSampling.Available", &avail);
p_geti(caps, "SuperSampling.NeedsUpdatedDriver", &driver);
}
N.available = avail != 0;
N.ngx_up = 1;
rt_log("dlaa: NGX up; DLSS %s%s", avail ? "available" : "NOT available (is " DLSS_MODEL " next to the executable?)",
driver ? "; the driver needs an update" : "");
}
int vk_dlaa_available(void) { return vk_dlaa_wanted() && N.available; }
// ---------------------------------------------------------------- where DLAA runs in NX2navi's frame
// Measured (NX2NAVI_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: NX2NAVI_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.
#define OCAM_BLOCK 0x3500u // Ocarina's scene context block (vk_dlaa_draw)
#define OCAM_BYTES 0xb0u // its rows 0-10: the view and the projection
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;
VkImage mask, chars[2]; // the bias mask DLSS reads, the character class mask of this and last frame (R8)
VmaAllocation mask_mem, chars_mem[2];
VkImageView mask_view, chars_view[2];
int chars_cur, chars_ok; // chars[chars_cur] is written next; chars_ok: the other holds last frame's
VkImage dist[2]; // each pixel's view distance, this and last frame (R32F, dlaa_mv.comp depth_out)
VmaAllocation dist_mem[2];
VkImageView dist_view[2];
int dist_cur, dist_ok; // as chars_cur and chars_ok
NgxHandle *feat;
uint64_t used; // evals count when it last ran
} sizes[5], *last; // last: the one the previous DLAA frame ran with
VkImage last_color; // the target DLAA ran on last frame: another one means a new history
NgxParam *params;
int failed, reset;
uint64_t evals, frames_missed;
int share_off; // frames left that pick the output pass without the mode's share (vk_dlaa_pass, vk_dlaa_frame)
// 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 (vk_dlaa_draw), 0: none seen
uint32_t cam_size, cam_vp; // its size and the offset of its view-projection rows
struct { // Ocarina: this frame's scene contexts of light-target draws
uint64_t addr, seq; // seq: vk_exec_submit_seq at the last draw that used it
uint32_t n; // draws
int got; // cam holds its rows 0-10 as the first draw read them (vk_usnap_read: 1, 2), 0 not yet
float cam[OCAM_BYTES / 4];
} views[8];
int nviews;
VkBuffer camb; // two CAM_SLOT slots: this frame's block and last frame's
VmaAllocation camb_mem;
VkBuffer mvm; // MVM_SLOTS pairs of blocks for dlaa_mv.comp: the identity and the reprojection (mv_pass)
VmaAllocation mvm_mem;
uint8_t *mvm_map;
uint32_t mvm_slot;
double cam_prev[16]; // last frame's view-projection (rows 3-6 of its block), for the reprojection
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, masked; // masked: frames with the characters' bias mask
uint64_t why[3]; // history resets: scene size changed, no camera, scene target changed
// frames without a camera and what mv_pass did about them (dlaa_cam_keep, cam_note)
uint64_t cam_none_draw, cam_none_snap; // no scene-context draw this frame / one, not in the evaluating submission's copy
uint64_t cam_at_draw; // camera taken from the bytes the draw read, where the evaluating submission lacks them
uint64_t cam_kept, cam_kept_max; // no camera, history kept with zero motion / runs cut short at KEEP_MAX
int keep_run; // frames in a row kept without a camera
uint64_t gap_logged, miss_logged, target_logged, second_logged;
uint64_t seq_present; // vk_exec_submit_seq at the last present (vk_dlaa_frame)
uint64_t seconds; // present intervals with a second scene after DLSS ran
int on; // the dlaa setting, read at each present (the menu switches it live)
int preset, preset_dirty; // the DLSS model features are created with (preset_value); a change pending
VkExecTarget ids; // this frame's G-buffer target 0 (object classes in green), valid with ids_ok
int ids_ok;
unsigned cfg_seen; // cfg_version when preset was read
uint64_t last_eval_ns; // plat_now_ns of the previous evaluation (FrameTimeDeltaInMsec)
VkFfxImage fg_depth, fg_mv; // the last evaluation's depth and motion vectors, for frame generation
VkImageView fg_depth_view, fg_mv_view;
VkDlaaCamera fg_cam; // this frame's camera (mv_pass), fg_cam_ok when known
int fg_cam_ok;
float fg_jx, fg_jy;
int fg_fresh, fg_reset; // fresh: not handed out yet (vk_dlaa_fg_inputs)
// the picture without the HUD for frame generation (vk_dlaa_fg_hudless): DLSS's output encoded to sRGB as the game's
// last pass encodes its picture, then copied bit for bit into an RGBA8 UNORM image, the format the present reads; with
// HDR on, DLSS's output as RGBA16F, as the game's float picture the present encodes (hl_srgb unused)
VkImage hl_srgb, hl;
VmaAllocation hl_srgb_mem, hl_mem;
VkImageView hl_view;
uint32_t hl_w, hl_h;
VkFormat hl_fmt;
int hl_fresh;
} D = {.mv_ok = -1, .cfg_seen = ~0u};
// What this frame drew into a D32F depth at least DLAA_SCENE_MIN_W wide before DLSS ran (vk_dlaa_draw), for the line a
// frame without a camera logs (cam_note); cleared at each present (vk_dlaa_frame).
static struct {
uint32_t zdraws, zother; // draws into the scene depth / into another such depth than last frame's (jdepth)
uint32_t zother_w, zother_h;
uint32_t ocam, ocam_off; // of the scene-depth draws: with the scene context at c3 / of those, not into a scene
VkFormat ocam_off_fmt; // colour target (the format of the last such)
uint32_t c3_other, c3_size; // with another block at c3 (the size of the last such; 0: none bound)
uint64_t seq0; // vk_exec_submit_seq at the frame's first scene-depth draw
uint32_t one_n, one_w, one_h; // after arming: passes with one colour target and no depth (vk_dlaa_pass), the last's
VkFormat one_fmt; // size and format, for a frame without the DLAA point (vk_dlaa_frame)
uint32_t second; // after DLSS ran: passes shaped like the light target's (another scene)
VkImage second_img;
} F;
int vk_dlaa_fg_hudless(VkImage *img, VkImageView *view, uint32_t *w, uint32_t *h, VkFormat *fmt) {
if (!D.hl_fresh) return 0;
D.hl_fresh = 0;
*img = D.hl, *view = D.hl_view, *w = D.hl_w, *h = D.hl_h, *fmt = D.hl_fmt;
return 1;
}
int vk_dlaa_fg_views(VkImageView *depth, VkImageView *mv) {
*depth = D.fg_depth_view, *mv = D.fg_mv_view;
return D.fg_depth_view && D.fg_mv_view;
}
int vk_dlaa_fg_camera(VkDlaaCamera *c) {
if (!D.fg_cam_ok) return 0;
*c = D.fg_cam;
return 1;
}
int vk_dlaa_fg_inputs(VkFfxImage *depth, VkFfxImage *mv, float *jx, float *jy, int *reset) {
if (!D.fg_fresh || D.failed) return 0;
D.fg_fresh = 0;
*depth = D.fg_depth, *mv = D.fg_mv, *jx = D.fg_jx, *jy = D.fg_jy, *reset = 0;
return 1;
}
const VkTexImage *vk_dlaa_swap_img;
VkImageView vk_dlaa_swap_view;
static int dl_active(void) { return N.available && !D.failed && D.on; }
// The upscaler this frame runs with, as vk_dlaa_frame read it. The menu can set NX2NAVI_TAA to dlss between that and
// evaluate; read again there while NGX is not up (DLSS starts only after a restart), it sent evaluate to DLSS's path
// with NGX's functions not loaded, a call to address 0 (issue #325).
static int use_fsr(void) { return !N.ngx_up && fsr_frame; }
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;
}
// The images and views of a size, then its feature. The device must be idle: free_size waits for it, vk_dlaa_release
// has. Whatever was not made is skipped, so a half-made size goes the same way.
static void destroy_size(struct Size *e) {
const VkCtx *c = vk_ctx();
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->mask_view) vkDestroyImageView(c->device, e->mask_view, NULL);
if (e->mask) vmaDestroyImage(c->vma, e->mask, e->mask_mem);
for (int i = 0; i < 2; i++) {
if (e->chars_view[i]) vkDestroyImageView(c->device, e->chars_view[i], NULL);
if (e->chars[i]) vmaDestroyImage(c->vma, e->chars[i], e->chars_mem[i]);
if (e->dist_view[i]) vkDestroyImageView(c->device, e->dist_view[i], NULL);
if (e->dist[i]) vmaDestroyImage(c->vma, e->dist[i], e->dist_mem[i]);
}
if (e->feat && N.release) N.release(e->feat);
memset(e, 0, sizeof *e);
}
static void free_size(struct Size *e) {
vk_queue_lock(), vkDeviceWaitIdle(vk_ctx()->device), vk_queue_unlock(); // a third scene size: the evicted images may still be in flight
destroy_size(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. NX2navi'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 < 5; i++) {
if (D.sizes[i].w == w && D.sizes[i].h == h && D.sizes[i].ow == ow && D.sizes[i].oh == oh) return &D.sizes[i];
if (!D.sizes[i].out && !e) e = &D.sizes[i];
if (D.sizes[i].used < lru->used) lru = &D.sizes[i];
}
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;
VkImageUsageFlags u8 = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_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 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &e->mv, &e->mv_mem, &e->mv_view) ||
!image2d(w, h, VK_FORMAT_R8_UNORM, u8, &e->mask, &e->mask_mem, &e->mask_view) ||
!image2d(w, h, VK_FORMAT_R8_UNORM, u8, &e->chars[0], &e->chars_mem[0], &e->chars_view[0]) ||
!image2d(w, h, VK_FORMAT_R8_UNORM, u8, &e->chars[1], &e->chars_mem[1], &e->chars_view[1]) ||
!image2d(w, h, VK_FORMAT_R32_SFLOAT, u8, &e->dist[0], &e->dist_mem[0], &e->dist_view[0]) ||
!image2d(w, h, VK_FORMAT_R32_SFLOAT, u8, &e->dist[1], &e->dist_mem[1], &e->dist_view[1]))
return NULL;
VkImageMemoryBarrier2 ib[7];
VkImage im[7] = {e->out, e->mv, e->mask, e->chars[0], e->chars[1], e->dist[0], e->dist[1]};
for (int i = 0; i < 7; 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 = 7,
.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;
}
// ---------------------------------------------------------------- timing (NX2NAVI_DLAA_TIMES=1)
// GPU timestamps around the camera motion dispatch, the per-object motion pass and DLSS's evaluation, and the CPU
// time of NGX's call and of draining the recorder before it, summed and logged every TIMES_SUMMARY frames:
// dlaa times: gpu camera motion a ms, object motion b ms, DLSS c ms (frames timed); cpu: recorder drain d ms, NGX
// evaluate e ms, motion pass recording f ms
// Each frame takes its own slot of TIMES_SLOTS; a slot's results are read when it comes round again (by then the GPU is
// long done with it; not ready: that frame is left out).
enum { T_MV0, T_MV1, T_OBJ, T_DL0, T_DL1, T_N };
#define TIMES_SLOTS 8u
#define TIMES_SUMMARY 600
static struct {
int on; // -1 not read
VkQueryPool pool;
uint32_t slot;
int used[TIMES_SLOTS]; // the slot holds a frame's timestamps (all T_N written)
double gpu[3]; // ms summed: camera motion, object motion, DLSS
uint64_t frames, cpu_drain, cpu_ngx, cpu_mv; // ns summed
} T = {.on = -1};
static int times_on(void) {
if (T.on < 0) {
T.on = rt_knob("DLAA_TIMES", "0");
VkQueryPoolCreateInfo qi = {.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
.queryType = VK_QUERY_TYPE_TIMESTAMP, .queryCount = TIMES_SLOTS * T_N};
if (T.on && vkCreateQueryPool(vk_ctx()->device, &qi, NULL, &T.pool) != VK_SUCCESS) T.on = 0;
}
return T.on;
}
static void times_mark(VkCommandBuffer cb, int which) {
if (times_on()) vkCmdWriteTimestamp2(cb, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, T.pool, T.slot * T_N + (uint32_t)which);
}
// At the start of a frame's timing (mv_pass): the slot's last results are read and it is reset.
static void times_begin(VkCommandBuffer cb) {
if (!times_on()) return;
T.slot = (T.slot + 1) % TIMES_SLOTS;
if (T.used[T.slot]) {
uint64_t q[T_N];
if (vkGetQueryPoolResults(vk_ctx()->device, T.pool, T.slot * T_N, T_N, sizeof q, q, sizeof q[0],
VK_QUERY_RESULT_64_BIT) == VK_SUCCESS) {
double ns = vk_ctx()->props.limits.timestampPeriod / 1e6; // ticks to ms
T.gpu[0] += (double)(q[T_MV1] - q[T_MV0]) * ns, T.gpu[1] += (double)(q[T_OBJ] - q[T_MV1]) * ns;
T.gpu[2] += (double)(q[T_DL1] - q[T_DL0]) * ns;
if (++T.frames % TIMES_SUMMARY == 0) {
rt_log("dlaa times: gpu camera motion %.3f ms, object motion %.3f ms, DLSS %.3f ms (%llu frames timed); "
"cpu: recorder drain %.3f ms, NGX evaluate %.3f ms, motion pass recording %.3f ms",
T.gpu[0] / TIMES_SUMMARY, T.gpu[1] / TIMES_SUMMARY, T.gpu[2] / TIMES_SUMMARY,
(unsigned long long)T.frames, T.cpu_drain / 1e6 / TIMES_SUMMARY, T.cpu_ngx / 1e6 / TIMES_SUMMARY,
T.cpu_mv / 1e6 / TIMES_SUMMARY);
T.gpu[0] = T.gpu[1] = T.gpu[2] = 0, T.cpu_drain = T.cpu_ngx = T.cpu_mv = 0;
}
}
}
T.used[T.slot] = 0;
vkCmdResetQueryPool(cb, T.pool, T.slot * T_N, T_N);
}
// ---------------------------------------------------------------- motion vectors
// The camera's motion first (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 the two (inv4 and mv_pass below). Then the per-object
// pass (vk_exec_draw.c, vk_mvobj_execute) writes the motion of whatever moves on its own over it.
#define CAM_BYTES 256u // vec4 rows 0-15: view, view-projection (3-6), projection, inverse view
#define CAM_BLOCK 0x940u // the whole block, kept for the per-object motion pass's vertex shaders (vk_exec_draw.c)
#define CAM_SLOT 0xa00u // camb slot stride
#define MVM_SLOTS 16u // frames the GPU may still be reading the reprojection blocks of
// dlaa_mv.comp's push constants in its layout (std430: dz at offset 32)
typedef struct {
float size[2], jitter[2], bias, prev_ok, zfit, zprev_ok;
float dz[4]; // the projection's [2][2], [2][3], [3][2], [3][3]
float zmask;
} MvPush;
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[10] = {
{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},
{4, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{5, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{6, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{7, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{8, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{9, 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 = 10, .pBindings = b};
VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(MvPush)};
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_SLOT,
.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;
VkBufferCreateInfo mbi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = MVM_SLOTS * 2 * CAM_BYTES,
.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT};
VmaAllocationCreateInfo mai = {.usage = VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
VMA_ALLOCATION_CREATE_MAPPED_BIT};
VmaAllocationInfo minfo;
if (vmaCreateBuffer(c->vma, &mbi, &mai, &D.mvm, &D.mvm_mem, &minfo) != VK_SUCCESS) goto fail;
D.mvm_map = minfo.pMappedData;
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);
m = VK_NULL_HANDLE;
if (r != VK_SUCCESS) goto fail;
return D.mv_ok = 1;
fail:
if (m) vkDestroyShaderModule(c->device, m, NULL); // made before a later step failed
rt_log("dlaa: the motion-vector pass could not be set up: DLAA runs with zero motion");
return 0;
}
// The reprojection from this frame's clip space to last frame's, last * inverse(this), in double precision: the shader
// took each pixel back to world space through a float inverse of the view-projection, and with NX2navi's world
// coordinates in the thousands and its far plane the result was noise of a fraction of a pixel and more on distant
// surfaces, which DLSS followed into a shimmer like heat haze (roofs and trees, most of all in the upscaling modes).
// The shader is unchanged: its "this frame" block gets the identity and its "last frame" block this matrix, so it
// applies just the one matrix to each pixel. A still camera gives the identity, and zero motion exactly.
static int inv4(const double m[16], double o[16]) {
double a[4][8];
for (int r = 0; r < 4; r++)
for (int k = 0; k < 8; k++) a[r][k] = k < 4 ? m[r * 4 + k] : (k - 4 == r);
for (int col = 0; col < 4; col++) {
int piv = col;
for (int r = col + 1; r < 4; r++)
if (fabs(a[r][col]) > fabs(a[piv][col])) piv = r;
if (fabs(a[piv][col]) < 1e-300) return 0;
for (int k = 0; k < 8; k++) { double t = a[col][k]; a[col][k] = a[piv][k]; a[piv][k] = t; }
double d = a[col][col];
for (int k = 0; k < 8; k++) a[col][k] /= d;
for (int r = 0; r < 4; r++)
if (r != col) {
double f = a[r][col];
for (int k = 0; k < 8; k++) a[r][k] -= f * a[col][k];
}
}
for (int r = 0; r < 4; r++)
for (int k = 0; k < 4; k++) o[r * 4 + k] = a[r][k + 4];
return 1;
}
// Ocarina's camera from its scene context block (vk_dlaa_draw): its scene vertex shaders take the world position to
// the camera through rows 0-2 (a 3x4 view) and then to clip space through rows 7-10 (the projection, 4x4), so the
// view-projection is rows 7-10 times rows 0-2.
static void ocam_vp(const float *v, double out[16]) {
const float *P = v + 7 * 4;
double V[16] = {v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11], 0, 0, 0, 1};
for (int r = 0; r < 4; r++)
for (int k = 0; k < 4; k++) {
double acc = 0;
for (int j = 0; j < 4; j++) acc += (double)P[r * 4 + j] * V[j * 4 + k];
out[r * 4 + k] = acc;
}
}
// Frame generation's camera (vk_dlaa_fg_camera) from the Ocarina block: the projection is rows 7-10, the view rows 0-2
// (rows: right, up, back; the camera looks down -z), m the reprojection from this frame's clip space to last frame's.
// Each matrix is handed out transposed, for row vectors.
static void fg_store(float out[16], const double m[16]) {
for (int r = 0; r < 4; r++)
for (int k = 0; k < 4; k++) out[r * 4 + k] = (float)m[k * 4 + r];
}
static void fg_camera(const float *v, const double m[16]) {
double P[16], Pi[16], mi[16];
for (int i = 0; i < 16; i++) P[i] = v[28 + i];
if (!inv4(P, Pi) || !inv4(m, mi)) return;
VkDlaaCamera *c = &D.fg_cam;
fg_store(c->view_to_clip, P), fg_store(c->clip_to_view, Pi);
fg_store(c->clip_to_prev_clip, m), fg_store(c->prev_clip_to_clip, mi);
for (int i = 0; i < 3; i++) {
c->right[i] = v[i], c->up[i] = v[4 + i], c->fwd[i] = -v[8 + i];
// the position: -R^T t, R the view's 3x3 and t its last column
c->pos[i] = -(v[i] * v[3] + v[4 + i] * v[7] + v[8 + i] * v[11]);
}
c->fov_y = P[5] != 0 ? 2.0f * (float)atan(1.0 / fabs(P[5])) : 1.0f;
c->aspect = P[0] != 0 ? (float)fabs(P[5] / P[0]) : 1.777f;
D.fg_cam_ok = 1;
}
// Frames without a camera (dlaa_cam_keep, NX2NAVI_DLAA_CAM_KEEP; 1 by default, 0 restores the old handling). Measured in
// Kokiri Forest during dialogue (Saria, dlss = performance): about 1 frame in 20 had no camera, and each started a new
// history twice, on that frame and on the next (nothing to reproject from): 24 to 26 resets per 300 frames. Those were
// frames the event order held past their present (vk_exec.c), which then ran in a submission without a uniform copy
// (the present thread's empty one), so the lookup at DLSS found nothing. With the change: no camera reset there in
// 3600 frames but the first. Two things change:
// - Ocarina's camera rows are taken from the bytes the scene draws themselves read (vk_dlaa_draw, views[].cam), not
// looked up again in the uniform copy of the submission DLSS runs in, which on some frames has none or lost the
// block to a GPU write.
// - A frame that has no camera at all keeps DLSS's history: its vectors are zero (the camera taken as still) and last
// frame's camera stays the one the next frame reprojects from. At most KEEP_MAX frames in a row: a longer stretch
// is something else (a cut scene with a camera of its own), and a still history there would trail what moves.
#define KEEP_MAX 6
static const char *const usnap_why[] = {"found", "no copy in this submission", "dropped by a GPU write in this submission",
"left out: a GPU write in flight", "not memory the CPU writes",
"not bound in this submission"};
// One line for each of the first frames without a camera: what the frame drew into the scene depth, which submission
// the scene context was seen in and why the evaluating one lacks it, and what was done.
static void cam_note(int view, int kept) {
uint64_t seq = vk_exec_submit_seq;
char snap[200] = "";
if (D.cam_addr)
snprintf(snap, sizeof snap, "; scene context %#llx last drawn %llu submission(s) before DLSS's, there: %s",
(unsigned long long)D.cam_addr, (unsigned long long)(view >= 0 ? seq - D.views[view].seq : 0),
usnap_why[vk_usnap_why(D.cam_addr, D.cam_size == OCAM_BLOCK ? OCAM_BYTES : D.cam_size)]);
rt_log("dlaa: frame %llu without a camera: %llu scene-depth draws over %llu submission(s) (%u into another D32 "
"depth %ux%u), %u with the scene context (%u not into a scene colour target, format %d), %u with another c3 "
"block (last size %#x)%s; %s",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED) + 1, (unsigned long long)F.zdraws,
(unsigned long long)(F.zdraws + F.zother ? seq - F.seq0 + 1 : 0), F.zother, F.zother_w, F.zother_h, F.ocam,
F.ocam_off, (int)F.ocam_off_fmt, F.c3_other, F.c3_size, snap,
kept == 1 ? "history kept, zero motion" : kept == 2 ? "new history (more than KEEP_MAX in a row)"
: "new history");
}
// 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); 2: no camera, but the history is kept (the vectors stay zero, dlaa_cam_keep).
// bias > 0 with this frame's G-buffer classes (D.ids) also writes e->mask, the bias mask (dlaa_mv.comp); *masked says
// whether it did.
static int mv_pass(VkExec *ex, struct Size *e, VkImageView zv, float jx, float jy, float bias, int *masked) {
*masked = 0;
VkCommandBuffer cb = ex->cb;
uint32_t w = e->w, h = e->h;
static int keep = -1;
if (keep < 0) keep = rt_knob("DLAA_CAM_KEEP", "1");
VkDescriptorBufferInfo cam;
int view = -1; // Ocarina: the views[] entry of the camera
for (int i = 0; D.cam_size == OCAM_BLOCK && D.cam_addr && i < D.nviews; i++)
if (D.views[i].addr == D.cam_addr) view = i;
const float *held = keep && view >= 0 && D.views[view].got ? D.views[view].cam : NULL;
int found = mv_init() && D.cam_addr && vk_usnap_find(D.cam_addr, D.cam_size == OCAM_BLOCK ? OCAM_BYTES : D.cam_size, 4, &cam);
if (!found && held && D.mv_ok == 1) {
D.cam_at_draw++;
if (D.gap_logged < 40) {
D.gap_logged++;
rt_log("dlaa: frame %llu: camera read at the draw: scene context %#llx last drawn %llu submission(s) before "
"DLSS's, there: %s; the frame's scene-depth draws over %llu submission(s); %d held submissions",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED) + 1,
(unsigned long long)D.cam_addr, (unsigned long long)(vk_exec_submit_seq - D.views[view].seq),
usnap_why[vk_usnap_why(D.cam_addr, OCAM_BYTES)],
(unsigned long long)(F.zdraws + F.zother ? vk_exec_submit_seq - F.seq0 + 1 : 0), vk_exec_held());
}
}
else if (!found) {
D.mv_none++;
if (D.cam_addr) D.cam_none_snap++;
else D.cam_none_draw++;
e->chars_ok = e->dist_ok = 0;
int kept = 0;
if (keep && D.mv_ok == 1 && D.cam_prev_ok) {
if (D.keep_run < KEEP_MAX) kept = 1, D.keep_run++, D.cam_kept++;
else kept = 2, D.cam_kept_max++;
}
if (D.gap_logged < 40) D.gap_logged++, cam_note(view, kept);
if (kept == 1) return 2;
D.cam_prev_ok = 0;
return 0;
}
D.keep_run = 0;
// this frame's view-projection as the scene draws read it (Ocarina, dlaa_cam_keep) or as the snapshot holds it, for
// the reprojection; kept as last frame's for the next
const float *cr = held ? held
: D.cam_size == OCAM_BLOCK ? (const float *)vk_usnap_bytes(D.cam_addr, OCAM_BYTES)
: (const float *)vk_usnap_bytes(D.cam_addr + D.cam_vp, 64);
double cur_vp[16], m[16], ci[16];
int have_m = 0;
if (cr && D.cam_size == OCAM_BLOCK) ocam_vp(cr, cur_vp);
else if (cr)
for (int i = 0; i < 16; i++) cur_vp[i] = cr[i];
if (cr) {
if (D.cam_prev_ok && inv4(cur_vp, ci)) {
for (int r = 0; r < 4; r++)
for (int k = 0; k < 4; k++) {
double v = 0;
for (int j = 0; j < 4; j++) v += D.cam_prev[r * 4 + j] * ci[j * 4 + k];
m[r * 4 + k] = v;
}
have_m = 1;
}
}
D.fg_cam_ok = 0;
if (cr && have_m && D.cam_size == OCAM_BLOCK) fg_camera(cr, m);
int s = D.cam_slot, had_prev = D.cam_prev_ok;
if (D.cam_size == CAM_BLOCK) { // the whole block, for the per-object motion pass (the deferred engine's only)
VkBufferCopy bc = {cam.offset, (VkDeviceSize)s * CAM_SLOT, CAM_BLOCK};
vkCmdCopyBuffer(cb, cam.buffer, D.camb, 1, &bc);
full_barrier(cb);
}
D.cam_slot ^= 1, D.cam_prev_ok = cr != NULL;
if (cr) memcpy(D.cam_prev, cur_vp, sizeof cur_vp);
if (!had_prev || !have_m) { // nothing to reproject into: zero motion, new history
e->chars_ok = e->dist_ok = 0;
return 0;
}
VkDescriptorImageInfo zi = {D.mv_samp, zv, VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo oi = {VK_NULL_HANDLE, e->mv_view, VK_IMAGE_LAYOUT_GENERAL};
uint32_t ms = D.mvm_slot++ % MVM_SLOTS;
float *blk = (float *)(D.mvm_map + (size_t)ms * 2 * CAM_BYTES); // rows 3-6 of each block are read
memset(blk, 0, 2 * CAM_BYTES);
for (int r = 0; r < 4; r++)
for (int k = 0; k < 4; k++)
blk[12 + r * 4 + k] = r == k ? 1.0f : 0.0f, blk[64 + 12 + r * 4 + k] = (float)m[r * 4 + k];
vmaFlushAllocation(vk_ctx()->vma, D.mvm_mem, (VkDeviceSize)ms * 2 * CAM_BYTES, 2 * CAM_BYTES);
VkDescriptorBufferInfo cur = {D.mvm, (VkDeviceSize)ms * 2 * CAM_BYTES, CAM_BYTES};
VkDescriptorBufferInfo prev = {D.mvm, (VkDeviceSize)ms * 2 * CAM_BYTES + CAM_BYTES, CAM_BYTES};
// The class mask needs the G-buffer at the scene size; otherwise bindings 4-7 get the mask images as stand-ins
// (the shader returns before reading them with bias 0).
const VkExecTarget *ids = &D.ids;
int use = bias > 0 && D.ids_ok && ids->image && ids->width == w && ids->height == h && !ids->is3d;
VkImageView iv = use ? vk_exec_target_view(ids->img, ids->format, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT,
ids->level, ids->base_layer, 1, 0)
: e->mask_view;
int cur_c = e->chars_cur;
VkDescriptorImageInfo ii = {D.mv_samp, iv, VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo mki = {VK_NULL_HANDLE, e->mask_view, VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo cpi = {VK_NULL_HANDLE, e->chars_view[cur_c ^ 1], VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo coi = {VK_NULL_HANDLE, e->chars_view[cur_c], VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo dpi = {VK_NULL_HANDLE, e->dist_view[e->dist_cur ^ 1], VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo doi = {VK_NULL_HANDLE, e->dist_view[e->dist_cur], VK_IMAGE_LAYOUT_GENERAL};
VkWriteDescriptorSet wr[10] = {
{.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},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 4, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &ii},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 5, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &mki},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 6, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &cpi},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 7, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &coi},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 8, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &dpi},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 9, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &doi}};
times_begin(cb);
times_mark(cb, T_MV0);
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, 10, wr);
// The depth check (dlaa_mv.comp, depth_prev) where nothing else gives characters their own motion: Ocarina's frame,
// which has neither the per-object pass nor the class buffer. Its distances take the projection's depth terms from
// rows 7-10 of the scene context (ocam_vp). NX2NAVI_DLAA_ZFIT=0 (test): the camera's motion alone, as before.
static int zfit_on = -1;
if (zfit_on < 0) zfit_on = rt_knob("DLAA_ZFIT", "1");
int zfit = zfit_on && !use && cr && D.cam_size == OCAM_BLOCK;
MvPush pc = {{(float)w, (float)h}, {jx, jy}, use ? bias : 0.0f, use && e->chars_ok ? 1.0f : 0.0f,
zfit ? 1.0f : 0.0f, zfit && e->dist_ok ? 1.0f : 0.0f,
{zfit ? cr[38] : 0.0f, zfit ? cr[39] : 0.0f, zfit ? cr[42] : 0.0f, zfit ? cr[43] : 0.0f},
zfit ? bias : 0.0f};
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);
times_mark(cb, T_MV1);
vk_mvcheck_camera(cb, e->mv, w, h, jx, jy); // NX2NAVI_MV_CHECK (test)
// the characters' own motion over the camera's (vk_exec_draw.c, per-object motion)
uint64_t c0 = T.on > 0 ? kern_now_ns() : 0;
if (D.cam_size == CAM_BLOCK && vk_mvobj_execute(ex, D.cam_addr, e->mv_view, zv, D.depth.format, w, h)) full_barrier(cb);
if (T.on > 0) T.cpu_mv += kern_now_ns() - c0;
times_mark(cb, T_OBJ);
if (T.on > 0) T.used[T.slot] = 1; // the DLSS marks follow in evaluate
vk_mvcheck_final(cb, ex->fence, e->mv, D.color.image, D.color.format, D.color.level, D.color.base_layer, w, h, jx, jy);
D.mv_frames++;
if (use) e->chars_cur ^= 1, e->chars_ok = 1, D.masked++;
else e->chars_ok = 0;
if (zfit && bias > 0) D.masked++;
e->dist_cur ^= 1, e->dist_ok = zfit;
*masked = use || (zfit && bias > 0);
return 1;
}
// Last frame's camera block for the per-object motion pass, recorded before this frame's mv_pass: that pass writes
// this frame's into slot cam_slot and leaves the other slot, last frame's, as it is. 0: none (no history).
int vk_dlaa_prev_camera(VkDescriptorBufferInfo *out, float jitter[2]) {
if (!dl_active() || !D.cam_prev_ok || !D.camb) return 0;
if (D.cam_size != CAM_BLOCK) return 0; // the per-object pass knows the deferred engine's block only
*out = (VkDescriptorBufferInfo){D.camb, (VkDeviceSize)(D.cam_slot ^ 1) * CAM_SLOT, CAM_BLOCK};
jitter[0] = D.jit_ok ? D.jx : 0.0f, jitter[1] = D.jit_ok ? D.jy : 0.0f;
return 1;
}
// ---------------------------------------------------------------- reactive mask
// Particles, smoke, sparks and other transparents have no motion vectors of their own: the motion image holds the
// surface's behind them, and DLSS carried their old colour along that surface (trails behind sparks, smoke smeared
// with the camera). DLSS takes a mask of where to trust this frame's colour over the history (NGX
// "DLSS.Input.Bias.Current.Color.Mask"). It is made from the picture itself, at no cost on the CPU: the light target is
// copied when the transparents start (the pass that arms DLAA, vk_dlaa_pass) and compared with what DLSS gets
// (runtime/dlaa_mask_spv.h, tools/make_dlaa_mask.py): the share of a pixel's colour that changed, from MASK_THR on,
// times MASK_GAIN. Off by default (NX2NAVI_DLSS_REACTIVE=1 turns it on, NX2NAVI_DLAA_MASKDEBUG=1 shows the mask instead of
// the picture): the pass that arms also draws the sky and blended fog layers over the solid scene, and the mask
// covered the sky, sunlit trees and roofs and a wide fog region besides the particles (seen with MASKDEBUG at 19:45 in
// the first save), where DLSS would give up its anti-aliasing. It needs the particle draws alone (drawn again into the
// mask, like the motion draws) before it can be on. In the upscaling modes the light target DLSS reads also holds the
// bloom by then; the copy would have to be compared at the end of the scene instead.
#include "dlaa_mask_spv.h"
#define MASK_THR 0.1f
#define MASK_GAIN 2.5f
#define SNAPS 3
static struct {
struct Snap { // per light target size and format: its copy at arming, and the mask
uint32_t w, h;
VkFormat f;
VkImage before, mask;
VmaAllocation before_mem, mask_mem;
VkImageView before_view, mask_view;
uint64_t used;
} s[SNAPS];
struct Snap *cur; // this frame's copy, NULL: none
VkDescriptorSetLayout dsl;
VkPipelineLayout layout;
VkPipeline pipe;
int ok, knob; // ok: -1 not built, 0 failed, 1 ready; knob: -1 not read
uint64_t made, missed; // frames with a mask; frames DLSS ran without the copy
} R = {.ok = -1, .knob = -1};
static int mask_init(void) {
if (R.knob < 0) R.knob = rt_knob("DLSS_REACTIVE", "0");
if (!R.knob) return 0;
if (R.ok >= 0) return R.ok;
R.ok = 0;
const VkCtx *c = vk_ctx();
VkDescriptorSetLayoutBinding b[3] = {
{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
{2, 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 = 3, .pBindings = b};
VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 16};
VkShaderModuleCreateInfo mi = {.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, .codeSize = sizeof dlaa_mask_spv,
.pCode = dlaa_mask_spv};
VkShaderModule m = VK_NULL_HANDLE;
if (vkCreateDescriptorSetLayout(c->device, &dci, NULL, &R.dsl) != VK_SUCCESS) goto fail;
VkPipelineLayoutCreateInfo li = {.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .setLayoutCount = 1,
.pSetLayouts = &R.dsl, .pushConstantRangeCount = 1, .pPushConstantRanges = &pr};
if (vkCreatePipelineLayout(c->device, &li, NULL, &R.layout) != 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 = R.layout};
VkResult r = vkCreateComputePipelines(c->device, VK_NULL_HANDLE, 1, &ci, NULL, &R.pipe);
vkDestroyShaderModule(c->device, m, NULL);
m = VK_NULL_HANDLE;
if (r != VK_SUCCESS) goto fail;
return R.ok = 1;
fail:
if (m) vkDestroyShaderModule(c->device, m, NULL); // made before a later step failed
rt_log("dlaa: the reactive mask pass could not be set up: DLSS runs without it");
return 0;
}
// A snapshot's images and views. The device must be idle: free_snap waits for it, vk_dlaa_release has.
static void destroy_snap(struct Snap *s) {
const VkCtx *c = vk_ctx();
if (s->before_view) vkDestroyImageView(c->device, s->before_view, NULL);
if (s->mask_view) vkDestroyImageView(c->device, s->mask_view, NULL);
if (s->before) vmaDestroyImage(c->vma, s->before, s->before_mem);
if (s->mask) vmaDestroyImage(c->vma, s->mask, s->mask_mem);
memset(s, 0, sizeof *s);
}
static void free_snap(struct Snap *s) {
vk_queue_lock(), vkDeviceWaitIdle(vk_ctx()->device), vk_queue_unlock(); // a fourth size: the evicted images may still be in flight
destroy_snap(s);
}
static struct Snap *snap_for(VkCommandBuffer cb, uint32_t w, uint32_t h, VkFormat f) {
static uint64_t tick;
struct Snap *e = NULL, *lru = &R.s[0];
for (int i = 0; i < SNAPS; i++) {
if (R.s[i].w == w && R.s[i].h == h && R.s[i].f == f) return R.s[i].used = ++tick, &R.s[i];
if (!R.s[i].before && !e) e = &R.s[i];
if (R.s[i].used < lru->used) lru = &R.s[i];
}
if (!e) free_snap(e = lru);
VkImageUsageFlags u = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
if (!image2d(w, h, f, u, &e->before, &e->before_mem, &e->before_view) ||
!image2d(w, h, VK_FORMAT_R8_UNORM, u | VK_IMAGE_USAGE_STORAGE_BIT, &e->mask, &e->mask_mem, &e->mask_view)) {
free_snap(e);
return NULL;
}
VkImageMemoryBarrier2 ib[2];
VkImage im[2] = {e->before, e->mask};
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->f = f, e->used = ++tick;
return e;
}
// At arming: the light target as it is before the transparents, outside any pass.
static void mask_snapshot(VkExec *ex) {
R.cur = NULL;
if (mask_init() <= 0) return;
const VkExecTarget *t = &D.color;
struct Snap *s = snap_for(ex->cb, t->width, t->height, t->format);
if (!s) return;
vk_exec_barrier(ex);
VkImageCopy c = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, t->level, t->base_layer, 1},
.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .extent = {t->width, t->height, 1}};
vkCmdCopyImage(ex->cb, t->image, VK_IMAGE_LAYOUT_GENERAL, s->before, VK_IMAGE_LAYOUT_GENERAL, 1, &c);
full_barrier(ex->cb);
ex->recorded += 2;
R.cur = s;
}
// Before DLSS: the mask from the copy and the light target (view cv). NULL: none this frame.
static struct Snap *mask_pass(VkCommandBuffer cb, VkImageView cv, uint32_t w, uint32_t h) {
struct Snap *s = R.cur;
R.cur = NULL;
if (mask_init() <= 0) return NULL;
if (!s || s->w != w || s->h != h || s->f != D.color.format) return R.missed++, NULL;
VkDescriptorImageInfo bi = {D.mv_samp, s->before_view, VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo ai = {D.mv_samp, cv, VK_IMAGE_LAYOUT_GENERAL};
VkDescriptorImageInfo mi = {VK_NULL_HANDLE, s->mask_view, VK_IMAGE_LAYOUT_GENERAL};
VkWriteDescriptorSet wr[3] = {
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 0, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &bi},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 1, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &ai},
{.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .dstBinding = 2, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .pImageInfo = &mi}};
vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, R.pipe);
rec_push(vk_pipeline_push_fn(), cb, VK_PIPELINE_BIND_POINT_COMPUTE, R.layout, 0, 3, wr);
float pc[4] = {(float)w, (float)h, MASK_THR, MASK_GAIN};
vkCmdPushConstants(cb, R.layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof pc, pc);
vkCmdDispatch(cb, (w + 7) / 8, (h + 7) / 8, 1);
full_barrier(cb);
R.made++;
return s;
}
// ---------------------------------------------------------------- teardown
// The HUD-less picture's images, a half-made pair too. The device must be idle, or the images not yet used.
static void hl_destroy(void) {
const VkCtx *c = vk_ctx();
if (D.hl_view) vkDestroyImageView(c->device, D.hl_view, NULL);
if (D.hl) vmaDestroyImage(c->vma, D.hl, D.hl_mem);
if (D.hl_srgb) vmaDestroyImage(c->vma, D.hl_srgb, D.hl_srgb_mem);
D.hl_view = VK_NULL_HANDLE, D.hl = D.hl_srgb = VK_NULL_HANDLE;
}
// The device is idle here. Release NGX features and parameters before their Vulkan resources, then shut down NGX even
// if initialization succeeded but the layout check failed. The Linux core's Shutdown1 takes an extra output pointer
// compared with the SDK's public wrapper; it reports the number of devices still using NGX.
void vk_dlaa_release(void) {
#ifndef _WIN32
const VkCtx *c = vk_ctx();
if (!c) return;
for (int i = 0; i < 5; i++)
if (D.sizes[i].feat) N.release(D.sizes[i].feat), D.sizes[i].feat = NULL;
if (D.params) N.destroy_params(D.params);
if (N.caps_map) N.destroy_params(N.caps_map);
for (int i = 0; i < 5; i++) destroy_size(&D.sizes[i]);
for (int i = 0; i < SNAPS; i++) destroy_snap(&R.s[i]);
hl_destroy();
if (D.mv_pipe) vkDestroyPipeline(c->device, D.mv_pipe, NULL);
if (D.mv_layout) vkDestroyPipelineLayout(c->device, D.mv_layout, NULL);
if (D.mv_dsl) vkDestroyDescriptorSetLayout(c->device, D.mv_dsl, NULL);
if (D.mv_samp) vkDestroySampler(c->device, D.mv_samp, NULL);
if (D.camb) vmaDestroyBuffer(c->vma, D.camb, D.camb_mem);
if (D.mvm) vmaDestroyBuffer(c->vma, D.mvm, D.mvm_mem); // mapped for good: the destroy unmaps it
if (R.pipe) vkDestroyPipeline(c->device, R.pipe, NULL);
if (R.layout) vkDestroyPipelineLayout(c->device, R.layout, NULL);
if (R.dsl) vkDestroyDescriptorSetLayout(c->device, R.dsl, NULL);
if (T.pool) vkDestroyQueryPool(c->device, T.pool, NULL);
memset(&D, 0, sizeof D), D.mv_ok = -1, D.cfg_seen = ~0u;
memset(&R, 0, sizeof R), R.ok = -1, R.knob = -1;
memset(&T, 0, sizeof T), T.on = -1;
memset(&F, 0, sizeof F);
vk_dlaa_swap_img = NULL, vk_dlaa_swap_view = VK_NULL_HANDLE;
if (!N.device) return; // NGX never came up on this device: DLAA off, FSR 3.1, or its init failed
unsigned left = 0;
vk_queue_lock(); // NGX may wait for the device itself
NgxResult r = N.shutdown1(N.device, &left);
vk_queue_unlock();
rt_log("dlaa: NGX shut down (%08x, %u devices left)", (unsigned)r, left);
N.device = NULL, N.caps_map = NULL, N.ngx_up = 0, N.available = 0;
#endif
}
// ---------------------------------------------------------------- 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;
}
static int scene_color(VkFormat f);
void vk_dlaa_draw(VkExec *ex) {
if (!dl_active() || D.ended) return;
static int survey = -1; // NX2NAVI_DLAA_SURVEY=1 (test): what is drawn into the armed light target
if (survey < 0) survey = rt_knob("DLAA_SURVEY", "0");
static uint64_t dfn[16]; // scene draws writing depth, by depth test (reversed depth: GREATER/GEQUAL)
if (survey && ex->depth.image && ex->depth.image == D.jdepth && ex->pipe.ds.dt && ex->pipe.ds.dw)
dfn[ex->pipe.ds.df & 15]++;
if (survey && D.armed && ex->color[0].image == D.color.image) {
static uint64_t n[2][2][2], arms, frames, last_frame; // [blend][depth write][depth test]
const VkPipeState *s = &ex->pipe;
n[s->color.blend_en & 1][s->ds.dw][s->ds.dt]++;
uint64_t f = __atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED);
if (f != last_frame) last_frame = f, frames++;
static uint64_t ps;
if (ex->pass_serial != ps) ps = ex->pass_serial, arms++;
if (frames % 300 == 0) {
static uint64_t logged;
if (logged != frames) {
logged = frames;
rt_log("dlaa survey: scene draws writing depth by depth test (NVN func 1-8: never less equal lequal "
"greater notequal gequal always): %llu %llu %llu %llu %llu %llu %llu %llu",
(unsigned long long)dfn[1], (unsigned long long)dfn[2], (unsigned long long)dfn[3],
(unsigned long long)dfn[4], (unsigned long long)dfn[5], (unsigned long long)dfn[6],
(unsigned long long)dfn[7], (unsigned long long)dfn[8]);
rt_log("dlaa survey: %llu frames, %.1f passes a frame into the light target after arming; draws a frame "
"(blend/depth write/depth test): 000 %.1f 001 %.1f 010 %.1f 011 %.1f 100 %.1f 101 %.1f 110 %.1f 111 %.1f",
(unsigned long long)frames, (double)arms / frames, (double)n[0][0][0] / frames, (double)n[0][0][1] / frames,
(double)n[0][1][0] / frames, (double)n[0][1][1] / frames, (double)n[1][0][0] / frames,
(double)n[1][0][1] / frames, (double)n[1][1][0] / frames, (double)n[1][1][1] / frames);
}
}
}
// The scene camera of a draw into the scene depth: the deferred engine binds a 0x940-byte block at c4 with the
// view-projection in rows 3-6 (0x30); Ocarina's opaque scene draws bind a 0x3500-byte scene context at c3, whose
// rows 0-2 and 7-10 their vertex shaders use as the view and the projection (ocam_vp). Its full-screen passes bind
// a 0x200-byte block at c3 instead, which is not the camera. Without a camera there is no camera motion and no
// jitter (next_jitter), so DLSS runs on each frame alone without shaking the picture.
const p_bind_buf *b = &ex->ubo[0][1]; // c4: the replay keeps user banks from c3 on
const VkExecTarget *z = &ex->depth;
if (!z->image || z->width < DLAA_SCENE_MIN_W || z->format != VK_FORMAT_D32_SFLOAT) return;
if (!F.zdraws && !F.zother) F.seq0 = vk_exec_submit_seq;
if (D.jdepth && z->image != D.jdepth) {
F.zother++, F.zother_w = z->width, F.zother_h = z->height;
return;
}
F.zdraws++;
if (ex->ubo[0][0].size == OCAM_BLOCK && ex->ubo[0][0].addr) {
F.ocam++;
if (!ex->color[0].image || !scene_color(ex->color[0].format)) F.ocam_off++, F.ocam_off_fmt = ex->color[0].format;
} else F.c3_other++, F.c3_size = ex->ubo[0][0].addr ? ex->ubo[0][0].size : 0;
if (b->size == CAM_BLOCK && b->addr) D.cam_addr = b->addr, D.cam_size = CAM_BLOCK, D.cam_vp = 0x30;
else if (ex->ubo[0][0].size == OCAM_BLOCK && ex->ubo[0][0].addr && ex->color[0].image &&
scene_color(ex->color[0].format)) { // Ocarina: the scene context most light-target draws use this frame
uint64_t a = ex->ubo[0][0].addr;
int i = 0, best = 0;
while (i < D.nviews && D.views[i].addr != a) i++;
if (i == D.nviews && D.nviews < 8) D.views[D.nviews].addr = a, D.views[D.nviews].n = 0, D.views[D.nviews++].got = 0;
if (i < D.nviews) {
D.views[i].n++, D.views[i].seq = vk_exec_submit_seq;
// The camera rows as this draw reads them, from its own submission's copy: DLSS runs in a later submission
// on some frames, whose copy may not hold the block (mv_pass, dlaa_cam_keep).
if (!D.views[i].got) D.views[i].got = vk_usnap_read(a, OCAM_BYTES, D.views[i].cam);
}
for (int k = 1; k < D.nviews; k++)
if (D.views[k].n > D.views[best].n) best = k;
D.cam_addr = D.views[best].addr, D.cam_size = OCAM_BLOCK, D.cam_vp = 0;
}
}
// 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.
// The sequence is as long as NVIDIA's DLSS guide asks for the upscaling ratio, 8 x (output / scene)^2 phases (18 in
// Quality, 24 in Balanced, 32 in Performance, 72 in Ultra Performance), and 16 at least, the length DLAA has used from the start.
static void next_jitter(uint32_t w, uint32_t ow) {
static int nj = -1;
if (nj < 0) nj = !rt_knob("DLAA_JITTER", "1"); // NX2NAVI_DLAA_JITTER=0: no jitter (test)
double r = w ? (double)ow / w : 1.0;
uint32_t phases = (uint32_t)ceil(8.0 * r * r - 1e-6);
if (phases < 16) phases = 16;
if (phases > 72) phases = 72;
uint32_t i = D.jframe++ % phases + 1;
D.jx = halton(i, 2) - 0.5f, D.jy = halton(i, 3) - 0.5f;
// Jitter only where the camera is known (vk_dlaa_draw), and not on Ocarina's frame: with it the picture went white
// within seconds (no matter the motion vectors; without it the same frames look right), so DLSS there keeps its
// history along the camera's motion but samples the same spot of each pixel.
D.jit_ok = !D.hold && !nj && D.cam_size == CAM_BLOCK;
}
// The DLSS model (NX2NAVI_DLSS_PRESET, live): default takes NVIDIA's model per mode (evaluate: K for DLAA, Quality and
// Balanced, M for Performance, L for Ultra Performance), 0 here. A letter a..m takes that model in every mode: k pins
// K, j is the other transformer model, which NVIDIA describes as slightly less ghosting at the cost of extra flicker, e
// the older CNN model, cheaper on slower RTX cards. The value is an NVSDK_NGX_DLSS_Hint_Render_Preset (1 A ... 13 M),
// read when a feature is created; a change recreates the features (preset_check).
static int preset_value(void) {
const char *v = cfg_get("NX2NAVI_DLSS_PRESET");
int c = v && v[0] && !v[1] ? v[0] | 0x20 : 0;
return c >= 'a' && c <= 'm' ? c - 'a' + 1 : 0;
}
// How strongly DLSS favours the current frame on characters and where they just were (NX2NAVI_DLSS_CHAR_MASK, percent,
// live; 0 off). Where a character's vectors are the camera's only (dlaa_objmv = 0, or a draw the per-object pass
// skips), one that moves on its own drags a faint copy of itself through DLSS's history; the bias mask makes DLSS take
// less of the history there, at the cost of some of its anti-aliasing on those pixels. Ocarina's frame has no class
// buffer to find characters by: there the mask covers the pixels whose depth the camera's motion does not explain
// (dlaa_mv.comp, the depth check).
static float char_bias(void) {
const char *v = cfg_get("NX2NAVI_DLSS_CHAR_MASK");
long n = v && *v ? strtol(v, NULL, 10) : 65;
return n <= 0 ? 0.0f : n >= 100 ? 1.0f : (float)n / 100.0f;
}
// 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;
}
// Every 300 frames DLSS ran, the history resets and camera gaps of those frames, while there were any (at most 400 lines a
// run): the measure for dlaa_cam_keep at one spot of the game.
static void window_line(void) {
enum { N_ = 10 };
static uint64_t last[N_];
static int lines;
if (D.evals % 300) return;
uint64_t now[N_] = {D.why[0], D.why[1], D.why[2], D.mv_none, D.cam_none_draw, D.cam_none_snap, D.cam_kept,
D.cam_at_draw, D.frames_missed, D.seconds}, d[N_], any = 0;
for (int i = 0; i < N_; i++) d[i] = now[i] - last[i], last[i] = now[i];
for (int i = 0; i < N_; i++) any |= d[i];
if (!any || lines >= 400) return;
lines++;
rt_log("dlaa: frames %llu-%llu: resets %llu size, %llu camera, %llu target; %llu without a camera (%llu without a "
"scene-context draw, %llu not in DLSS's submission), %llu kept with zero motion; %llu cameras read at the draw; "
"%llu frames without the DLAA point, %llu with a second scene after DLSS ran",
(unsigned long long)(D.evals - 299), (unsigned long long)D.evals, (unsigned long long)d[0],
(unsigned long long)d[1], (unsigned long long)d[2], (unsigned long long)d[3], (unsigned long long)d[4],
(unsigned long long)d[5], (unsigned long long)d[6], (unsigned long long)d[7], (unsigned long long)d[8],
(unsigned long long)d[9]);
}
// dst: the target DLSS's picture goes to, NULL for the light target itself (DLAA in place).
static void hudless(VkCommandBuffer cb, struct Size *e, uint32_t w, uint32_t h);
// Another light target than last frame's: a new history. The first few are logged with the new target's size, to tell a
// target the game made anew from two it alternates between.
static void target_changed(const VkExecTarget *t) {
if (D.last_color && D.target_logged < 16)
D.target_logged++, rt_log("dlaa: frame %llu: the light target changed from %p to %p (%ux%u format %d): new history",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED) + 1,
(void *)D.last_color, (void *)t->image, t->width, t->height, (int)t->format);
D.reset = 1, D.why[2]++, D.last_color = t->image;
}
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)
if (D.preset_dirty) { // another model: features are created with it, so every size gets a new one
for (int i = 0; i < 3; i++)
if (D.sizes[i].out) free_size(&D.sizes[i]);
D.last = NULL, D.preset_dirty = 0;
}
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]++, e->chars_ok = 0; // another size's history is from another moment
if (!use_fsr() && !N.ngx_up) return; // neither runs this frame: vk_dlaa_frame turns DLAA off at the next present
if (!use_fsr() && !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"); // NX2NAVI_DLAA_MV=0: zero motion (test)
int masked = 0, mv = no_mv ? 0 : mv_pass(ex, e, zv, jx, jy, char_bias(), &masked);
if (mv != 1) {
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);
// no camera: the history cannot be moved along (2: kept as it is for a short gap, mv_pass dlaa_cam_keep)
if (!no_mv && mv == 0) D.reset = 1, D.why[1]++;
}
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);
struct Snap *mk = D.mv_samp ? mask_pass(cb, cv, w, h) : NULL;
int timed = T.on > 0 && T.used[T.slot]; // mv_pass began this frame's slot
if (timed) times_mark(cb, T_DL0);
uint64_t c0 = timed ? kern_now_ns() : 0;
rec_drain(); // NGX records into the command buffer itself: the recorder thread must have made every call so far
if (timed) T.cpu_drain += kern_now_ns() - c0;
if (use_fsr()) { // FSR 3.1 (vk_ffx.cpp) in DLSS's place: the same images, then the same blit below
if (t->level || t->base_layer || z->level || z->base_layer) return dl_fail("FSR 3.1 on a target that is not level 0, layer 0", 0);
if (D.last_color != t->image) target_changed(t);
uint64_t now = plat_now_ns();
double dt = D.last_eval_ns ? (now - D.last_eval_ns) / 1e6 : 0;
D.last_eval_ns = now;
VkFfxImage fc = {t->image, t->format, w, h, 0}, fz = {z->image, z->format, w, h, 0},
fm = {e->mv, VK_FORMAT_R16G16_SFLOAT, w, h, 1}, fo = {e->out, VK_FORMAT_R16G16B16A16_SFLOAT, ow, oh, 1};
if (!vk_ffx_upscale(cb, &fc, &fz, &fm, &fo, jx, jy, D.reset, dt > 0 && dt < 100 ? (float)dt : 16.67f, 0))
return dl_fail("FSR 3.1", 0);
static int told;
if (!told++) rt_log("dlaa: FSR 3.1 at %ux%u -> %ux%u (scene format %d, depth format %d)", w, h, ow, oh,
(int)t->format, (int)z->format);
goto evaluated;
}
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);
// The model per mode (NVSDK_NGX_DLSS_Hint_Render_Preset: 1 A ... 11 K, 12 L, 13 M), as NVIDIA recommends for
// DLSS 4.5 (310.x): K (transformer) for DLAA, Quality and Balanced, M for Performance, L for Ultra Performance.
// M and L cost more on cards without FP8 (RTX 20/30). dlss_preset (D.preset, preset_check) takes one model for
// every mode instead.
int pk = D.preset ? D.preset : 11, pm = D.preset ? D.preset : 13, pl = D.preset ? D.preset : 12;
p_setu(p, "DLSS.Hint.Render.Preset.DLAA", (unsigned)pk);
p_setu(p, "DLSS.Hint.Render.Preset.UltraQuality", (unsigned)pk);
p_setu(p, "DLSS.Hint.Render.Preset.Quality", (unsigned)pk);
p_setu(p, "DLSS.Hint.Render.Preset.Balanced", (unsigned)pk);
p_setu(p, "DLSS.Hint.Render.Preset.Performance", (unsigned)pm);
p_setu(p, "DLSS.Hint.Render.Preset.UltraPerformance", (unsigned)pl);
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;
int q = perf_quality(w, ow), pr = q == 0 ? pm : q == 3 ? pl : pk;
rt_log("dlaa: DLSS feature created at %ux%u -> %ux%u, quality value %d, preset %c (scene format %d, depth format "
"%d)", w, h, ow, oh, q, 'A' + pr - 1, (int)t->format, (int)z->format);
}
if (D.last_color != t->image) target_changed(t);
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);
// One bias mask: the reactive one (NX2NAVI_DLSS_REACTIVE, a test) where it ran, else the characters' (mv_pass), else
// none. The parameter object is reused, so it is cleared explicitly.
NgxResourceVK rk = mk ? res_image(mk->mask_view, mk->mask, VK_FORMAT_R8_UNORM, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0)
: res_image(e->mask_view, e->mask, VK_FORMAT_R8_UNORM, w, h, VK_IMAGE_ASPECT_COLOR_BIT, 0);
p_setp(p, "DLSS.Input.Bias.Current.Color.Mask", mk || masked ? (void *)&rk : NULL);
p_setu(p, "DLSS.Input.Bias.Current.Color.Subrect.Base.X", 0);
p_setu(p, "DLSS.Input.Bias.Current.Color.Subrect.Base.Y", 0);
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);
// The time since the previous evaluation, which DLSS weighs its history by; 60 fps before the first and after a
// gap (a pause, a load), where no history carries over anyway.
uint64_t now = plat_now_ns();
double dt = D.last_eval_ns ? (now - D.last_eval_ns) / 1e6 : 0;
D.last_eval_ns = now;
p_setf(p, "FrameTimeDeltaInMsec", dt > 0 && dt < 100 ? (float)dt : 16.67f);
c0 = timed ? kern_now_ns() : 0;
NgxResult r = N.evaluate(cb, e->feat, p, NULL);
if (timed) T.cpu_ngx += kern_now_ns() - c0;
if (!NGX_OK(r)) return dl_fail("DLSS evaluation", r);
evaluated:
if (timed) times_mark(cb, T_DL1); // through the recorder, after NGX's own commands
D.reset = 0;
D.last = e, e->used = D.evals + 1;
full_barrier(cb);
vk_mvcheck_output(cb, e->out, ow, oh); // NX2NAVI_MV_CHECK (test)
// 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}}};
// NX2NAVI_DLAA_MVDEBUG=1 (test): the motion vectors in place of the picture, x in red and y in green, render pixels
// as scene light (the post passes still run over them)
static int mvdebug = -1;
if (mvdebug < 0) mvdebug = rt_knob("DLAA_MVDEBUG", "0");
static int maskdebug = -1;
if (maskdebug < 0) maskdebug = rt_knob("DLAA_MASKDEBUG", "0");
// (NX2NAVI_DLAA_MASKDEBUG=1 shows whichever bias mask DLSS got: the reactive one, or the characters')
VkImage shown = mvdebug ? e->mv : maskdebug && mk ? mk->mask : maskdebug && masked ? e->mask : e->out;
if (shown != e->out) b.srcOffsets[1] = (VkOffset3D){(int32_t)w, (int32_t)h, 1};
vkCmdBlitImage(cb, shown, 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
if (vk_dlaa_hudless_wanted) hudless(cb, e, ow, oh); // frame generation keeps the HUD out of its generated frames
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;
// for frame generation at this frame's present (vk_dlaa_fg_inputs)
D.fg_depth = (VkFfxImage){z->image, z->format, w, h, 0};
D.fg_mv = (VkFfxImage){e->mv, VK_FORMAT_R16G16_SFLOAT, w, h, 1};
D.fg_depth_view = zv, D.fg_mv_view = e->mv_view;
D.fg_jx = jx, D.fg_jy = jy, D.fg_fresh = 1;
next_jitter(w, ow);
if (++D.evals == 1 || D.evals == 300 || D.evals % 3600 == 0) // 300: one early line with the frames counted
rt_log("dlaa: %llu frames anti-aliased (scene %ux%u, output %ux%u; %llu frames without the DLAA point, %llu with camera "
"motion, %llu with the characters' mask, %llu without a camera, %llu jitter holds; resets: %llu size, %llu "
"camera, %llu target; reactive mask %llu, without its copy %llu; no camera: %llu without a scene-context "
"draw, %llu not in DLSS's submission; %llu kept with zero motion, %llu runs past %d; %llu cameras read at the "
"draw)",
(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.masked, (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], (unsigned long long)R.made, (unsigned long long)R.missed,
(unsigned long long)D.cam_none_draw, (unsigned long long)D.cam_none_snap, (unsigned long long)D.cam_kept,
(unsigned long long)D.cam_kept_max, KEEP_MAX, (unsigned long long)D.cam_at_draw);
window_line();
}
// The HUD-less picture (vk_dlaa_fg_hudless): DLSS's output, which the HUD is then drawn over, through the encode the
// game's last pass gives its picture (linear to sRGB), as RGBA8 UNORM bytes like the picture the present reads. With
// HDR (NX2NAVI_HDR = 1) the game's picture stays float and linear up to the present, which encodes it to PQ
// (vk_hdr_encode): DLSS's output is kept as RGBA16F for the same encode. The game's own HDR (native) encodes inside the
// game, which this cannot follow: no HUD-less picture there.
int vk_dlaa_hudless_wanted;
static void hudless(VkCommandBuffer cb, struct Size *e, uint32_t w, uint32_t h) {
const VkCtx *c = vk_ctx();
int hdr = vk_hdr_wanted() && !vk_hdr_native();
if (vk_hdr_native()) return;
VkFormat fmt = hdr ? VK_FORMAT_R16G16B16A16_SFLOAT : VK_FORMAT_R8G8B8A8_UNORM;
if (D.hl && (D.hl_w != w || D.hl_h != h || D.hl_fmt != fmt)) {
vk_queue_lock(), vkDeviceWaitIdle(c->device), vk_queue_unlock();
hl_destroy();
}
if (!D.hl) {
VkImageView v2 = VK_NULL_HANDLE;
VkImageUsageFlags u = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
if ((!hdr && !image2d(w, h, VK_FORMAT_R8G8B8A8_SRGB, u, &D.hl_srgb, &D.hl_srgb_mem, &v2)) ||
!image2d(w, h, fmt, u | VK_IMAGE_USAGE_STORAGE_BIT, &D.hl, &D.hl_mem, &D.hl_view)) {
if (v2) vkDestroyImageView(c->device, v2, NULL); // the first image's view, when the second image failed
hl_destroy(); // and what of the two images was made
rt_log("dlaa: the HUD-less picture's images could not be made: frame generation sees the HUD");
vk_dlaa_hudless_wanted = 0;
return;
}
if (v2) vkDestroyImageView(c->device, v2, NULL);
D.hl_w = w, D.hl_h = h, D.hl_fmt = fmt;
VkImageMemoryBarrier2 ib[2];
VkImage im[2] = {D.hl, D.hl_srgb};
int nim = D.hl_srgb ? 2 : 1;
for (int i = 0; i < nim; 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 = (uint32_t)nim,
.pImageMemoryBarriers = ib};
vkCmdPipelineBarrier2(cb, &di);
}
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, 0, 0, 1}, .dstOffsets = {{0, 0, 0}, {(int32_t)w, (int32_t)h, 1}}};
vkCmdBlitImage(cb, e->out, VK_IMAGE_LAYOUT_GENERAL, hdr ? D.hl : D.hl_srgb, VK_IMAGE_LAYOUT_GENERAL, 1, &b,
VK_FILTER_NEAREST);
full_barrier(cb);
if (hdr) {
D.hl_fresh = 1;
return;
}
VkImageCopy cp = {.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
.extent = {w, h, 1}};
vkCmdCopyImage(cb, D.hl_srgb, VK_IMAGE_LAYOUT_GENERAL, D.hl, VK_IMAGE_LAYOUT_GENERAL, 1, &cp);
full_barrier(cb);
D.hl_fresh = 1;
}
static int scene_color(VkFormat f) {
return f == VK_FORMAT_B10G11R11_UFLOAT_PACK32 || f == VK_FORMAT_R16G16B16A16_SFLOAT;
}
// Two frame shapes. A deferred frame (the G-buffer, several colour targets at the scene size) arms on the light target
// drawn after it and ends the scene at the first pass a quarter as wide (the bloom), as described above. Ocarina's
// frame has no G-buffer: its light target (B10G11R11 at the scene size, with the D32F scene depth) is drawn into from the
// first opaque pass on, half- and quarter-size effect passes come and go in between, and the scene ends at the pass
// that tonemaps the light target into the 8-bit output target. So without a G-buffer the frame arms on the first
// scene-size light pass and ends at that output pass: at the output size and without depth when DLSS scales up
// (DLSS writes the output and the tonemap samples it through vk_dlaa_swap_img), an sRGB target of the scene size in
// DLAA (DLSS's picture goes back into the light target, which the tonemap then reads).
static int srgb8(VkFormat f) { return f == VK_FORMAT_R8G8B8A8_SRGB || f == VK_FORMAT_B8G8R8A8_SRGB; }
// The output target DLAA runs at. With the game's own HDR (vk_hdr.c vk_hdr_native) the same pass, at the same point of
// the frame, tonemaps into its PQ picture (vk_hdr.c vk_hdr_native_picture) instead of the 8-bit sRGB one; matching sRGB
// alone left DLAA off for the whole run there (no frame anti-aliased) and with it the frame generation that takes
// DLAA's depth and motion.
static int output_target(VkFormat f) { return srgb8(f) || vk_hdr_native_picture(f); }
double wide_dlss_share(void); // widescreen.c: the DLSS mode's share of the picture (1 DLAA), 0 off
void vk_dlaa_pass(VkExec *ex) {
const VkExecTarget *c = &ex->color[0], *z = &ex->depth;
if (!dl_active()) return;
if (D.done) { // diagnostics: another scene drawn into a light target in the same present interval
if (ex->pass_ncolor == 1 && c->image && scene_color(c->format) && z->image && z->format == VK_FORMAT_D32_SFLOAT &&
c->width == D.color.width && c->height == D.color.height && z->width == c->width)
F.second++, F.second_img = c->image;
return;
}
static int deferred; // a scene-size G-buffer was seen: the deferred shape
unsigned o[2], s[2];
res_sizes(o, s);
// Ocarina's builds carry no scene or output patch sets, so res_sizes reports placeholders there: the sizes come
// from the frame itself (the light target's, and the output pass's).
int scene = z->image && z->format == VK_FORMAT_D32_SFLOAT && z->width >= DLAA_SCENE_MIN_W;
// The G-buffer: several colour targets with the D32F scene depth. 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.
// A pass of that shape smaller than the light target already armed is not one: Ocarina draws a half-size effect
// into three targets with a half-size D32F depth after its scene, and taking that for a G-buffer switched every
// later frame to the deferred shape, where DLSS's and FSR 3.1's smaller modes never found their output pass.
if (ex->pass_ncolor >= 3 && scene && !(D.armed && (z->width < D.color.width || z->height < D.color.height))) {
if (!deferred)
rt_log("dlaa: a G-buffer pass (%d colour targets, depth %ux%u, target 0 format %d): the deferred frame shape",
ex->pass_ncolor, z->width, z->height, c->image ? (int)c->format : 0);
D.gbuf = 1, D.armed = 0, deferred = 1;
// target 0 is the object-class buffer (RGBA8, the scene size): the characters' bias mask reads its green. A
// smaller pass of the same shape (640x360, seen while loading) does not replace the scene's in the same frame.
if (c->image && c->format == VK_FORMAT_R8G8B8A8_UNORM && c->width == z->width && c->height == z->height &&
c->samples <= 1 && !c->is3d && (!D.ids_ok || c->width >= D.ids.width))
D.ids = *c, D.ids_ok = 1;
return;
}
// the scene depth is D32F; a D16 target of the scene size also serves one composite pass before the transparents.
// A smaller pair never takes over an armed one: the camera rune draws a half-size RGBA16F target with a half-size
// D32F depth after the lighting (852x480 under a 1704x960 scene), and DLSS ran on that and wrote its picture into
// the scene's own light target, which left every object black.
if ((D.gbuf || !deferred) && ex->pass_ncolor == 1 && c->image && scene_color(c->format) && scene &&
c->width == z->width && c->height == z->height &&
(!D.armed || (c->width >= D.color.width && c->height >= D.color.height)) && c->samples <= 1 && !c->is3d) {
int first = !D.armed;
D.color = *c, D.depth = *z, D.armed = 1;
static int told;
if (first && !told++)
rt_log("dlaa: first scene armed: light target %ux%u format %d, depth %ux%u", c->width, c->height, (int)c->format,
z->width, z->height);
if (first) mask_snapshot(ex); // the lit scene, before the transparents (reactive mask)
return;
}
if (!D.armed) return;
if (!deferred) { // Ocarina's shape: the output pass ends the scene and runs DLSS
int one = ex->pass_ncolor == 1 && c->image && !z->image && c->image != D.color.image && c->samples <= 1 &&
!c->is3d;
if (one) F.one_n++, F.one_w = c->width, F.one_h = c->height, F.one_fmt = c->format;
// the output pass is the picture's size, the scene over the mode's share: at Ultra Performance (854 wide) a
// 960x540 post pass comes first, and DLSS wrote there, which left a 540-line picture stretched to the output
// A frame whose scene is not at that share (the first presents before the scale patch takes, a dynamic
// resolution step) has no such pass: after a frame that missed DLSS the first pass wider than the scene is
// taken for 120 frames (D.share_off, vk_dlaa_frame), so a mismatch costs one frame rather than every frame.
double share = wide_dlss_share();
int big = D.share_off || share <= 0 || share >= 1 || c->width >= 0.95 * D.color.width / share;
if (one && big && c->width > D.color.width && c->height > D.color.height) {
D.ended = D.done = D.up = 1;
evaluate(ex, c);
} else if (one && output_target(c->format) && c->width == D.color.width &&
c->height == D.color.height) {
D.ended = D.done = 1;
evaluate(ex, NULL);
}
return;
}
if (!D.ended) {
if (!ex->pass_w || ex->pass_w * 4 > D.color.width) return;
D.ended = 1;
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 of the output size, no depth
if (ex->pass_ncolor == 1 && c->image && !z->image && scene_color(c->format) && c->width > D.color.width &&
c->width == o[0] && c->height == o[1] && c->samples <= 1 && !c->is3d) {
D.done = D.up = 1;
evaluate(ex, c);
}
}
// NX2NAVI_DLSS, read at each present (the menu switches it live): the scene size of the mode (resolution.c) and the
// texture bias that goes with it while DLSS runs.
static void dlss_mode(void) {
static char mode[32];
static int bias_on = -1;
const char *m = dynres_override(); // dynamic resolution's step (dynres.c) while it differs from the setting
if (!m) m = cfg_value("NX2NAVI_DLSS");
if (strcmp(m, mode)) {
snprintf(mode, sizeof mode, "%s", m);
res_dlss_mode(m);
bias_on = -1;
}
int b = dl_active();
if (b != bias_on) bias_on = b, vk_sampler_dlss_bias(b ? res_dlss_lod_bias() : 0.0f);
}
// The preset, read again when a setting changed (the menu); a different one recreates the features at the next DLAA run.
static void preset_check(void) {
unsigned v = cfg_version();
if (v == D.cfg_seen) return;
D.cfg_seen = v;
int p = preset_value();
if (p == D.preset) return;
if (D.evals) {
if (p) rt_log("dlaa: DLSS preset %c in every mode; the features are created again", 'A' + p - 1);
else rt_log("dlaa: DLSS presets per mode; the features are created again");
}
D.preset = p, D.preset_dirty = 1, D.reset = 1;
}
void vk_dlaa_frame(void) {
vk_dlaa_swap_img = NULL, vk_dlaa_swap_view = VK_NULL_HANDLE;
dlss_mode();
preset_check();
if (!N.ngx_up) { // FSR 3.1 follows the setting
fsr_frame = fsr3();
N.available = fsr_frame && cfg_bool("NX2NAVI_DLAA") && vk_ffx_load();
}
int on = N.available && cfg_bool("NX2NAVI_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;
memset(&F, 0, sizeof F);
return;
}
if (!dl_active()) return;
if (D.share_off) D.share_off--;
if (!D.done && D.armed) D.share_off = 120; // vk_dlaa_pass: the output pass without the mode's share for a while
if (!D.done) {
D.frames_missed++;
// the first few after DLSS first ran: what the frame drew, to tell a frame drawn another way from a loading screen
if (D.evals && D.miss_logged < 24) {
D.miss_logged++;
char arm[64] = "never armed";
if (D.armed) snprintf(arm, sizeof arm, "armed on a %ux%u light target", D.color.width, D.color.height);
rt_log("dlaa: frame %llu without the DLAA point: %s; %u scene-depth draws (%u into another D32 depth); %u "
"later passes with one colour target and no depth (last %ux%u format %d); %llu submissions since the "
"last present, %d held submissions waiting for a signal",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED), arm, F.zdraws, F.zother,
F.one_n, F.one_w, F.one_h, (int)F.one_fmt, (unsigned long long)(vk_exec_submit_seq - D.seq_present),
vk_exec_held());
}
}
if (D.done && F.second) {
D.seconds++;
if (D.second_logged < 24)
D.second_logged++, rt_log("dlaa: frame %llu: a second scene after DLSS ran (%u passes into light target %p; "
"DLSS ran on %p); %llu submissions since the last present, %d held",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED),
F.second, (void *)F.second_img, (void *)D.color.image,
(unsigned long long)(vk_exec_submit_seq - D.seq_present), vk_exec_held());
}
D.seq_present = vk_exec_submit_seq;
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 = D.ids_ok = 0;
D.cam_addr = 0, D.nviews = 0;
memset(&F, 0, sizeof F);
}
// ---------------------------------------------------------------- the game's FXAA (NX2NAVI_FXAA, live)
// NX2navi'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, the one with patches 0010
// and 0011 (the shadow filter spread) applied, and that one with the zero_locals job flag (Mesa, vk_caps.c).
// 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,
0xaad42238801d31d8ull};
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("NX2NAVI_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) { // the scaling pass, which DLSS replaced
static int told;
if (D.up && !told++) rt_log("dlaa: the game's scaling draw left out, DLSS wrote it (fragment shader %016llx)",
(unsigned long long)h);
return D.up;
}
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;
}