Files
NX2navi/runtime/vk_dlssg.c
chrg6 501d5bd084 Release pass: fix crashes, freezes and races, cut VRAM use, and translate more shaders.
Crashes: the render-target heap (HeapDef DynamicTextureAllocatorMem and its parent) grows with the widescreen
picture, so the pause menu no longer reads a null block at 5120x2160; texture uploads keep the game's memory mapped
while they copy it, so UnmapPhysicalMemory no longer pulls it away mid-copy; DLSS Frame Generation no longer crashes
in Streamline's set-up (physical devices and the window surface go through its proxies, its swapchain images are
counted first, resources are tagged per frame); a stale core-wait target is cleared before its thread is freed.

Freezes and races: a resize during a swapchain rebuild is kept, a failed frame generation swapchain is retried
instead of replaced by a plain one, three acquire timeouts in a row rebuild the swapchain, device waits take the
queue lock, a translator child that stops answering times out, an in-flight compute pipeline builds at normal
priority, a save Commit started before the window closes finishes and none starts after, a settings change just
before closing is saved, and a movie sample taken before a flush is dropped.

HDR: Enhanced HDR extends the game's own tonemap so highlights go above the picture's white (the hue slider,
which no longer applies, is gone from the menu); frame generation gets a HUD-less picture, the HDR flag and the HDR10
metadata under HDR too.

Memory: ASTC textures are encoded to BC3 unless the PC has 20 GiB of VRAM and 48 GiB of RAM, as Windows charges video
memory to the commit charge (a long session held 17 GiB of RGBA8 textures and 45.7 GiB of commit on a 32 GiB PC).

Shaders: the translator lowers spill-mode programs with more than eight uniform register groups in a wider spill
layout, and local loads and stores with a uniform-register address (36029 of the game's 36031 variants translate,
20 failed before).

The launcher release ships the shader tools and AMD's FidelityFX library (make_launcher.py --ffx); windres there gets
the toolchain on PATH.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 16:02:30 -05:00

174 lines
8.0 KiB
C

