// (hookshot) AMD FSR 3.1's upscaler as our own dispatches over AMD's vendored passes, and its place in the gameplay upscale's // dispatch (fsr3_upscale, at the end); see vk_fsr3.h. // // The resource table and the per-pass binding lists are the SDK's, not ours: ffx_fsr3upscaler.cpp decides the formats and // sizes, and each pass file numbers its own bindings (FSR3UPSCALER_BIND_*). Getting one wrong is a validation error at best // and a wrong picture at worst, so they are written out here in the SDK's order rather than derived. #include #include #include #include #include #include #include #include #include #include #include #include "vk_fsr3.h" #include "vk_fsr3_inputs.h" #include "vk_draw.h" // (descriptors_disturbed) #include "vk_gprof.h" // (RX_VK_PASS_TIMING: a span per pass, so the report names them) #include "vk_menu.h" #include "vk_temporal.h" // (temporal_env_chosen: RX_VK_DLSS / RX_VK_FSR4 over the row's FSR 3.1) #include "vk_texture.h" #include "upscaler_rows.h" #include "shaders/dlss_out_comp_spv.h" // (the network's output from a picture: its encoding squared back, as for DLSS) #include "shaders/fsr3_accumulate_comp_spv.h" #include "shaders/fsr3_luma_instability_comp_spv.h" #include "shaders/fsr3_luma_pyramid_comp_spv.h" #include "shaders/fsr3_luma_pyramid_nowave_comp_spv.h" #include "shaders/fsr3_prepare_inputs_comp_spv.h" #include "shaders/fsr3_prepare_reactivity_comp_spv.h" #include "shaders/fsr3_shading_change_comp_spv.h" #include "shaders/fsr3_shading_change_pyramid_comp_spv.h" #include "shaders/fsr3_shading_change_pyramid_nowave_comp_spv.h" #include "vk_work.h" // (after the others: counts the commands that do GPU work, for full_barrier) namespace mkwvk { VkPipelineCache shared_pipeline_cache(); // (vk_draw.cpp: the pipeline cache kept across runs) } namespace mkwvk::fsr3 { namespace { /// A descriptor's kind, in the binding order each pass file declares. Every pass also takes the two /// samplers at bindings 1000 (point clamp) and 1001 (linear clamp). enum Kind : uint8_t { T, I, U }; // sampled texture, storage image, uniform buffer struct PassInfo { const char* name; const uint32_t* spv; size_t spv_bytes; const Kind* bindings; size_t binding_count; }; constexpr Kind PREPARE_INPUTS[]{T, T, T, I, I, I, I, I, U}; constexpr Kind LUMA_PYRAMID[]{T, T, I, I, I, I, I, I, I, I, I, U, U}; constexpr Kind SHADING_CHANGE_PYRAMID[]{T, T, T, T, I, I, I, I, I, I, I, U, U}; constexpr Kind SHADING_CHANGE[]{T, I, U}; constexpr Kind PREPARE_REACTIVITY[]{T, T, T, T, T, T, T, T, T, I, I, I, U}; constexpr Kind LUMA_INSTABILITY[]{T, T, T, T, T, T, T, I, I, U}; constexpr Kind ACCUMULATE[]{T, T, T, T, T, T, T, T, T, I, I, I, U}; #define PASS(n, spv, b) PassInfo{n, spv, sizeof spv, b, sizeof b / sizeof b[0]} /// The passes, in the order PassId numbers them. The two _nowave pyramids are alternatives to the two before them, for /// devices without the subgroup operations the single-pass downsampler wants. FSR's own sharpening (accumulate_sharpen and /// RCAS, compiled with the rest) is not used: the renderer's Sharpness row sharpens the finished picture for every upscaler const PassInfo PASSES[]{ PASS("prepare_inputs", FSR3_PREPARE_INPUTS_COMP_SPV, PREPARE_INPUTS), PASS("luma_pyramid", FSR3_LUMA_PYRAMID_COMP_SPV, LUMA_PYRAMID), PASS("luma_pyramid_nowave", FSR3_LUMA_PYRAMID_NOWAVE_COMP_SPV, LUMA_PYRAMID), PASS("shading_change_pyramid", FSR3_SHADING_CHANGE_PYRAMID_COMP_SPV, SHADING_CHANGE_PYRAMID), PASS("shading_change_pyramid_nowave", FSR3_SHADING_CHANGE_PYRAMID_NOWAVE_COMP_SPV, SHADING_CHANGE_PYRAMID), PASS("shading_change", FSR3_SHADING_CHANGE_COMP_SPV, SHADING_CHANGE), PASS("prepare_reactivity", FSR3_PREPARE_REACTIVITY_COMP_SPV, PREPARE_REACTIVITY), PASS("luma_instability", FSR3_LUMA_INSTABILITY_COMP_SPV, LUMA_INSTABILITY), PASS("accumulate", FSR3_ACCUMULATE_COMP_SPV, ACCUMULATE), }; #undef PASS enum PassId : size_t { P_PREPARE_INPUTS, P_LUMA_PYRAMID, P_LUMA_PYRAMID_NOWAVE, P_SHADING_CHANGE_PYRAMID, P_SHADING_CHANGE_PYRAMID_NOWAVE, P_SHADING_CHANGE, P_PREPARE_REACTIVITY, P_LUMA_INSTABILITY, P_ACCUMULATE, kPassCount }; static_assert(sizeof PASSES / sizeof PASSES[0] == kPassCount, "PassId must name every pass"); constexpr uint32_t kSpdStoredMips = 6; struct Pipeline { VkDescriptorSetLayout set = VK_NULL_HANDLE; VkPipelineLayout layout = VK_NULL_HANDLE; VkPipeline pipeline = VK_NULL_HANDLE; }; struct Image { VkImage image = VK_NULL_HANDLE; VmaAllocation memory = nullptr; VkImageView view = VK_NULL_HANDLE; ///< every level std::vector levels; ///< one per level, for the mipped ones uint32_t width = 0, height = 0, level_count = 1; VkFormat format = VK_FORMAT_UNDEFINED; }; /// cbFSR3Upscaler, exactly as ffx_fsr3upscaler.cpp lays it out. The size is asserted because every /// pass reads it by offset: a field out of place is a wrong picture, not a compile error. struct Constants { int32_t render_size[2]; int32_t previous_render_size[2]; int32_t upscale_size[2]; int32_t previous_upscale_size[2]; int32_t max_render_size[2]; int32_t max_upscale_size[2]; float device_to_view_depth[4]; float jitter[2]; float previous_jitter[2]; float motion_vector_scale[2]; float downscale_factor[2]; float motion_vector_jitter_cancellation[2]; float tan_half_fov; float jitter_phase_count; float delta_time; float delta_pre_exposure; float view_space_to_meters; float frame_index; float velocity_factor; float reactiveness_scale; float shading_change_scale; float accumulation_added_per_frame; float min_disocclusion_accumulation; }; static_assert(sizeof(Constants) == 148, "cbFSR3Upscaler must match the SDK's layout"); struct SpdConstants { uint32_t mips; uint32_t num_work_groups; uint32_t work_group_offset[2]; uint32_t render_size[2]; }; /// One descriptor of a dispatch: an image view, or a range of the uniform buffer. struct Resource { VkImageView view = VK_NULL_HANDLE; VkBuffer buffer = VK_NULL_HANDLE; VkDeviceSize offset = 0; VkDeviceSize size = 0; }; /// A memory dependency over the whole queue, in the synchronization2 form this renderer loads. void memory_barrier(VkCommandBuffer cmd, VkPipelineStageFlags2 src_stage, VkAccessFlags2 src, VkPipelineStageFlags2 dst_stage, VkAccessFlags2 dst) { VkMemoryBarrier2 b{VK_STRUCTURE_TYPE_MEMORY_BARRIER_2}; b.srcStageMask = src_stage, b.srcAccessMask = src; b.dstStageMask = dst_stage, b.dstAccessMask = dst; VkDependencyInfo di{VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; di.memoryBarrierCount = 1, di.pMemoryBarriers = &b; vkCmdPipelineBarrier2(cmd, &di); } constexpr VkImageSubresourceRange ALL_LEVELS{VK_IMAGE_ASPECT_COLOR_BIT, 0, VK_REMAINING_MIP_LEVELS, 0, 1}; struct State { bool tried = false; bool ok = false; bool wave = true; ///< the pyramids with subgroup operations (else their _nowave variants) Pipeline passes[kPassCount]; VkSampler point = VK_NULL_HANDLE; VkSampler linear = VK_NULL_HANDLE; // The SDK's internal images. The pairs ping-pong on frame parity, as its resource tables do. Image accumulation[2], luma[2], luma_history[2], internal_upscaled[2]; Image farthest_depth, shading_change, new_locks, spd_mips, farthest_depth_mip1; Image dilated_motion_vectors, dilated_depth, previous_nearest_depth, dilated_reactive_masks; Image frame_info, spd_atomic, lanczos_lut, default_reactive, output; uint32_t render_width = 0, render_height = 0, upscale_width = 0, upscale_height = 0; // The uniform buffer the constant blocks are written into, one set of slots per frame in flight so a frame being read // is not overwritten. VkBuffer uniforms = VK_NULL_HANDLE; VmaAllocation uniforms_memory = nullptr; void* uniforms_mapped = nullptr; VkDeviceSize slot_fsr = 0, slot_spd = 0, frame_stride = 0; uint32_t uniform_frame = 0; // History, as fsr3upscalerDispatch carries it. int32_t previous_render_size[2]{}; int32_t previous_upscale_size[2]{}; float previous_jitter[2]{}; float frame_index = 0.0f; uint32_t parity = 0; bool first_evaluation = true; ///< the images are new: their first layout, cleared bool lut_uploaded = false; // Images of an earlier size, freed once the frames that may still read them are done (texture_frame_no) std::vector> dead; }; constexpr uint32_t kUniformFrames = 4; // (more than the swapchain's images in flight) State g; void destroy_now(Image& t) { for (VkImageView v : t.levels) vkDestroyImageView(dev.device, v, nullptr); if (t.view) vkDestroyImageView(dev.device, t.view, nullptr); if (t.image) mkwvk::destroy_image(t.image, t.memory); t = Image{}; } /// An image let go: destroyed a few presents on, as work recorded with it may still be in flight void drop_image(Image& t) { if (t.image) g.dead.push_back({texture_frame_no(), std::move(t)}); t = Image{}; } void free_dead() { const uint64_t now = texture_frame_no(); for (size_t i = 0; i < g.dead.size();) { if (now - g.dead[i].first > 4) { destroy_now(g.dead[i].second); g.dead[i] = std::move(g.dead.back()); g.dead.pop_back(); } else { i++; } } } /// One of the SDK's internal images: storage and sampled, GENERAL throughout, with a view per level when it has more than /// one (the pyramids bind their levels separately). bool make_image(Image& t, VkFormat format, uint32_t width, uint32_t height, uint32_t levels = 1) { drop_image(t); t.format = format, t.width = std::max(1u, width), t.height = std::max(1u, height); t.level_count = std::max(1u, levels); VkImageCreateInfo ci{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; ci.imageType = VK_IMAGE_TYPE_2D; ci.format = format; ci.extent = {t.width, t.height, 1}; ci.mipLevels = t.level_count; ci.arrayLayers = 1; ci.samples = VK_SAMPLE_COUNT_1_BIT; ci.tiling = VK_IMAGE_TILING_OPTIMAL; ci.usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; if (!create_image(ci, t.image, t.memory, false)) { logf("vk: fsr3: a %ux%u image (format %d) was not made", t.width, t.height, (int)format); t.image = VK_NULL_HANDLE; return false; } VkImageViewCreateInfo vi{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; vi.image = t.image; vi.viewType = VK_IMAGE_VIEW_TYPE_2D; vi.format = format; vi.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, t.level_count, 0, 1}; if (vkCreateImageView(dev.device, &vi, nullptr, &t.view) != VK_SUCCESS) return t.view = VK_NULL_HANDLE, false; if (t.level_count > 1) { for (uint32_t level = 0; level < t.level_count; level++) { vi.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, level, 1, 0, 1}; VkImageView v = VK_NULL_HANDLE; if (vkCreateImageView(dev.device, &vi, nullptr, &v) != VK_SUCCESS) return false; t.levels.push_back(v); } } return true; } bool make_pipeline(Pipeline& p, const PassInfo& info) { std::vector bindings; bindings.reserve(info.binding_count + 2); for (size_t i = 0; i < info.binding_count; i++) { const VkDescriptorType type = info.bindings[i] == T ? VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE : info.bindings[i] == I ? VK_DESCRIPTOR_TYPE_STORAGE_IMAGE : VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; bindings.push_back({(uint32_t)i, type, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}); } // (the two samplers every pass declares, at the bindings the SDK's GLSL fixes them to) bindings.push_back({1000, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}); bindings.push_back({1001, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}); VkDescriptorSetLayoutCreateInfo li{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; li.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; li.bindingCount = (uint32_t)bindings.size(); li.pBindings = bindings.data(); if (vkCreateDescriptorSetLayout(dev.device, &li, nullptr, &p.set) != VK_SUCCESS) return false; VkPipelineLayoutCreateInfo pi{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; pi.setLayoutCount = 1, pi.pSetLayouts = &p.set; if (vkCreatePipelineLayout(dev.device, &pi, nullptr, &p.layout) != VK_SUCCESS) return false; VkShaderModuleCreateInfo mi{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; mi.codeSize = info.spv_bytes; mi.pCode = info.spv; VkShaderModule m = VK_NULL_HANDLE; if (vkCreateShaderModule(dev.device, &mi, nullptr, &m) != VK_SUCCESS) return false; VkComputePipelineCreateInfo ci{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; ci.stage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, VK_SHADER_STAGE_COMPUTE_BIT, m, "main", nullptr}; ci.layout = p.layout; // (hookshot, a stutter: through the pipeline cache kept across runs. Made with none, FSR 3.1's dozen passes were compiled // again at every start, inside the first upscaled frame: a 2.7 s first frame of play against 1.0 s without FSR, 2026-11-10) const VkResult made = vkCreateComputePipelines(dev.device, shared_pipeline_cache(), 1, &ci, nullptr, &p.pipeline); vkDestroyShaderModule(dev.device, m, nullptr); if (made != VK_SUCCESS) { logf("vk: fsr3: the %s pass pipeline was not made (%d)", info.name, (int)made); p.pipeline = VK_NULL_HANDLE; return false; } return true; } bool make_samplers() { VkSamplerCreateInfo si{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; si.addressModeU = si.addressModeV = si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; si.minLod = 0.0f, si.maxLod = VK_LOD_CLAMP_NONE; si.magFilter = si.minFilter = VK_FILTER_NEAREST; si.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; if (vkCreateSampler(dev.device, &si, nullptr, &g.point) != VK_SUCCESS) return false; si.magFilter = si.minFilter = VK_FILTER_LINEAR; si.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; return vkCreateSampler(dev.device, &si, nullptr, &g.linear) == VK_SUCCESS; } /// Every storage format the internal images need. A device missing one cannot run the passes, and finding that out here is /// better than a failed image allocation in the middle of a frame. bool formats_supported() { static const VkFormat needed[]{ VK_FORMAT_R8_UNORM, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_UINT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R16_SNORM, }; for (VkFormat f : needed) { VkFormatProperties props{}; vkGetPhysicalDeviceFormatProperties(dev.physical, f, &props); if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) || !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { logf("vk: fsr3: not on this GPU: format %d cannot be a storage and sampled image here", (int)f); return false; } } return true; } /// The uniform buffer the two constant blocks (and the Lanczos table, once) are written into: host visible and mapped, with /// a set of slots per frame in flight so writing one frame cannot disturb a frame still being read. bool make_uniforms() { const VkDeviceSize align = std::max(dev.props.limits.minUniformBufferOffsetAlignment, 16); const auto round_up = [align](VkDeviceSize n) { return (n + align - 1) / align * align; }; g.slot_fsr = round_up(sizeof(Constants)); g.slot_spd = round_up(sizeof(SpdConstants)); g.frame_stride = g.slot_fsr + g.slot_spd + round_up(128 * sizeof(int16_t)); return create_buffer(g.frame_stride * kUniformFrames, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, g.uniforms, g.uniforms_memory, &g.uniforms_mapped); } /// Records one pass: its descriptors pushed in the order the pass file numbers them, then the two samplers it declares at /// 1000 and 1001, then the dispatch, and a barrier after it (every pass reads what the one before it wrote). void record_pass(VkCommandBuffer cmd, size_t pass, const Resource* res, size_t count, uint32_t groups_x, uint32_t groups_y) { const PassInfo& info = PASSES[pass]; const Pipeline& p = g.passes[pass]; std::vector images(count); std::vector buffers(count); std::vector writes; writes.reserve(count + 2); for (size_t i = 0; i < count; i++) { VkWriteDescriptorSet w{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; w.dstBinding = (uint32_t)i; w.descriptorCount = 1; if (info.bindings[i] == U) { buffers[i] = {res[i].buffer, res[i].offset, res[i].size}; w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; w.pBufferInfo = &buffers[i]; } else { images[i] = {VK_NULL_HANDLE, res[i].view, VK_IMAGE_LAYOUT_GENERAL}; w.descriptorType = info.bindings[i] == T ? VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE : VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; w.pImageInfo = &images[i]; } writes.push_back(w); } const VkDescriptorImageInfo point{g.point, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_UNDEFINED}; const VkDescriptorImageInfo linear{g.linear, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_UNDEFINED}; for (const auto& [binding, info_ptr] : {std::pair{1000, &point}, std::pair{1001, &linear}}) { VkWriteDescriptorSet w{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; w.dstBinding = binding; w.descriptorCount = 1; w.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER; w.pImageInfo = info_ptr; writes.push_back(w); } const bool timed = gprof_begin(cmd); // (RX_VK_PASS_TIMING=1: GPU ms by pass name) vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, p.pipeline); vkCmdPushDescriptorSetKHR(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, p.layout, 0, (uint32_t)writes.size(), writes.data()); vkCmdDispatch(cmd, std::max(1u, groups_x), std::max(1u, groups_y), 1); if (timed) gprof_end(cmd, std::string("fsr3 ") + info.name); memory_barrier(cmd, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT); } std::vector all_images() { std::vector all{&g.farthest_depth, &g.shading_change, &g.new_locks, &g.spd_mips, &g.farthest_depth_mip1, &g.dilated_motion_vectors, &g.dilated_depth, &g.previous_nearest_depth, &g.dilated_reactive_masks, &g.frame_info, &g.spd_atomic, &g.lanczos_lut, &g.default_reactive, &g.output}; for (size_t i = 0; i < 2; i++) { all.push_back(&g.accumulation[i]); all.push_back(&g.luma[i]); all.push_back(&g.luma_history[i]); all.push_back(&g.internal_upscaled[i]); } return all; } /// The pipelines and the internal images for an evaluation at these sizes, made again when the sizes change bool prepare(uint32_t render_width, uint32_t render_height, uint32_t upscale_width, uint32_t upscale_height) { if (!supported()) return false; if (!g.tried) { g.tried = true; g.ok = make_samplers() && make_uniforms(); for (size_t i = 0; i < kPassCount && g.ok; i++) { const bool needed = g.wave ? (i != P_LUMA_PYRAMID_NOWAVE && i != P_SHADING_CHANGE_PYRAMID_NOWAVE) : (i != P_LUMA_PYRAMID && i != P_SHADING_CHANGE_PYRAMID); if (needed) g.ok = make_pipeline(g.passes[i], PASSES[i]); } if (g.ok) logf("vk: fsr3: its passes are ready (%s subgroup operations)", g.wave ? "with" : "without"); } if (!g.ok) return false; if (g.output.image && g.render_width == render_width && g.render_height == render_height && g.upscale_width == upscale_width && g.upscale_height == upscale_height) return true; const uint32_t rw = std::max(1u, render_width), rh = std::max(1u, render_height); const uint32_t uw = std::max(1u, upscale_width), uh = std::max(1u, upscale_height); bool made = true; for (size_t i = 0; i < 2 && made; i++) { made = made && make_image(g.accumulation[i], VK_FORMAT_R8_UNORM, rw, rh); made = made && make_image(g.luma[i], VK_FORMAT_R16_SFLOAT, rw, rh); // (the pass files declare the luma history as rgba8; the SDK allocates RGBA16F, which a storage format qualifier // does not match, so this allocates what the shaders store) made = made && make_image(g.luma_history[i], VK_FORMAT_R8G8B8A8_UNORM, rw, rh); made = made && make_image(g.internal_upscaled[i], VK_FORMAT_R16G16B16A16_SFLOAT, uw, uh); } const uint32_t half_w = std::max(1u, rw / 2), half_h = std::max(1u, rh / 2); const uint32_t spd_levels = (uint32_t)std::floor(std::log2((float)std::max(half_w, half_h))) + 1; made = made && make_image(g.farthest_depth, VK_FORMAT_R16_SFLOAT, rw, rh); made = made && make_image(g.shading_change, VK_FORMAT_R8_UNORM, half_w, half_h); made = made && make_image(g.new_locks, VK_FORMAT_R8_UNORM, uw, uh); made = made && make_image(g.spd_mips, VK_FORMAT_R16G16_SFLOAT, half_w, half_h, std::max(spd_levels, kSpdStoredMips)); made = made && make_image(g.farthest_depth_mip1, VK_FORMAT_R16_SFLOAT, half_w, half_h); made = made && make_image(g.dilated_motion_vectors, VK_FORMAT_R16G16_SFLOAT, rw, rh); made = made && make_image(g.dilated_depth, VK_FORMAT_R32_SFLOAT, rw, rh); made = made && make_image(g.previous_nearest_depth, VK_FORMAT_R32_UINT, rw, rh); made = made && make_image(g.dilated_reactive_masks, VK_FORMAT_R8G8B8A8_UNORM, rw, rh); made = made && make_image(g.frame_info, VK_FORMAT_R32G32B32A32_SFLOAT, 1, 1); made = made && make_image(g.spd_atomic, VK_FORMAT_R32_UINT, 1, 1); made = made && make_image(g.lanczos_lut, VK_FORMAT_R16_SNORM, 128, 1); made = made && make_image(g.default_reactive, VK_FORMAT_R8_UNORM, 1, 1); made = made && make_image(g.output, VK_FORMAT_R16G16B16A16_SFLOAT, uw, uh); g.first_evaluation = true; // (new images: their first layout and cleared, the history from nothing) g.lut_uploaded = false; g.parity = 0; if (!made) { for (Image* t : all_images()) drop_image(*t); g.render_width = g.render_height = g.upscale_width = g.upscale_height = 0; return false; } g.render_width = rw, g.render_height = rh, g.upscale_width = uw, g.upscale_height = uh; logf("vk: fsr3: %ux%u -> %ux%u", rw, rh, uw, uh); return true; } } // namespace bool supported() { if (!dev.device) return false; // (asked before the device is made, by the menu: not an answer to keep) static const bool answer = [] { // (the widest pass pushes thirteen descriptors and the two samplers) if (!dev.push_descriptor || !vkCmdPushDescriptorSetKHR || dev.max_push_descriptors < 15) { logf("vk: fsr3: not on this GPU: no push descriptors, or fewer than 15 (%u)", dev.max_push_descriptors); return false; } if (!dev.features.shaderStorageImageExtendedFormats || !dev.features.shaderStorageImageWriteWithoutFormat) { logf("vk: fsr3: not on this GPU: no extended storage image formats, or no storage writes without a format"); return false; } if (!formats_supported()) return false; VkPhysicalDeviceSubgroupProperties sg{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES}; VkPhysicalDeviceProperties2 p2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2}; p2.pNext = &sg; vkGetPhysicalDeviceProperties2(dev.physical, &p2); const VkSubgroupFeatureFlags want = VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT; g.wave = (sg.supportedOperations & want) == want && (sg.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT); logf("vk: fsr3: AMD FSR 3.1 can run on this GPU"); return true; }(); return answer; } bool upscale(VkCommandBuffer cmd, const Inputs& in) { free_dead(); if (!in.color || !in.depth || !in.motion) return false; if (!prepare(in.render_width, in.render_height, in.upscale_width, in.upscale_height)) return false; const bool first = g.first_evaluation; const bool reset = in.reset || first; g.first_evaluation = false; const int32_t rw = (int32_t)g.render_width, rh = (int32_t)g.render_height; const int32_t uw = (int32_t)g.upscale_width, uh = (int32_t)g.upscale_height; Constants k{}; k.render_size[0] = rw, k.render_size[1] = rh; k.upscale_size[0] = uw, k.upscale_size[1] = uh; k.max_render_size[0] = rw, k.max_render_size[1] = rh; k.max_upscale_size[0] = uw, k.max_upscale_size[1] = uh; for (int i = 0; i < 2; i++) { k.previous_render_size[i] = first ? k.render_size[i] : g.previous_render_size[i]; k.previous_upscale_size[i] = first ? k.upscale_size[i] : g.previous_upscale_size[i]; k.jitter[i] = in.jitter[i]; k.previous_jitter[i] = first ? in.jitter[i] : g.previous_jitter[i]; } memcpy(k.device_to_view_depth, in.camera.device_to_view_depth, sizeof k.device_to_view_depth); k.tan_half_fov = in.camera.tan_half_fov_x; // (not read by the 3.1.4 upscaler's passes; set as the SDK sets it) k.motion_vector_scale[0] = in.motion_scale[0] / (float)std::max(1, rw); k.motion_vector_scale[1] = in.motion_scale[1] / (float)std::max(1, rh); k.downscale_factor[0] = (float)rw / (float)std::max(1, uw); k.downscale_factor[1] = (float)rh / (float)std::max(1, uh); k.jitter_phase_count = (float)std::max(1u, in.jitter_phases); k.delta_time = std::clamp(in.frame_time_ms / 1000.0f, 0.0f, 1.0f); k.delta_pre_exposure = 1.0f; k.view_space_to_meters = 1.0f; g.frame_index = reset ? 0.0f : g.frame_index + 1.0f; k.frame_index = g.frame_index; k.velocity_factor = 1.0f; // (the SDK's FFX_FSR3UPSCALER_CONFIGURE_UPSCALE_KEY_* defaults) k.reactiveness_scale = 1.0f; k.shading_change_scale = 1.0f; k.accumulation_added_per_frame = 1.0f / 3.0f; k.min_disocclusion_accumulation = -1.0f / 3.0f; for (int i = 0; i < 2; i++) { g.previous_render_size[i] = k.render_size[i]; g.previous_upscale_size[i] = k.upscale_size[i]; g.previous_jitter[i] = in.jitter[i]; } const uint32_t spd_x = (g.render_width - 1) / 64 + 1; const uint32_t spd_y = (g.render_height - 1) / 64 + 1; SpdConstants spd{}; spd.mips = (uint32_t)std::min(std::floor(std::log2((float)std::max(g.render_width, g.render_height))), 12.0f); spd.num_work_groups = spd_x * spd_y; spd.render_size[0] = g.render_width, spd.render_size[1] = g.render_height; // This frame's slots, written through the mapped buffer. const VkDeviceSize base = (VkDeviceSize)(g.uniform_frame % kUniformFrames) * g.frame_stride; g.uniform_frame++; uint8_t* const mapped = (uint8_t*)g.uniforms_mapped + base; memcpy(mapped, &k, sizeof k); memcpy(mapped + g.slot_fsr, &spd, sizeof spd); const VkDeviceSize lut_at = g.slot_fsr + g.slot_spd; if (!g.lut_uploaded) { // (the accumulate pass's Lanczos weights, 128 taps as the SDK builds them) int16_t weights[128]; for (size_t i = 0; i < 128; i++) { const float x = 2.0f * (float)i / 127.0f; const float pi_x = 3.14159265358979f * x; const float y = std::abs(x) < FLT_EPSILON ? 1.0f : (std::sin(pi_x) / pi_x) * (std::sin(0.5f * pi_x) / (0.5f * pi_x)); weights[i] = (int16_t)std::lround(y * 32767.0f); } memcpy(mapped + lut_at, weights, sizeof weights); } flush_mapped(g.uniforms_memory, g.frame_stride * kUniformFrames); const uint32_t p = g.parity, q = p ^ 1u; // What was written before (the inputs: vk_fsr3_inputs.cpp) has to be visible, and new images need their first layout. memory_barrier(cmd, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_2_SHADER_WRITE_BIT | VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT | VK_ACCESS_2_TRANSFER_WRITE_BIT); const std::vector all = all_images(); if (first) { std::vector to_general; to_general.reserve(all.size()); for (const Image* t : all) { VkImageMemoryBarrier2 b{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2}; b.srcStageMask = VK_PIPELINE_STAGE_2_NONE; b.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT; b.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT; b.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; b.newLayout = VK_IMAGE_LAYOUT_GENERAL; b.srcQueueFamilyIndex = b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; b.image = t->image; b.subresourceRange = ALL_LEVELS; to_general.push_back(b); } VkDependencyInfo di{VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; di.imageMemoryBarrierCount = (uint32_t)to_general.size(); di.pImageMemoryBarriers = to_general.data(); vkCmdPipelineBarrier2(cmd, &di); const VkClearColorValue zero{}; for (const Image* t : all) vkCmdClearColorImage(cmd, t->image, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &ALL_LEVELS); } if (!g.lut_uploaded) { g.lut_uploaded = true; VkBufferImageCopy copy{}; copy.bufferOffset = base + lut_at; copy.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; copy.imageExtent = {128, 1, 1}; vkCmdCopyBufferToImage(cmd, g.uniforms, g.lanczos_lut.image, VK_IMAGE_LAYOUT_GENERAL, 1, ©); } // Per frame: the nearest-depth scratch, the SPD counter and its mips; the history on a reset. const VkClearColorValue zero{}; for (const Image* t : {&g.previous_nearest_depth, &g.spd_atomic, &g.spd_mips}) vkCmdClearColorImage(cmd, t->image, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &ALL_LEVELS); if (reset) { vkCmdClearColorImage(cmd, g.accumulation[p].image, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &ALL_LEVELS); VkClearColorValue info{}; info.float32[0] = -1.0f, info.float32[1] = 1.0f; vkCmdClearColorImage(cmd, g.frame_info.image, VK_IMAGE_LAYOUT_GENERAL, &info, 1, &ALL_LEVELS); } memory_barrier(cmd, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT); const auto tex = [](const Image& t) { return Resource{t.view}; }; const auto mip = [](uint32_t level) { const size_t n = g.spd_mips.levels.size(); return Resource{g.spd_mips.levels[std::min(level, n ? n - 1 : 0)]}; }; const Resource color{in.color}, depth{in.depth}, motion{in.motion}; const Resource exposure = tex(g.frame_info); // (FSR computes its own exposure) const Resource current_luma = tex(g.luma[p]); const Resource cb_fsr{VK_NULL_HANDLE, g.uniforms, base, g.slot_fsr}; const Resource cb_spd{VK_NULL_HANDLE, g.uniforms, base + g.slot_fsr, g.slot_spd}; const auto groups = [](int32_t size, uint32_t tile) { return ((uint32_t)std::max(1, size) + tile - 1) / tile; }; const auto run = [&](size_t pass, std::initializer_list res, uint32_t gx, uint32_t gy) { record_pass(cmd, pass, res.begin(), res.size(), gx, gy); }; run(P_PREPARE_INPUTS, {motion, depth, color, tex(g.dilated_motion_vectors), tex(g.dilated_depth), tex(g.previous_nearest_depth), tex(g.farthest_depth), current_luma, cb_fsr}, groups(rw, 8), groups(rh, 8)); run(g.wave ? P_LUMA_PYRAMID : P_LUMA_PYRAMID_NOWAVE, {current_luma, tex(g.farthest_depth), tex(g.spd_atomic), tex(g.frame_info), mip(0), mip(1), mip(2), mip(3), mip(4), mip(5), tex(g.farthest_depth_mip1), cb_fsr, cb_spd}, spd_x, spd_y); // The two pyramid passes share one atomic counter, and the single-pass downsampler uses it to elect the workgroup that // finishes the chain: it counts up to num_work_groups and the last one through does the tail. Cleared only once a frame, // the second pass would start at the total, elect no workgroup, and the ones waiting on the tail would spin memory_barrier(cmd, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT); vkCmdClearColorImage(cmd, g.spd_atomic.image, VK_IMAGE_LAYOUT_GENERAL, &zero, 1, &ALL_LEVELS); memory_barrier(cmd, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT | VK_ACCESS_2_SHADER_WRITE_BIT); run(g.wave ? P_SHADING_CHANGE_PYRAMID : P_SHADING_CHANGE_PYRAMID_NOWAVE, {current_luma, tex(g.luma[q]), tex(g.dilated_motion_vectors), exposure, tex(g.spd_atomic), mip(0), mip(1), mip(2), mip(3), mip(4), mip(5), cb_fsr, cb_spd}, spd_x, spd_y); run(P_SHADING_CHANGE, {tex(g.spd_mips), tex(g.shading_change), cb_fsr}, groups(rw / 2, 8), groups(rh / 2, 8)); run(P_PREPARE_REACTIVITY, {tex(g.previous_nearest_depth), tex(g.dilated_motion_vectors), tex(g.dilated_depth), tex(g.default_reactive), tex(g.default_reactive), tex(g.accumulation[p]), tex(g.shading_change), current_luma, exposure, tex(g.dilated_reactive_masks), tex(g.new_locks), tex(g.accumulation[q]), cb_fsr}, groups(rw, 8), groups(rh, 8)); run(P_LUMA_INSTABILITY, {exposure, tex(g.dilated_reactive_masks), tex(g.dilated_motion_vectors), tex(g.frame_info), tex(g.luma_history[p]), tex(g.farthest_depth_mip1), current_luma, tex(g.luma_history[q]), tex(g.farthest_depth), cb_fsr}, groups(rw, 8), groups(rh, 8)); run(P_ACCUMULATE, {exposure, tex(g.dilated_reactive_masks), tex(g.dilated_motion_vectors), tex(g.internal_upscaled[p]), tex(g.lanczos_lut), tex(g.farthest_depth_mip1), current_luma, tex(g.farthest_depth), color, tex(g.internal_upscaled[q]), tex(g.output), tex(g.new_locks), cb_fsr}, groups(uw, 8), groups(uh, 8)); g.parity = q; return true; } VkImage output_image() { return g.output.image; } VkImageView output_view() { return g.output.view; } } // namespace mkwvk::fsr3 namespace mkwvk { namespace { int env_switch(const char* name) { // (-1: unset) const char* e = getenv(name); return e && *e ? atoi(e) : -1; } /// The network's output from FSR's picture: dlss_out.comp, the same pass DLSS's picture goes through (the colour FSR was /// given is the network's perceptual encoding, which this squares back to linear colour, as the network's own output does) struct Out { std::mutex mu; bool tried = false; VkDescriptorSetLayout set = VK_NULL_HANDLE; VkPipelineLayout layout = VK_NULL_HANDLE; VkPipeline pipe = VK_NULL_HANDLE; VkSampler point = VK_NULL_HANDLE; const char* reason = nullptr; int reason_repeats = 0; bool told_first = false; uint64_t drawn = 0; }; Out& out_state() { static Out o; return o; } bool make_out_pipeline() { Out& o = out_state(); if (o.pipe) return true; if (o.tried) return false; o.tried = true; const VkDescriptorSetLayoutBinding b[2] = { {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}, {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}}; VkDescriptorSetLayoutCreateInfo li{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; li.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; li.bindingCount = 2, li.pBindings = b; if (vkCreateDescriptorSetLayout(dev.device, &li, nullptr, &o.set) != VK_SUCCESS) return false; const VkPushConstantRange pr{VK_SHADER_STAGE_COMPUTE_BIT, 0, 8}; VkPipelineLayoutCreateInfo pi{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; pi.setLayoutCount = 1, pi.pSetLayouts = &o.set, pi.pushConstantRangeCount = 1, pi.pPushConstantRanges = ≺ if (vkCreatePipelineLayout(dev.device, &pi, nullptr, &o.layout) != VK_SUCCESS) return false; VkShaderModuleCreateInfo mi{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; mi.codeSize = sizeof DLSS_OUT_COMP_SPV, mi.pCode = DLSS_OUT_COMP_SPV; VkShaderModule m = VK_NULL_HANDLE; if (vkCreateShaderModule(dev.device, &mi, nullptr, &m) != VK_SUCCESS) return false; VkComputePipelineCreateInfo ci{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; ci.stage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, VK_SHADER_STAGE_COMPUTE_BIT, m, "main", nullptr}; ci.layout = o.layout; const VkResult r = vkCreateComputePipelines(dev.device, shared_pipeline_cache(), 1, &ci, nullptr, &o.pipe); // (kept across runs, above) vkDestroyShaderModule(dev.device, m, nullptr); if (r != VK_SUCCESS) return o.pipe = VK_NULL_HANDLE, false; VkSamplerCreateInfo si{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; si.magFilter = si.minFilter = VK_FILTER_NEAREST; si.addressModeU = si.addressModeV = si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; if (vkCreateSampler(dev.device, &si, nullptr, &o.point) != VK_SUCCESS) { vkDestroyPipeline(dev.device, o.pipe, nullptr); return o.pipe = VK_NULL_HANDLE, false; } return true; } bool fail(const char* why) { // (the network runs: why, when it changes and every 600th time) Out& o = out_state(); if (why != o.reason || ++o.reason_repeats % 600 == 0) logf("vk: fsr3: the game's upscale runs (%s)", why); if (why != o.reason) o.reason = why, o.reason_repeats = 0; return false; } } // namespace bool fsr3_wanted() { static const int env = env_switch("RX_VK_FSR"); if (env == 0) return false; // (the Upscaler row's FSR 3.1, upscaler_rows.h, read each time: the row changes it while the game runs. RX_VK_DLSS=1 / 2 // or RX_VK_FSR4=1 / 2 goes over the row, its FSR 3.1 too: vk_temporal.cpp's chain draws then) return (env > 0 || (opts.dlss == upscaler_rows::FSR3 && !temporal_env_chosen())) && fsr3::supported(); } bool fsr3_upscale(VkCommandBuffer cmd, uint64_t key, bool known, Texture* in, VkImageView in_view, Texture* out, VkImageView out_view, uint32_t out_level) { const bool upscaling = fsr3_wanted(); if (!upscaling && !fsr3_inputs::wanted()) return false; if (!in || !in_view || !out || !out_view) return false; // (another network of the upscale's shape, as temporal_upscale takes them: only the scene into the picture. The gameplay // networks sample the scene's B10G11R11 colour and write the B10G11R11 picture) if (!known && (in->format != VK_FORMAT_B10G11R11_UFLOAT_PACK32 || out->format != VK_FORMAT_B10G11R11_UFLOAT_PACK32 || (out->width >> out_level) <= in->width || !fsr3_inputs::is_scene(in))) return false; fsr3_inputs::Frame f; if (!fsr3_inputs::prepare(cmd, in, in_view, f)) return upscaling ? fail("its inputs could not be made") : false; if (!upscaling) return false; // (frame interpolation's inputs alone: the network or DLSS upscales) Out& o = out_state(); std::lock_guard lk(o.mu); const uint32_t ow = std::max(1u, out->width >> out_level), oh = std::max(1u, out->height >> out_level); if (out->format != VK_FORMAT_B10G11R11_UFLOAT_PACK32 || ow < f.width || oh < f.height) return fail("unexpected output"); if (!make_out_pipeline()) return fail("its output pass was not made"); struct Disturbed { // (from here commands are recorded: the program's descriptor pushes are pushed again after) ~Disturbed() { descriptors_disturbed(); } } disturbed; fsr3::Inputs ai; ai.color = f.color, ai.depth = f.depth, ai.motion = f.motion; ai.render_width = f.width, ai.render_height = f.height; ai.upscale_width = ow, ai.upscale_height = oh; ai.jitter[0] = f.jitter[0], ai.jitter[1] = f.jitter[1]; ai.jitter_phases = fsr3_inputs::jitter_size(2) ? fsr3_inputs::jitter_size(2) : 8; ai.camera = f.camera; ai.frame_time_ms = f.frame_ms; ai.reset = f.reset; if (!fsr3::upscale(cmd, ai)) return fail("its passes could not be recorded"); { const int32_t pc[2] = {(int32_t)ow, (int32_t)oh}; const VkDescriptorImageInfo info[2] = {{o.point, fsr3::output_view(), VK_IMAGE_LAYOUT_GENERAL}, {VK_NULL_HANDLE, out_view, VK_IMAGE_LAYOUT_GENERAL}}; VkWriteDescriptorSet w[2]{{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}, {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}}; w[0].dstBinding = 0, w[0].descriptorCount = 1, w[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; w[0].pImageInfo = &info[0]; w[1].dstBinding = 1, w[1].descriptorCount = 1, w[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; w[1].pImageInfo = &info[1]; vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, o.pipe); vkCmdPushDescriptorSetKHR(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, o.layout, 0, 2, w); vkCmdPushConstants(cmd, o.layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof pc, pc); vkCmdDispatch(cmd, (ow + 7) / 8, (oh + 7) / 8, 1); } full_barrier(cmd); fsr3_inputs::upscaled(f.width, f.height, ow, oh); // (every 600 frames: that it still draws, and the jitter it was given, which says the host's jitter is on) if (++o.drawn % 600 == 0) logf("vk: fsr3: %llu frames drawn, %ux%u -> %ux%u, this one's jitter %+.3f %+.3f px of %u phases", (unsigned long long)o.drawn, f.width, f.height, ow, oh, f.jitter[0], f.jitter[1], ai.jitter_phases); if (o.reason) logf("vk: fsr3: FSR 3.1 draws the upscale again (frame %llu)", (unsigned long long)f.frame); o.reason = nullptr; if (!o.told_first) { o.told_first = true; logf("vk: fsr3 %ux%u -> %ux%u with assembled depth and camera motion (network %016llx; jitter %+.3f %+.3f px, " "%u phases)", f.width, f.height, ow, oh, (unsigned long long)key, f.jitter[0], f.jitter[1], ai.jitter_phases); } return true; } } // namespace mkwvk