// RenoDX is Carlos Lopez's (github.com/clshortfuse/renodx): Copyright (c) 2025 Carlos Lopez Jr.; its Zelda OoT mod, // Copyright (C) 2026 Carlos Lopez. SPDX-License-Identifier: MIT. What follows is worked from that mod's addon: the // notice and the license's text are in third_party/renodx/LICENSE.md. // // (local, RenoDX port) RenoDX's Zelda OoT mod (src/games/zelda-oot-oz, MIT, Carlos Lopez) inside the renderer: its replacement // shaders (renodx_spv.h, from scripts/renodx_shaders.py) take the place of the game's scene tone mapping, HDR output encoder and // fog when their modules are made (vk_shader.cpp make_module), and read RenoDX's settings from a second descriptor set, as its // ReShade addon gives them (addon.cpp): set 1, bindings 0 and 1 the eye adaptation's state images (the one read, the one // written), 2 its constants, 3 the anti-aliasing controls, 4 the settings (shared.h ShaderInjectData). // // The eye adaptation (adaptation.slangi) keeps its state in two 3 x 1 images, read from one and written to the other, swapped each // present. One scene draw a frame is told to meter the picture and one fog draw to record the camera's field of view; each record // carries its frame's generation, and a reader takes only the frame before's. The constants a frame's draws read are that frame's // own (a ring of kRing frames of them, with a descriptor set each), since the GPU runs a frame's draws after the CPU has gone on. // // Not ported: the anti-aliasing and reconstruction shaders (Hookshot's own upscalers stand where they would go), the local // exposure and SDR scene permutations, and the RGBA16F scene target the addon asks the game for. // RX_VK_RENODX=0: off, the game's own shaders. RX_VK_RENODX_TRACE=1: every 1200th frame's draws by fragment module. #include #include #include #include #include #include #include #include #include #include "vk_menu.h" #include "vk_renodx.h" // RenoDX's shaders are not part of Hookshot: a build that asks for them fetches and compiles them (scripts/renodx_shaders.py // into HOOKSHOT_RENODX's renodx_spv.h, which compiles this file with HOOKSHOT_RENODX). Without it only the stubs at the end // are here: nothing is replaced, and the game keeps its own tone mapping and scene format. #ifdef HOOKSHOT_RENODX #include "renodx_spv.h" #include "vk_work.h" // (last: counts the commands that do GPU work, for full_barrier) namespace mkwvk { namespace { // (shared.h ShaderInjectData: 17 floats, scalar layout) struct Injection { float tone_map_type, peak_white_nits, diffuse_white_nits, graphics_white_nits; float tone_map_highlights, tone_map_shadows, tone_map_contrast, tone_map_saturation, tone_map_cone_contrast; float bloom_strength, custom_hue_clip, custom_flags, local_exposure, tone_map_exposure; float adaptation_target, adaptation_min_stops, adaptation_max_stops; }; static_assert(sizeof(Injection) == 17 * sizeof(float)); constexpr size_t kShaders = sizeof RENODX_SHADERS / sizeof RENODX_SHADERS[0]; // (a draw's part in the eye adaptation, which picks its constants: renodx_spv.h's kinds 1 the fog, 2 the scene) enum { kPlain = 0, kFog = 1, kMeter = 2, kKinds = 3 }; constexpr uint32_t kRing = 8; // (frames of constants kept apart; even, so a frame's images follow from its place in the ring) constexpr uint64_t kSlot = 256; // (a uniform range's place: a multiple of any minUniformBufferOffsetAlignment) constexpr uint64_t kInjectionAt = 0, kAaAt = kSlot, kSeedAt = 2 * kSlot, kAdaptationAt = 4 * kSlot; constexpr uint64_t kBufferSize = kAdaptationAt + kRing * kKinds * kSlot; constexpr uint32_t kGenerations = 1048576u; // (shared.h RENODX_ADAPTATION_GENERATION_COUNT) struct State { bool tried = false, ok = false; VkDescriptorSetLayout layout = VK_NULL_HANDLE; VkDescriptorPool pool = VK_NULL_HANDLE; VkDescriptorSet sets[kRing][kKinds]{}; VkImage images[2]{}; VmaAllocation image_allocs[2]{}; VkImageView views[2]{}; VkBuffer buffer = VK_NULL_HANDLE; VmaAllocation buffer_alloc = nullptr; void* mapped = nullptr; std::chrono::steady_clock::time_point last_present = std::chrono::steady_clock::now(); }; State st; std::mutex mu; std::atomic frame{0}; // (the frame being recorded: presents so far) std::atomic meter_claimed{false}, fog_claimed{false}; // (this frame's one metering draw and one fog record) std::atomic binds[kShaders]; // (draws through each of RenoDX's shaders since the last report) std::atomic meters{0}, fogs{0}; // (frames metered and field-of-view records made since the last report) bool enabled() { // (Triforce, 11-13: the RenoDX HDR row as it was at the start; RX_VK_RENODX=0 or 1 over it) return renodx_chosen(); } std::atomic replaced_modules{0}; // (modules of the game's that RenoDX's took the place of, this run) bool adapting() { return opts.rdx_tonemap && opts.rdx_midgray == 2; } /// The settings from the Insert menu's rows, parsed as addon.cpp parses its own (0 to 100 with 50 neutral is 0 to 2), and the /// constants of frame f's draws (delta: the time since the frame before) void write_settings(uint64_t f, float delta_seconds) { Injection in{}; in.tone_map_type = opts.rdx_tonemap ? 9.0f : 0.0f; // (RENODX_TONE_MAP_TYPE_PSYCHOV35, _VANILLA) in.peak_white_nits = (float)opts.hdr_peak; in.diffuse_white_nits = (float)opts.hdr_white; in.graphics_white_nits = (float)opts.rdx_ui_white; in.tone_map_highlights = opts.rdx_highlights * 0.02f, in.tone_map_shadows = opts.rdx_shadows * 0.02f; in.tone_map_contrast = opts.rdx_contrast * 0.02f, in.tone_map_saturation = opts.rdx_saturation * 0.02f; in.tone_map_cone_contrast = 1.0f; in.bloom_strength = opts.rdx_bloom * 0.02f; in.custom_hue_clip = 0.5f; // (midgray: 0 the render's, 1 vanilla's, 16 the eye adaptation's; 2: match the tone slope; the colour space in bits 2 and 3) const uint32_t midgray = opts.rdx_midgray == 2 ? 16u : opts.rdx_midgray == 1 ? 1u : 0u; const uint32_t flags = midgray | 2u | ((uint32_t)std::clamp(opts.rdx_space, 0, 2) << 2); std::memcpy(&in.custom_flags, &flags, sizeof flags); in.local_exposure = 0.0f; in.tone_map_exposure = opts.rdx_exposure * 0.01f; in.adaptation_target = 0.18f, in.adaptation_min_stops = -4.0f, in.adaptation_max_stops = 2.0f; const float aa[2] = {1.0f, 0.0f}; // (AA strength, reconstruction: native) uint8_t* m = (uint8_t*)st.mapped; std::memcpy(m + kInjectionAt, &in, sizeof in); std::memcpy(m + kAaAt, aa, sizeof aa); for (int kind = 0; kind < kKinds; kind++) { // (adaptation.slangi: delta_seconds, generation, capture_fov, meter_draw) const float adaptation[4] = {delta_seconds, (float)(f % kGenerations), kind == kFog ? 1.0f : 0.0f, kind == kMeter ? 1.0f : 0.0f}; std::memcpy(m + kAdaptationAt + ((f % kRing) * kKinds + kind) * kSlot, adaptation, sizeof adaptation); } flush_mapped(st.buffer_alloc, kBufferSize); } /// The state images' seed copied in, on the replay's queue, waited for (once) bool seed_images() { VkCommandPoolCreateInfo pi{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO}; pi.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; pi.queueFamilyIndex = dev.queue_family; VkCommandPool pool = VK_NULL_HANDLE; if (vkCreateCommandPool(dev.device, &pi, nullptr, &pool) != VK_SUCCESS) return false; VkCommandBufferAllocateInfo ai{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; ai.commandPool = pool, ai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, ai.commandBufferCount = 1; VkCommandBuffer cmd = VK_NULL_HANDLE; VkFenceCreateInfo fi{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; VkFence fence = VK_NULL_HANDLE; bool ok = vkAllocateCommandBuffers(dev.device, &ai, &cmd) == VK_SUCCESS && vkCreateFence(dev.device, &fi, nullptr, &fence) == VK_SUCCESS; if (ok) { VkCommandBufferBeginInfo bi{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; vkBeginCommandBuffer(cmd, &bi); for (const VkImage image : st.images) { VkImageMemoryBarrier2 b{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2}; b.srcStageMask = VK_PIPELINE_STAGE_2_NONE; b.dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT; b.dstAccessMask = VK_ACCESS_2_MEMORY_READ_BIT | VK_ACCESS_2_MEMORY_WRITE_BIT; b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, b.newLayout = VK_IMAGE_LAYOUT_GENERAL; b.srcQueueFamilyIndex = b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; b.image = image; b.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; VkDependencyInfo di{VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; di.imageMemoryBarrierCount = 1, di.pImageMemoryBarriers = &b; vkCmdPipelineBarrier2(cmd, &di); const VkBufferImageCopy c{kSeedAt, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {3, 1, 1}}; vkCmdCopyBufferToImage(cmd, st.buffer, image, VK_IMAGE_LAYOUT_GENERAL, 1, &c); } vkEndCommandBuffer(cmd); VkCommandBufferSubmitInfo cb{VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO}; cb.commandBuffer = cmd; VkSubmitInfo2 si{VK_STRUCTURE_TYPE_SUBMIT_INFO_2}; si.commandBufferInfoCount = 1, si.pCommandBufferInfos = &cb; { std::lock_guard qk(dev.present_mu); // (the queue's lock) queue_flush_locked(); ok = vkQueueSubmit2(dev.queue, 1, &si, fence) == VK_SUCCESS; } if (ok) vkWaitForFences(dev.device, 1, &fence, VK_TRUE, UINT64_MAX); } if (fence) vkDestroyFence(dev.device, fence, nullptr); vkDestroyCommandPool(dev.device, pool, nullptr); return ok; } bool make() { const VkShaderStageFlags stages = VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT; const VkDescriptorSetLayoutBinding bindings[5] = { {0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, stages, nullptr}, {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, stages, nullptr}, {2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, stages, nullptr}, {3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, stages, nullptr}, {4, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, stages, nullptr}, }; VkDescriptorSetLayoutCreateInfo li{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; li.bindingCount = 5, li.pBindings = bindings; if (vkCreateDescriptorSetLayout(dev.device, &li, nullptr, &st.layout) != VK_SUCCESS) return false; constexpr uint32_t kSets = kRing * kKinds; const VkDescriptorPoolSize sizes[2] = {{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2 * kSets}, {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3 * kSets}}; VkDescriptorPoolCreateInfo pi{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO}; pi.maxSets = kSets, pi.poolSizeCount = 2, pi.pPoolSizes = sizes; if (vkCreateDescriptorPool(dev.device, &pi, nullptr, &st.pool) != VK_SUCCESS) return false; if (!create_buffer(kBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, st.buffer, st.buffer_alloc, &st.mapped) || !st.mapped) return false; // (addon.cpp's seed. Pixel 0: the linear anchor, log2 fast, log2 slow, generation; 1: the FOV capture; 2: the log2 filtered // target, the bleached fraction, reserved, generation. log2(0.18); the negative generations make these records stale) const float seed[12] = {0.18f, -2.473931188332412f, -2.473931188332412f, -1.0f, 0.0f, 0.0f, 0.0f, -2.0f, -2.473931188332412f, 0.0f, 0.0f, -2.0f}; std::memcpy((uint8_t*)st.mapped + kSeedAt, seed, sizeof seed); write_settings(frame.load(), 1.0f / 60.0f); for (int i = 0; i < 2; i++) { VkImageCreateInfo ic{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; ic.imageType = VK_IMAGE_TYPE_2D, ic.format = VK_FORMAT_R32G32B32A32_SFLOAT, ic.extent = {3, 1, 1}; ic.mipLevels = ic.arrayLayers = 1, ic.samples = VK_SAMPLE_COUNT_1_BIT, ic.tiling = VK_IMAGE_TILING_OPTIMAL; ic.usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; if (!create_image(ic, st.images[i], st.image_allocs[i])) return false; VkImageViewCreateInfo vi{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; vi.image = st.images[i], vi.viewType = VK_IMAGE_VIEW_TYPE_2D, vi.format = ic.format; vi.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; if (vkCreateImageView(dev.device, &vi, nullptr, &st.views[i]) != VK_SUCCESS) return false; } if (!seed_images()) return false; for (uint32_t ring = 0; ring < kRing; ring++) { for (int kind = 0; kind < kKinds; kind++) { VkDescriptorSetAllocateInfo ai{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; ai.descriptorPool = st.pool, ai.descriptorSetCount = 1, ai.pSetLayouts = &st.layout; if (vkAllocateDescriptorSets(dev.device, &ai, &st.sets[ring][kind]) != VK_SUCCESS) return false; // (the image the frame before wrote, then the one this frame writes) const VkDescriptorImageInfo images[2] = {{VK_NULL_HANDLE, st.views[ring & 1], VK_IMAGE_LAYOUT_GENERAL}, {VK_NULL_HANDLE, st.views[(ring & 1) ^ 1], VK_IMAGE_LAYOUT_GENERAL}}; const VkDescriptorBufferInfo buffers[3] = {{st.buffer, kAdaptationAt + (ring * kKinds + kind) * kSlot, 16}, {st.buffer, kAaAt, 8}, {st.buffer, kInjectionAt, sizeof(Injection)}}; VkWriteDescriptorSet w[5]; for (uint32_t i = 0; i < 5; i++) { w[i] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; w[i].dstSet = st.sets[ring][kind], w[i].dstBinding = i, w[i].descriptorCount = 1; if (i < 2) w[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, w[i].pImageInfo = &images[i]; else w[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, w[i].pBufferInfo = &buffers[i - 2]; } vkUpdateDescriptorSets(dev.device, 5, w, 0, nullptr); } } return true; } bool ready() { std::lock_guard lk(mu); if (!st.tried) { st.tried = true; st.ok = make(); logf(st.ok ? "vk: RenoDX: its settings and state made (set 1); peak %d nits, paper white %d nits" : "vk: RenoDX: its settings could not be made: the replaced shaders read nothing there", opts.hdr_peak, opts.hdr_white); } return st.ok; } std::mutex trace_mu; std::vector traced; } // namespace std::atomic renodx_tracing{false}; const std::vector* renodx_replacement(uint32_t crc) { if (!enabled()) return nullptr; static const std::unordered_map> table = [] { std::unordered_map> out; for (const auto& s : RENODX_SHADERS) out.emplace(s.crc, std::vector(s.words, s.words + s.count)); return out; }(); const auto it = table.find(crc); if (it != table.end()) replaced_modules.fetch_add(1, std::memory_order_relaxed); return it == table.end() ? nullptr : &it->second; } VkDescriptorSetLayout renodx_set_layout() { return ready() ? st.layout : VK_NULL_HANDLE; } void renodx_bind(VkCommandBuffer cmd, VkPipelineBindPoint bp, VkPipelineLayout layout, uint32_t crc) { if (!ready()) return; int kind = kPlain; for (size_t i = 0; i < kShaders; i++) { if (RENODX_SHADERS[i].crc != crc) continue; binds[i].fetch_add(1, std::memory_order_relaxed); // (addon.cpp PrepareAdaptationDraw, OnDrawAdaptationFog: with the eye adaptation on, the frame's first scene draw // meters and its first fog draw records the field of view) if (!adapting()) break; if (RENODX_SHADERS[i].kind == 2 && !meter_claimed.exchange(true)) kind = kMeter, meters.fetch_add(1, std::memory_order_relaxed); if (RENODX_SHADERS[i].kind == 1 && !fog_claimed.exchange(true)) kind = kFog, fogs.fetch_add(1, std::memory_order_relaxed); break; } vkCmdBindDescriptorSets(cmd, bp, layout, 1, 1, &st.sets[frame.load(std::memory_order_relaxed) % kRing][kind], 0, nullptr); } void renodx_trace_draw(uint32_t frag_crc) { std::lock_guard lk(trace_mu); traced.push_back(frag_crc); } void renodx_present() { { // (RX_VK_RENODX_TRACE=1: every 1200th frame's draws, in order, by fragment module) static const bool trace = getenv("RX_VK_RENODX_TRACE") != nullptr; static int64_t frames; if (trace) { if (renodx_tracing.exchange(false)) { std::lock_guard lk(trace_mu); // (the frame's last 120 draws, 40 a line: the tone mapping and what follows it close the frame, and a // longer line is cut by the log) const size_t from = traced.size() > 120 ? traced.size() - 120 : 0; logf("vk: RenoDX trace: a frame of %zu draws; by fragment module from draw %zu:", traced.size(), from); for (size_t at = from; at < traced.size(); at += 40) { std::string line; char b[16]; for (size_t k = at; k < std::min(at + 40, traced.size()); k++) snprintf(b, sizeof b, " %08X", traced[k]), line += b; logf("vk: RenoDX trace:%s", line.c_str()); } traced.clear(); } if (++frames % 1200 == 0) renodx_tracing.store(true); } } { // (Triforce, 11-13) RenoDX chosen and nothing of the game's replaced half a minute in: said, once. Its shaders are // named by the CRC-32 of the module this translator makes, so another translation of the same program (a later // change to the emitter, another card's fixes) silently leaves the game's own HDR running static std::atomic presents{0}; if (enabled() && presents.fetch_add(1, std::memory_order_relaxed) == 1800 && !replaced_modules.load(std::memory_order_relaxed)) logf("vk: RenoDX: on, and none of its four shaders has replaced one of the game's in 1800 presents: the game's own " "picture runs. Either HDR is not Native on an HDR10 display (its shaders are the native HDR ones), or this " "build names them by other checksums (scripts/renodx_shaders.py SHADERS: match them again)"); } std::lock_guard lk(mu); if (!st.ok) return; const auto now = std::chrono::steady_clock::now(); const float delta = std::chrono::duration(now - st.last_present).count(); st.last_present = now; // (the next frame: its constants written before any of its draws is recorded; its place in the ring was last read kRing // frames ago) const uint64_t next = frame.load() + 1; write_settings(next, delta); frame.store(next); meter_claimed.store(false), fog_claimed.store(false); // (how much of the picture goes through it. A scene draw and the output encoder each frame is the whole of it; the scene at 0 // means a permutation of the game's tone mapping that RenoDX has no replacement for) if (next % 600 == 0) { char line[256]; int n = 0; for (size_t i = 0; i < kShaders && n < (int)sizeof line - 32; i++) n += snprintf(line + n, sizeof line - n, " %08X %.2f", RENODX_SHADERS[i].crc, (double)binds[i].exchange(0, std::memory_order_relaxed) / 600.0); logf("vk: RenoDX: draws a frame through its shaders over the last 600 presents:%s; eye adaptation %s, %lld frames metered, " "%lld field-of-view records", line, adapting() ? "on" : "off", (long long)meters.exchange(0), (long long)fogs.exchange(0)); } } bool renodx_built() { return true; } } // namespace mkwvk #else // (no RenoDX shaders in this build: nothing is replaced) namespace mkwvk { std::atomic renodx_tracing{false}; bool renodx_built() { return false; } const std::vector* renodx_replacement(uint32_t) { return nullptr; } VkDescriptorSetLayout renodx_set_layout() { return VK_NULL_HANDLE; } void renodx_bind(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t) {} void renodx_trace_draw(uint32_t) {} void renodx_present() {} } // namespace mkwvk #endif