mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-16 09:39:58 -04:00
Jitter was off on Ocarina because with it the ground and characters went white within seconds. The cause: the game draws its depth pre-pass into the scene depth, copies it into a second image of the same size, and shades the same geometry into the light target against the copy with the depth test EQUAL. Only the draws into the first image took the jitter, so the shading draws compared unjittered depth with jittered depth, EQUAL failed on nearly every pixel, and the light target kept its clear colour. Frame dumps with and without jitter show the shading passes darkening the light target from a mean of 133 to 13 without it and leaving it at 112 with it. On Ocarina's frame every draw that projects through the camera (it binds the scene context at c3) into a D32F depth of the scene's size now takes the jitter, and full-screen passes drawn with a scene depth attached do not: the bloom composite DLSS reads would otherwise move the picture by the jitter a second time. The viewport is recorded again whenever a draw's jitter differs from the last one recorded. Jitter is on for Ocarina by default (dlaa_jitter = 0 still turns it off), and the DLAA log line counts jittered frames and draws. Checked in Hyrule Field with the camera turning: the picture's brightness matches the run without jitter (mean 33 to 63 against 35 to 60; 144 to 188 before the fix), and in 20 motion-vector checks the warp error is lowest with the jitter applied as DLSS is told it (0.032 to 0.077), against 0.076 to 0.141 with its sign flipped and 0.059 to 0.106 left out, still cameras included: the scene moves by the jitter of that frame, in render pixels. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
98 lines
7.3 KiB
C
98 lines
7.3 KiB
C
// DLAA (vk_dlaa.c): NVIDIA DLSS at the scene's own size, behind NX2NAVI_DLAA (nx2navi.ini dlaa = 1).
|
|
#pragma once
|
|
#include "vk.h"
|
|
#include "vk_ffx.h"
|
|
|
|
// The narrowest scene the DLSS pass and the motion passes recognise by its D32F depth: Ultra Performance at a 1080p
|
|
// output renders 640 wide, smaller windows less.
|
|
#define DLAA_SCENE_MIN_W 320u
|
|
|
|
int vk_dlaa_wanted(void); // the setting is on (the device may still lack DLSS)
|
|
// DLSS Frame Generation through NGX itself (vk_dlaa.c vk_ngxfg_*, gfx_present.c's presenter): NX2NAVI_FRAMEGEN = dlss
|
|
// where Streamline does not run (every build but the Windows one, where these all answer 0).
|
|
typedef struct { VkImage img; VkImageView view; VkFormat fmt; uint32_t w, h; } VkNgxImage; // in GENERAL
|
|
int vk_ngxfg_wanted(void); // this run can generate frames through NGX (DLSS upscaling on at the start)
|
|
int vk_ngxfg_max(void); // generated frames per rendered one the GPU allows (1 = 2x, 5 = 6x), 0 when unavailable
|
|
int vk_ngxfg_on(void); // ... and NX2NAVI_FRAMEGEN = dlss now (the menu switches it live)
|
|
void vk_ngxfg_reset(void); // the next generation starts without history (a resize, the menu)
|
|
// Records count generated frames into out[] and a copy of bb into real; returns how many were made (0: none, and real
|
|
// is not written).
|
|
int vk_ngxfg_evaluate(VkCommandBuffer cb, const VkNgxImage *bb, const VkNgxImage *hudless, const VkNgxImage *out, int count,
|
|
const VkNgxImage *real);
|
|
int vk_dlaa_fsr3(void); // the setting is on and its upscaler is AMD FSR 3.1, which loads
|
|
int vk_dlaa_needs_restart(void); // the menu's upscaler cannot start in this run
|
|
// Frame generation (vk_fg.cpp): the depth and motion vectors of the frame DLSS or FSR 3.1 last ran on, with its jitter
|
|
// and whether its history reset; 1 once per evaluation (0: none since the last call). The images stay valid until the
|
|
// next frame's scene draws over them, after this present.
|
|
int vk_dlaa_fg_inputs(VkFfxImage *depth, VkFfxImage *mv, float *jx, float *jy, int *reset);
|
|
// ... their views, and this frame's camera for DLSS Frame Generation (vk_dlssg.c): matrices for row vectors (v * M, the
|
|
// rows stored in order), as Streamline takes them; 0 without a camera that frame.
|
|
// znear and zfar: the view distances the depth buffer holds as 0 and 1 (1 and 0 when inverted), from the frame's own
|
|
// projection and the device's depth mode (vk_dlaa.c proj_planes); with an infinite far plane (infinite) zfar is
|
|
// VK_DLAA_FAR_INFINITE, a distance no surface reaches.
|
|
#define VK_DLAA_FAR_INFINITE 1e8f
|
|
typedef struct {
|
|
float view_to_clip[16], clip_to_view[16], clip_to_prev_clip[16], prev_clip_to_clip[16];
|
|
float pos[3], up[3], right[3], fwd[3];
|
|
float fov_y, aspect;
|
|
float znear, zfar;
|
|
int infinite, inverted;
|
|
} VkDlaaCamera;
|
|
int vk_dlaa_fg_views(VkImageView *depth, VkImageView *mv);
|
|
// The picture without the HUD at the size of the game's picture, in *fmt: RGBA8 UNORM bytes like it (sRGB-encoded), or
|
|
// RGBA16F linear with HDR on; made at each evaluation while vk_dlaa_hudless_wanted (frame generation sets it); 1 once per
|
|
// evaluation.
|
|
extern int vk_dlaa_hudless_wanted;
|
|
int vk_dlaa_fg_hudless(VkImage *img, VkImageView *view, uint32_t *w, uint32_t *h, VkFormat *fmt);
|
|
int vk_dlaa_fg_camera(VkDlaaCamera *c); // ... and its temporal upscaler is AMD FSR 3.1 (NX2NAVI_TAA = fsr3) instead of DLSS
|
|
int vk_dlaa_ffx_camera(VkFfxCamera *c); // the same camera as FSR takes it (vk_ffx.h); 0 without one that frame
|
|
// vk_device.c: NGX's instance and device extensions join the lists (room for max names); vk_dlaa_init after the
|
|
// device exists brings NGX up and checks that DLSS is available.
|
|
void vk_dlaa_instance_exts(const char **ext, uint32_t *n, uint32_t max);
|
|
void vk_dlaa_device_exts(const VkExtensionProperties *have, uint32_t nhave, const char **ext, uint32_t *n, uint32_t max);
|
|
void vk_dlaa_init(void);
|
|
// vk_device.c destroy_all, once the device is idle and before the allocator and the device go (Linux): releases the NGX
|
|
// features and parameters, frees every image, buffer, pipeline and query pool DLAA made, resets its state for a later
|
|
// device and shuts NGX down for this one. Safe when NGX never came up, when nothing was made, and more than once.
|
|
// Windows: does nothing.
|
|
void vk_dlaa_release(void);
|
|
// 1 when dlaa is on and NGX came up with DLSS (after vk_dlaa_init): a DLSS mode's smaller scene is scaled up by DLSS.
|
|
int vk_dlaa_available(void);
|
|
// The video memory DLSS reports for its features (NGX's statistics), for the log; -1 while unknown.
|
|
int64_t vk_dlaa_vram(void);
|
|
// vk_exec.c vk_exec_pass_begin, once the pass's targets are resolved and before its barrier: arms the frame on the
|
|
// scene's light target or, at the first quarter-width pass after it, runs DLAA on that target. Each present ends the
|
|
// frame (vk_dlaa_frame).
|
|
typedef struct VkExec VkExec;
|
|
void vk_dlaa_pass(VkExec *ex);
|
|
void vk_dlaa_frame(void);
|
|
// 1 once, at the present of the first frame whose scene has a new size after a setting changed (vk_dlaa.c).
|
|
int vk_dlaa_resized_take(void);
|
|
// vk_exec_draw.c, each draw before its fixed state is recorded: notes the scene camera block (vk_dlaa_draw), and moves
|
|
// the viewport of the scene's draws by the frame's jitter (vk_dlaa_viewport, when the viewport is recorded).
|
|
void vk_dlaa_draw(VkExec *ex);
|
|
void vk_dlaa_viewport(VkExec *ex, VkViewport *v);
|
|
void vk_dlaa_jitter_check(VkExec *ex); // before each draw's fixed state: records the viewport again where its jitter changes
|
|
// vk_mvsurvey.c (NX2NAVI_MV_SURVEY): notes the uniform blocks of each scene draw, beside vk_dlaa_draw; each present
|
|
// compares them with the previous frames' and logs a summary now and then.
|
|
void vk_mvsurvey_draw(VkExec *ex);
|
|
void vk_mvsurvey_frame(void);
|
|
void vk_mvprev_draw(VkExec *ex); // vk_mvprev.c: notes the scene draw's object and bone blocks
|
|
// Per-object motion (vk_exec_draw.c): the moving scene draws are listed again during the replay with
|
|
// their vertex shader's last-frame variant; vk_dlaa.c mv_pass records them over the camera motion into ex->cb (and
|
|
// leaves every binding of the replay to be set again; draws whose camera block is not cam are left out).
|
|
// vk_dlaa_prev_camera: last frame's camera block and this frame's jitter, 0 when there is no history.
|
|
int vk_mvobj_execute(VkExec *ex, uint64_t cam, VkImageView mv, VkImageView depth, VkFormat depth_fmt, uint32_t w,
|
|
uint32_t h);
|
|
int vk_dlaa_prev_camera(VkDescriptorBufferInfo *out, float jitter[2]);
|
|
// vk_mvcheck.c (NX2NAVI_MV_CHECK, test): mv_pass hands it the motion image after the camera pass and, after the object
|
|
// pass, the motion image again and the scene light target it ran on; it measures how well the vectors fit the picture.
|
|
void vk_mvcheck_camera(VkCommandBuffer cb, VkImage mv, uint32_t w, uint32_t h, float jx, float jy);
|
|
void vk_mvcheck_final(VkCommandBuffer cb, uint64_t fence, VkImage mv, VkImage cimg, VkFormat cfmt, uint32_t level,
|
|
uint32_t layer, uint32_t w, uint32_t h, float jx, float jy);
|
|
const char *vk_mvobj_frame_masks(void); // vk_exec_draw.c: the last motion list, per position and changed banks
|
|
void vk_mvcheck_output(VkCommandBuffer cb, VkImage out, uint32_t ow, uint32_t oh); // after DLSS on a check frame
|
|
// vk_exec_draw.c, once a draw's fragment shader is known: 1 skips the draw (the game's FXAA while NX2NAVI_FXAA is 0, its
|
|
// scaling draw when DLSS wrote the scaled picture).
|
|
int vk_dlaa_skip_draw(VkExec *ex, const GfxShader *fs);
|