diff --git a/runtime/boot.c b/runtime/boot.c index 0bb7e505..382ac850 100644 --- a/runtime/boot.c +++ b/runtime/boot.c @@ -21,13 +21,14 @@ #include "vk.h" #define SYM_INIT_START "_ZN2nn4init5StartEmmPFvvES2_S2_" -// main: return addresses of nnMain's SetFocusHandlingMode call (section 0.4; 1.4.3: MNG scripts/verify_boot.py:9) and -// of the first nvnBootstrapLoader call, per game version. +// main: return addresses of nnMain's SetFocusHandlingMode call (1.2.1 from this port's analysis of main; 1.4.3 from +// MacNativeGames' scripts/verify_boot.py) and of the first nvnBootstrapLoader call, per game version. #define CHECKPOINT_RET (RT_V143 ? 0xbdb48cull : 0xe7a954ull) #define NVN_RET (RT_V143 ? 0xbe0360ull : 0xe7eb2cull) #define CTOR_DONE 2 // a module's constructor flag after its DT_INIT ran the init_array -// The init_array sizes (1.2.1: section 0.1; 1.4.3: DT_INIT_ARRAYSZ); MacNativeGames' boot check expects the same. +// The init_array sizes (1.2.1: counted in the modules; 1.4.3: DT_INIT_ARRAYSZ); MacNativeGames' boot check expects +// the same. typedef struct { const char *name; uint64_t entries; } InitCount; static const InitCount inits_121[] = {{"main", 10673}, {"subsdk0", 45}, {"sdk", 116}}; static const InitCount inits_143[] = {{"main", 10717}, {"subsdk0", 45}, {"sdk", 83}}; diff --git a/runtime/gfx.h b/runtime/gfx.h index d317382f..5acadd2a 100644 --- a/runtime/gfx.h +++ b/runtime/gfx.h @@ -97,7 +97,7 @@ uint32_t gfx_shader_inputs(const GfxShader *s, GfxShaderIo io[32]); // Input uint32_t gfx_shader_outputs(const GfxShader *s, GfxShaderIo io[32]); // 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 -// ---- back end (gfx_null.c, vk_*.c). Called by nvn_api.c on guest threads. +// ---- back end (gfx_null.c, vk_*.c). Called by the NVN front end (nvn_api_*.c, nvn_ext.c) on guest threads. typedef struct { const char *name; int (*pool_init)(pool_t *p); // 0 fails MemoryPoolInitialize @@ -129,7 +129,7 @@ const GfxBackend *gfx_backend(void); // TOTK_GPU=null|vulk void nvn_procs_register(void); // hostfn_register every proc; before hostfn_seal (ov_gfx.c) uint64_t nvn_proc_address(const char *name); // synthetic host address of a proc, 0 for an unknown name -// ---- statistics and frames (nvn_api.c, vk_*.c; boot.c prints them) +// ---- statistics and frames (nvn_api_*.c, vk_*.c; boot.c prints them) typedef struct { uint64_t frames, nvn_calls, nvn_distinct, unimplemented, validation_errors, shader_failures, draws_skipped; } GfxStats; GfxStats gfx_stats(void); diff --git a/runtime/gfx_shader.c b/runtime/gfx_shader.c index 4f06272a..4df23fea 100644 --- a/runtime/gfx_shader.c +++ b/runtime/gfx_shader.c @@ -1,8 +1,8 @@ // Shader service client: turns an NVN program (control section, code, c1 constants and the // translator's answers) into SPIR-V plus reflection through `totk_xlate.exe --serve` children, started lazily with -// pipes and kept for the life of the process (a pool: TOTK_XLATE_PROCS at run time, more for the boot prewarm). Results -// are cached in memory and on disk (build/v121/shader-cache/.spv and .res.json), so a shader is translated -// once per machine and translator. +// pipes and kept for the life of the process (a pool: TOTK_XLATE_PROCS at run time, more for the boot prewarm). +// Results are cached in memory and on disk (shader-cache/.spv and .res.json next to totk.exe), so a shader +// is translated once per machine and translator. // // Keys. The code hash is sha256 over stage (u32), the 0x880-byte control section, code_size (u64), the code, the c1 // length (u32) and bytes. Per code hash and translator the cache holds a use mask (pub.init; if (!init) return 0; @@ -566,7 +566,8 @@ uint64_t ldr_plt_stub(const char *module, const char *name) { } // ---- --probe-loader -// Expected values, measured on the 1.2.1 and 1.4.3 modules (1.4.3 relocation totals match MNG v1.4.3-port.md:20). +// Expected values, measured on the 1.2.1 and 1.4.3 modules; the 1.4.3 relocation totals match the ones +// MacNativeGames' port notes give for that version. typedef struct { const char *name; uint64_t kinds[K_COUNT], total, sym_import, sym_own; diff --git a/runtime/memory.c b/runtime/memory.c index 0af559d7..5d1d7c11 100644 --- a/runtime/memory.c +++ b/runtime/memory.c @@ -604,7 +604,7 @@ uint32_t mem_query(uint64_t a, RtMemoryInfo *out) { r.perm = PERM_RX; } // Moved stacks: the destination is Stack, the source Normal without access; free and normal regions around them - // are clipped (MNG services.c:357-363). + // are clipped (MNG services.c). for (unsigned i = 0; i < nstack_maps; i++) { const StackMap *m = &stack_maps[i]; uint64_t end = m->dst + m->size, send = m->src + m->size; diff --git a/runtime/nvn_api_cmd.c b/runtime/nvn_api_cmd.c index b05b1da2..ece6999b 100644 --- a/runtime/nvn_api_cmd.c +++ b/runtime/nvn_api_cmd.c @@ -750,7 +750,7 @@ NVN_API(nvnCommandBufferDrawElementsInstanced) { } // void nvnCommandBufferDrawElementsIndirect(NVNcommandBuffer *cmd, NVNdrawPrimitive prim, NVNindexType type, // NVNbufferAddress indices, NVNbufferAddress indirect): the arguments at indirect are often GPU-written, so the replay -// draws with vkCmdDrawIndexedIndirect from the pool buffer (nxnative hle_nvn.c:2160, SavageWindRecomp cmdbuf.c:608) +// draws with vkCmdDrawIndexedIndirect from the pool buffer (nxnative hle_nvn.c, SavageWindRecomp cmdbuf.c) NVN_API(nvnCommandBufferDrawElementsIndirect) { *REC(cmd_of(c), OP_DRAW_IDX_IND, p_draw_idx_ind) = (p_draw_idx_ind){(int)arg_x(c, 1), (int)arg_x(c, 2), arg_x(c, 3), arg_x(c, 4)}; } @@ -831,7 +831,7 @@ NVN_API(nvnCommandBufferCopyTextureToTexture) { // void nvnCommandBufferDownsample(NVNcommandBuffer *cmd, const NVNtexture *src, const NVNtexture *dst): level 0 of src // into level 0 of dst, whole extents, filtered. Recorded as a linear-filter texture copy: copy_t2t resolves a // multisample source into an equal-size target and blits (2x2 average at half size) between sizes. As nxnative -// hle_nvn.c:2219 and SavageWindRecomp cmdbuf.c:650 record it; maxwell.md 1.19. +// hle_nvn.c and SavageWindRecomp cmdbuf.c record it; docs/maxwell.md 1.19. NVN_API(nvnCommandBufferDownsample) { p_copy_t2t *o = REC(cmd_of(c), OP_COPY_T2T, p_copy_t2t); o->src = tex_pin(arg_p(c, 1)); diff --git a/runtime/nvn_api_core.c b/runtime/nvn_api_core.c index e672878e..51c80c74 100644 --- a/runtime/nvn_api_core.c +++ b/runtime/nvn_api_core.c @@ -130,7 +130,7 @@ const pool_t *nvn_pool_find(uint64_t addr, uint64_t len) { return p; } -// Physical and virtual pools (MacNativeGames totk_vpool.c:32-52 checks). A CPU-invisible one gets a GPU window range. +// Physical and virtual pools (MacNativeGames totk_vpool.c checks). A CPU-invisible one gets a GPU window range. // A CPU-visible physical pool (1.4.3: flags 0x18c, GPU_NO_ACCESS) keeps the game's storage for the CPU; the back end // gives it device memory as any physical pool (vk_memory.c vk_pool_init), which the GPU reaches through virtual pools. static int pool_place(pool_t *o) { @@ -344,7 +344,7 @@ NVN_API(nvnMemoryPoolMap) { if (o->magic != NVN_POOL_MAGIC || (o->flags & NVN_MEMORY_POOL_FLAGS_CPU_NO_ACCESS)) { ret_x(c, 0); return; } ret_x(c, (uintptr_t)o->mem); } -// MacNativeGames totk_vpool.c:54-67: every request is checked before any mapping changes. +// MacNativeGames totk_vpool.c: every request is checked before any mapping changes. static int check_request(const pool_t *v, const nvn_mapping_t *r, int i) { uint64_t end = (uint64_t)r->virtual_offset + r->size; if (r->virtual_offset < 0 || r->physical_offset < 0 || !r->size) { @@ -617,7 +617,7 @@ NVN_API(nvnQueueSubmitCommands) { __atomic_store_n(&lod_issued, no, __ATOMIC_SEQ_CST); } -// The producer releases the read lock on obj+0x538 at lr 0x70008c70c8 (main_0103.c f_70008c6460); when +// The producer (1.2.1 main f_70008c6460) releases the read lock on obj+0x538 at lr 0x70008c70c8; when // [obj+0x529] == [obj+0x528] (x19 = obj) it goes on to rewrite the back half. Waits off the core, at most ~400 ms. static void obs_release_read(Cpu *c) { uint64_t lr = c->x[30], obj = c->x[19]; diff --git a/runtime/nvn_ext.c b/runtime/nvn_ext.c index 11346faf..2aa78324 100644 --- a/runtime/nvn_ext.c +++ b/runtime/nvn_ext.c @@ -164,7 +164,7 @@ NVN_API(nvnTextureViewSetSwizzle) { v->set_swizzle = 1; } // void nvnTextureViewSetDepthStencilMode(NVNtextureView *v, NVNtextureDepthStencilMode mode): STENCIL makes the replay -// sample a depth-stencil texture through a stencil-aspect view (vk_exec_draw.c get_view; nxnative hle_nvn.c:1935) +// sample a depth-stencil texture through a stencil-aspect view (vk_exec_draw.c get_view; nxnative hle_nvn.c) NVN_API(nvnTextureViewSetDepthStencilMode) { uint32_t m = (uint32_t)arg_x(c, 1); if (m > NVN_TEXTURE_DEPTH_STENCIL_MODE_STENCIL) rt_fatal("nvn: invalid texture view depth-stencil mode %u", m); diff --git a/runtime/nvn_obj.h b/runtime/nvn_obj.h index 36031365..662ba149 100644 --- a/runtime/nvn_obj.h +++ b/runtime/nvn_obj.h @@ -3,7 +3,8 @@ // Objects are stored in place in the NVN object memory allocated by the game, with size not exceeding the reserved size in nvn.h (FITS static assertion). // State objects (Blend / Color / ... 4–0x18 bytes) are small structs the game copies by value; their layout is packed in place with bit-fields. // -// In this port the interface layer is runtime/nvn_api.c and the replay layers are the back ends of gfx.h (GfxBackend). +// In this port the interface layer is runtime/nvn_api_*.c and nvn_ext.c, and the replay layers are the back ends of +// gfx.h (GfxBackend). #pragma once #include #include diff --git a/runtime/nvn_pool_index.h b/runtime/nvn_pool_index.h index f808803c..eaf8d331 100644 --- a/runtime/nvn_pool_index.h +++ b/runtime/nvn_pool_index.h @@ -4,7 +4,7 @@ /* TOTK: memory pools sorted by guest address. The world scene keeps about 3,200 pools alive, and the replay resolves several dozen buffer addresses per draw (vertex / index / uniform / storage bindings). A linear scan of all pools for each of them was the largest part of - the ~87k instructions per draw. Lookups are now a binary search on the range start plus a backwards walk that is + the ~87k instructions per draw. Lookups are a binary search on the range start plus a backwards walk that is bounded by a running maximum of the range ends, so a pool nested inside or overlapping another is still found. Not thread-safe: the caller holds the pool mutex for every call. */ #include diff --git a/runtime/nvn_probe.c b/runtime/nvn_probe.c index 5dfcfa68..39fb726d 100644 --- a/runtime/nvn_probe.c +++ b/runtime/nvn_probe.c @@ -107,7 +107,7 @@ static void probe_device_and_pools(void) { CHECK(nvn_pool_find(U(pmem) + 0x100, 0x200) == P() && !nvn_pool_find(U(pmem) + PROBE_POOL_SIZE - 8, 16), "pool index"); n_objects += 6; - // refused: no storage, PHYSICAL | VIRTUAL, a size that is not a 64 KiB multiple (MNG totk_vpool.c:32-52) + // refused: no storage, PHYSICAL | VIRTUAL, a size that is not a 64 KiB multiple (MNG totk_vpool.c) static NVNmemoryPool bad; CHECK(make_pool(&bad, NULL, 0x10000, NVN_MEMORY_POOL_FLAGS_CPU_CACHED) == 0, "a pool without storage is refused"); CHECK(make_pool(&bad, gmem, PROBE_GPOOL_SIZE, NVN_MEMORY_POOL_FLAGS_PHYSICAL | NVN_MEMORY_POOL_FLAGS_VIRTUAL) == 0, diff --git a/runtime/nvn_procs.c b/runtime/nvn_procs.c index 9ee03374..dac46453 100644 --- a/runtime/nvn_procs.c +++ b/runtime/nvn_procs.c @@ -1,7 +1,7 @@ // NVN proc table. Every name the game's proc loader asks for gets a synthetic host // address through hostfn_register before hostfn_seal; nvnBootstrapLoader and nvnDeviceGetProcAddress hand them out. -// nvnp_ is the implementation of one proc: the weak definitions here stop with the proc's name, nvn_api.c and -// nvn_ext.c define the strong ones. The name list is runtime/nvn_procs.inc (tools/gen_nvn_procs.py). +// nvnp_ is the implementation of one proc: the weak definitions here stop with the proc's name, nvn_api_*.c +// and nvn_ext.c define the strong ones. The name list is runtime/nvn_procs.inc (tools/gen_nvn_procs.py). #include #include #include diff --git a/runtime/ov_system.c b/runtime/ov_system.c index 91574d6c..d3d98878 100644 --- a/runtime/ov_system.c +++ b/runtime/ov_system.c @@ -298,7 +298,7 @@ static void ov_show_error(Cpu *c) { caller(c, lr, sizeof lr)); } -// ==== SDK-internal initialisation (services.c:208-218) +// ==== SDK-internal initialisation (services.c) static void ov_diag_startup(Cpu *c) { (void)c; rt_log("diag: host diagnostics"); } static void ov_aoc_initialize(Cpu *c) { (void)c; rt_log("aoc: no add-on content"); } // 1.4.3's main lists add-on content (MNG services.c host_aoc_list): there is none. @@ -312,7 +312,7 @@ static void ov_err_context(Cpu *c) { (void)c; rt_log("err: error contexts stay l static void ov_pctl_initialize(Cpu *c) { (void)c; rt_log("pctl: no parental controls"); } static void ov_abort_observer(Cpu *c) { (void)c; rt_log("diag: the host crash reporter observes aborts"); } -// ==== observers (services.c:273-288): log, then the guest definition +// ==== observers (services.c): log, then the guest definition static void observe(Cpu *c, const char *name) { rt_log("ENTER %s", name); rt_original(c); @@ -613,7 +613,7 @@ static void ov_current_time(Cpu *c) { } // time_point StandardSteadyClock::now(): the int64 seconds in x0 only. The SDK caller (sdk+0x3d1d88) reads x0; -// returning the 0x18-byte struct through x8 would write through a stale pointer (time_host.c:47-49). +// returning the 0x18-byte struct through x8 would write through a stale pointer (time_host.c). static void ov_steady_now(Cpu *c) { ret_x(c, (uint64_t)steady_now().value); } // Result ToCalendarTime(CalendarTime *out, CalendarAdditionalInfo *info, const PosixTime &t): local time diff --git a/runtime/prof_win.c b/runtime/prof_win.c index 969be816..1b5a567e 100644 --- a/runtime/prof_win.c +++ b/runtime/prof_win.c @@ -557,7 +557,8 @@ int rt_knob(const char *name, const char *def) { // TOTK_ONE_PER_CORE=1: the process keeps the first logical processor of each physical core, so busy threads (the // render thread, the guest cores, the job workers) never share a core's execution units with another; "ab" switches -// it with the A/B blocks. Off by default until measured (Savage Wind Recomp #200: +4-10% on an 8-core SMT CPU). +// it with the A/B blocks. Off by default until measured here; Savage Wind Recomp +// reported +4-10% from the same rule on an 8-core SMT CPU. static void cpu_placement(void) { static int mode = -1, applied = -1; static DWORD_PTR all, one; diff --git a/runtime/tex_probe.c b/runtime/tex_probe.c index 9f5bf9e3..b1d09e03 100644 --- a/runtime/tex_probe.c +++ b/runtime/tex_probe.c @@ -528,7 +528,7 @@ static int test_textures(pool_t *tpool, pool_t *phys) { vk_write_texels(&g, NULL, &all, gl[0], 256, 256 * 64); if (read_back(&g, 0, gl, 0, "physical-pool RGBA8 WriteTexels")) return 1; - // a slot of a finalized texture follows the live texture at the same storage (MNG hle_nvn.c:373-393) + // a slot of a finalized texture follows the live texture at the same storage (MNG hle_nvn.c) vk_texture_register(5, &b, NULL); vk_texture_release(&b); tex_t b2 = make_tex(tpool, 0x40000, 0x25, 16, 12, 1, 4); diff --git a/runtime/vk.h b/runtime/vk.h index 8bcfe00d..961f2f35 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -270,7 +270,7 @@ typedef struct { // attach it in ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT (vk_exec.c vk_exec_pass_begin) } VkTexImage; const VkTexImage *vk_texture_get(const tex_t *t); // created and made current; NULL for BUFFER or unmapped formats -// A texture slot; a slot whose texture was finalized follows the live texture at the same storage (hle_nvn.c:373-393). +// A texture slot; a slot whose texture was finalized follows the live texture at the same storage (hle_nvn.c). const VkTexImage *vk_texture_by_id(int id, view_t *view, int *has_view); // The replay looks up many slots per draw: it takes the texture lock once around them (vk_texture_lock) and uses the // _locked lookups; vk_texture_slots_gen changes whenever a slot may resolve to another image or view. @@ -279,7 +279,8 @@ void vk_texture_unlock(void); const VkTexImage *vk_texture_by_id_locked(int id, view_t *view, int *has_view); VkSampler vk_sampler_by_id_locked(int id); // The slot's sampler with nearest filtering and no anisotropy: a depth texture read without a compare lands on one texel -// on the Switch although the game binds a linear sampler (MacNativeGames 6283599). VK_NULL_HANDLE for an empty slot. +// on the Switch although the game binds a linear sampler, and MacNativeGames samples it the same way. VK_NULL_HANDLE +// for an empty slot. VkSampler vk_sampler_point_by_id_locked(int id); uint32_t vk_texture_slots_gen(void); // What vk_texture_by_id(id) returns can change only when this does: the slot is registered again, or a texture entry at @@ -334,7 +335,7 @@ void vk_sync_shutdown(void); // finish, stop the completion thread int vk_exec_record(VkCommandBuffer cb, const uint64_t *handles, int n, uint64_t fence); // Inside vk_exec_record, outside a render pass: ends the command buffer recorded so far, submits it (after the upload // batch) without a signal, and returns a new begun one for the rest of the submission. The submission's timeline value -// is signalled by its last part, whose signal covers every earlier part in submission order (port-lessons P1). +// is signalled by its last part, whose signal covers every earlier part in submission order. VkCommandBuffer vk_sync_split(void); // Runs fn(arg) on the completion thread once fence is done on the GPU (event writes, counter reports, sync state). // Callbacks run in the order they were added, after those of earlier values; a value already done runs at once there. @@ -344,7 +345,7 @@ void rdoc_init(void); // runtime/rdoc_win.c: TOTK_RDOC debug int rdoc_active(void); void rdoc_after_present(uint64_t frame); void vk_present_drain(void); // returns once every queued present was submitted to gfx_queue -int vk_replay_async(void); // TOTK_REPLAY_ASYNC (default 1): submissions replay on the replay thread +int vk_replay_async(void); // TOTK_REPLAY_ASYNC (default 0): submissions replay on the replay thread void vk_program_release(const prog_t *p); // GfxBackend.program_release: vk_pipeline.c; weak no-op in vk_backend.c void vk_backend_shutdown(void); // presents, vk_sync_shutdown, vk_mem_shutdown, vk_shutdown in that order @@ -455,7 +456,7 @@ PFN_vkUpdateDescriptorSetWithTemplate vk_pipeline_update_tpl_fn(void); int vk_pipeline_set_indep(int on); typedef struct { uint64_t graphics, compute, failures, hits, layouts, push_layouts, async_built, pending_skips; } VkPipeStats; void vk_pipeline_stats(VkPipeStats *s); -void vk_pipeline_save(void); // writes the VkPipelineCache to build/v121/pipeline-cache.bin +void vk_pipeline_save(void); // writes the VkPipelineCache to pipeline-cache.bin next to totk.exe void vk_pipeline_autosave(void); // vk_pipeline_save at most every 20 s, when pipelines were built since void vk_pipeline_shutdown(void); // waits for background builds, saves, destroys pipelines, layouts and the // cache; before vk_shutdown diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index c1540295..d82c0574 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -1,8 +1,9 @@ // The op-stream replay core of the Vulkan back end: walks the command handles of // one submission into its command buffer, keeps render targets and fixed-function state, opens and closes dynamic -// rendering passes and records clears and barriers. Draws, binds and dispatches go to vk_exec_op_draw (T6c2); copies, -// counters, events and conditional rendering to vk_exec_op_xfer (T6c3). Images stay in VK_IMAGE_LAYOUT_GENERAL -// (vk_texture.c); full memory barriers order passes, clears and whatever T6c2/T6c3 record between them. +// rendering passes and records clears and barriers. Draws, binds and dispatches go to vk_exec_op_draw +// (vk_exec_draw.c); copies, counters, events and conditional rendering to vk_exec_op_xfer (vk_exec_xfer.c). Images +// stay in VK_IMAGE_LAYOUT_GENERAL (vk_texture.c); full memory barriers order passes, clears and whatever those two +// record between them. // // The op loop (END / BEGIN / JUMP / CALL, which ops are pure state, the state defaults, render targets kept until they // change, clears skipped while rendering is disabled) follows MacNativeGames @@ -106,7 +107,7 @@ static void warn_once(int key, const char *fmt, ...) { rt_log("vk: %s (logged once)", msg); } -// NVN defaults of the replay state (nvn_mtl.m:5449-5457). +// NVN defaults of the replay state (nvn_mtl.m). static void state_reset(VkExec *ex) { memset(ex, 0, sizeof *ex); ex->st_vmask[0] = ex->st_vmask[1] = ex->st_wmask[0] = ex->st_wmask[1] = 0xff; @@ -205,10 +206,10 @@ static void resolve_target(const tex_t *t, const view_t *v, int has_v, int depth if (!o->aspect) o->image = VK_NULL_HANDLE; } -/* The size of a pass without attachments: the far corner of viewport 0, else of the scissor, 1..16384 (MacNativeGames - 62da927, nxnative 7ed061f). TotK draws a fragment shader that only writes a storage buffer into a 1x1 viewport; a - pass sized by the viewport's width alone puts an offset viewport outside the scissor, and the cave rock loses its - ambient light. */ +/* The size of a pass without attachments: the far corner of viewport 0, else of the scissor, 1..16384, as + MacNativeGames and nxnative size it. TotK draws a fragment shader that only writes a storage buffer into a 1x1 + viewport; a pass sized by the viewport's width alone puts an offset viewport outside the scissor, and the cave rock + loses its ambient light. */ void vk_exec_noatt_dims(const VkExec *ex, uint32_t *w, uint32_t *h) { double x1 = 0, y1 = 0; if (ex->has_vp) { @@ -553,7 +554,7 @@ static void clear_color(VkExec *ex, const p_clear_color *c) { } uint32_t mask = (uint32_t)c->mask & 0xf; if (!mask) return; - if (mask != 0xf) { // vkCmdClearAttachments ignores write masks; a masked clear needs a draw (T6c2) + if (mask != 0xf) { // vkCmdClearAttachments ignores write masks; a masked clear needs a draw (vk_exec_draw.c) warn_once(W_CLEAR_MASK, "colour clear with channel mask %#x is not replayed: skipped", mask); return; } @@ -610,7 +611,7 @@ static void set_rt(VkExec *ex, const p_set_rt *r) { ex->rt_resolved = 0; } -// ---- command buffer parts (port-lessons P1) +// ---- command buffer parts // NVN starts the GPU as soon as commands are submitted; one Vulkan command buffer per submission starts it only after // the whole replay. Between passes, once TOTK_SPLIT_DRAWS (64; 0 off) draws and dispatches were recorded since the // last part, the part goes to the queue (vk_sync_split) and the replay continues in a new command buffer. Only diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index a274cfb3..c81d5c61 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -1,6 +1,7 @@ -// The op-stream replay of the Vulkan back end. vk_exec.c (T6c1) walks the command +// The op-stream replay of the Vulkan back end. vk_exec.c walks the command // handles of a submission, keeps render targets, passes, clears and fixed-function state; draws, binds and dispatches -// (T6c2) and copies, counters, events and conditional rendering (T6c3) plug in through the two hooks at the bottom. +// (vk_exec_draw.c) and copies, counters, events and conditional rendering (vk_exec_xfer.c) plug in through the two +// hooks at the bottom. // Runs on the submitting thread under vk_sync_submit's lock: no locking inside. // The op loop follows MacNativeGames nvn_mtl.m (MIT, Copyright (c) 2026 jhaizhou) and the pass handling LAS Recomp // (MIT, Copyright (c) 2026 Peiikai); vk_exec.c names the sources. @@ -11,7 +12,7 @@ #include "vk.h" // Dynamic state the next draw must record (VkExec.dirty). vk_exec_record sets them all at the start of each command -// buffer; the state ops set theirs; T6c2 clears what it recorded. +// buffer; the state ops set theirs; vk_exec_draw.c clears what it recorded. enum { VK_EXEC_DIRTY_VIEWPORT = 1 << 0, // viewports or depth range VK_EXEC_DIRTY_SCISSOR = 1 << 1, @@ -56,7 +57,7 @@ typedef struct VkExec { // VK_FORMAT_UNDEFINED: none uint32_t pass_ncolor, pass_samples; // colorAttachmentCount and rasterization samples of the pass - // ---- fixed-function state (T6c1 keeps it; T6c2 records it before draws) + // ---- fixed-function state (vk_exec.c keeps it; vk_exec_draw.c records it before draws) float vp[16][6]; // OP_VIEWPORTS: x, y, w, h, near, far int has_vp; // a viewport was set; else the render area p_scissor scissor; // OP_SCISSOR (scissor 0) @@ -67,20 +68,21 @@ typedef struct VkExec { p_poly_offset poly_offset; // OP_POLY_OFFSET: depth bias factor, units, clamp p_prim_restart prim_restart; // OP_PRIM_RESTART: applied to indexed strip and fan draws (op_draw_idx) float blend_color[4]; // OP_BLEND_COLOR - int64_t copy_stride; // OP_COPY_STRIDE: row stride of buffer <-> texture copies (T6c3) + int64_t copy_stride; // OP_COPY_STRIDE: row stride of buffer <-> texture copies (vk_exec_xfer.c) const dpool_t *tex_pool, *samp_pool; // OP_SET_TEX_POOL, OP_SET_SAMP_POOL - // Pipeline inputs. T6c1 writes depth_clamp (OP_DEPTH_CLAMP), raster_discard (OP_RASTER_DISCARD) and, at pass begin, - // color_fmt, depth_fmt and samples; T6c2 owns every other field (shaders, prim, y_flip, state objects, vertex input). + // Pipeline inputs. vk_exec.c writes depth_clamp (OP_DEPTH_CLAMP), raster_discard (OP_RASTER_DISCARD) and, at pass + // begin, color_fmt, depth_fmt and samples; vk_exec_draw.c owns every other field (shaders, prim, y_flip, state + // objects, vertex input). VkPipeState pipe; - // ---- T6c2 slots (draws, binds, dispatch): left empty by T6c1 + // ---- vk_exec_draw.c slots (draws, binds, dispatch): left empty by vk_exec.c const prog_t *prog; // OP_BIND_PROGRAM int32_t prog_stages; NVNbufferRange vbuf[16]; // OP_BIND_VBUF p_bind_buf ubo[6][18], ssbo[6][16]; // OP_BIND_UBO / OP_BIND_SSBO per stage and index uint64_t tex[6][128], samp[6][128], img[6][32]; // OP_BIND_TEX / OP_BIND_SAMP / OP_BIND_IMG handles per stage - // ---- T6c3 slots (render enable, conditional rendering): left empty by T6c1 + // ---- vk_exec_xfer.c slots (render enable, conditional rendering): left empty by vk_exec.c int render_disabled; // OP_RENDER_ENABLE false or a failed OP_RENDER_COND: clears and draws skip p_render_cond render_cond; // last OP_RENDER_COND int has_render_cond; @@ -161,14 +163,14 @@ void vk_c0_fill(uint8_t bank[VK_C0_BYTES], int stage, const p_bind_buf ssbo[16], const uint32_t dispatch[3], uint32_t base_instance); // Handler hooks. vk_exec.c defines both WEAK: they stop with rt_fatal naming the op. -// T6c2: OP_DRAW, OP_DRAW_IDX, OP_DISPATCH, OP_BIND_* (program, state, vattr, vstream, vbuf, ubo, ssbo, tex, samp, img), -// OP_UPDATE_UB, OP_DRAW_IDX_IND, OP_DISPATCH_IND. payload: nvn_op_payload of the record. +// vk_exec_draw.c: OP_DRAW, OP_DRAW_IDX, OP_DISPATCH, OP_BIND_* (program, state, vattr, vstream, vbuf, ubo, ssbo, tex, +// samp, img), OP_UPDATE_UB, OP_DRAW_IDX_IND, OP_DISPATCH_IND. payload: nvn_op_payload of the record. void vk_exec_op_draw(VkExec *ex, uint32_t op, const void *payload); // The aspect a sampled view of img reads (vk_exec_draw.c get_view): stencil for a view in STENCIL depth-stencil mode. VkImageAspectFlags vk_exec_view_aspect(const VkTexImage *img, const view_t *v, int hv); VkImageView vk_exec_target_view(const VkTexImage *img, VkFormat format, VkImageViewType type, uint32_t aspect, uint32_t level, uint32_t base, uint32_t layers, int blocks); // kept for the image's life -// T6c3: OP_COPY_B2B, OP_COPY_B2T, OP_COPY_T2B, OP_COPY_T2T, OP_CLEAR_TEX, OP_SIGNAL_EVENT, OP_REPORT_COUNTER, +// vk_exec_xfer.c: OP_COPY_B2B, OP_COPY_B2T, OP_COPY_T2B, OP_COPY_T2T, OP_CLEAR_TEX, OP_SIGNAL_EVENT, OP_REPORT_COUNTER, // OP_RESET_COUNTER, OP_RENDER_ENABLE, OP_RENDER_COND, OP_CLEAR_BUF. void vk_exec_op_xfer(VkExec *ex, uint32_t op, const void *payload); // vk_exec_xfer.c, samples-passed counting: a draw about to be recorded in the open pass (begins an occlusion query diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index b39a87a8..e9326df5 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -444,7 +444,7 @@ static VkComponentSwizzle swz_of(uint8_t s) { // A view in STENCIL mode samples the stencil plane (TextureViewSetDepthStencilMode); otherwise depth wins. The // translator declares every sampled image float and the shader takes the raw bits, as for integer formats (nxnative -// nvn_mtl.m:3174). +// nvn_mtl.m). VkImageAspectFlags vk_exec_view_aspect(const VkTexImage *img, const view_t *v, int hv) { if (hv && v->set_dsmode && v->dsmode == NVN_TEXTURE_DEPTH_STENCIL_MODE_STENCIL && (img->aspect & VK_IMAGE_ASPECT_STENCIL_BIT)) return VK_IMAGE_ASPECT_STENCIL_BIT; @@ -806,7 +806,7 @@ static void c0_table(uint8_t *at, const p_bind_buf b[16]) { // candidate base from here and compares the global pointer against it. Compute: dispatch size at 0x200, the uniform // buffer table at 0x210 + 16 r. Graphics: the largest point size (Maxwell's limit, GLSLC clamps gl_PointSize to it) at // 0x610, the base instance at 0x644. Other stages: zeros. Unbound slots read zero, since the replay keeps them zero. -// Layout: nxnative dm/gfx/nvn/nvn_mtl.m:4395-4420 (MIT). +// Layout: nxnative dm/gfx/nvn/nvn_mtl.m (MIT). void vk_c0_fill(uint8_t bank[VK_C0_BYTES], int stage, const p_bind_buf ssbo[16], const p_bind_buf ubo[16], const uint32_t dispatch[3], uint32_t base_instance) { memset(bank, 0, VK_C0_BYTES); @@ -823,7 +823,7 @@ void vk_c0_fill(uint8_t bank[VK_C0_BYTES], int stage, const p_bind_buf ssbo[16], memcpy(bank + 0x644, &base_instance, 4); } -static int c0_on(void) { // TOTK_FIX_C0=0: c0 reads zeros, as in M4 +static int c0_on(void) { // TOTK_FIX_C0=0: c0 reads zeros instead of the driver constants static int on = -1; if (on < 0) { on = cfg_bool("TOTK_FIX_C0"); diff --git a/runtime/vk_exec_probe.c b/runtime/vk_exec_probe.c index 87f482d3..746b51d9 100644 --- a/runtime/vk_exec_probe.c +++ b/runtime/vk_exec_probe.c @@ -2,7 +2,7 @@ // submissions get consecutive fence values; fence_wait and fence_done agree; completion callbacks run in submit order on // the completion thread; a guest-memory word a callback writes is visible once fence_wait returns; finish drains every // submission; a present of a cleared vk_texture.c image (layout GENERAL) reads back exactly through the swapchain -// capture. Clear part (task T6c1): a hand-built op stream (SET_RT to an RGBA8 and a D32 texture, whole-target clears, +// capture. Clear part: a hand-built op stream (SET_RT to an RGBA8 and a D32 texture, whole-target clears, // then scissored clears) through submit reads back exactly with read_texels. #include #include @@ -154,7 +154,7 @@ static int test_present(const GfxBackend *b, uint8_t *guest, int *w_out, int *h_ return 0; } -// ---- clear part (task T6c1): a hand-built op stream through submit, read back with read_texels. +// ---- clear part: a hand-built op stream through submit, read back with read_texels. static uint8_t *put(uint8_t *p, uint32_t op, const void *payload, uint32_t n) { op_hdr h = {op, (uint32_t)((sizeof h + n + 7) & ~7u)}; @@ -239,7 +239,7 @@ static int test_clear(const GfxBackend *b, uint8_t *guest, int *n_inside) { return 0; } -// ---- draw part (task T6c2): the pipeline self-test, then a hand-built stream that clears an RGBA8 target, binds a census +// ---- draw part: the pipeline self-test, then a hand-built stream that clears an RGBA8 target, binds a census // vertex + fragment pair and draws one triangle; a census compute shader is dispatched. The census (build/v121/shaders, // tools/shader_census.py) is read the way vk_pipeline_selftest reads it: a pair is a fragment shader and a vertex // shader of the same source file. @@ -544,7 +544,7 @@ static int test_draw(const GfxBackend *b, uint8_t *guest, int *n_drawn, int *n_t return 0; } -// ---- xfer part (task T6c3): copies, texture clear, event and counter through submit. +// ---- xfer part: copies, texture clear, event and counter through submit. #define XF_W 64 #define XF_H 64 diff --git a/runtime/vk_exec_xfer.c b/runtime/vk_exec_xfer.c index 8c63e030..34548153 100644 --- a/runtime/vk_exec_xfer.c +++ b/runtime/vk_exec_xfer.c @@ -1,5 +1,5 @@ // Transfers of the Vulkan op-stream replay: buffer and texture copies, texture -// clears, event signals, counter reports and conditional rendering. vk_exec.c (T6c1) calls vk_exec_op_xfer for these ops. +// clears, event signals, counter reports and conditional rendering. vk_exec.c calls vk_exec_op_xfer for these ops. // // Buffers are guest memory: vk_mem_resolve maps an address to the VkBuffer behind its pool, textures are the vk_texture.c images // (linear texel layout, GENERAL layout; block-linear storage is only converted when a mirrored texture is uploaded). So a @@ -22,10 +22,11 @@ // from guest memory; a counter reported by an earlier submission that is not done yet counts as 0 if it is a timestamp, // as unknown if it is samples passed. An unknown count renders: the report usually sits in the command buffer being // recorded, so its value cannot be waited for, and the word in memory still holds an older query's count. Rendering -// costs at most the work the condition would have saved (MacNativeGames nvn_mtl.m:1708 decides the same); in the field +// costs at most the work the condition would have saved (MacNativeGames nvn_mtl.m decides the same); in the field // TOTK conditions only on timestamp reports. The condition sets VkExec.render_disabled, which vk_exec.c honours for -// clears and T6c2 for draws and dispatches. A condition that cannot be read (address outside every pool) renders. -// Copies and CLEAR_TEX are not conditional (as in MacNativeGames, nvn_mtl.m:7949, 8383). +// clears and vk_exec_draw.c for draws and dispatches. A condition that cannot be read (address outside every pool) +// renders. +// Copies and CLEAR_TEX are not conditional (as in MacNativeGames, nvn_mtl.m). // // The copy semantics (region and layer arithmetic, row and image strides, whole-level clears, copy / blit / resolve // choice) follow MacNativeGames games/totk/third_party/d2r_gfx/gfx/nvn/nvn_mtl.m:10080-10368, 10618-10642, 1700-1725 @@ -544,7 +545,7 @@ static int int_format(VkFormat f) { } // Whole levels only (vkCmdClear*Image has no rectangle); partial regions, channel masks and a view that reinterprets -// the format are skipped (MacNativeGames does not replay them either, nvn_mtl.m:10325-10368). +// the format are skipped (MacNativeGames does not replay them either, nvn_mtl.m). static void clear_tex(VkExec *ex, const p_clear_tex *p) { const tex_t *t = p->tex; if (!t) return; diff --git a/runtime/vk_memory.c b/runtime/vk_memory.c index 23c967da..cde3b60c 100644 --- a/runtime/vk_memory.c +++ b/runtime/vk_memory.c @@ -327,7 +327,7 @@ void vk_pool_fini(pool_t *p) { else destroy_rec(c, r); } -// Requests were checked by the front end (nvn_api_core.c, MNG totk_vpool.c:54-67); apply them in order. +// Requests were checked by the front end (nvn_api_core.c, MNG totk_vpool.c); apply them in order. int vk_pool_map_virtual(pool_t *v, int n, const void *requests) { const nvn_mapping_t *rq = requests; AcquireSRWLockExclusive(&pool_lock); @@ -1482,7 +1482,7 @@ static void mirror_log(uint64_t frame) { qpc_ms(a.presnap_t) / f, qpc_ms(a.sync_t) / f, ver); } -// With TOTK_TRACE=perf every 600 frames: what holds device-local memory (backlog: GPU memory over long sessions). +// With TOTK_TRACE=perf every 600 frames: what holds device-local memory, to see what grows over a long session. // VMA's blocks and allocations on the device-local heaps, texture entries with their own memory, the VRAM mirrors and // the objects waiting for their last submission to retire. static void vram_log(uint64_t frame) { diff --git a/runtime/vk_pipeline.c b/runtime/vk_pipeline.c index 52cfaafe..15758686 100644 --- a/runtime/vk_pipeline.c +++ b/runtime/vk_pipeline.c @@ -33,7 +33,7 @@ // binding strides only); and, where VK_EXT_extended_dynamic_state3 offers them, depth clamp, polygon mode, blend enables, // equations, write masks and alpha to coverage. The key holds the rest: shaders, target formats, sample count, topology // class, depth clip mode, logic op and what is not dynamic on the GPU. The VkPipelineCache persists to -// build/v121/pipeline-cache.bin (TOTK_PIPELINE_CACHE overrides the path). +// pipeline-cache.bin next to totk.exe (TOTK_PIPELINE_CACHE overrides the path). // // Provenance: the NVN -> Vulkan enum mappings (blend factors and equations, compare functions, stencil ops), the vertex // format table with its 3-component fallback and the pipeline cache file handling follow LAS Recomp @@ -262,8 +262,8 @@ static int ensure_init(void) { rt_log("vk_pipeline: descriptor update templates unavailable: sets are written with write structs"); } // TOTK_VK_DYN_VERTEX=0/1 forces dynamic vertex input off or on. Default off on Intel's frozen Windows driver for its - // older integrated GPUs (UHD 630, Ice Lake: Vulkan 1.3.215 and older), which draws nothing with it (LAS Recomp - // 61fe44ff, its issues #8 and #357). + // older integrated GPUs (UHD 630, Ice Lake: Vulkan 1.3.215 and older), which draws nothing with it; LAS Recomp + // turns it off there for the same reason. const char *dv = cfg_get("TOTK_VK_DYN_VERTEX"); // no fixed default: it depends on the GPU, see above int intel_legacy = c->props.vendorID == 0x8086 && c->props.apiVersion <= VK_MAKE_API_VERSION(0, 1, 3, 215); int dv_on = dv && *dv ? strcmp(dv, "0") != 0 : !intel_legacy; @@ -1831,7 +1831,7 @@ static struct { CONDITION_VARIABLE idle; // with P.lock: no job queued or running } A = {.idle = CONDITION_VARIABLE_INIT}; -// ---- pipeline keys (build/v121/pipeline-keys.bin next to the pipeline cache) +// ---- pipeline keys (pipeline-keys.bin next to the pipeline cache) // Every graphics pipeline built in a game run appends a KeyRec: the VkPipeState it was built from with the shader // pointers zeroed and the shaders named by their gfx_shader input ids instead, which do not depend on the translator, // so the record rebuilds the pipeline without guest memory. At the next boot vk_pipeline_prewarm (rt_boot, before the @@ -2958,7 +2958,7 @@ void vk_pipeline_set_dynamic(VkCommandBuffer cb, const VkPipeState *s) { const ds_st *d = &s->ds; // The front face maps unchanged: TOTK sets the upper-left window origin, and the y-flipped viewport (y_flip) puts // NDC +y at row 0 as NVN does, so the framebuffer winding Vulkan tests is the one NVN tests (MacNativeGames passes - // it to Metal unchanged; LAS Recomp exec.c:2735 mirrors it only for the lower-left origin). + // it to Metal unchanged; LAS Recomp exec.c mirrors it only for the lower-left origin). int front_cw = pl->front == NVN_FRONT_FACE_CW; vkCmdSetCullMode(cb, (VkCullModeFlags)(pl->cull & 3)); // NVN_FACE_* has VkCullModeFlagBits' values vkCmdSetFrontFace(cb, front_cw ? VK_FRONT_FACE_CLOCKWISE : VK_FRONT_FACE_COUNTER_CLOCKWISE); diff --git a/runtime/vk_rec.h b/runtime/vk_rec.h index 33e5f15c..afbb2937 100644 --- a/runtime/vk_rec.h +++ b/runtime/vk_rec.h @@ -10,8 +10,8 @@ // extension commands called through function pointers have rec_* wrappers of their own. TOTK_VK_RECORDER=0 makes every // call at once (the same calls in the same order), =ab switches it with the A/B blocks (rt_ab), per submission part. // -// Design from Savage Wind Recomp #189 and LAS Recomp runtime/nvn/vulkan/record.c (bb52932, c2bdc17, 76f4f21; MIT, -// Copyright (c) 2026 Peiikai): the driver's work behind the commands depends on nothing the replay decides next. +// The design follows Savage Wind Recomp's and LAS Recomp's recorder threads (LAS Recomp runtime/nvn/vulkan/record.c, +// MIT, Copyright (c) 2026 Peiikai): the driver's work behind the commands depends on nothing the replay decides next. #pragma once void rec_begin(VkCommandBuffer cb); // the submitting thread, sub_lock held diff --git a/runtime/vk_texture.c b/runtime/vk_texture.c index 71b3f1b4..b65f21e7 100644 --- a/runtime/vk_texture.c +++ b/runtime/vk_texture.c @@ -246,7 +246,7 @@ static int block_views_ok(const VkImageCreateInfo *ci) { ci->arrayLayers <= q->maxArrayLayers; } -// UNDEFINED -> GENERAL; new depth / stencil images start cleared (LAS textures.c:315-327: the game copies depth +// UNDEFINED -> GENERAL; new depth / stencil images start cleared (LAS textures.c: the game copies depth // without stencil, and the stencil of those images must not be whatever the memory held). static void init_image(Tex *e, VkCommandBuffer cb) { VkImageMemoryBarrier2 ib = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, .srcStageMask = VK_PIPELINE_STAGE_2_NONE, @@ -314,7 +314,7 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) { usage |= VK_IMAGE_USAGE_STORAGE_BIT; VkImageCreateFlags flags = ds ? 0 : VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; // format-reinterpreting views if (type == VK_IMAGE_TYPE_2D && layers >= 6 && w == h && samples == 1) flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; - // NVN renders into a 3D texture slice by slice (a view's min layer is the depth plane, nvn_mtl.m:4158), e.g. the + // NVN renders into a 3D texture slice by slice (a view's min layer is the depth plane, nvn_mtl.m), e.g. the // grading LUT of the menu background blur. Vulkan needs a 2D view of the slice for that. if (type == VK_IMAGE_TYPE_3D && (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; VkImageCreateInfo ci = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .flags = flags, .imageType = type, .format = f.vk, @@ -934,7 +934,7 @@ static Tex *slot_resolve(TexSlot *s, view_t *view, int *has_view) { TexKey k; make_key(&s->t, &k); Tex *e = nvn_hm_get(&by_key, &k); - if (!e || e->released) { // MNG hle_nvn.c:373-393: a finalized slot follows the live texture at its storage + if (!e || e->released) { // MNG hle_nvn.c: a finalized slot follows the live texture at its storage // Prefer the live entry that differs from the slot descriptor only in its swizzle: transient render targets // share storage, and the newest one at the address is usually another size. The map screen samples its // 2250x1080 map target through an (R,G,B,1) descriptor and followed a 960x60 target at the same address. @@ -1075,7 +1075,7 @@ static int region_of(const tex_t *t, const view_t *v, const NVNcopyRegion *r, ui return 1; } -// Pool bytes <-> caller rows of the region alone (nvn_texels_box). MNG nvn_mtl.m:10121-10132, 10158-10170 go through a +// Pool bytes <-> caller rows of the region alone (nvn_texels_box). MacNativeGames' nvn_mtl.m goes through a // linear copy of the whole level; for a small region of a large texture that cost tens of milliseconds while the guest // thread held its virtual core and the caller the texture lock (monsters2 replay, frames 765-790). static int storage_texels(const tex_t *t, const Region *g, const NVNcopyRegion *r, uint8_t *mem, int write) { @@ -1406,7 +1406,7 @@ void vk_texture_write_back_small(uint64_t fence) { unlock(); } -// ---------------------------------------------------------------- samplers (LAS textures.c:778-844) +// ---------------------------------------------------------------- samplers (LAS textures.c) static VkCompareOp compare_op(uint32_t f) { switch (f) { case NVN_COMPARE_FUNC_NEVER: return VK_COMPARE_OP_NEVER; diff --git a/runtime/vk_usnap.c b/runtime/vk_usnap.c index 82815823..a05eb658 100644 --- a/runtime/vk_usnap.c +++ b/runtime/vk_usnap.c @@ -13,7 +13,7 @@ // an image-to-buffer copy: vk_usnap_drop) drops the copies it touches from then on, so later draws read the result. // - The arena goes back to a free list once the submission's fence is done (completion thread). // The design follows MacNativeGames' TOTK_UBO_SNAPSHOT (games/totk/third_party/d2r_gfx/gfx/nvn/nvn_mtl.m usnap_take, -// usnap_drop, @ ffd8d10, MIT, Copyright (c) 2026 jhaizhou); the code is ours. +// usnap_drop; MIT, Copyright (c) 2026 jhaizhou); the code is ours. // The copy is taken where vk_exec_record starts: at the submit call when the replay runs on the submitting thread, later // with TOTK_REPLAY_ASYNC. TOTK_UBO_SNAPSHOT=0 binds live memory as before; =ab alternates (TOTK_AB). #include diff --git a/tools/shader_census.py b/tools/shader_census.py index 6e15b1a6..50f669fa 100644 --- a/tools/shader_census.py +++ b/tools/shader_census.py @@ -35,7 +35,7 @@ ROOT = Path(__file__).resolve().parent.parent XLATE = ROOT / 'build' / 'xlate' / 'totk_xlate.exe' SPIRV_VAL = Path(r'C:\msys64\ucrt64\bin\spirv-val.exe') ZSTD = b'\x28\xb5\x2f\xfd' -# NVN program control section magic, u32 0x98761234 (refs/d2r-mobile/dm/gfx/tools/shader_map.py:19) +# NVN program control section magic, u32 0x98761234 (d2r-mobile dm/gfx/tools/shader_map.py) CONTROL_MAGIC = b'\x34\x12\x76\x98' STAGE_IDS = {0: 'vs', 1: 'ps', 5: 'cs'} MAX_WORKERS = 20