// Texture / sampler registrations and the driver's constant banks (from the WebGPU renderer's gpu/render/rx_nvn.cpp, // whose comments explain the layouts: measured on TOTK by the MIT-licensed reference layer, NVN2 compute's packed c0 // found from MKW's programs). #include #include #include #include #include #include #include #include #define NOMINMAX #define WIN32_LEAN_AND_MEAN #include #include "vk_internal.h" #include "vk_state.h" namespace mkwvk { // (hookshot) the seed's compute programs (vk_shader.cpp seed_program) have no bound program to read their layout from. Translated // with Maxwell's table instead, one kept the right key and the wrong storage buffers, and play would have used it as it was thread_local const uint8_t* seed_cs_control = nullptr; namespace { struct TexReg { nvn_tex t{}; nvn_view v{}; bool has_view = false, ok = false, released = false; }; struct SampReg { nvn_samp_par p{}; bool ok = false; }; std::mutex reg_mu; std::vector tex_regs; std::vector samp_regs; std::unordered_map> regs_by_serial; std::atomic reg_gen{1}; // (bumped by every texture registration: resolved handles go stale) std::atomic samp_gen{1}; // (bumped when a sampler registration's contents change: sampler_for's cache, vk_draw.cpp) // (and a version a slot: caches of what a slot resolves to check theirs, not every registration's) constexpr int kSlotVersions = 1 << 20; std::unique_ptr[]> slot_versions{new std::atomic[kSlotVersions]()}; // (hookshot, RX_VK_SAMPLER_CACHE: the same for sampler ids, so what a sampler id resolves to can be cached and checked // without taking reg_mu, and descriptor reuse can tell that a sampler was registered anew) constexpr int kSampVersions = 1 << 12; std::unique_ptr[]> samp_versions{new std::atomic[kSampVersions]()}; // NVN2 compute's c0: the workgroup counts at 0, then the uniform buffer table, the storage buffer table, texture // handles and image handles, as many slots of each as the control section says (+0xb1, +0xb2, +0xb3, +0xb6) // (hookshot) with push constants first, right after the counts: +0xa9 is their size in words (OoT's NV12 -> RGBA // shader: 15, reading 0x10..0x4b; its upscaler's last pass: 21), the area rounded to 16 bytes; +0xba is the whole // bank's size (0x10 + push area + the tables), which this matches for every program OoT dispatches. struct CsLayout { uint32_t ubo = 0, ssbo = 0, tex = 0, img = 0, push = 0; uint32_t ubo_at() const { return 0x10 + push; } uint32_t ssbo_at() const { return ubo_at() + 16 * ubo; } uint32_t tex_at() const { return ssbo_at() + 16 * ssbo; } uint32_t img_at() const { return tex_at() + 8 * tex; } uint32_t end() const { return img_at() + 8 * img; } }; CsLayout cs_layout_of(const uint8_t* c) { // (c: the control section from +0x58) CsLayout l; l.ubo = c[0xb1 - 0x58], l.ssbo = c[0xb2 - 0x58], l.tex = c[0xb3 - 0x58], l.img = c[0xb6 - 0x58]; l.push = ((uint32_t)c[0xa9 - 0x58] * 4 + 15) & ~15u; return l; } CsLayout cs_layout(const NvnState& s) { if (seed_cs_control) return cs_layout_of(seed_cs_control + 0x58); static std::mutex mu; static std::unordered_map by_serial; std::lock_guard lk(mu); if (auto it = by_serial.find(s.prog.serial); it != by_serial.end()) return it->second; CsLayout l; for (uint32_t i = 0; i < s.prog.nstage && i < 6; i++) { uint8_t c[0x60]; uint32_t magic = 0; uint16_t st = 0; if (!s.prog.sd[i].control || !host->gpu_read(s.prog.sd[i].control + 0x58, c, sizeof c)) continue; host->gpu_read(s.prog.sd[i].control, &magic, 4); host->gpu_read(s.prog.sd[i].control + 0x56, &st, 2); if (magic != 0x98761234 || st != 5) continue; l = cs_layout_of(c); static const bool log_cs = getenv("RX_VK_LOG_CS") != nullptr; // (hookshot) the control bytes 0xb0..0xbf if (log_cs) { char hex[700]; int k = 0; uint8_t wide[0xc0]{}; host->gpu_read(s.prog.sd[i].control + 0x58, wide, sizeof wide); for (int j = 0; j < 0xc0; j++) k += snprintf(hex + k, sizeof hex - k, "%s%02x", j % 16 ? "" : " |", wide[j]); logf("vk: compute control %#llx: %s(ubo %u ssbo %u tex %u img %u; push constants %u bytes)", (unsigned long long)s.prog.sd[i].control, hex, l.ubo, l.ssbo, l.tex, l.img, s.cs_push_n); } break; } if (by_serial.size() > 4096) by_serial.clear(); by_serial[s.prog.serial] = l; return l; } } // namespace /// (EvilOOT) where the bound compute program's storage buffer table is in c0, and how many slots it has (vk_shader.cpp gives /// them to the translator: Eden's Maxwell layout had it at 0x310, NVN2 compute right after the uniform buffer table) uint32_t compute_ssbo_table(const NvnState& s, uint32_t* count, uint32_t* layout_end) { const CsLayout l = cs_layout(s); if (count) *count = l.ssbo; if (layout_end) *layout_end = l.end(); return l.ssbo_at(); } /// (hookshot, #940) For the seed's compute programs (vk_shader.cpp seed_compute), whether c0+offset holds a buffer's address in play: /// the address word of an entry of the uniform or storage buffer table its control section lays out. Nothing is bound before the /// game, so the storage buffer pass's port (EDEN_NX2_GM_LEGACY=0), which binds an access to a pointer only when that pointer is /// mapped (Env::IsCbufStorageBufferPointer), found none and left every access to the run-time search, under the key play then used /// the program by. Answered from the layout, the prepared program comes out as play translates it bool seed_cs_buffer_word(uint32_t offset) { if (!seed_cs_control || (offset & 15)) return false; const CsLayout l = cs_layout_of(seed_cs_control + 0x58); const auto in = [offset](uint32_t at, uint32_t n) { return offset >= at && offset < at + 16 * std::min(n, 16u); }; return in(l.ubo_at(), l.ubo) || in(l.ssbo_at(), l.ssbo); } const void* descriptor_ok(const void* p, size_t n) { if (!p) return nullptr; const uintptr_t q = (uintptr_t)p, base = (uintptr_t)host->guest_base(); if (q >= base && q + n <= base + host->guest_size()) return p; uint64_t avail = 0; if (const uint8_t* h = host->gpu_ptr((uint64_t)q, &avail); h && avail >= n) return h; // (the host's own copies: registrations made before the renderer started, kept by host/rx_backend.c) MEMORY_BASIC_INFORMATION mi{}; if (VirtualQuery(p, &mi, sizeof mi) == sizeof mi && mi.State == MEM_COMMIT && (mi.Protect & (PAGE_READONLY | PAGE_READWRITE | PAGE_WRITECOPY)) && !(mi.Protect & PAGE_GUARD) && q + n <= (uintptr_t)mi.BaseAddress + mi.RegionSize) return p; static int logged; if (logged++ < 8) logf("vk: descriptor outside guest memory: refused"); return nullptr; } void register_texture(int id, const nvn_tex* t, const nvn_view* v) { if (id < 0 || id >= (1 << 20) || !t) return; t = (const nvn_tex*)descriptor_ok(t, sizeof(nvn_tex)); if (!t) return; v = (const nvn_view*)descriptor_ok(v, sizeof(nvn_view)); // a bad view only loses the view register_texture_copy(id, *t, v); } void register_texture_copy(int id, const nvn_tex& tex, const nvn_view* v) { if (id < 0 || id >= (1 << 20)) return; const nvn_tex* t = &tex; std::lock_guard lk(reg_mu); if ((size_t)id >= tex_regs.size()) tex_regs.resize((size_t)id + 1024); TexReg& r = tex_regs[id]; { // (slots registered again at another size: the dynamic resolution's steps, counted and logged now and then) static int64_t resized, all; all++; if (r.ok && (r.t.d.width != t->d.width || r.t.d.height != t->d.height)) { resized++; static int64_t logged_at = 0; if (resized - logged_at >= 200000) { logged_at = resized; logf("vk: texture slots registered again at another size: %lld (of %lld registrations; slot %d %ux%u -> %ux%u)", (long long)resized, (long long)all, id, r.t.d.width, r.t.d.height, t->d.width, t->d.height); } } } if (r.ok) { auto it = regs_by_serial.find(r.t.serial); if (it != regs_by_serial.end()) { std::erase(it->second, id); if (it->second.empty()) regs_by_serial.erase(it); } } r.t = *t; r.has_view = v != nullptr; r.v = v ? *v : nvn_view{}; r.ok = true; r.released = false; regs_by_serial[t->serial].push_back(id); slot_versions[id].fetch_add(1, std::memory_order_acq_rel); reg_gen++; } uint32_t texture_slot_version(int id) { return id >= 0 && id < kSlotVersions ? slot_versions[id].load(std::memory_order_acquire) : 0; } uint64_t registrations_generation() { return reg_gen.load(std::memory_order_acquire); } void register_sampler(int id, const nvn_samp_par* p) { if (id < 0 || id >= (1 << 12) || !p) return; p = (const nvn_samp_par*)descriptor_ok(p, sizeof(nvn_samp_par)); if (!p) return; register_sampler_copy(id, *p); } void register_sampler_copy(int id, const nvn_samp_par& par) { if (id < 0 || id >= (1 << 12)) return; const nvn_samp_par* p = ∥ std::lock_guard lk(reg_mu); if ((size_t)id >= samp_regs.size()) samp_regs.resize((size_t)id + 256); // (sampler_for's cache goes stale only when a registration's contents change, not at each rewrite of the same) const bool same = samp_regs[id].ok && !std::memcmp(&samp_regs[id].p, p, sizeof *p); samp_regs[id].p = *p; samp_regs[id].ok = true; if (!same) samp_gen.fetch_add(1, std::memory_order_acq_rel); samp_versions[id].fetch_add(1, std::memory_order_acq_rel); // (hookshot: caches of what an id resolves to check this) } uint32_t sampler_slot_version(int id) { return id >= 0 && id < kSampVersions ? samp_versions[id].load(std::memory_order_acquire) : 0; } uint64_t sampler_registrations_generation() { return samp_gen.load(std::memory_order_acquire); } void texture_released(uint64_t serial) { std::lock_guard lk(reg_mu); auto it = regs_by_serial.find(serial); if (it == regs_by_serial.end()) return; for (int id : it->second) if (id >= 0 && (size_t)id < tex_regs.size()) tex_regs[id].released = true, slot_versions[id].fetch_add(1); reg_gen++; } bool texture_of(int id, nvn_tex* t, nvn_view* v, bool* has_view) { std::lock_guard lk(reg_mu); if (id < 0 || (size_t)id >= tex_regs.size() || !tex_regs[id].ok) return false; const TexReg& r = tex_regs[id]; *t = r.t, *v = r.v, *has_view = r.has_view; return true; } bool sampler_of(int id, nvn_samp_par* p) { std::lock_guard lk(reg_mu); if (id < 0 || (size_t)id >= samp_regs.size() || !samp_regs[id].ok) return false; *p = samp_regs[id].p; return true; } void driver_bank(const NvnState& s, int bank, int stage, uint8_t d[0xA00]) { std::memset(d, 0, 0xA00); for (uint32_t off = 0; off < 0xA00; off += 4) { const uint32_t w = driver_bank_word(s, bank, stage, off); std::memcpy(d + off, &w, 4); } } // (hookshot) What task and mesh programs read through pointers: the words of their small storage buffers that are GPU addresses // outside every binding, gathered into up to three regions of one pool each. c0 from 0x880 (after the mesh table, which nothing else // uses) gives them to the programs as a table of storage buffers (translate_program.cpp AddGlobalTables). Without it those reads // gave 0: skinned and instanced models lost their bones and collapsed into spikes. struct PointerEntry { uint64_t addr, size; }; constexpr uint32_t kPointerTable = 0x880, kPointerEntries = 3; const PointerEntry* pointer_table(const NvnState& s, int stage) { thread_local PointerEntry e[kPointerEntries]; thread_local uint64_t for_gen = ~0ull; thread_local const NvnState* for_state = nullptr; thread_local int for_stage = -1; if (for_gen == s.bind_gen && for_state == &s && for_stage == stage) return e; for_gen = s.bind_gen, for_state = &s, for_stage = stage; std::memset(e, 0, sizeof e); uint64_t found[32]; uint32_t n = 0; const auto bound = [&](uint64_t v) { for (const nvn_p_bind_buf& b : s.ssbo[stage]) if (b.addr && v >= b.addr && v < b.addr + b.size) return true; return false; }; for (const nvn_p_bind_buf& b : s.ssbo[stage]) { if (!b.addr || !b.size || b.size > 0x100) continue; uint64_t w[32]{}; const uint32_t words = (uint32_t)std::min(b.size / 8, 32); if (!memory_read_as_submitted(b.addr, w, (uint64_t)words * 8)) continue; for (uint32_t i = 0; i < words && n < 32; i++) { const uint64_t v = w[i]; if ((v & 3) || v < (1ull << 32) || v >= (1ull << 40) || !host->gpu_guest(v) || bound(v)) continue; bool have = false; for (uint32_t k = 0; k < n; k++) have |= found[k] == v; if (!have) found[n++] = v; } } std::sort(found, found + n); uint32_t regions = 0; if (stage == 5 || stage == 6 || stage == 7) { // (EvilOOT) compute, task and mesh: whole pools // (mesh programs too: once OoT's foliage draws were given work they read their instances through the same kind of // pointers, and with 1 MB regions every primitive was clipped away: positions read as 0) // OoT's culling passes follow pointers found in their records into lists that hold more pointers, spread over one // ~100 MB pool: regions of 1 MB past the first pointers missed them, the reads gave 0 and every object was culled. // The pools that hold the pointers are bound whole (read by the shader's search; GPU-only, never copied back, as // vk_draw.cpp binds the table), as far as a storage buffer reaches. const uint64_t most = std::min(dev.props.limits.maxStorageBufferRange, 0xFFFFFF00ull) & ~0xFFull; for (uint32_t i = 0; i < n && regions < kPointerEntries; i++) { const uint64_t lo = gpu_pool_start(found[i]), hi = gpu_pool_end(found[i]); if (!hi || hi <= lo) continue; bool have = false; for (uint32_t k = 0; k < regions; k++) have |= e[k].addr == lo; if (have) continue; e[regions++] = {lo, std::min(hi - lo, most)}; } return e; } for (uint32_t i = 0; i < n && regions < kPointerEntries; regions++) { const uint64_t first = found[i], end = gpu_pool_end(first); if (!end) { i++, regions--; continue; } while (i + 1 < n && found[i + 1] < end && found[i + 1] - first < (64ull << 20)) i++; // (past the last pointer: what is left of the pool, 1 MB at most) e[regions] = {first, std::min(found[i] + (1ull << 20), end) - first}; i++; } return e; } void driver_bank_fill(const NvnState& s, int bank, int stage, uint8_t* d, uint32_t n) { std::memset(d, 0, n); if (stage < 0 || stage >= kNvnStages) return; auto put = [&](uint32_t off, uint32_t v) { if (off + 4 <= n) std::memcpy(d + off, &v, 4); }; auto entry = [&](uint32_t off, const nvn_p_bind_buf& e) { put(off, (uint32_t)e.addr), put(off + 4, (uint32_t)(e.addr >> 32)), put(off + 8, (uint32_t)e.size); }; if (bank == 2) { // (driver_bank_word's layout: handles' low words, 8 bytes a slot) for (uint32_t i = 0; i < 32 && 0x20 + 8 * i < n; i++) put(0x20 + 8 * i, (uint32_t)s.tex[stage][i]); for (uint32_t i = 0; i < 9 && 0x120 + 8 * i < n; i++) put(0x120 + 8 * i, (uint32_t)s.img[stage][i]); for (uint32_t i = 0; i < 128 && 0x168 + 8 * i < n; i++) put(0x168 + 8 * i, (uint32_t)s.tex[stage][i]); for (uint32_t i = 0; i < 128 && 0x568 + 8 * i < n; i++) put(0x568 + 8 * i, (uint32_t)s.samp[stage][i]); return; } if (bank != 0) return; if (stage == 5) { const CsLayout l = cs_layout(s); for (uint32_t i = 0; i < 3; i++) put(4 * i, s.grid[i]); for (uint32_t o = 0; o + 4 <= l.push && 0x10 + o + 4 <= n; o += 4) { // (hookshot) the push area uint32_t v = 0; if (o + 4 <= s.cs_push_n) std::memcpy(&v, s.cs_push + o, 4); put(0x10 + o, v); } for (uint32_t i = 0; i < std::min(l.ubo, 16u); i++) entry(l.ubo_at() + 16 * i, s.ubo[5][i]); for (uint32_t i = 0; i < std::min(l.ssbo, 16u); i++) entry(l.ssbo_at() + 16 * i, s.ssbo[5][i]); for (uint32_t i = 0; i < l.tex && l.tex_at() + 8 * i < n; i++) put(l.tex_at() + 8 * i, (uint32_t)s.tex[5][std::min(i, 127u)]); for (uint32_t i = 0; i < l.img && l.img_at() + 8 * i < n; i++) put(l.img_at() + 8 * i, (uint32_t)s.img[5][std::min(i, 31u)]); // (EvilOOT) compute programs read through pointers kept in their small storage buffers too (OoT's culling passes: // their object lists, reached through the setup pass's records): the same table as task and mesh programs get, at // 0x880, past the layout (translate_program.cpp AddGlobalTables gives it to compute programs whose layout ends before) if (l.end() <= kPointerTable && n > kPointerTable) { const PointerEntry* e = pointer_table(s, 5); for (uint32_t i = 0; i < kPointerEntries; i++) { const uint32_t off = kPointerTable + 16 * i; put(off, (uint32_t)e[i].addr), put(off + 4, (uint32_t)(e[i].addr >> 32)), put(off + 8, (uint32_t)e[i].size); } } return; } static constexpr uint32_t kSsboTable[kNvnStages] = {0x110, 0x510, 0x410, 0x210, 0x310, 0, 0x670, 0x770}; if (const uint32_t base = kSsboTable[stage]) for (uint32_t i = 0; i < 16 && base + 16 * i < n; i++) entry(base + 16 * i, s.ssbo[stage][i]); if ((stage == 6 || stage == 7) && n > kPointerTable) { const PointerEntry* e = pointer_table(s, stage); for (uint32_t i = 0; i < kPointerEntries; i++) { const uint32_t off = kPointerTable + 16 * i; put(off, (uint32_t)e[i].addr), put(off + 4, (uint32_t)(e[i].addr >> 32)), put(off + 8, (uint32_t)e[i].size); } } if (stage == 0) put(0x610, std::bit_cast(2047.9375f)); } /// (hookshot) the bound compute program's texture and image slot counts (its control section's) void cs_slot_counts(const NvnState& s, uint32_t* tex, uint32_t* img) { const CsLayout l = cs_layout(s); *tex = l.tex, *img = l.img; } uint32_t driver_bank_word(const NvnState& s, int bank, int stage, uint32_t offset) { if (stage < 0 || stage >= kNvnStages || offset + 4 > 0xA00 || (offset & 3)) return 0; auto lo = [](uint64_t v) { return (uint32_t)v; }; auto hi = [](uint64_t v) { return (uint32_t)(v >> 32); }; if (bank == 2) { if (offset & 7) return 0; if (offset >= 0x568 && offset < 0x568 + 8 * 128) return lo(s.samp[stage][(offset - 0x568) / 8]); if (offset >= 0x168 && offset < 0x168 + 8 * 128) return lo(s.tex[stage][(offset - 0x168) / 8]); if (offset >= 0x120 && offset < 0x120 + 8 * 9) return lo(s.img[stage][(offset - 0x120) / 8]); if (offset >= 0x20 && offset < 0x20 + 8 * 32) return lo(s.tex[stage][(offset - 0x20) / 8]); return 0; } if (bank != 0) return 0; if (stage == 5) { const CsLayout l = cs_layout(s); if (offset < 0x10) return offset < sizeof s.grid ? s.grid[offset / 4] : 0; auto entry = [&](const nvn_p_bind_buf& e, uint32_t in) -> uint32_t { return in == 0 ? lo(e.addr) : in == 4 ? hi(e.addr) : in == 8 ? (uint32_t)e.size : 0; }; if (offset < l.ubo_at()) { // (hookshot) the push area uint32_t v = 0; if (offset - 0x10 + 4 <= s.cs_push_n) std::memcpy(&v, s.cs_push + (offset - 0x10), 4); return v; } if (offset < l.ssbo_at()) return (offset - l.ubo_at()) / 16 < 16 ? entry(s.ubo[5][(offset - l.ubo_at()) / 16], (offset - l.ubo_at()) % 16) : 0; if (offset < l.tex_at()) return (offset - l.ssbo_at()) / 16 < 16 ? entry(s.ssbo[5][(offset - l.ssbo_at()) / 16], (offset - l.ssbo_at()) % 16) : 0; if (offset < l.img_at()) return (offset & 7) ? 0 : lo(s.tex[5][std::min((offset - l.tex_at()) / 8, 127)]); if (offset < l.end()) return (offset & 7) ? 0 : lo(s.img[5][std::min((offset - l.img_at()) / 8, 31)]); // (EvilOOT) compute's pointer table, as task and mesh programs' (translate_program.cpp AddGlobalTables): past the // layout's end only if (l.end() <= kPointerTable && offset >= kPointerTable && offset < kPointerTable + 16 * kPointerEntries) { const PointerEntry& e = pointer_table(s, 5)[(offset - kPointerTable) / 16]; const uint32_t in = (offset - kPointerTable) % 16; return in == 0 ? lo(e.addr) : in == 4 ? hi(e.addr) : in == 8 ? (uint32_t)e.size : 0; } return 0; } // (the storage buffer tables: 0x110 + 0x100 a hardware stage: vertex 0x110, tessellation control 0x210 and // evaluation 0x310, geometry 0x410, fragment 0x510; NVN2's task and mesh stages at 0x670 and 0x770: OoT binds index 0 to // both and its programs read those addresses. Taken for slot 6 of tables at 0x610 and 0x710, every task program read a null // buffer, found nothing to draw and made no primitives: the door, the fences and all else drawn this way never showed) static constexpr uint32_t kSsboTable[kNvnStages] = {0x110, 0x510, 0x410, 0x210, 0x310, 0, 0x670, 0x770}; const uint32_t base = kSsboTable[stage]; auto table = [&](const nvn_p_bind_buf* t, uint32_t at) -> uint32_t { const nvn_p_bind_buf& e = t[(offset - at) / 16]; switch ((offset - at) % 16) { case 0: return lo(e.addr); case 4: return hi(e.addr); case 8: return (uint32_t)e.size; default: return 0; } }; if (base && offset >= base && offset < base + 16 * 16) return table(s.ssbo[stage], base); if ((stage == 6 || stage == 7) && offset >= kPointerTable && offset < kPointerTable + 16 * kPointerEntries) { const PointerEntry& e = pointer_table(s, stage)[(offset - kPointerTable) / 16]; const uint32_t in = (offset - kPointerTable) % 16; return in == 0 ? lo(e.addr) : in == 4 ? hi(e.addr) : in == 8 ? (uint32_t)e.size : 0; } if (stage == 0 && offset == 0x610) return std::bit_cast(2047.9375f); return 0; } } // namespace mkwvk