diff --git a/runtime/vk_backend.c b/runtime/vk_backend.c index 09ec7e5e..497529a8 100644 --- a/runtime/vk_backend.c +++ b/runtime/vk_backend.c @@ -345,6 +345,7 @@ void gfx_exit_log(void) { static void vk_be_present(const tex_t *t, const int crop[4], uint64_t at_ns) { static _Thread_local int pcore; // the game's render thread: the one that presents if (!pcore) pcore = 1, perf_core_thread(PCORE_RENDER); + vk_dlaa_game_present(); // the camera jitter moves on with the game's frames (vk_dlaa.c) vk_sync_start(); if (!gfx_replay_async()) { uint64_t frame = __atomic_add_fetch(&gfx_counters.frames, 1, __ATOMIC_RELAXED); diff --git a/runtime/vk_dlaa.c b/runtime/vk_dlaa.c index d224dd47..b29c19db 100644 --- a/runtime/vk_dlaa.c +++ b/runtime/vk_dlaa.c @@ -951,6 +951,8 @@ static void next_jitter(uint32_t w, uint32_t ow) { // view-projection, rows 3-6, each a 64-byte memcpy, which ov_memcpy hands over): a perspective camera with the scene's // aspect, the main one and its half-size copy among them, gets the offset in its projection's centre terms and the same // in its view-projection, x_clip += sx w and y_clip += sy w. Its shadow cascades are orthographic and stay as they are. +// The offset moves on at the first projection copied after each of the game's presents (vk_dlaa_game_present): the game +// fills two sets of blocks in turn, one per frame, so a block written again is not a new frame. // The replay reads the offset back from the snapshot of the scene camera's block (cam_offset, the snapshot is the block // as of the submit) for DLSS, the motion vectors and the per-object pass, which reproject with the camera unjittered; // after the DLSS point the snapshots of the jittered blocks are written back unjittered (cam_unjitter), so the effects @@ -964,8 +966,9 @@ static void next_jitter(uint32_t w, uint32_t ow) { static struct { PlatMutex lk; - uint64_t seen[CAMJ_BLOCKS]; // blocks whose projection was copied since the jitter last moved on - int nseen; + uint64_t presents, moved; // the game's presents, and their count when the offset last moved on + struct { uint64_t blk; float sx, sy; } cur[CAMJ_BLOCKS]; // this frame's blocks and the offset each projection took + int ncur; uint64_t blocks[CAMJ_BLOCKS]; // every block that took an offset (cam_unjitter) int nblocks; uint32_t idx; // phases handed out @@ -988,6 +991,8 @@ static int in_list(const uint64_t *l, int n, uint64_t a) { return 0; } +void vk_dlaa_game_present(void) { __atomic_add_fetch(&CJ.presents, 1, __ATOMIC_RELEASE); } + // The game's thread, after a 64-byte memcpy: lr is the copy's return address into the game, dst where it copied to. void vk_dlaa_camera_copied(uint64_t lr, uint64_t dst) { if ((lr != CAMJ_P_LR && lr != CAMJ_VP_LR) || !cam_mode()) return; @@ -1004,10 +1009,11 @@ void vk_dlaa_camera_copied(uint64_t lr, uint64_t dst) { plat_mutex_unlock(&CJ.lk); return; } - if (in_list(CJ.seen, CJ.nseen, blk)) { // the game copies each camera once a frame: a block again is a new frame + uint64_t pf = __atomic_load_n(&CJ.presents, __ATOMIC_ACQUIRE); + if (pf != CJ.moved) { // the first projection of a new frame static int nj = -1; if (nj < 0) nj = !rt_knob("DLAA_JITTER", "1"); - CJ.nseen = 0, CJ.sx = CJ.sy = 0.0f; + CJ.moved = pf, CJ.ncur = 0, CJ.sx = CJ.sy = 0.0f; if (dl_active() && !__atomic_load_n(&D.hold, __ATOMIC_RELAXED) && !nj && s[0] && s[1]) { double r = (double)o[0] / s[0]; uint32_t ph = (uint32_t)ceil(8.0 * r * r - 1e-6); @@ -1017,14 +1023,19 @@ void vk_dlaa_camera_copied(uint64_t lr, uint64_t dst) { CJ.sy = -2.0f * (halton(i, 3) - 0.5f) / (float)s[1]; // and down: NDC +y is the top row } } - if (CJ.nseen < CAMJ_BLOCKS) CJ.seen[CJ.nseen++] = blk; if (CJ.sx != 0.0f || CJ.sy != 0.0f) { m[2] -= CJ.sx, m[6] -= CJ.sy; if (!in_list(CJ.blocks, CJ.nblocks, blk) && CJ.nblocks < CAMJ_BLOCKS) CJ.blocks[CJ.nblocks++] = blk; + int i = 0; + while (i < CJ.ncur && CJ.cur[i].blk != blk) i++; + if (i < CAMJ_BLOCKS) CJ.cur[i].blk = blk, CJ.cur[i].sx = CJ.sx, CJ.cur[i].sy = CJ.sy, CJ.ncur += i == CJ.ncur; } - } else if ((CJ.sx != 0.0f || CJ.sy != 0.0f) && in_list(CJ.seen, CJ.nseen, blk) && - in_list(CJ.blocks, CJ.nblocks, blk)) { - for (int k = 0; k < 4; k++) m[k] += CJ.sx * m[12 + k], m[4 + k] += CJ.sy * m[12 + k]; + } else { // the view-projection takes the offset its block's projection took this frame + for (int i = 0; i < CJ.ncur; i++) + if (CJ.cur[i].blk == blk) { + for (int k = 0; k < 4; k++) m[k] += CJ.cur[i].sx * m[12 + k], m[4 + k] += CJ.cur[i].sy * m[12 + k]; + break; + } } plat_mutex_unlock(&CJ.lk); } diff --git a/runtime/vk_dlaa.h b/runtime/vk_dlaa.h index 719c5171..f06b7a6d 100644 --- a/runtime/vk_dlaa.h +++ b/runtime/vk_dlaa.h @@ -44,6 +44,7 @@ int vk_mvobj_execute(VkExec *ex, uint64_t cam, VkImageView mv, VkImageView depth int vk_dlaa_prev_camera(VkDescriptorBufferInfo *out, float jitter[2]); // nvn_api_core.c ov_memcpy, after a 64-byte copy on the game's thread: the camera jitter of 1.4.3 (vk_dlaa.c). void vk_dlaa_camera_copied(uint64_t lr, uint64_t dst); +void vk_dlaa_game_present(void); // vk_backend.c, each of the game's presents, on its thread // vk_mvcheck.c (TOTK_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);