From c688db8f0827e5e6361c62bec727b852a033529e Mon Sep 17 00:00:00 2001 From: lightningterror <18107717+lightningterror@users.noreply.github.com> Date: Sat, 13 Jul 2024 18:36:19 +0200 Subject: [PATCH] GS/HW: Rename blend second pass to blend multi pass. Easier if I want to add more passes. --- pcsx2/GS/Renderers/Common/GSDevice.h | 6 +- pcsx2/GS/Renderers/DX11/GSDevice11.cpp | 8 +-- pcsx2/GS/Renderers/DX12/GSDevice12.cpp | 12 ++-- pcsx2/GS/Renderers/HW/GSRendererHW.cpp | 84 +++++++++++------------ pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp | 14 ++-- pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp | 12 ++-- 6 files changed, 68 insertions(+), 68 deletions(-) diff --git a/pcsx2/GS/Renderers/Common/GSDevice.h b/pcsx2/GS/Renderers/Common/GSDevice.h index fd7c3af3c1..3d63487488 100644 --- a/pcsx2/GS/Renderers/Common/GSDevice.h +++ b/pcsx2/GS/Renderers/Common/GSDevice.h @@ -715,16 +715,16 @@ struct alignas(16) GSHWDrawConfig AlphaPass alpha_second_pass; - struct BlendPass + struct BlendMultiPass { BlendState blend; u8 blend_hw; u8 dither; bool enable; }; - static_assert(sizeof(BlendPass) == 8, "blend pass is 8 bytes"); + static_assert(sizeof(BlendMultiPass) == 8, "blend multi pass is 8 bytes"); - BlendPass blend_second_pass; + BlendMultiPass blend_multi_pass; VSConstantBuffer cb_vs; PSConstantBuffer cb_ps; diff --git a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp index 0526655d07..5d2dc6be38 100644 --- a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp +++ b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp @@ -2653,12 +2653,12 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) OMSetRenderTargets(hdr_rt ? hdr_rt : config.rt, config.ds, &config.scissor); DrawIndexedPrimitive(); - if (config.blend_second_pass.enable) + if (config.blend_multi_pass.enable) { - config.ps.blend_hw = config.blend_second_pass.blend_hw; - config.ps.dither = config.blend_second_pass.dither; + config.ps.blend_hw = config.blend_multi_pass.blend_hw; + config.ps.dither = config.blend_multi_pass.dither; SetupPS(config.ps, &config.cb_ps, config.sampler); - SetupOM(config.depth, OMBlendSelector(config.colormask, config.blend_second_pass.blend), config.blend_second_pass.blend.constant); + SetupOM(config.depth, OMBlendSelector(config.colormask, config.blend_multi_pass.blend), config.blend_multi_pass.blend.constant); DrawIndexedPrimitive(); } diff --git a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp index 7f73171ccf..e576bf6af6 100644 --- a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp +++ b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp @@ -3980,14 +3980,14 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) DrawIndexedPrimitive(); // blend second pass - if (config.blend_second_pass.enable) + if (config.blend_multi_pass.enable) { - if (config.blend_second_pass.blend.constant_enable) - SetBlendConstants(config.blend_second_pass.blend.constant); + if (config.blend_multi_pass.blend.constant_enable) + SetBlendConstants(config.blend_multi_pass.blend.constant); - pipe.bs = config.blend_second_pass.blend; - pipe.ps.blend_hw = config.blend_second_pass.blend_hw; - pipe.ps.dither = config.blend_second_pass.dither; + pipe.bs = config.blend_multi_pass.blend; + pipe.ps.blend_hw = config.blend_multi_pass.blend_hw; + pipe.ps.dither = config.blend_multi_pass.dither; if (BindDrawPipeline(pipe)) DrawIndexedPrimitive(); } diff --git a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp index 75e73f38ce..daa7d4ed15 100644 --- a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp +++ b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp @@ -4258,8 +4258,8 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // HW blend can be done in multiple passes when there's no overlap. // Blend second pass is only useful when texture barriers aren't supported. // Speed wise Texture barriers > blend second pass > texture copies. - const bool blend_second_pass_support = !features.texture_barrier && no_prim_overlap && is_basic_blend; - const bool bmix1_second_pass = blend_second_pass_support && blend_mix1 && (alpha_c0_high_max_one || alpha_c2_high_one) && m_conf.ps.blend_d == 2; + const bool blend_multi_pass_support = !features.texture_barrier && no_prim_overlap && is_basic_blend; + const bool bmix1_second_pass = blend_multi_pass_support && blend_mix1 && (alpha_c0_high_max_one || alpha_c2_high_one) && m_conf.ps.blend_d == 2; // We don't want to enable blend mix if we are doing a second pass, it's useless. blend_mix &= !bmix1_second_pass; @@ -4323,7 +4323,7 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo } else { - const bool ad_second_pass = blend_second_pass_support && alpha_c1_high_no_rta_correct && COLCLAMP.CLAMP && + const bool ad_second_pass = blend_multi_pass_support && alpha_c1_high_no_rta_correct && COLCLAMP.CLAMP && (blend_flag & (BLEND_HW3 | BLEND_HW5 | BLEND_HW6 | BLEND_HW7 | BLEND_HW9)); switch (GSConfig.AccurateBlendingUnit) @@ -4619,9 +4619,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo m_conf.ps.rta_correction = rt->m_rt_alpha_scale; } - if (blend_second_pass_support) + if (blend_multi_pass_support) { - const HWBlend blend_second_pass = GSDevice::GetBlend(blend_index); + const HWBlend blend_multi_pass = GSDevice::GetBlend(blend_index); if (bmix1_second_pass) { // Alpha = As or Af. @@ -4630,9 +4630,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo blend.src = GSDevice::CONST_ONE; blend.dst = GSDevice::CONST_ONE; // Render pass 2: Blend the result (Cd) from render pass 1 with alpha range of 0-2. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR); - m_conf.blend_second_pass.blend = {true, GSDevice::DST_COLOR, (m_conf.ps.blend_c == 2) ? GSDevice::CONST_COLOR : GSDevice::SRC1_COLOR, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, m_conf.ps.blend_c == 2, AFIX}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR); + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_COLOR, (m_conf.ps.blend_c == 2) ? GSDevice::CONST_COLOR : GSDevice::SRC1_COLOR, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, m_conf.ps.blend_c == 2, AFIX}; } else if ((alpha_c0_high_max_one || alpha_c1_high_no_rta_correct || alpha_c2_high_one) && (blend_flag & BLEND_HW1)) { @@ -4642,9 +4642,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo m_conf.ps.blend_hw = static_cast(HWBlendType::SRC_HALF_ONE_DST_FACTOR); blend.dst = (m_conf.ps.blend_c == 1) ? GSDevice::DST_ALPHA : GSDevice::SRC1_COLOR; // Render pass 2: Take result (Cd) from render pass 1 and double it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); - m_conf.blend_second_pass.blend = {true, blend_second_pass.src, GSDevice::CONST_ONE, blend_second_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); + m_conf.blend_multi_pass.blend = {true, blend_multi_pass.src, GSDevice::CONST_ONE, blend_multi_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW3)) { @@ -4652,8 +4652,8 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Cs*Alpha, Cs*Alpha + Cd, Cd - Cs*Alpha. // Render pass 1: Do Cs*Alpha, Cs*Alpha + Cd or Cd - Cs*Alpha on first pass. // Render pass 2: Take result (Cd) from render pass 1 and either add or rev subtract Cs*Alpha based on the blend operation. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend = {true, blend_second_pass.src, GSDevice::CONST_ONE, blend_second_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend = {true, blend_multi_pass.src, GSDevice::CONST_ONE, blend_multi_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if ((alpha_c0_high_max_one || alpha_c2_high_one) && (blend_flag & BLEND_HW4)) { @@ -4667,9 +4667,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo blend.dst = (m_conf.ps.blend_c == 2) ? GSDevice::CONST_COLOR : GSDevice::SRC1_COLOR; blend.op = GSDevice::OP_ADD; // Render pass 2: Add or subtract result of render pass 1(Cd) from Cs. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.dither = dither * GSConfig.Dithering; - m_conf.blend_second_pass.blend = {true, blend_second_pass.src, GSDevice::CONST_ONE, blend_second_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.dither = dither * GSConfig.Dithering; + m_conf.blend_multi_pass.blend = {true, blend_multi_pass.src, GSDevice::CONST_ONE, blend_multi_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW5)) { @@ -4677,9 +4677,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Cd*Alpha - Cs*Alpha, Cs*Alpha - Cd*Alpha. // Render pass 1: Do (Cd - Cs)*Alpha, (Cs - Cd)*Alpha or Cd*Alpha on first pass. // Render pass 2: Take result (Cd) from render pass 1 and double it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); - m_conf.blend_second_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW6)) { @@ -4690,9 +4690,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo AFIX = 64; blend.src = GSDevice::CONST_COLOR; // Render pass 2: Take result (Cd) from render pass 1 and double it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); - m_conf.blend_second_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW7)) { @@ -4704,9 +4704,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo blend.dst = GSDevice::DST_ALPHA; blend.op = GSDevice::OP_SUBTRACT; // Render pass 2: Take result (Cd) from render pass 1 and double it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); - m_conf.blend_second_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_COLOR, GSDevice::CONST_ONE, GSDevice::OP_ADD, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (blend_flag & BLEND_HW8) { @@ -4714,9 +4714,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Cs*(1 + Alpha). // Render pass 1: Do Cs. // Render pass 2: Try to double Cs, then take result (Cd) from render pass 1 and add Cs*Alpha to it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend_hw = static_cast(HWBlendType::SRC_DOUBLE); - m_conf.blend_second_pass.blend = {true, GSDevice::DST_ALPHA, GSDevice::CONST_ONE, blend_second_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend_hw = static_cast(HWBlendType::SRC_DOUBLE); + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_ALPHA, GSDevice::CONST_ONE, blend_multi_pass.op, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } else if (alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW9)) { @@ -4724,12 +4724,12 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Cs*(1 - Alpha). // Render pass 1: Do Cs*(1 - Alpha). // Render pass 2: Take result (Cd) from render pass 1 and subtract Cs*Alpha from it. - m_conf.blend_second_pass.enable = true; - m_conf.blend_second_pass.blend = {true, GSDevice::DST_ALPHA, GSDevice::CONST_ONE, GSDevice::OP_REV_SUBTRACT, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; + m_conf.blend_multi_pass.enable = true; + m_conf.blend_multi_pass.blend = {true, GSDevice::DST_ALPHA, GSDevice::CONST_ONE, GSDevice::OP_REV_SUBTRACT, GSDevice::CONST_ONE, GSDevice::CONST_ZERO, false, 0}; } } - if (!m_conf.blend_second_pass.enable && blend_flag & BLEND_HW1) + if (!m_conf.blend_multi_pass.enable && blend_flag & BLEND_HW1) { m_conf.ps.blend_hw = static_cast(HWBlendType::SRC_ONE_DST_FACTOR); } @@ -4737,27 +4737,27 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo { m_conf.ps.blend_hw = static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR); } - else if (!m_conf.blend_second_pass.enable && alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW3)) + else if (!m_conf.blend_multi_pass.enable && alpha_c1_high_no_rta_correct && (blend_flag & BLEND_HW3)) { m_conf.ps.blend_hw = static_cast(HWBlendType::SRC_DOUBLE); } if (m_conf.ps.blend_c == 2 && (m_conf.ps.blend_hw == static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR) || m_conf.ps.blend_hw == static_cast(HWBlendType::SRC_HALF_ONE_DST_FACTOR) - || m_conf.blend_second_pass.blend_hw == static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR))) + || m_conf.blend_multi_pass.blend_hw == static_cast(HWBlendType::SRC_ALPHA_DST_FACTOR))) { m_conf.cb_ps.TA_MaxDepth_Af.a = static_cast(AFIX) / 128.0f; } - const GSDevice::BlendFactor src_factor_alpha = m_conf.blend_second_pass.enable ? GSDevice::CONST_ZERO : GSDevice::CONST_ONE; - const GSDevice::BlendFactor dst_factor_alpha = m_conf.blend_second_pass.enable ? GSDevice::CONST_ONE : GSDevice::CONST_ZERO; + const GSDevice::BlendFactor src_factor_alpha = m_conf.blend_multi_pass.enable ? GSDevice::CONST_ZERO : GSDevice::CONST_ONE; + const GSDevice::BlendFactor dst_factor_alpha = m_conf.blend_multi_pass.enable ? GSDevice::CONST_ONE : GSDevice::CONST_ZERO; m_conf.blend = {true, blend.src, blend.dst, blend.op, src_factor_alpha, dst_factor_alpha, m_conf.ps.blend_c == 2, AFIX}; // Remove second color output when unused. Works around bugs in some drivers (e.g. Intel). m_conf.ps.no_color1 = !GSDevice::IsDualSourceBlendFactor(m_conf.blend.src_factor) && !GSDevice::IsDualSourceBlendFactor(m_conf.blend.dst_factor) && - !GSDevice::IsDualSourceBlendFactor(m_conf.blend_second_pass.blend.src_factor) && - !GSDevice::IsDualSourceBlendFactor(m_conf.blend_second_pass.blend.dst_factor); + !GSDevice::IsDualSourceBlendFactor(m_conf.blend_multi_pass.blend.src_factor) && + !GSDevice::IsDualSourceBlendFactor(m_conf.blend_multi_pass.blend.dst_factor); } // Notify the shader that it needs to invert rounding @@ -5959,10 +5959,10 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta } else { - if (m_conf.blend_second_pass.enable) + if (m_conf.blend_multi_pass.enable) { - m_conf.blend_second_pass.blend.src_factor_alpha = GSDevice::SRC1_ALPHA; - m_conf.blend_second_pass.blend.dst_factor_alpha = GSDevice::INV_SRC1_ALPHA; + m_conf.blend_multi_pass.blend.src_factor_alpha = GSDevice::SRC1_ALPHA; + m_conf.blend_multi_pass.blend.dst_factor_alpha = GSDevice::INV_SRC1_ALPHA; } else { @@ -6106,7 +6106,7 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta m_conf.ps.fba = m_context->FBA.FBA; - if (m_conf.ps.dither || m_conf.blend_second_pass.dither) + if (m_conf.ps.dither || m_conf.blend_multi_pass.dither) { const GIFRegDIMX& DIMX = m_draw_env->DIMX; GL_DBG("DITHERING mode %d (%d)", (GSConfig.Dithering == 3) ? "Force 32bit" : ((GSConfig.Dithering == 0) ? "Disabled" : "Enabled"), GSConfig.Dithering); @@ -6122,7 +6122,7 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta else if (GSConfig.Dithering > 2) { m_conf.ps.dither = GSConfig.Dithering; - m_conf.blend_second_pass.dither = GSConfig.Dithering; + m_conf.blend_multi_pass.dither = GSConfig.Dithering; } if (PRIM->FGE) diff --git a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp index d2750ae524..7c109d5557 100644 --- a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp +++ b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp @@ -2612,21 +2612,21 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) SendHWDraw(config, psel.ps.IsFeedbackLoop()); - if (config.blend_second_pass.enable) + if (config.blend_multi_pass.enable) { if (config.blend.IsEffective(config.colormask)) { - OMSetBlendState(config.blend_second_pass.blend.enable, s_gl_blend_factors[config.blend_second_pass.blend.src_factor], - s_gl_blend_factors[config.blend_second_pass.blend.dst_factor], s_gl_blend_ops[config.blend_second_pass.blend.op], - s_gl_blend_factors[config.blend_second_pass.blend.src_factor_alpha], s_gl_blend_factors[config.blend_second_pass.blend.dst_factor_alpha], - config.blend_second_pass.blend.constant_enable, config.blend_second_pass.blend.constant); + OMSetBlendState(config.blend_multi_pass.blend.enable, s_gl_blend_factors[config.blend_multi_pass.blend.src_factor], + s_gl_blend_factors[config.blend_multi_pass.blend.dst_factor], s_gl_blend_ops[config.blend_multi_pass.blend.op], + s_gl_blend_factors[config.blend_multi_pass.blend.src_factor_alpha], s_gl_blend_factors[config.blend_multi_pass.blend.dst_factor_alpha], + config.blend_multi_pass.blend.constant_enable, config.blend_multi_pass.blend.constant); } else { OMSetBlendState(); } - psel.ps.blend_hw = config.blend_second_pass.blend_hw; - psel.ps.dither = config.blend_second_pass.dither; + psel.ps.blend_hw = config.blend_multi_pass.blend_hw; + psel.ps.dither = config.blend_multi_pass.dither; SetupPipeline(psel); SendHWDraw(config, psel.ps.IsFeedbackLoop()); } diff --git a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp index 38547adf44..12f5a8cd0f 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp +++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp @@ -5826,14 +5826,14 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) SendHWDraw(config, draw_rt, config.require_one_barrier, config.require_full_barrier, skip_first_barrier); // blend second pass - if (config.blend_second_pass.enable) + if (config.blend_multi_pass.enable) { - if (config.blend_second_pass.blend.constant_enable) - SetBlendConstants(config.blend_second_pass.blend.constant); + if (config.blend_multi_pass.blend.constant_enable) + SetBlendConstants(config.blend_multi_pass.blend.constant); - pipe.bs = config.blend_second_pass.blend; - pipe.ps.blend_hw = config.blend_second_pass.blend_hw; - pipe.ps.dither = config.blend_second_pass.dither; + pipe.bs = config.blend_multi_pass.blend; + pipe.ps.blend_hw = config.blend_multi_pass.blend_hw; + pipe.ps.dither = config.blend_multi_pass.dither; if (BindDrawPipeline(pipe)) { // TODO: This probably should have barriers, in case we want to use it conditionally.