From 8daa367ef09a693d21b1aeb82abee64c43b1ff7e Mon Sep 17 00:00:00 2001 From: TJnotJT Date: Sun, 27 Sep 2026 14:33:25 -0400 Subject: [PATCH] GS:VK: Add DS as RT support. --- bin/resources/shaders/vulkan/tfx.glsl | 14 ++ pcsx2/GS/Renderers/HW/GSRendererHW.cpp | 13 +- pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp | 238 ++++++++++++++++------ pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h | 42 ++-- pcsx2/GS/Renderers/Vulkan/GSTextureVK.cpp | 7 +- pcsx2/GS/Renderers/Vulkan/GSTextureVK.h | 28 ++- pcsx2/GS/Renderers/Vulkan/VKBuilders.h | 6 +- pcsx2/ShaderCacheVersion.h | 2 +- 8 files changed, 245 insertions(+), 105 deletions(-) diff --git a/bin/resources/shaders/vulkan/tfx.glsl b/bin/resources/shaders/vulkan/tfx.glsl index cbd4c4c713..389537259c 100644 --- a/bin/resources/shaders/vulkan/tfx.glsl +++ b/bin/resources/shaders/vulkan/tfx.glsl @@ -650,6 +650,16 @@ layout(location = 0) in VSOutput vec4 o_col0; #endif +#if PS_FEEDBACK_LOOP_IS_NEEDED_DEPTH && PS_NO_COLOR1 && PS_DEPTH_FEEDBACK_SUPPORT == 2 + #if !PS_NO_COLOR || PS_DATE >= 5 + // Color target occupies location 1. + layout(location = 1) out float o_col1; + #else + // No color target. + layout(location = 0) out float o_col1; + #endif +#endif + #if PS_ROV_COLOR layout(set = 1, binding = 5, rgba8) uniform restrict coherent image2D RtImageRov; vec4 rov_rt_value; @@ -1976,6 +1986,10 @@ void main() // Writing back depth #if PS_RETURN_DEPTH gl_FragDepth = input_z; + #if PS_FEEDBACK_LOOP_IS_NEEDED_DEPTH && PS_NO_COLOR1 && PS_DEPTH_FEEDBACK_SUPPORT == 2 + // Output color clone for feedback. + o_col1 = input_z; + #endif #elif PS_RETURN_DEPTH_ROV if (!rov_discard_depth) imageStore(DepthImageRov, ivec2(gl_FragCoord.xy), vec4(input_z, 0, 0, 1.0f)); diff --git a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp index 1cd995ad18..6161dc8e51 100644 --- a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp +++ b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp @@ -6415,16 +6415,9 @@ void GSRendererHW::DetermineBarriers(GSTextureCache::Target* rt, GSTextureCache: if (m_conf.require_one_barrier || m_conf.require_full_barrier) pxAssert(!m_conf.blend.enable); - // If we use depth feedback directly, we must use barriers for the depth texture. - // If we use depth-as-color feedback, then FB fetch can be used for depth also. - const bool need_barriers_for_depth = m_conf.ps.IsFeedbackLoopDepth() && features.depth_feedback; - - if (!need_barriers_for_depth) - { - // Barriers aren't needed with fbfetch - m_conf.require_one_barrier = false; - m_conf.require_full_barrier = false; - } + // Barriers aren't needed with fbfetch + m_conf.require_one_barrier = false; + m_conf.require_full_barrier = false; } // Multi-pass algorithms shouldn't be needed with full barrier and backends may not handle this correctly pxAssert(!m_conf.require_full_barrier || !m_conf.ps.colclip_hw); diff --git a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp index fd4a7a1ecc..24652be7fa 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp +++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp @@ -520,6 +520,7 @@ bool GSDeviceVK::SelectDeviceFeatures() m_device_features.geometryShader = available_features.geometryShader; m_device_features.fragmentStoresAndAtomics = available_features.fragmentStoresAndAtomics; m_device_features.pipelineStatisticsQuery = available_features.pipelineStatisticsQuery; + m_device_features.independentBlend = available_features.independentBlend; return true; } @@ -1062,17 +1063,22 @@ bool GSDeviceVK::CreateGlobalDescriptorPool() return true; } -VkRenderPass GSDeviceVK::GetRenderPass(VkFormat color_format, VkFormat depth_format, - VkAttachmentLoadOp color_load_op, VkAttachmentStoreOp color_store_op, - VkAttachmentLoadOp depth_load_op, VkAttachmentStoreOp depth_store_op, +VkRenderPass GSDeviceVK::GetRenderPass( + VkFormat color_format, VkFormat depth_as_color_format, VkFormat depth_format, + VkAttachmentLoadOp color_load_op, VkAttachmentStoreOp color_store_op, + VkAttachmentLoadOp depth_as_color_load_op, VkAttachmentStoreOp depth_as_color_store_op, + VkAttachmentLoadOp depth_load_op, VkAttachmentStoreOp depth_store_op, VkAttachmentLoadOp stencil_load_op, VkAttachmentStoreOp stencil_store_op, bool color_feedback_loop, bool depth_feedback_loop) { RenderPassCacheKey key = {}; key.color_format = color_format; + key.depth_as_color_format = depth_as_color_format; key.depth_format = depth_format; key.color_load_op = color_load_op; key.color_store_op = color_store_op; + key.depth_as_color_load_op = depth_as_color_load_op; + key.depth_as_color_store_op = depth_as_color_store_op; key.depth_load_op = depth_load_op; key.depth_store_op = depth_store_op; key.stencil_load_op = stencil_load_op; @@ -1116,6 +1122,39 @@ VkRenderPass GSDeviceVK::GetRenderPassForRestarting(VkRenderPass pass) return pass; } +VkRenderPass GSDeviceVK::GetTFXRenderPass( + bool rt, bool ds_as_rt, bool ds, bool colclip, bool stencil, bool rt_feedback, bool depth_feedback, + VkAttachmentLoadOp rt_op, VkAttachmentLoadOp ds_as_rt_op, VkAttachmentLoadOp ds_op) +{ + if (!ds_as_rt) + { + return m_tfx_render_pass[rt][ds][colclip][stencil][rt_feedback][depth_feedback][rt_op][ds_op]; + } + else + { + VkFormat invalid_format = LookupNativeFormat(GSTexture::Format::Invalid); + VkFormat rt_format = rt ? (colclip ? LookupNativeFormat(GSTexture::Format::ColorClip) : + LookupNativeFormat(GSTexture::Format::Color)) : + invalid_format; + VkFormat ds_as_rt_format = ds_as_rt ? LookupNativeFormat(GSTexture::Format::DepthColor) : invalid_format; + VkFormat ds_format = ds ? LookupNativeFormat(GSTexture::Format::DepthStencil) : invalid_format; + + VkAttachmentLoadOp rt_load_op = rt ? rt_op : VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp rt_store_op = rt ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE; + VkAttachmentLoadOp ds_as_rt_load_op = ds_as_rt ? ds_as_rt_op : VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp ds_as_rt_store_op = ds_as_rt ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE; + VkAttachmentLoadOp ds_load_op = ds ? ds_op : VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp ds_store_op = ds ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE; + VkAttachmentLoadOp stencil_load_op = stencil ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE; + VkAttachmentStoreOp stencil_store_op = stencil ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE; + + return GetRenderPass(rt_format, ds_as_rt_format, ds_format, + rt_load_op, rt_store_op, ds_as_rt_load_op, ds_as_rt_store_op, + ds_load_op, ds_store_op, stencil_load_op, stencil_store_op, + rt_feedback, depth_feedback); + } +} + VkCommandBuffer GSDeviceVK::GetCurrentInitCommandBuffer() { FrameResources& res = m_frame_resources[m_current_frame]; @@ -1680,15 +1719,20 @@ VkRenderPass GSDeviceVK::CreateCachedRenderPass(RenderPassCacheKey key) const GSTextureVK::Layout color_layout = key.color_feedback_loop ? GSTextureVK::Layout::FeedbackLoop : GSTextureVK::Layout::ColorAttachment; + + const GSTextureVK::Layout depth_as_color_layout = + key.depth_feedback_loop ? GSTextureVK::Layout::FeedbackLoop : GSTextureVK::Layout::ColorAttachment; - const GSTextureVK::Layout depth_layout = - key.depth_feedback_loop ? - (m_features.depth_feedback ? GSTextureVK::Layout::FeedbackLoop : GSTextureVK::Layout::General) : - GSTextureVK::Layout::DepthStencilAttachment; + // We sample from real depth only if we're not using depth as color. + const bool using_depth_as_color = key.depth_as_color_format != VK_FORMAT_UNDEFINED; + const bool sampling_real_depth = key.depth_feedback_loop && !using_depth_as_color; + const GSTextureVK::Layout depth_layout = sampling_real_depth ? + (m_features.depth_feedback ? GSTextureVK::Layout::FeedbackLoop : GSTextureVK::Layout::General) : + GSTextureVK::Layout::DepthStencilAttachment; const VkDependencyFlags feedback_dependency = GetFeedbackBarrierDependencyFlags(true); - if (key.color_feedback_loop) + if (key.color_feedback_loop || (key.depth_feedback_loop && using_depth_as_color)) { rpb.SetColorFeedbackBarrier( s_color_feedback_src_stage, s_color_feedback_src_access, @@ -1698,7 +1742,7 @@ VkRenderPass GSDeviceVK::CreateCachedRenderPass(RenderPassCacheKey key) rpb.AddSubpassFlags(VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT); } - if (key.depth_feedback_loop) + if (sampling_real_depth) { rpb.SetDepthFeedbackBarrier( s_depth_feedback_src_stage, s_depth_feedback_src_access, @@ -1718,6 +1762,18 @@ VkRenderPass GSDeviceVK::CreateCachedRenderPass(RenderPassCacheKey key) !m_features.framebuffer_fetch); } + if (key.depth_as_color_format != VK_FORMAT_UNDEFINED) + { + rpb.AddColorAttachment( + GSTextureVK::GetVkImageLayout(depth_as_color_layout), + static_cast(key.depth_as_color_format), + static_cast(key.depth_as_color_load_op), + static_cast(key.depth_as_color_store_op), + key.depth_feedback_loop, + !UseFeedbackLoopLayout(), + !m_features.framebuffer_fetch); + } + if (key.depth_format != VK_FORMAT_UNDEFINED) { rpb.AddDepthStencilAttachment( @@ -1727,9 +1783,9 @@ VkRenderPass GSDeviceVK::CreateCachedRenderPass(RenderPassCacheKey key) static_cast(key.depth_store_op), static_cast(key.stencil_load_op), static_cast(key.stencil_store_op), - key.depth_feedback_loop, + sampling_real_depth, !UseFeedbackLoopLayout(), - !m_features.framebuffer_fetch); + sampling_real_depth); } VkRenderPass pass = rpb.Create(m_device); @@ -2533,7 +2589,8 @@ GSDevice::PresentResult GSDeviceVK::BeginPresent(bool frame_skip) GSVector4i render_area(0, 0, swap_chain_texture->GetWidth(), swap_chain_texture->GetHeight()); - if (!BeginPresentRenderPass(GetRenderPass(swap_chain_texture->GetVkFormat(), VK_FORMAT_UNDEFINED, + if (!BeginPresentRenderPass(GetRenderPass( + swap_chain_texture->GetVkFormat(), VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE), render_area, swap_chain_texture)) { return GSDevice::PresentResult::FrameSkipped; @@ -2833,9 +2890,16 @@ bool GSDeviceVK::CheckFeatures() m_features.line_expand = (m_device_features.wideLines && limits.lineWidthRange[0] <= f_upscale && limits.lineWidthRange[1] >= f_upscale); - m_features.depth_feedback = m_features.feedback_loops(); + m_features.depth_feedback = (GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::Auto || + GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::Depth) && + !m_features.framebuffer_fetch; m_features.aa1 = GSConfig.HWAA1 && m_features.vs_expand && m_features.feedback_loops(); + if (!m_features.depth_feedback && !m_device_features.independentBlend) + { + DevCon.Warning("VK: Device does not support independent blend; depth feedback with DS as RT won't function correctly."); + } + DevCon.WriteLn("Optional features:%s%s%s%s%s", m_features.primitive_id ? " primitive_id" : "", m_features.texture_barrier ? " texture_barrier" : "", m_features.framebuffer_fetch ? " framebuffer_fetch" : "", m_features.provoking_vertex_last ? " provoking_vertex_last" : "", m_features.vs_expand ? " vs_expand" : ""); @@ -3255,8 +3319,8 @@ void GSDeviceVK::BeginRenderPassForStretchRect( else { // integer formats, etc - const VkRenderPass rp = GetRenderPass(dTex->GetVkFormat(), VK_FORMAT_UNDEFINED, load_op, - VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE); + const VkRenderPass rp = GetRenderPass(dTex->GetVkFormat(), VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, + load_op, VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE); if (load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { BeginClearRenderPass(rp, dtex_rc, dTex->GetClearColor()); @@ -3705,7 +3769,7 @@ void GSDeviceVK::OMSetRenderTargets(FramebufferInfo fb, const GSVector4i& scisso } else { - std::array clear_values; + std::array clear_values; u32 num_clear_values = 0; u32 num_color_attachments = 0; for (GSTextureVK* tex : fb.Attachments()) @@ -3749,18 +3813,27 @@ void GSDeviceVK::OMSetRenderTargets(FramebufferInfo fb, const GSVector4i& scisso if (!InRenderPass()) { - std::array attachments = { fb.rt, fb.ds }; - std::array dirty_flags = { - DIRTY_FLAG_TFX_TEXTURE_0 << TFX_TEXTURE_RT, - DIRTY_FLAG_TFX_TEXTURE_0 << TFX_TEXTURE_DEPTH + std::array attachments = { + fb.rt, + fb.ds_as_rt, + fb.ds, + }; + std::array dirty_texture_flag = { + DIRTY_FLAG_TFX_TEXTURE_0 << TFX_TEXTURE_RT, // RT + DIRTY_FLAG_TFX_TEXTURE_0 << TFX_TEXTURE_DEPTH, // DS as RT + DIRTY_FLAG_TFX_TEXTURE_0 << TFX_TEXTURE_DEPTH, // DS + }; + std::array use_feedback = { + fb.IsRTFeedbackLoop(), // RT + fb.IsTestingAndSamplingDepth() && fb.ds_as_rt, // DS as RT + fb.IsTestingAndSamplingDepth() && !fb.ds_as_rt, // DS }; - std::array feedback_flags = { fb.IsRTFeedbackLoop(), fb.IsTestingAndSamplingDepth() }; - for (u32 i = 0; i < 2; i++) + for (u32 i = 0; i < 3; i++) { GSTextureVK* tex = attachments[i]; - const u32 dirty_flag = dirty_flags[i]; - const bool feedback = feedback_flags[i]; + const u32 dirty_flag = dirty_texture_flag[i]; + const bool feedback = use_feedback[i]; if (tex) { @@ -4067,9 +4140,12 @@ bool GSDeviceVK::CreateRenderPasses() { return GetRenderPass( rt, + VK_FORMAT_UNDEFINED, // For DS as RT (unused) depth, (rt != VK_FORMAT_UNDEFINED) ? load_rt : VK_ATTACHMENT_LOAD_OP_DONT_CARE, (rt != VK_FORMAT_UNDEFINED) ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, // For DS as RT (unused) + VK_ATTACHMENT_STORE_OP_DONT_CARE, // For DS as RT (unused) (depth != VK_FORMAT_UNDEFINED) ? load_depth : VK_ATTACHMENT_LOAD_OP_DONT_CARE, (depth != VK_FORMAT_UNDEFINED) ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE, (depth != VK_FORMAT_UNDEFINED) ? load_stencil : VK_ATTACHMENT_LOAD_OP_DONT_CARE, @@ -4138,8 +4214,10 @@ bool GSDeviceVK::CreateRenderPasses() GET(m_utility_depth_render_pass_discard, VK_FORMAT_UNDEFINED, depth_format, false, false, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE); - m_date_setup_render_pass = GetRenderPass(VK_FORMAT_UNDEFINED, depth_format, VK_ATTACHMENT_LOAD_OP_LOAD, - VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, + m_date_setup_render_pass = GetRenderPass(VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, depth_format, + VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, m_features.stencil_buffer ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_DONT_CARE, m_features.stencil_buffer ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE); if (m_date_setup_render_pass == VK_NULL_HANDLE) @@ -4191,6 +4269,7 @@ bool GSDeviceVK::CompileConvertPipelines() else if (shader.DepthOutput()) { rp = GetRenderPass( + LookupNativeFormat(GSTexture::Format::Invalid), LookupNativeFormat(GSTexture::Format::Invalid), LookupNativeFormat(GSTexture::Format::DepthStencil), VK_ATTACHMENT_LOAD_OP_DONT_CARE); @@ -4200,6 +4279,7 @@ bool GSDeviceVK::CompileConvertPipelines() rp = GetRenderPass( LookupNativeFormat(shader.OutputFormat()), LookupNativeFormat(GSTexture::Format::Invalid), + LookupNativeFormat(GSTexture::Format::Invalid), VK_ATTACHMENT_LOAD_OP_DONT_CARE); } @@ -4263,8 +4343,8 @@ bool GSDeviceVK::CompileConvertPipelines() { pxAssert(!arr[ds][fbl]); - gpb.SetRenderPass(GetTFXRenderPass(true, ds != 0, is_setup, false, fbl != 0, false, - VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE), + gpb.SetRenderPass(GetTFXRenderPass(true, false, ds != 0, is_setup, false, fbl != 0, false, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE,VK_ATTACHMENT_LOAD_OP_DONT_CARE), 0); arr[ds][fbl] = gpb.Create(m_device, g_vulkan_shader_cache->GetPipelineCache(true), false); if (!arr[ds][fbl]) @@ -4282,9 +4362,12 @@ bool GSDeviceVK::CompileConvertPipelines() { for (u32 clear = 0; clear < 2; clear++) { - m_primid_image_setup_render_passes[ds][clear] = GetRenderPass(LookupNativeFormat(GSTexture::Format::PrimID), - ds ? LookupNativeFormat(GSTexture::Format::DepthStencil) : VK_FORMAT_UNDEFINED, + m_primid_image_setup_render_passes[ds][clear] = GetRenderPass( + LookupNativeFormat(GSTexture::Format::PrimID), + LookupNativeFormat(GSTexture::Format::Invalid), + ds ? LookupNativeFormat(GSTexture::Format::DepthStencil) : LookupNativeFormat(GSTexture::Format::Invalid), VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, ds ? (clear ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD) : VK_ATTACHMENT_LOAD_OP_DONT_CARE, ds ? VK_ATTACHMENT_STORE_OP_STORE : VK_ATTACHMENT_STORE_OP_DONT_CARE); } @@ -4332,7 +4415,8 @@ bool GSDeviceVK::CompilePresentPipelines() { // we may not have a swap chain if running in headless mode. m_swap_chain_render_pass = - GetRenderPass(m_swap_chain ? m_swap_chain->GetTextureFormat() : VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED); + GetRenderPass(m_swap_chain ? m_swap_chain->GetTextureFormat() : VK_FORMAT_R8G8B8A8_UNORM, + VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED); if (m_swap_chain_render_pass == VK_NULL_HANDLE) return false; @@ -4394,7 +4478,8 @@ bool GSDeviceVK::CompileInterlacePipelines() } VkRenderPass rp = - GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); + GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), + VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); if (!rp) return false; @@ -4445,7 +4530,8 @@ bool GSDeviceVK::CompileMergePipelines() } VkRenderPass rp = - GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); + GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), + VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); if (!rp) return false; @@ -4490,7 +4576,8 @@ bool GSDeviceVK::CompileMergePipelines() bool GSDeviceVK::CompilePostProcessingPipelines() { VkRenderPass rp = - GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); + GetRenderPass(LookupNativeFormat(GSTexture::Format::Color), + VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD); if (!rp) return false; @@ -4593,7 +4680,8 @@ bool GSDeviceVK::CompileCASPipelines() gpb.SetVertexShader(vs); gpb.SetRenderPass( - GetRenderPass(VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_DONT_CARE), 0); + GetRenderPass(VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, + VK_ATTACHMENT_LOAD_OP_DONT_CARE), 0); std::optional cas_source = ReadShaderSource("shaders/vulkan/cas.glsl"); if (!cas_source.has_value() || !GetCASShaderSource(&cas_source.value())) @@ -4973,6 +5061,7 @@ VkShaderModule GSDeviceVK::GetTFXFragmentShader(const GSHWDrawConfig::PSSelector std::stringstream ss; AddShaderHeader(ss); AddShaderStageMacro(ss, false, false, true); + AddMacro(ss, "PS_DEPTH_FEEDBACK_SUPPORT", m_features.depth_feedback ? 1 : 2); AddMacro(ss, "PS_FST", sel.fst); AddMacro(ss, "PS_WMS", sel.wms); AddMacro(ss, "PS_WMT", sel.wmt); @@ -5080,9 +5169,10 @@ VkPipeline GSDeviceVK::CreateTFXPipeline(const PipelineSelector& p) else { gpb.SetRenderPass( - GetTFXRenderPass(p.rt, p.ds, p.ps.colclip_hw, p.dss.date, + GetTFXRenderPass(p.rt, p.ds_as_rt, p.ds, p.ps.colclip_hw, p.dss.date, p.IsRTFeedbackLoop(), p.IsTestingAndSamplingDepth(), p.rt ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE, + p.ds_as_rt ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE, p.ds ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), 0); } @@ -5156,7 +5246,7 @@ VkPipeline GSDeviceVK::CreateTFXPipeline(const PipelineSelector& p) VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, p.cms.wrgba); } - if (p.IsRTFeedbackLoop()) + if (m_features.framebuffer_fetch && (p.IsRTFeedbackLoop() || (p.ds_as_rt && p.IsDepthFeedbackLoop()))) { // Tests have shown that it's faster to just enable rast order on the entire pass, rather than alternating // between turning it on and off for different draws, and adding the required barrier between non-rast-order @@ -5169,6 +5259,10 @@ VkPipeline GSDeviceVK::CreateTFXPipeline(const PipelineSelector& p) if (p.IsTestingAndSamplingDepth() && UseFeedbackLoopLayout()) gpb.AddFlags(VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT); + + if (p.ds_as_rt) + gpb.SetBlendAttachment(p.rt ? 1 : 0, false, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, + VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, VK_COLOR_COMPONENT_R_BIT); VkPipeline pipeline = gpb.Create(m_device, g_vulkan_shader_cache->GetPipelineCache(true)); if (pipeline) @@ -5322,7 +5416,7 @@ void GSDeviceVK::ExecuteCommandBufferAndRestartPresent(bool wait_for_completion, pxAssert(fb); VkRenderPassBeginInfo rp = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO}; - rp.renderPass = GetRenderPass(swap_chain_texture->GetVkFormat(), VK_FORMAT_UNDEFINED, + rp.renderPass = GetRenderPass(swap_chain_texture->GetVkFormat(), VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE); rp.framebuffer = fb; rp.renderArea.extent.width = swap_chain_texture->GetWidth(); @@ -6125,6 +6219,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) const GSVector2i rtsize(config.rt ? config.rt->GetSize() : config.ds->GetSize()); FramebufferInfo fb; fb.rt = config.ps.HasColorROV() ? nullptr : static_cast(config.rt); + fb.ds_as_rt = config.ps.HasDepthROV() ? nullptr : static_cast(m_ds_as_rt); fb.ds = config.ps.HasDepthROV() ? nullptr : static_cast(config.ds); GSTextureVK* draw_rt_rov = config.ps.HasColorROV() ? static_cast(config.rt) : nullptr; GSTextureVK* draw_ds_rov = config.ps.HasDepthROV() ? static_cast(config.ds) : nullptr; @@ -6192,19 +6287,19 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) // if this target was cleared and never drawn to, perform the clear as part of the resolve here. if (fb.rt->GetState() == GSTexture::State::Cleared) { - alignas(16) std::array clear_values = fb.GetClearValues(); + alignas(16) std::array clear_values = fb.GetClearValues(); const u32 num_attachments = fb.NumAttachments(); - BeginClearRenderPass(GetTFXRenderPass(true, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), - pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_CLEAR, + BeginClearRenderPass(GetTFXRenderPass(true, false, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), + pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE, pipe.ds ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), fb.GetRect(), clear_values.data(), num_attachments); fb.rt->SetState(GSTexture::State::Dirty); } else { - BeginRenderPass(GetTFXRenderPass(true, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), - pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_LOAD, + BeginRenderPass(GetTFXRenderPass(true, false, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), + pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_DONT_CARE, pipe.ds ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), fb.GetRect()); } @@ -6315,14 +6410,14 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) { // avoid restarting the render pass just to switch from rt+depth to rt and vice versa // keep the depth even if doing colclip hw draws, because the next draw will probably re-enable depth. - if (!(fb.rt || draw_rt_rov) && m_current_framebuffer.rt && + if (!(fb.rt || draw_rt_rov) && !fb.ds_as_rt && m_current_framebuffer.rt && config.tex != m_current_framebuffer.rt && fb.ds && m_current_framebuffer.rt->GetSize() == fb.ds->GetSize()) { fb.rt = m_current_framebuffer.rt; m_pipeline_selector.rt = true; } - else if (!(fb.ds || draw_ds_rov) && m_current_framebuffer.ds && + else if (!(fb.ds || draw_ds_rov) && !fb.ds_as_rt && m_current_framebuffer.ds && config.tex != m_current_framebuffer.ds && fb.rt && m_current_framebuffer.ds->GetSize() == fb.rt->GetSize()) { @@ -6403,12 +6498,15 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) PSSetShaderResource(TFX_TEXTURE_RT, nullptr, false); } - if (pipe.IsDepthFeedbackLoop() && fb.ds) + GSTextureVK* depth_for_barrier = pipe.IsDepthFeedbackLoop() ? + (m_features.depth_feedback ? fb.ds : fb.ds_as_rt) : nullptr; + + if (depth_for_barrier) { pxAssertMsg(m_features.texture_barrier, "Texture barriers enabled"); - PSSetShaderResource(TFX_TEXTURE_DEPTH, fb.ds, false); + PSSetShaderResource(TFX_TEXTURE_DEPTH, depth_for_barrier, false); - if (m_tfx_textures[TFX_TEXTURE_DEPTH_ROV] == fb.ds) + if (m_tfx_textures[TFX_TEXTURE_DEPTH_ROV] == depth_for_barrier) { // Unbind to avoid conflicts. PSSetShaderResource(TFX_TEXTURE_DEPTH_ROV, nullptr, false); @@ -6430,11 +6528,14 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (!InRenderPass()) { const VkAttachmentLoadOp rt_op = GetLoadOpForTexture(fb.rt); + const VkAttachmentLoadOp ds_as_rt_op = GetLoadOpForTexture(fb.ds_as_rt); const VkAttachmentLoadOp ds_op = GetLoadOpForTexture(fb.ds); - const VkRenderPass rp = GetTFXRenderPass(pipe.rt, pipe.ds, pipe.ps.colclip_hw, + const VkRenderPass rp = GetTFXRenderPass(pipe.rt, pipe.ds_as_rt, pipe.ds, pipe.ps.colclip_hw, config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::Stencil, pipe.IsRTFeedbackLoop(), - pipe.IsTestingAndSamplingDepth(), rt_op, ds_op); - const bool is_clearing_rt = (rt_op == VK_ATTACHMENT_LOAD_OP_CLEAR || ds_op == VK_ATTACHMENT_LOAD_OP_CLEAR); + pipe.IsTestingAndSamplingDepth(), rt_op, ds_as_rt_op, ds_op); + const bool is_clearing_rt = rt_op == VK_ATTACHMENT_LOAD_OP_CLEAR || + ds_as_rt_op == VK_ATTACHMENT_LOAD_OP_CLEAR || + ds_op == VK_ATTACHMENT_LOAD_OP_CLEAR; // Only draw to the active area of the colclip hw target. Except when depth is cleared, we need to use the full // buffer size, otherwise it'll only clear the draw part of the depth buffer. @@ -6445,7 +6546,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (is_clearing_rt) { // when we're clearing, we set the draw area to the whole fb, otherwise part of it will be undefined - alignas(16) std::array clear_values = fb.GetClearValues(); + alignas(16) std::array clear_values = fb.GetClearValues(); const u32 num_attachments = fb.NumAttachments(); BeginClearRenderPass(rp, render_area, clear_values.data(), num_attachments); @@ -6491,7 +6592,8 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) // now we can do the actual draw if (BindDrawPipeline(pipe)) SendHWDraw(config, pipe.IsRTFeedbackLoop() ? fb.rt : nullptr, - pipe.IsDepthFeedbackLoop() ? fb.ds : nullptr, config.require_one_barrier, config.require_full_barrier); + pipe.IsDepthFeedbackLoop() ? depth_for_barrier : nullptr, + config.require_one_barrier, config.require_full_barrier); // blend second pass if (config.blend_multi_pass.enable) @@ -6527,8 +6629,8 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (BindDrawPipeline(pipe)) { SendHWDraw(config, pipe.IsRTFeedbackLoop() ? fb.rt : nullptr, - pipe.IsDepthFeedbackLoop() ? fb.ds : nullptr, config.alpha_second_pass.require_one_barrier, - config.alpha_second_pass.require_full_barrier); + pipe.IsDepthFeedbackLoop() ? depth_for_barrier : nullptr, + config.alpha_second_pass.require_one_barrier, config.alpha_second_pass.require_full_barrier); } } @@ -6559,19 +6661,19 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) // if this target was cleared and never drawn to, perform the clear as part of the resolve here. if (fb.rt->GetState() == GSTexture::State::Cleared) { - alignas(16) std::array clear_values = fb.GetClearValues(); + alignas(16) std::array clear_values = fb.GetClearValues(); const u32 num_attachments = fb.NumAttachments(); - BeginClearRenderPass(GetTFXRenderPass(true, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), - pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_CLEAR, + BeginClearRenderPass(GetTFXRenderPass(true, false, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), + pipe.IsTestingAndSamplingDepth(), VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE, pipe.ds ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), fb.rt->GetRect(), clear_values.data(), num_attachments); fb.rt->SetState(GSTexture::State::Dirty); } else { - BeginRenderPass(GetTFXRenderPass(true, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), - pipe.IsDepthFeedbackLoop(), VK_ATTACHMENT_LOAD_OP_LOAD, + BeginRenderPass(GetTFXRenderPass(true, false, pipe.ds, false, false, pipe.IsRTFeedbackLoop(), + pipe.IsDepthFeedbackLoop(), VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_DONT_CARE, pipe.ds ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), fb.rt->GetRect()); } @@ -6601,6 +6703,7 @@ void GSDeviceVK::UpdateHWPipelineSelector(GSHWDrawConfig& config, PipelineSelect pipe.cms.key = config.ps.HasColorROV() ? GSHWDrawConfig::ColorMaskSelector().key : config.colormask.key; pipe.topology = static_cast(config.topology); pipe.rt = config.rt != nullptr && !config.ps.HasColorROV(); + pipe.ds_as_rt = m_ds_as_rt != nullptr; pipe.ds = config.ds != nullptr && !config.ps.HasDepthROV(); FeedbackLoopFlags flags = FeedbackLoopFlags::None; if (m_features.texture_barrier) @@ -6690,10 +6793,19 @@ void GSDeviceVK::FeedbackBarrier(GSTextureVK* rt, GSTextureVK* ds, bool by_regio if (ds) { VkImageMemoryBarrier2& barrier = barriers[num_barriers++] = barrier_template; - barrier.srcStageMask = s_depth_feedback_src_stage; - barrier.srcAccessMask = s_depth_feedback_src_access; barrier.image = ds->GetImage(); - barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + if (ds->IsDepthStencil()) + { + barrier.srcStageMask = s_depth_feedback_src_stage; + barrier.srcAccessMask = s_depth_feedback_src_access; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + } + else + { + barrier.srcStageMask = s_color_feedback_src_stage; + barrier.srcAccessMask = s_color_feedback_src_access; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + } } VkDependencyInfo dependency = {VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; diff --git a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h index 4b144a7440..14919860d5 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h +++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h @@ -83,9 +83,12 @@ public: __fi bool IsDeviceAMD() const { return (m_device_properties.vendorID == 0x1002); } // Creates a simple render pass. - VkRenderPass GetRenderPass(VkFormat color_format, VkFormat depth_format, + VkRenderPass GetRenderPass( + VkFormat color_format, VkFormat depth_as_color_format, VkFormat depth_format, VkAttachmentLoadOp color_load_op = VK_ATTACHMENT_LOAD_OP_LOAD, VkAttachmentStoreOp color_store_op = VK_ATTACHMENT_STORE_OP_STORE, + VkAttachmentLoadOp depth_as_color_load_op = VK_ATTACHMENT_LOAD_OP_LOAD, + VkAttachmentStoreOp depth_as_color_store_op = VK_ATTACHMENT_STORE_OP_STORE, VkAttachmentLoadOp depth_load_op = VK_ATTACHMENT_LOAD_OP_LOAD, VkAttachmentStoreOp depth_store_op = VK_ATTACHMENT_STORE_OP_STORE, VkAttachmentLoadOp stencil_load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE, @@ -167,19 +170,22 @@ private: { struct { - u32 color_format : 8; - u32 depth_format : 8; - u32 color_load_op : 2; - u32 color_store_op : 1; - u32 depth_load_op : 2; - u32 depth_store_op : 1; - u32 stencil_load_op : 2; - u32 stencil_store_op : 1; - u32 color_feedback_loop : 1; - u32 depth_feedback_loop : 1; + u64 color_format : 8; + u64 depth_as_color_format : 8; + u64 depth_format : 8; + u64 color_load_op : 2; + u64 color_store_op : 1; + u64 depth_as_color_load_op : 2; + u64 depth_as_color_store_op : 1; + u64 depth_load_op : 2; + u64 depth_store_op : 1; + u64 stencil_load_op : 2; + u64 stencil_store_op : 1; + u64 color_feedback_loop : 1; + u64 depth_feedback_loop : 1; }; - u32 key; + u64 key; }; using ExtensionList = std::vector; @@ -297,7 +303,7 @@ private: bool m_last_submit_failed = false; - std::map m_render_pass_cache; + std::map m_render_pass_cache; VkDebugUtilsMessengerEXT m_debug_messenger_callback = VK_NULL_HANDLE; @@ -341,6 +347,7 @@ public: { u32 topology : 2; u32 rt : 1; + u32 ds_as_rt : 1; u32 ds : 1; FeedbackLoopFlags feedback_loop_flags : 3; }; @@ -540,11 +547,10 @@ public: /// Returns true if Vulkan is suitable as a default for the devices in the system. static bool IsSuitableDefaultRenderer(); - __fi VkRenderPass GetTFXRenderPass(bool rt, bool ds, bool colclip, bool stencil, - bool rt_feedback, bool depth_feedback, VkAttachmentLoadOp rt_op, VkAttachmentLoadOp ds_op) const - { - return m_tfx_render_pass[rt][ds][colclip][stencil][rt_feedback][depth_feedback][rt_op][ds_op]; - } + __fi VkRenderPass GetTFXRenderPass( + bool rt, bool ds_as_rt, bool ds, bool colclip, bool stencil, bool rt_feedback, bool depth_feedback, + VkAttachmentLoadOp rt_op, VkAttachmentLoadOp ds_as_rt_op, VkAttachmentLoadOp ds_op); + __fi VkSampler GetPointSampler() const { return m_point_sampler; } __fi VkSampler GetLinearSampler() const { return m_linear_sampler; } diff --git a/pcsx2/GS/Renderers/Vulkan/GSTextureVK.cpp b/pcsx2/GS/Renderers/Vulkan/GSTextureVK.cpp index 0cfbabf0c8..bdf5356e90 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSTextureVK.cpp +++ b/pcsx2/GS/Renderers/Vulkan/GSTextureVK.cpp @@ -14,7 +14,10 @@ VkFramebuffer GSTextureVK::CreateNullFramebuffer(u32 w, u32 h) { const VkRenderPass rp = GSDeviceVK::GetInstance()->GetRenderPass( - VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, + VK_FORMAT_UNDEFINED, + VK_FORMAT_UNDEFINED, + VK_FORMAT_UNDEFINED, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, @@ -793,9 +796,11 @@ void GSTextureVK::GetLinkedFramebuffer(FramebufferInfo& fb) const VkRenderPass rp = GSDeviceVK::GetInstance()->GetRenderPass( fb.rt ? fb.rt->GetVkFormat() : VK_FORMAT_UNDEFINED, + fb.ds_as_rt ? fb.ds_as_rt->GetVkFormat() : VK_FORMAT_UNDEFINED, fb.ds ? fb.ds->GetVkFormat() : VK_FORMAT_UNDEFINED, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, fb.IsRTFeedbackLoop(), fb.IsTestingAndSamplingDepth()); diff --git a/pcsx2/GS/Renderers/Vulkan/GSTextureVK.h b/pcsx2/GS/Renderers/Vulkan/GSTextureVK.h index 36f333f4b3..458b69ed1e 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSTextureVK.h +++ b/pcsx2/GS/Renderers/Vulkan/GSTextureVK.h @@ -63,20 +63,27 @@ public: struct FramebufferInfo { GSTextureVK* rt; + GSTextureVK* ds_as_rt; GSTextureVK* ds; FeedbackLoopFlagsVK feedback_loop_flags; VkFramebuffer framebuffer; - FramebufferInfo(GSTexture* rt, GSTexture* ds, + FramebufferInfo(GSTexture* rt, GSTexture* ds_as_rt, GSTexture* ds, bool rt_feedback = false, bool depth_feedback = false) : rt(static_cast(rt)) + , ds_as_rt(static_cast(ds_as_rt)) , ds(static_cast(ds)) , feedback_loop_flags(FeedbackLoopFlagsVK::None) , framebuffer(VK_NULL_HANDLE) { } - FramebufferInfo() : FramebufferInfo(nullptr, nullptr, false, false) + FramebufferInfo(GSTexture* rt, GSTexture* ds, bool rt_feedback = false, bool depth_feedback = false) + : FramebufferInfo(rt, nullptr, ds, rt_feedback, depth_feedback) + { + } + + FramebufferInfo() : FramebufferInfo(nullptr, nullptr, nullptr, false, false) { } @@ -87,31 +94,34 @@ public: bool Matches(const FramebufferInfo& other) const { return rt == other.rt && + ds_as_rt == other.ds_as_rt && ds == other.ds && feedback_loop_flags == other.feedback_loop_flags; } u32 NumAttachments() const { - return (rt ? 1 : 0) + (ds ? 1 : 0); + return (rt ? 1 : 0) + (ds_as_rt ? 1 : 0) + (ds ? 1 : 0); } GSTextureVK* FirstAttachment() const { - return rt ? rt : ds; + return rt ? rt : (ds_as_rt ? ds_as_rt : ds); } - std::array Attachments() const + std::array Attachments() const { - return std::array{ rt, ds }; + return std::array{ rt, ds_as_rt, ds }; } - std::array GetClearValues() const + std::array GetClearValues() const { - alignas(16) std::array clear_values; + alignas(16) std::array clear_values; u32 count = 0; if (rt) GSVector4::store(&clear_values[count++].color, rt->GetClearForFormat()); + if (ds_as_rt) + GSVector4::store(&clear_values[count++].color, ds_as_rt->GetClearForFormat()); if (ds) { clear_values[count].depthStencil.depth = ds->GetClearDepth(); @@ -133,7 +143,7 @@ public: GSVector2i GetSize() const { - return (rt ? rt->GetSize() : (ds ? ds->GetSize() : GSVector2i(0, 0))); + return (rt ? rt->GetSize() : (ds_as_rt ? ds_as_rt->GetSize() : (ds ? ds->GetSize() : GSVector2i(0, 0)))); } GSVector4i GetRect() const diff --git a/pcsx2/GS/Renderers/Vulkan/VKBuilders.h b/pcsx2/GS/Renderers/Vulkan/VKBuilders.h index 22e7be133c..dc37aa0330 100644 --- a/pcsx2/GS/Renderers/Vulkan/VKBuilders.h +++ b/pcsx2/GS/Renderers/Vulkan/VKBuilders.h @@ -29,7 +29,7 @@ namespace Vulkan class RenderPassBuilder { public: - static constexpr u32 MAX_COLOR_ATTACHMENTS = 1; + static constexpr u32 MAX_COLOR_ATTACHMENTS = 2; static constexpr u32 MAX_ATTACHMENTS = MAX_COLOR_ATTACHMENTS + 1; void AddColorAttachment(VkImageLayout layout, VkFormat format, @@ -144,7 +144,7 @@ namespace Vulkan MAX_SHADER_STAGES = 3, MAX_VERTEX_ATTRIBUTES = 16, MAX_VERTEX_BUFFERS = 8, - MAX_ATTACHMENTS = 2, + MAX_ATTACHMENTS = 3, MAX_DYNAMIC_STATE = 8 }; @@ -337,7 +337,7 @@ namespace Vulkan { enum : u32 { - MAX_ATTACHMENTS = 2, + MAX_ATTACHMENTS = 3, }; public: diff --git a/pcsx2/ShaderCacheVersion.h b/pcsx2/ShaderCacheVersion.h index 014fb8c63a..c76614ccb8 100644 --- a/pcsx2/ShaderCacheVersion.h +++ b/pcsx2/ShaderCacheVersion.h @@ -3,4 +3,4 @@ /// Version number for GS and other shaders. Increment whenever any of the contents of the /// shaders change, to invalidate the cache. -static constexpr u32 SHADER_CACHE_VERSION = 122; // Last changed in PR: #15108 +static constexpr u32 SHADER_CACHE_VERSION = 123; // Last changed in PR: #15012