mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-17 15:49:57 -04:00
Fix shadows, colour writes and present pacing on drivers that read Vulkan's undefined cases differently.
A depth-compare read through a sampler whose compare is off now gets the slot's comparing sampler, as the Switch compares there and only NVIDIA's driver did so on its own. Colour components a fragment shader does not write are masked out, as Maxwell leaves them alone. Without mailbox presentation the swapchain takes relaxed FIFO, or immediate, so a late frame no longer halves the frame rate. NX2NAVI_VK_NOOPT=1 builds pipelines without the driver's optimiser, for a driver whose compiler fails on one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -54,10 +54,10 @@ static const char *const known[] = {
|
||||
"RENDER_SCALE", "REPLAY_ASYNC",
|
||||
"REPLAY_CHECK", "RESOLVE_CHECK", "RESTART_WAIT", "ROMFS", "ROMFS_INDEX", "ROMFS_MMAP", "ROMFS_MODS", "ROMFS_PATCHES",
|
||||
"ROMFS_PROOF_DIR", "ROMFS_VERIFY", "RSTICK_DEADZONE", "RUMBLE", "RUMBLE_CURVE", "RUMBLE_STRENGTH", "RUMBLE_TRIGGERS", "SHADER_CACHE",
|
||||
"SHADER_MEMO", "SHADOW_RANGE", "SHADOW_RES", "SHADOW_SCALE", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR",
|
||||
"SHADER_MEMO", "SHADOW_COMPARE", "SHADOW_RANGE", "SHADOW_RES", "SHADOW_SCALE", "SHARED_FONTS", "SHARPNESS", "SHOTS", "SHOTS_DIR",
|
||||
"SHOTS_FULL", "SPEED_PROBE", "SPIN", "SPIN_HANDOFF_US", "SPLIT_DRAWS", "SPLIT_US", "STICK_DEADZONE", "STICK_SENS",
|
||||
"SWKBD_ANSWER",
|
||||
"SWKBD_TEST", "TEST_PAD", "TEST_PAD_AT", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_MEMO", "TEX_VRAM_PRESSURE", "TIMER_1MS", "TRACE", "TXD_TRANSPOSE", "UBO_SNAPSHOT", "UPSCALER", "VK_DYN_A2C", "VK_DYN_VERTEX", "VK_NO_FLOAT64",
|
||||
"SWKBD_TEST", "TEST_PAD", "TEST_PAD_AT", "TEST_PREPARE_SHADERS", "TEX_ALIAS", "TEX_MEMO", "TEX_VRAM_PRESSURE", "TIMER_1MS", "TRACE", "TXD_TRANSPOSE", "UBO_SNAPSHOT", "UPSCALER", "VK_DYN_A2C", "VK_DYN_VERTEX", "VK_NOOPT", "VK_NO_FLOAT64",
|
||||
"VK_PRESENT", "VK_RECORDER", "VK_SSBO_ALIGN", "VK_SUBGROUP", "VK_SUBGROUP_PIN", "VK_VALIDATION", "VOLUME", "VRAM_HEADROOM", "VS_OUTS",
|
||||
"WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS",
|
||||
"ZSTD_CHECK", "ZSTD_NATIVE",
|
||||
@@ -133,7 +133,7 @@ static const CfgMeta metas[] = {
|
||||
{"HDR_UI_NITS", "203", "80..500", LIVE}, {"HDR_HUE", "80", "0..100", LIVE},
|
||||
{"DEVICE_PROFILE", "auto", "auto|desktop|deck", RESTART},
|
||||
{"SHADOW_RES", "game", "game|256|512|768|1024|1536|2048", RESTART},
|
||||
{"SHADOW_SCALE", "1", "1..4", RESTART},
|
||||
{"SHADOW_SCALE", "1", "1..4", RESTART}, {"SHADOW_COMPARE", "1", "0|1", RESTART}, // vk_texture.c
|
||||
{"SHADOW_RANGE", "100", "50..400", RESTART}, {"CONTACT_SHADOWS", "0", "0..100", RESTART},
|
||||
{"PCSS", "0", "0..200", RESTART},
|
||||
// Game
|
||||
@@ -179,6 +179,7 @@ static const CfgMeta metas[] = {
|
||||
// Vulkan
|
||||
{"VK_VALIDATION", "0", "0|1", RESTART}, {"VK_DYN_VERTEX", "", "0|1", RESTART},
|
||||
{"VK_DYN_A2C", "", "0|1", RESTART}, {"VK_SUBGROUP_PIN", "1", "0|1", RESTART},
|
||||
{"VK_NOOPT", "0", "0|1", RESTART}, // vk_pipeline.c noopt_flag
|
||||
// diagnostics
|
||||
{"TRACE", "", NULL, RESTART}, {"FLIGHT", "0", "0|1", RESTART}, {"FLIGHT_SPIKE_MS", "100", "0..60000", RESTART},
|
||||
{"WB_FENCE_LIMIT", "65536", "0..1073741824", RESTART}, {"WB_MERGE", "1", "0|1", RESTART}, {"WB_EXACT", "1", "0|1", RESTART},
|
||||
|
||||
@@ -115,6 +115,7 @@ int gfx_shader_resources(const GfxShader *s, int kind, const GfxShaderRes **res)
|
||||
uint32_t gfx_shader_slot_mask(const GfxShader *s); // texture/image slots whose type its translation read
|
||||
uint32_t gfx_shader_inputs(const GfxShader *s, GfxShaderIo io[32]); // Input Locations (VS attributes, FS varyings) as a mask
|
||||
uint32_t gfx_shader_outputs(const GfxShader *s, GfxShaderIo io[32]);
|
||||
uint32_t gfx_shader_omap(const GfxShader *s); // FS: colour components it writes, 4 bits per target (SPH omap); 0 unknown
|
||||
uint32_t gfx_shader_mvprev_banks(const GfxShader *s); // a last-frame variant: the banks (bit n: cn) its position reads // Output Locations (VS varyings, FS colour targets)
|
||||
void gfx_shader_local_size(const GfxShader *s, uint32_t local[3]); // CS: the LocalSize execution mode; 1, 1, 1 otherwise
|
||||
|
||||
|
||||
@@ -256,13 +256,23 @@ static VkPresentModeKHR pick_present_mode(VkPhysicalDevice pd) {
|
||||
if (n > 16) n = 16;
|
||||
vkGetPhysicalDeviceSurfacePresentModesKHR(pd, g_surface, &n, m);
|
||||
VkPresentModeKHR got = VK_PRESENT_MODE_FIFO_KHR;
|
||||
for (uint32_t i = 0; i < n; i++) if (m[i] == want) got = want;
|
||||
int relaxed = 0, immediate = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
if (m[i] == want) got = want;
|
||||
relaxed |= m[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR, immediate |= m[i] == VK_PRESENT_MODE_IMMEDIATE_KHR;
|
||||
}
|
||||
// Mailbox missing (several AMD drivers): plain FIFO holds a frame that misses a refresh to the next one, and the
|
||||
// game, paced at 60 on a 60 Hz display, drops to 30 at every slow frame. Relaxed FIFO shows a late frame at once
|
||||
// (a tear that once) and waits for the refresh otherwise; immediate where that is missing too.
|
||||
if (want == VK_PRESENT_MODE_MAILBOX_KHR && got != want)
|
||||
got = relaxed ? VK_PRESENT_MODE_FIFO_RELAXED_KHR : immediate ? VK_PRESENT_MODE_IMMEDIATE_KHR : got;
|
||||
const char *name = got == VK_PRESENT_MODE_MAILBOX_KHR ? "mailbox" : got == VK_PRESENT_MODE_IMMEDIATE_KHR ? "immediate" : "fifo";
|
||||
__atomic_store_n(&g_present_got, name, __ATOMIC_RELEASE);
|
||||
static int logged = -1; // the mode last logged: a change from the menu shows in the log
|
||||
if ((int)got != logged) {
|
||||
logged = (int)got;
|
||||
rt_log("gfx: present mode %s (NX2NAVI_VK_PRESENT=%s)", name, e);
|
||||
rt_log("gfx: present mode %s (NX2NAVI_VK_PRESENT=%s)",
|
||||
got == VK_PRESENT_MODE_FIFO_RELAXED_KHR ? "fifo relaxed" : name, e);
|
||||
}
|
||||
return got;
|
||||
}
|
||||
|
||||
@@ -88,6 +88,8 @@ struct GfxShader {
|
||||
GfxShaderIo in[32], out[32];
|
||||
uint32_t local[3];
|
||||
uint32_t mvprev_banks; // .res.json "mvprev_banks" (patch 0015), 0 none
|
||||
uint32_t omap; // FS: .res.json "frag_out_map", the colour components it writes
|
||||
// (4 bits per target, the SPH omap); 0 unknown (older translations)
|
||||
};
|
||||
|
||||
static PlatMutex cache_lock = PLAT_MUTEX_INIT; // memory cache
|
||||
@@ -861,6 +863,7 @@ static void reflect(GfxShader *s) {
|
||||
s->stage = !strcmp(stage, "cs") ? GFX_STAGE_CS : !strcmp(stage, "ps") ? GFX_STAGE_FS : !strcmp(stage, "ts") ? GFX_STAGE_TS
|
||||
: !strcmp(stage, "ms") ? GFX_STAGE_MS : GFX_STAGE_VS;
|
||||
s->mvprev_banks = (uint32_t)json_int(js, js + strlen(js), "mvprev_banks", 0);
|
||||
s->omap = s->stage == GFX_STAGE_FS ? (uint32_t)json_int(js, js + strlen(js), "frag_out_map", 0) : 0;
|
||||
for (int k = 0; k < GFX_RES_KINDS; k++) {
|
||||
int count = json_objects(js, kinds[k], NULL, s, k);
|
||||
s->res[k] = calloc(count ? count : 1, sizeof *s->res[k]);
|
||||
@@ -1886,6 +1889,8 @@ uint32_t gfx_shader_inputs(const GfxShader *s, GfxShaderIo io[32]) {
|
||||
|
||||
uint32_t gfx_shader_mvprev_banks(const GfxShader *s) { return s->mvprev_banks; }
|
||||
|
||||
uint32_t gfx_shader_omap(const GfxShader *s) { return s->omap; }
|
||||
|
||||
uint32_t gfx_shader_outputs(const GfxShader *s, GfxShaderIo io[32]) {
|
||||
if (io) memcpy(io, s->out, sizeof s->out);
|
||||
return s->out_mask;
|
||||
|
||||
@@ -407,6 +407,9 @@ VkSampler vk_sampler_by_id_locked(int id);
|
||||
// on the Switch although the game binds a linear sampler. VK_NULL_HANDLE
|
||||
// for an empty slot.
|
||||
VkSampler vk_sampler_point_by_id_locked(int id);
|
||||
// The slot's sampler with its compare on, for a depth-compare read (vk_texture.c, at the definition); the slot's own
|
||||
// sampler when it compares already. VK_NULL_HANDLE for an empty slot.
|
||||
VkSampler vk_sampler_compare_by_id_locked(int id);
|
||||
uint32_t vk_texture_slots_gen(void);
|
||||
int vk_texture_slot_count_locked(void);
|
||||
void vk_texture_create_budget_locked(int n); // slot lookups create at most n entries (mapped storage only); -1 any
|
||||
|
||||
@@ -1564,7 +1564,8 @@ static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int sto
|
||||
int sid = (int)(h >> 20 & 0xfff);
|
||||
int point = img && (img->aspect & VK_IMAGE_ASPECT_DEPTH_BIT) && !(r->type & 0x400) &&
|
||||
vk_exec_view_aspect(img, &v, hv) != VK_IMAGE_ASPECT_STENCIL_BIT;
|
||||
samp = point ? vk_sampler_point_by_id_locked(sid) : vk_sampler_by_id_locked(sid);
|
||||
samp = point ? vk_sampler_point_by_id_locked(sid)
|
||||
: r->type & 0x400 ? vk_sampler_compare_by_id_locked(sid) : vk_sampler_by_id_locked(sid);
|
||||
}
|
||||
}
|
||||
if (!view) {
|
||||
|
||||
@@ -1330,6 +1330,17 @@ static int target_count(const VkPipeState *s) {
|
||||
static int is_src1(unsigned f) { return f >= NVN_BLEND_FUNC_SRC1_COLOR && f <= NVN_BLEND_FUNC_ONE_MINUS_SRC1_ALPHA; }
|
||||
// Runs per draw (gkey_fill, target_wmask): only the blend factors of blend-enabled targets are read until one is SRC1,
|
||||
// which NX2navi never sets (0 of 876 pipelines in the field and fight saves).
|
||||
// NX2NAVI_VK_NOOPT=1: pipelines built without the driver's optimiser, for a driver whose shader compiler crashes on
|
||||
// one (the test switch for such a report); slower shaders, the same picture.
|
||||
static VkPipelineCreateFlags noopt_flag(void) {
|
||||
static int on = -1;
|
||||
if (on < 0) {
|
||||
on = cfg_int("NX2NAVI_VK_NOOPT") != 0;
|
||||
if (on) rt_log("vk_pipeline: pipelines built without the driver's optimiser (NX2NAVI_VK_NOOPT)");
|
||||
}
|
||||
return on ? VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT : 0;
|
||||
}
|
||||
|
||||
static int uses_src1(const VkPipeState *s) {
|
||||
for (uint32_t m = s->color.blend_en & 0xffu; m; m &= m - 1) {
|
||||
int i = __builtin_ctz(m);
|
||||
@@ -1347,9 +1358,16 @@ static int uses_src1(const VkPipeState *s) {
|
||||
// too: NX2NAVI's half-res transparency pass binds its linear depth (R32F) as target 7, samples it in the same draws and
|
||||
// writes only targets 0-2, 4 and 5; zeroed, the depth that later passes rebuild from it was 0 in tiles, and the fog
|
||||
// over distant geometry showed rectangles of clear sky.
|
||||
// The same holds per component: a shader that writes a target's RGB and not its alpha leaves the alpha alone on
|
||||
// Maxwell, while Vulkan writes undefined values, and AMD's driver writes whatever its export registers held (NaN and
|
||||
// saturated pixels the bloom then spreads). Components outside the shader's omap are masked out, where it is known.
|
||||
static uint32_t target_wmask(const VkPipeState *s, int i) {
|
||||
uint32_t m = s->chmask.mask >> (4 * i) & 0xf;
|
||||
if (s->fs && !(gfx_shader_outputs(s->fs, NULL) >> i & 1)) m = 0;
|
||||
if (s->fs) {
|
||||
uint32_t c = gfx_shader_omap(s->fs) >> (4 * i) & 0xf;
|
||||
if (c) m &= c;
|
||||
}
|
||||
if (i == 1 && s->fs && P.f_dual_src && uses_src1(s)) m = 0; // output 1 is the second blend source (spirv_dual_source)
|
||||
return m;
|
||||
}
|
||||
@@ -1563,7 +1581,7 @@ static VkPipeline create_graphics(const VkPipeState *s, const GKey *k, const Lay
|
||||
.stageCount = n_stages, .pStages = stages, .pVertexInputState = mesh ? NULL : &vi,
|
||||
.pInputAssemblyState = mesh ? NULL : &ia, .pViewportState = &vp, .pRasterizationState = &rs,
|
||||
.pMultisampleState = &ms, .pDepthStencilState = &ds, .pColorBlendState = &cb,
|
||||
.pDynamicState = &dy, .layout = l->layout};
|
||||
.pDynamicState = &dy, .layout = l->layout, .flags = noopt_flag()};
|
||||
if (k->fbl & 1) pi.flags |= VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT;
|
||||
if (k->fbl & 2) pi.flags |= VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT;
|
||||
uint64_t p0 = perf_begin();
|
||||
@@ -1633,7 +1651,7 @@ static VkPipeline lib_create(int kind, const VkPipeState *s, const GKey *k, VkPi
|
||||
VkPipelineDynamicStateCreateInfo dy = {.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
|
||||
.dynamicStateCount = P.n_dyn, .pDynamicStates = P.dyn};
|
||||
VkGraphicsPipelineCreateInfo pi = {.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .pNext = &ri,
|
||||
.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, .pDynamicState = &dy};
|
||||
.flags = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR | noopt_flag(), .pDynamicState = &dy};
|
||||
VkShaderModule m = VK_NULL_HANDLE;
|
||||
VkPipelineShaderStageCreateInfo st = {.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .pName = "main"};
|
||||
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo rq;
|
||||
@@ -2728,7 +2746,7 @@ static VkPipeline compute_create(const GfxShader *cs, const Layout *l) {
|
||||
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 = l->layout};
|
||||
.layout = l->layout, .flags = noopt_flag()};
|
||||
pin_subgroup32(&ci.stage, &rqc, code, words);
|
||||
// Subgroup operations in a workgroup whose width is a whole number of subgroups need every subgroup full: the
|
||||
// driver may otherwise run partial ones, and a ballot over the culling's candidates then counted differently from
|
||||
|
||||
@@ -75,8 +75,9 @@ typedef struct {
|
||||
view_t v;
|
||||
tex_t t;
|
||||
} TexSlot;
|
||||
typedef struct { samp_par p; VkSampler s, sp; uint8_t used; } SampSlot; // s: vk_sampler_for(&p) once looked up; sp:
|
||||
// its point-sampled form (vk_sampler_point_by_id_locked)
|
||||
typedef struct { samp_par p; VkSampler s, sp, sc; uint8_t used; } SampSlot; // s: vk_sampler_for(&p) once looked up; sp:
|
||||
// its point-sampled form (vk_sampler_point_by_id_locked),
|
||||
// sc its comparing form (vk_sampler_compare_by_id_locked)
|
||||
|
||||
static PlatRMutex tex_lock;
|
||||
static PlatOnce tex_once = PLAT_ONCE_INIT;
|
||||
@@ -2023,7 +2024,7 @@ void vk_sampler_register(int id, const samp_par *s) {
|
||||
sslots = p, nsslots = n;
|
||||
}
|
||||
sslots[id].p = *s;
|
||||
sslots[id].s = sslots[id].sp = VK_NULL_HANDLE;
|
||||
sslots[id].s = sslots[id].sp = sslots[id].sc = VK_NULL_HANDLE;
|
||||
sslots[id].used = 1;
|
||||
samp_gen++;
|
||||
unlock();
|
||||
@@ -2043,7 +2044,7 @@ void vk_sampler_dlss_bias(float b) {
|
||||
lock();
|
||||
if (b != dlss_bias) {
|
||||
dlss_bias = b;
|
||||
for (int i = 0; i < nsslots; i++) sslots[i].s = sslots[i].sp = VK_NULL_HANDLE; // looked up again (the key moves)
|
||||
for (int i = 0; i < nsslots; i++) sslots[i].s = sslots[i].sp = sslots[i].sc = VK_NULL_HANDLE; // looked up again (the key moves)
|
||||
samp_gen++;
|
||||
}
|
||||
unlock();
|
||||
@@ -2100,6 +2101,30 @@ VkSampler vk_sampler_point_by_id_locked(int id) {
|
||||
return s->sp;
|
||||
}
|
||||
|
||||
// A depth-compare read through a sampler without a compare is undefined in Vulkan. NVIDIA's driver compares anyway; AMD's
|
||||
// returns the raw depth, so the game's shadow tests (which sample this way) come out wrong there. Such a read gets the
|
||||
// slot's sampler with the compare on: the game's function when it set a valid one, LEQUAL otherwise, as NVIDIA's driver
|
||||
// compares. NX2NAVI_SHADOW_COMPARE=0 binds the game's sampler as it is.
|
||||
VkSampler vk_sampler_compare_by_id_locked(int id) {
|
||||
VkCtx *c = vk_ctx();
|
||||
if (!c || id < 0 || id >= nsslots || !sslots[id].used) return VK_NULL_HANDLE;
|
||||
SampSlot *s = &sslots[id];
|
||||
static int on = -1;
|
||||
if (on < 0) on = cfg_int("NX2NAVI_SHADOW_COMPARE") != 0;
|
||||
if (s->p.cmp_mode || !on) return vk_sampler_by_id_locked(id);
|
||||
if (!s->sc) {
|
||||
samp_par k = s->p;
|
||||
k.cmp_mode = 1;
|
||||
if (k.cmp_func < NVN_COMPARE_FUNC_NEVER || k.cmp_func > NVN_COMPARE_FUNC_ALWAYS) k.cmp_func = NVN_COMPARE_FUNC_LEQUAL;
|
||||
static int told;
|
||||
if (told++ < 8)
|
||||
rt_log("vk: a depth-compare read through sampler slot %d without a compare (function %u): compared with %u", id,
|
||||
(unsigned)s->p.cmp_func, (unsigned)k.cmp_func);
|
||||
s->sc = sampler_for(c, &k);
|
||||
}
|
||||
return s->sc;
|
||||
}
|
||||
|
||||
VkSampler vk_sampler_by_id(int id) {
|
||||
lock();
|
||||
VkSampler v = vk_sampler_by_id_locked(id);
|
||||
|
||||
Reference in New Issue
Block a user