Triforce v0.2.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ruckus7382sfgsgdf
2026-11-10 19:32:48 -06:00
commit 34b3683441
1730 changed files with 554853 additions and 0 deletions

826
gpu/vk/vk_fsr3.cpp Normal file
View File

@@ -0,0 +1,826 @@
// (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 <algorithm>
#include <atomic>
#include <cfloat>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
#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<VkImageView> 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<std::pair<uint64_t, Image>> 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<VkDescriptorSetLayoutBinding> 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<VkDeviceSize>(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<VkDescriptorImageInfo> images(count);
std::vector<VkDescriptorBufferInfo> buffers(count);
std::vector<VkWriteDescriptorSet> 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<uint32_t, const VkDescriptorImageInfo*>{1000, &point},
std::pair<uint32_t, const VkDescriptorImageInfo*>{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<Image*> all_images() {
std::vector<Image*> 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<Image*> all = all_images();
if (first) {
std::vector<VkImageMemoryBarrier2> 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, &copy);
}
// 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<size_t>(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<Resource> 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 = &pr;
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