// DLSS Frame Generation (NX2NAVI_FRAMEGEN = dlss; applies after a restart) through nx2navi_dlssg.dll
// (runtime/dlssg/nx2_sl.cpp), which drives NVIDIA Streamline. Like AMD's frame generation (vk_fg.cpp) it needs DLSS or
// FSR 3.1 upscaling on, whose depth, motion vectors and camera it hands over, and an RTX 40 or 50 GPU.
//
// The DLL and Streamline (sl.interposer.dll and its plugins, nvngx_dlssg.dll) sit next to the game. The instance and
// device are created through Streamline's proxies (vk_device.c), so it can add the extensions, features and queues
// DLSS-G needs; the present path calls Streamline's swapchain functions (gfx_present.c), and every present records the
// frame's constants and tags first (vk_dlssg_frame). Generation pauses while the menu is open.
#ifdef _WIN32
#include <windows.h>
#endif
#include <stdio.h>
#include <string.h>
#include "cfg.h"
#include "host.h"
#include "vk.h"
#include "vk_dlaa.h"
#include "vk_dlssg.h"
#include "dlssg/nx2_sl.h"
#include "ui/menu.h"
static struct {
int wanted, loaded, active;
PFN_nx2sl_init init;
PFN_nx2sl_instance_proc gipa;
PFN_nx2sl_device_proc gdpa;
PFN_nx2sl_available available;
PFN_nx2sl_frame frame;
PFN_nx2sl_present_marker marker;
PFN_nx2sl_shutdown shutdown;
PFN_vkCreateSwapchainKHR create_sc;
PFN_vkDestroySwapchainKHR destroy_sc;
PFN_vkGetSwapchainImagesKHR images;
PFN_vkAcquireNextImageKHR acquire;
PFN_vkQueuePresentKHR present;
} S = {.wanted = -1};
static void sl_line(const char *line) { rt_log("%s", line); }
int vk_dlssg_wanted(void) {
if (S.wanted < 0) {
S.wanted = !strcmp(cfg_value("NX2NAVI_FRAMEGEN"), "dlss");
if (S.wanted && !vk_dlaa_wanted()) {
rt_log("dlssg: frame generation needs DLSS or FSR 3.1 upscaling (any mode): off");
S.wanted = 0;
}
}
return S.wanted;
}
int vk_dlssg_early(void) {
if (!vk_dlssg_wanted()) return 0;
if (S.loaded) return S.loaded > 0;
S.loaded = -1;
#ifdef _WIN32
wchar_t dir[MAX_PATH], path[MAX_PATH + 32];
DWORD n = GetModuleFileNameW(NULL, dir, MAX_PATH);
while (n && dir[n - 1] != L'\\') n--;
dir[n ? n - 1 : 0] = 0;
swprintf(path, MAX_PATH + 32, L"%ls\\nx2navi_dlssg.dll", dir);
HMODULE m = LoadLibraryW(path);
if (!m) {
rt_log("dlssg: nx2navi_dlssg.dll is not next to the game: DLSS Frame Generation off");
return 0;
}
PFN_nx2sl_version ver = (PFN_nx2sl_version)(void *)GetProcAddress(m, "nx2sl_version");
S.init = (PFN_nx2sl_init)(void *)GetProcAddress(m, "nx2sl_init");
S.gipa = (PFN_nx2sl_instance_proc)(void *)GetProcAddress(m, "nx2sl_instance_proc");
S.gdpa = (PFN_nx2sl_device_proc)(void *)GetProcAddress(m, "nx2sl_device_proc");
S.available = (PFN_nx2sl_available)(void *)GetProcAddress(m, "nx2sl_available");
S.frame = (PFN_nx2sl_frame)(void *)GetProcAddress(m, "nx2sl_frame");
S.marker = (PFN_nx2sl_present_marker)(void *)GetProcAddress(m, "nx2sl_present_marker");
S.shutdown = (PFN_nx2sl_shutdown)(void *)GetProcAddress(m, "nx2sl_shutdown");
if (!ver || ver() != NX2SL_VERSION || !S.init || !S.gipa || !S.gdpa || !S.available || !S.frame || !S.marker) {
rt_log("dlssg: nx2navi_dlssg.dll is from another build: DLSS Frame Generation off");
return 0;
}
if (!S.init(dir, sl_line)) return 0;
S.loaded = 1;
return 1;
#else
return 0;
#endif
}
VkResult vk_dlssg_create_instance(const VkInstanceCreateInfo *ci, VkInstance *out) {
PFN_vkCreateInstance f = S.loaded > 0 ? (PFN_vkCreateInstance)S.gipa()(VK_NULL_HANDLE, "vkCreateInstance") : NULL;
return f ? f(ci, NULL, out) : vkCreateInstance(ci, NULL, out);
}
// An instance function through the interposer while Streamline is loaded, else NULL (the caller takes the loader's).
// The window surface goes through it: Streamline learns the window a swapchain shows from vkCreateWin32SurfaceKHR, and
// without that its swapchain hook found "no window corresponding to this application" and generated no frames.
PFN_vkVoidFunction vk_dlssg_instance_proc(VkInstance inst, const char *name) {
return S.loaded > 0 ? S.gipa()(inst, name) : NULL;
}
// The interposer's vkCreateDevice finds the device's instance in a map its own vkEnumeratePhysicalDevices fills; a
// physical device enumerated through the loader alone left it a null instance, so the plugins got an empty instance
// table and sl.common called a null GetPhysicalDeviceMemoryProperties while it set up. Enumerate through it as well.
VkResult vk_dlssg_enumerate(VkInstance inst, uint32_t *n, VkPhysicalDevice *pd) {
PFN_vkEnumeratePhysicalDevices f =
S.loaded > 0 ? (PFN_vkEnumeratePhysicalDevices)S.gipa()(inst, "vkEnumeratePhysicalDevices") : NULL;
return f ? f(inst, n, pd) : vkEnumeratePhysicalDevices(inst, n, pd);
}
VkResult vk_dlssg_create_device(VkInstance inst, VkPhysicalDevice pd, const VkDeviceCreateInfo *ci, VkDevice *out) {
PFN_vkCreateDevice f = S.loaded > 0 ? (PFN_vkCreateDevice)S.gipa()(inst, "vkCreateDevice") : NULL;
return f ? f(pd, ci, NULL, out) : vkCreateDevice(pd, ci, NULL, out);
}
void vk_dlssg_device_ready(VkDevice dev) {
if (S.loaded <= 0 || !S.available()) return;
PFN_vkGetDeviceProcAddr g = S.gdpa();
S.create_sc = (PFN_vkCreateSwapchainKHR)g(dev, "vkCreateSwapchainKHR");
S.destroy_sc = (PFN_vkDestroySwapchainKHR)g(dev, "vkDestroySwapchainKHR");
S.images = (PFN_vkGetSwapchainImagesKHR)g(dev, "vkGetSwapchainImagesKHR");
S.acquire = (PFN_vkAcquireNextImageKHR)g(dev, "vkAcquireNextImageKHR");
S.present = (PFN_vkQueuePresentKHR)g(dev, "vkQueuePresentKHR");
S.active = S.create_sc && S.destroy_sc && S.images && S.acquire && S.present;
rt_log("dlssg: %s", S.active ? "DLSS Frame Generation on the swapchain" : "the swapchain hooks are missing: off");
}
int vk_dlssg_active(void) { return S.active; }
VkResult vk_dlssg_create_swapchain(VkDevice d, const VkSwapchainCreateInfoKHR *ci, VkSwapchainKHR *sc) {
return S.create_sc(d, ci, NULL, sc);
}
void vk_dlssg_destroy_swapchain(VkDevice d, VkSwapchainKHR sc) { S.destroy_sc(d, sc, NULL); }
VkResult vk_dlssg_get_images(VkDevice d, VkSwapchainKHR sc, uint32_t *n, VkImage *img) { return S.images(d, sc, n, img); }
VkResult vk_dlssg_acquire(VkDevice d, VkSwapchainKHR sc, uint64_t t, VkSemaphore sem, uint32_t *idx) {
return S.acquire(d, sc, t, sem, VK_NULL_HANDLE, idx);
}
VkResult vk_dlssg_present(VkQueue q, const VkPresentInfoKHR *pi) {
S.marker(0);
VkResult r = S.present(q, pi);
S.marker(1);
return r;
}
void vk_dlssg_frame(VkCommandBuffer cb, VkExtent2D ext) {
if (!S.active) return;
VkFfxImage d, m;
VkImageView dv, mvv;
VkDlaaCamera c;
float jx = 0, jy = 0;
int reset = 0;
int have = vk_dlaa_fg_inputs(&d, &m, &jx, &jy, &reset) && vk_dlaa_fg_views(&dv, &mvv) && vk_dlaa_fg_camera(&c);
int on = have && !menu_is_open();
Nx2SlImage zd = {d.image, dv, d.format, d.width, d.height, VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT};
Nx2SlImage zm = {m.image, mvv, m.format, m.width, m.height, VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT};
Nx2SlCamera k;
memset(&k, 0, sizeof k);
if (have) {
memcpy(k.view_to_clip, c.view_to_clip, 64), memcpy(k.clip_to_view, c.clip_to_view, 64);
memcpy(k.clip_to_prev_clip, c.clip_to_prev_clip, 64), memcpy(k.prev_clip_to_clip, c.prev_clip_to_clip, 64);
memcpy(k.pos, c.pos, 12), memcpy(k.up, c.up, 12), memcpy(k.right, c.right, 12), memcpy(k.fwd, c.fwd, 12);
k.znear = 0.1f, k.zfar = 1e8f, k.fov_y = c.fov_y, k.aspect = c.aspect; // Ocarina's projection (vk_ffx.cpp)
k.jitter[0] = jx, k.jitter[1] = jy;
k.mv_scale[0] = 1.0f / (float)d.width, k.mv_scale[1] = 1.0f / (float)d.height; // render pixels
k.reset = reset;
}
S.frame(cb, have ? &zd : NULL, have ? &zm : NULL, NULL, have ? &k : NULL, ext.width, ext.height, on);
}
void vk_dlssg_release(void) {
if (S.loaded > 0 && S.shutdown) S.shutdown();
S.active = 0;
}