From 6e264970389e196327ae3192a6a41be9be45f44c Mon Sep 17 00:00:00 2001 From: Filoppi Date: Tue, 15 Apr 2025 15:21:25 +0300 Subject: [PATCH] GS: Add actual HDR and HQ textures and rename the "HDR" textures to colclip (hw) given that's actually what they are (HDR was a very loose term for it) --- bin/resources/shaders/dx11/convert.fx | 4 +- bin/resources/shaders/dx11/tfx.fx | 12 +- bin/resources/shaders/opengl/convert.glsl | 8 +- bin/resources/shaders/opengl/tfx_fs.glsl | 10 +- bin/resources/shaders/vulkan/convert.glsl | 8 +- bin/resources/shaders/vulkan/tfx.glsl | 12 +- pcsx2/GS/Renderers/Common/GSDevice.cpp | 26 +++- pcsx2/GS/Renderers/Common/GSDevice.h | 22 +-- pcsx2/GS/Renderers/Common/GSTexture.cpp | 10 +- pcsx2/GS/Renderers/Common/GSTexture.h | 11 +- pcsx2/GS/Renderers/DX11/GSDevice11.cpp | 58 +++---- pcsx2/GS/Renderers/DX11/GSTexture11.cpp | 4 +- pcsx2/GS/Renderers/DX12/GSDevice12.cpp | 123 ++++++++------- pcsx2/GS/Renderers/DX12/GSDevice12.h | 4 +- pcsx2/GS/Renderers/HW/GSRendererHW.cpp | 105 +++++++------ pcsx2/GS/Renderers/HW/GSRendererHW.h | 2 +- pcsx2/GS/Renderers/Metal/GSDeviceMTL.h | 8 +- pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm | 74 ++++----- pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h | 2 +- pcsx2/GS/Renderers/Metal/convert.metal | 4 +- pcsx2/GS/Renderers/Metal/tfx.metal | 12 +- pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp | 62 ++++---- pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp | 4 +- pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp | 156 ++++++++++--------- pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h | 10 +- pcsx2/ShaderCacheVersion.h | 2 +- 26 files changed, 390 insertions(+), 363 deletions(-) diff --git a/bin/resources/shaders/dx11/convert.fx b/bin/resources/shaders/dx11/convert.fx index ddcd70e5ae..9771e62d4c 100644 --- a/bin/resources/shaders/dx11/convert.fx +++ b/bin/resources/shaders/dx11/convert.fx @@ -170,7 +170,7 @@ PS_OUTPUT ps_rta_decorrection(PS_INPUT input) return output; } -PS_OUTPUT ps_hdr_init(PS_INPUT input) +PS_OUTPUT ps_colclip_init(PS_INPUT input) { PS_OUTPUT output; float4 value = sample_c(input.t); @@ -178,7 +178,7 @@ PS_OUTPUT ps_hdr_init(PS_INPUT input) return output; } -PS_OUTPUT ps_hdr_resolve(PS_INPUT input) +PS_OUTPUT ps_colclip_resolve(PS_INPUT input) { PS_OUTPUT output; float4 value = sample_c(input.t); diff --git a/bin/resources/shaders/dx11/tfx.fx b/bin/resources/shaders/dx11/tfx.fx index a0de0b4246..2bd548ec60 100644 --- a/bin/resources/shaders/dx11/tfx.fx +++ b/bin/resources/shaders/dx11/tfx.fx @@ -55,7 +55,7 @@ #define PS_CHANNEL_FETCH 0 #define PS_TALES_OF_ABYSS_HLE 0 #define PS_URBAN_CHAOS_HLE 0 -#define PS_HDR 0 +#define PS_COLCLIP_HW 0 #define PS_RTA_CORRECTION 0 #define PS_RTA_SRC_CORRECTION 0 #define PS_COLCLIP 0 @@ -799,7 +799,7 @@ void ps_fbmask(inout float4 C, float2 pos_xy) { if (PS_FBMASK) { - float multi = PS_HDR ? 65535.0f : 255.0f; + float multi = PS_COLCLIP_HW ? 65535.0f : 255.0f; float4 RT = trunc(RtTexture.Load(int3(pos_xy, 0)) * multi + 0.1f); C = (float4)(((uint4)C & ~FbMask) | ((uint4)RT & FbMask)); } @@ -843,13 +843,13 @@ void ps_color_clamp_wrap(inout float3 C) C += 7.0f; // Need to round up, not down since the shader will invert // Standard Clamp - if (PS_COLCLIP == 0 && PS_HDR == 0) + if (PS_COLCLIP == 0 && PS_COLCLIP_HW == 0) C = clamp(C, (float3)0.0f, (float3)255.0f); // In 16 bits format, only 5 bits of color are used. It impacts shadows computation of Castlevania if (PS_DST_FMT == FMT_16 && PS_DITHER != 3 && (PS_BLEND_MIX == 0 || PS_DITHER)) C = (float3)((int3)C & (int3)0xF8); - else if (PS_COLCLIP == 1 || PS_HDR == 1) + else if (PS_COLCLIP == 1 || PS_COLCLIP_HW == 1) C = (float3)((int3)C & (int3)0xFF); } else if (PS_DST_FMT == FMT_16 && PS_DITHER != 3 && PS_BLEND_MIX == 0 && PS_BLEND_HW == 0) @@ -898,7 +898,7 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy) } float Ad = PS_RTA_CORRECTION ? trunc(RT.a * 128.0f + 0.1f) / 128.0f : trunc(RT.a * 255.0f + 0.1f) / 128.0f; - float color_multi = PS_HDR ? 65535.0f : 255.0f; + float color_multi = PS_COLCLIP_HW ? 65535.0f : 255.0f; float3 Cd = trunc(RT.rgb * color_multi + 0.1f); float3 Cs = Color.rgb; @@ -1157,7 +1157,7 @@ PS_OUTPUT ps_main(PS_INPUT input) #if !PS_NO_COLOR output.c0.a = PS_RTA_CORRECTION ? C.a / 128.0f : C.a / 255.0f; - output.c0.rgb = PS_HDR ? float3(C.rgb / 65535.0f) : C.rgb / 255.0f; + output.c0.rgb = PS_COLCLIP_HW ? float3(C.rgb / 65535.0f) : C.rgb / 255.0f; #if !PS_NO_COLOR1 output.c1 = alpha_blend; #endif diff --git a/bin/resources/shaders/opengl/convert.glsl b/bin/resources/shaders/opengl/convert.glsl index b4c0d52721..27320a82ce 100644 --- a/bin/resources/shaders/opengl/convert.glsl +++ b/bin/resources/shaders/opengl/convert.glsl @@ -348,16 +348,16 @@ void ps_rta_decorrection() } #endif -#ifdef ps_hdr_init -void ps_hdr_init() +#ifdef ps_colclip_init +void ps_colclip_init() { vec4 value = sample_c(); SV_Target0 = vec4(round(value.rgb * 255.0f) / 65535.0f, value.a); } #endif -#ifdef ps_hdr_resolve -void ps_hdr_resolve() +#ifdef ps_colclip_resolve +void ps_colclip_resolve() { vec4 value = sample_c(); SV_Target0 = vec4(vec3(uvec3(value.rgb * 65535.0f) & 255u) / 255.0f, value.a); diff --git a/bin/resources/shaders/opengl/tfx_fs.glsl b/bin/resources/shaders/opengl/tfx_fs.glsl index 8dc7f852ff..f290e8d5e8 100644 --- a/bin/resources/shaders/opengl/tfx_fs.glsl +++ b/bin/resources/shaders/opengl/tfx_fs.glsl @@ -707,7 +707,7 @@ void ps_fbmask(inout vec4 C) { // FIXME do I need special case for 16 bits #if PS_FBMASK - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 vec4 RT = trunc(sample_from_rt() * 65535.0f); #else vec4 RT = trunc(sample_from_rt() * 255.0f + 0.1f); @@ -757,7 +757,7 @@ void ps_color_clamp_wrap(inout vec3 C) #endif // Correct the Color value based on the output format -#if PS_COLCLIP == 0 && PS_HDR == 0 +#if PS_COLCLIP == 0 && PS_COLCLIP_HW == 0 // Standard Clamp C = clamp(C, vec3(0.0f), vec3(255.0f)); #endif @@ -771,7 +771,7 @@ void ps_color_clamp_wrap(inout vec3 C) #if PS_DST_FMT == FMT_16 && PS_DITHER < 3 && (PS_BLEND_MIX == 0 || PS_DITHER) // In 16 bits format, only 5 bits of colors are used. It impacts shadows computation of Castlevania C = vec3(ivec3(C) & ivec3(0xF8)); -#elif PS_COLCLIP == 1 || PS_HDR == 1 +#elif PS_COLCLIP == 1 || PS_COLCLIP_HW == 1 C = vec3(ivec3(C) & ivec3(0xFF)); #endif @@ -828,7 +828,7 @@ float As = As_rgba.a; #endif // Let the compiler do its jobs ! - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 vec3 Cd = trunc(RT.rgb * 65535.0f); #else vec3 Cd = trunc(RT.rgb * 255.0f + 0.1f); @@ -1125,7 +1125,7 @@ void ps_main() #else SV_Target0.a = C.a / 255.0f; #endif - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 SV_Target0.rgb = vec3(C.rgb / 65535.0f); #else SV_Target0.rgb = C.rgb / 255.0f; diff --git a/bin/resources/shaders/vulkan/convert.glsl b/bin/resources/shaders/vulkan/convert.glsl index 7b370affc5..9a3b551dd0 100644 --- a/bin/resources/shaders/vulkan/convert.glsl +++ b/bin/resources/shaders/vulkan/convert.glsl @@ -148,16 +148,16 @@ void ps_rta_decorrection() } #endif -#ifdef ps_hdr_init -void ps_hdr_init() +#ifdef ps_colclip_init +void ps_colclip_init() { vec4 value = sample_c(v_tex); o_col0 = vec4(roundEven(value.rgb * 255.0f) / 65535.0f, value.a); } #endif -#ifdef ps_hdr_resolve -void ps_hdr_resolve() +#ifdef ps_colclip_resolve +void ps_colclip_resolve() { vec4 value = sample_c(v_tex); o_col0 = vec4(vec3(uvec3(value.rgb * 65535.5f) & 255u) / 255.0f, value.a); diff --git a/bin/resources/shaders/vulkan/tfx.glsl b/bin/resources/shaders/vulkan/tfx.glsl index 3061226288..ba21b4c0b5 100644 --- a/bin/resources/shaders/vulkan/tfx.glsl +++ b/bin/resources/shaders/vulkan/tfx.glsl @@ -281,7 +281,7 @@ void main() #define PS_CHANNEL_FETCH 0 #define PS_TALES_OF_ABYSS_HLE 0 #define PS_URBAN_CHAOS_HLE 0 -#define PS_HDR 0 +#define PS_COLCLIP_HW 0 #define PS_COLCLIP 0 #define PS_BLEND_A 0 #define PS_BLEND_B 0 @@ -974,7 +974,7 @@ void ps_fbmask(inout vec4 C) { #if PS_FBMASK - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 vec4 RT = trunc(sample_from_rt() * 65535.0f); #else vec4 RT = trunc(sample_from_rt() * 255.0f + 0.1f); @@ -1027,7 +1027,7 @@ void ps_color_clamp_wrap(inout vec3 C) #endif // Correct the Color value based on the output format -#if PS_COLCLIP == 0 && PS_HDR == 0 +#if PS_COLCLIP == 0 && PS_COLCLIP_HW == 0 // Standard Clamp C = clamp(C, vec3(0.0f), vec3(255.0f)); #endif @@ -1041,7 +1041,7 @@ void ps_color_clamp_wrap(inout vec3 C) #if PS_DST_FMT == FMT_16 && PS_DITHER != 3 && (PS_BLEND_MIX == 0 || PS_DITHER > 0) // In 16 bits format, only 5 bits of colors are used. It impacts shadows computation of Castlevania C = vec3(ivec3(C) & ivec3(0xF8)); -#elif PS_COLCLIP == 1 || PS_HDR == 1 +#elif PS_COLCLIP == 1 || PS_COLCLIP_HW == 1 C = vec3(ivec3(C) & ivec3(0xFF)); #endif @@ -1098,7 +1098,7 @@ void ps_blend(inout vec4 Color, inout vec4 As_rgba) #endif // Let the compiler do its jobs ! - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 vec3 Cd = trunc(RT.rgb * 65535.0f); #else vec3 Cd = trunc(RT.rgb * 255.0f + 0.1f); @@ -1390,7 +1390,7 @@ void main() #else o_col0.a = C.a / 255.0f; #endif - #if PS_HDR == 1 + #if PS_COLCLIP_HW == 1 o_col0.rgb = vec3(C.rgb / 65535.0f); #else o_col0.rgb = C.rgb / 255.0f; diff --git a/pcsx2/GS/Renderers/Common/GSDevice.cpp b/pcsx2/GS/Renderers/Common/GSDevice.cpp index 71195467e1..f717e9ca10 100644 --- a/pcsx2/GS/Renderers/Common/GSDevice.cpp +++ b/pcsx2/GS/Renderers/Common/GSDevice.cpp @@ -46,8 +46,8 @@ const char* shaderName(ShaderConvert value) case ShaderConvert::DATM_0: return "ps_datm0"; case ShaderConvert::DATM_1_RTA_CORRECTION: return "ps_datm1_rta_correction"; case ShaderConvert::DATM_0_RTA_CORRECTION: return "ps_datm0_rta_correction"; - case ShaderConvert::HDR_INIT: return "ps_hdr_init"; - case ShaderConvert::HDR_RESOLVE: return "ps_hdr_resolve"; + case ShaderConvert::COLCLIP_INIT: return "ps_colclip_init"; + case ShaderConvert::COLCLIP_RESOLVE: return "ps_colclip_resolve"; case ShaderConvert::RTA_CORRECTION: return "ps_rta_correction"; case ShaderConvert::RTA_DECORRECTION: return "ps_rta_decorrection"; case ShaderConvert::TRANSPARENCY_FILTER: return "ps_filter_transparency"; @@ -103,7 +103,9 @@ const char* shaderName(PresentShader value) enum class TextureLabel { ColorRT, - HDRRT, + ColorHQRT, + ColorHDRRT, + ColorClipRT, U16RT, U32RT, DepthStencil, @@ -127,8 +129,12 @@ static TextureLabel GetTextureLabel(GSTexture::Type type, GSTexture::Format form { case GSTexture::Format::Color: return TextureLabel::ColorRT; - case GSTexture::Format::HDRColor: - return TextureLabel::HDRRT; + case GSTexture::Format::ColorHQ: + return TextureLabel::ColorHQRT; + case GSTexture::Format::ColorHDR: + return TextureLabel::ColorHDRRT; + case GSTexture::Format::ColorClip: + return TextureLabel::ColorClipRT; case GSTexture::Format::UInt16: return TextureLabel::U16RT; case GSTexture::Format::UInt32: @@ -149,6 +155,7 @@ static TextureLabel GetTextureLabel(GSTexture::Type type, GSTexture::Format form case GSTexture::Format::BC2: case GSTexture::Format::BC3: case GSTexture::Format::BC7: + case GSTexture::Format::ColorHDR: return TextureLabel::ReplacementTexture; default: return TextureLabel::Other; @@ -163,14 +170,19 @@ static TextureLabel GetTextureLabel(GSTexture::Type type, GSTexture::Format form } } +// Debug names static const char* TextureLabelString(TextureLabel label) { switch (label) { case TextureLabel::ColorRT: return "Color RT"; - case TextureLabel::HDRRT: - return "HDR RT"; + case TextureLabel::ColorHQRT: + return "Color HQ RT"; + case TextureLabel::ColorHDRRT: + return "Color HDR RT"; + case TextureLabel::ColorClipRT: + return "Color Clip RT"; case TextureLabel::U16RT: return "U16 RT"; case TextureLabel::U32RT: diff --git a/pcsx2/GS/Renderers/Common/GSDevice.h b/pcsx2/GS/Renderers/Common/GSDevice.h index 5055fbaa3a..b61dca49be 100644 --- a/pcsx2/GS/Renderers/Common/GSDevice.h +++ b/pcsx2/GS/Renderers/Common/GSDevice.h @@ -22,8 +22,8 @@ enum class ShaderConvert DATM_0, DATM_1_RTA_CORRECTION, DATM_0_RTA_CORRECTION, - HDR_INIT, - HDR_RESOLVE, + COLCLIP_INIT, + COLCLIP_RESOLVE, RTA_CORRECTION, RTA_DECORRECTION, TRANSPARENCY_FILTER, @@ -360,10 +360,10 @@ struct alignas(16) GSHWDrawConfig u32 fixed_one_a : 1; u32 blend_hw : 3; /*HWBlendType*/ u32 a_masked : 1; - u32 hdr : 1; + u32 colclip_hw : 1; // colclip (COLCLAMP off) emulation through HQ textures u32 rta_correction : 1; u32 rta_source_correction : 1; - u32 colclip : 1; + u32 colclip : 1; // COLCLAMP off (color blend outputs wrap around 0-255) u32 blend_mix : 2; u32 round_inv : 1; // Blending will invert the value, so rounding needs to go the other way u32 pabe : 1; @@ -683,7 +683,7 @@ struct alignas(16) GSHWDrawConfig Full, ///< Full emulation (using barriers / ROV) }; - enum class HDRMode : u8 + enum class ColClipMode : u8 { NoModify = 0, ConvertOnly = 1, @@ -750,9 +750,9 @@ struct alignas(16) GSHWDrawConfig PSConstantBuffer cb_ps; // These are here as they need to be preserved between draws, and the state clear only does up to the constant buffers. - HDRMode hdr_mode; - GIFRegFRAME hdr_frame; - GSVector4i hdr_update_area; ///< Area in the framebuffer which HDR will modify; + ColClipMode colclip_mode; + GIFRegFRAME colclip_frame; + GSVector4i colclip_update_area; ///< Area in the framebuffer which colclip will modify; }; class GSDevice : public GSAlignedClass<32> @@ -873,7 +873,7 @@ protected: GSTexture* m_target_tmp = nullptr; GSTexture* m_current = nullptr; GSTexture* m_cas = nullptr; - GSTexture* m_hdr_rt = nullptr; ///< Temp HDR texture + GSTexture* m_colclip_rt = nullptr; ///< Temp hw colclip texture bool AcquireWindow(bool recreate_window); @@ -898,9 +898,9 @@ public: /// Returns a string containing current adapter in use. const std::string& GetName() const { return m_name; } - GSTexture* GetHDRTexture() const { return m_hdr_rt; } + GSTexture* GetColorClipTexture() const { return m_colclip_rt; } - void SetHDRTexture(GSTexture* tex) { m_hdr_rt = tex; } + void SetColorClipTexture(GSTexture* tex) { m_colclip_rt = tex; } /// Returns a string representing the specified API. static const char* RenderAPIToString(RenderAPI api); diff --git a/pcsx2/GS/Renderers/Common/GSTexture.cpp b/pcsx2/GS/Renderers/Common/GSTexture.cpp index e0212a7110..4de4714759 100644 --- a/pcsx2/GS/Renderers/Common/GSTexture.cpp +++ b/pcsx2/GS/Renderers/Common/GSTexture.cpp @@ -66,7 +66,9 @@ const char* GSTexture::GetFormatName(Format format) static constexpr const char* format_names[] = { "Invalid", "Color", - "HDRColor", + "ColorHQ", + "ColorHDR", + "ColorClip", "DepthStencil", "UNorm8", "UInt16", @@ -90,7 +92,9 @@ u32 GSTexture::GetCompressedBytesPerBlock(Format format) static constexpr u32 bytes_per_block[] = { 1, // Invalid 4, // Color/RGBA8 - 8, // HDRColor/RGBA16 + 4, // ColorHQ/RGB10A2 + 8, // ColorHDR/RGBA16F + 8, // ColorClip/RGBA16 4, // DepthStencil 1, // UNorm8/R8 2, // UInt16/R16UI @@ -99,7 +103,7 @@ u32 GSTexture::GetCompressedBytesPerBlock(Format format) 8, // BC1 - 16 pixels in 64 bits 16, // BC2 - 16 pixels in 128 bits 16, // BC3 - 16 pixels in 128 bits - 16, // BC4 - 16 pixels in 128 bits + 16, // BC7 - 16 pixels in 128 bits }; return bytes_per_block[static_cast(format)]; diff --git a/pcsx2/GS/Renderers/Common/GSTexture.h b/pcsx2/GS/Renderers/Common/GSTexture.h index fab5ece270..d9123dc599 100644 --- a/pcsx2/GS/Renderers/Common/GSTexture.h +++ b/pcsx2/GS/Renderers/Common/GSTexture.h @@ -22,15 +22,17 @@ public: Invalid = 0, RenderTarget = 1, DepthStencil, - Texture, - RWTexture, + Texture, // Generic texture (usually is color textures loaded by the game) + RWTexture, // UAV }; enum class Format : u8 { Invalid = 0, ///< Used for initialization - Color, ///< Standard (RGBA8) color texture - HDRColor, ///< Color texture with more bits for colclip emulation (RGBA16Unorm) + Color, ///< Standard (RGBA8) color texture (used to store most of PS2's textures) + ColorHQ, ///< High quality (RGB10A2) color texture (no proper alpha) + ColorHDR, ///< High dynamic range (RGBA16F) color texture + ColorClip, ///< Color texture with more bits for colclip (wrap) emulation, given that blending requires 9bpc (RGBA16Unorm) DepthStencil, ///< Depth stencil texture UNorm8, ///< A8UNorm texture for paletted textures and the OSD font UInt16, ///< UInt16 texture for reading back 16-bit depth @@ -40,6 +42,7 @@ public: BC2, ///< BC2, aka DXT2/3 compressed texture for replacements BC3, ///< BC3, aka DXT4/5 compressed texture for replacements BC7, ///< BC7, aka BPTC compressed texture for replacements + Last = BC7, }; enum class State : u8 diff --git a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp index 3e6f174b25..09f1097b77 100644 --- a/pcsx2/GS/Renderers/DX11/GSDevice11.cpp +++ b/pcsx2/GS/Renderers/DX11/GSDevice11.cpp @@ -1748,7 +1748,7 @@ void GSDevice11::SetupPS(const PSSelector& sel, const GSHWDrawConfig::PSConstant sm.AddMacro("PS_DST_FMT", sel.dst_fmt); sm.AddMacro("PS_DEPTH_FMT", sel.depth_fmt); sm.AddMacro("PS_PAL_FMT", sel.pal_fmt); - sm.AddMacro("PS_HDR", sel.hdr); + sm.AddMacro("PS_COLCLIP_HW", sel.colclip_hw); sm.AddMacro("PS_RTA_CORRECTION", sel.rta_correction); sm.AddMacro("PS_RTA_SRC_CORRECTION", sel.rta_source_correction); sm.AddMacro("PS_COLCLIP", sel.colclip); @@ -2521,43 +2521,43 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) GSVector2i rtsize = (config.rt ? config.rt : config.ds)->GetSize(); - GSTexture* hdr_rt = g_gs_device->GetHDRTexture(); + GSTexture* colclip_rt = g_gs_device->GetColorClipTexture(); - if (hdr_rt) + if (colclip_rt) { - if (config.hdr_mode == GSHWDrawConfig::HDRMode::EarlyResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::EarlyResolve) { const GSVector2i size = config.rt->GetSize(); - const GSVector4 dRect(config.hdr_update_area); + const GSVector4 dRect(config.colclip_update_area); const GSVector4 sRect = dRect / GSVector4(size.x, size.y).xyxy(); - StretchRect(hdr_rt, sRect, config.rt, dRect, ShaderConvert::HDR_RESOLVE, false); + StretchRect(colclip_rt, sRect, config.rt, dRect, ShaderConvert::COLCLIP_RESOLVE, false); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); - hdr_rt = nullptr; + colclip_rt = nullptr; } else - config.ps.hdr = 1; + config.ps.colclip_hw = 1; } - if (config.ps.hdr) + if (config.ps.colclip_hw) { - if (!hdr_rt) + if (!colclip_rt) { - config.hdr_update_area = config.drawarea; + config.colclip_update_area = config.drawarea; - const GSVector4 dRect = GSVector4((config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); + const GSVector4 dRect = GSVector4((config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); const GSVector4 sRect = dRect / GSVector4(rtsize.x, rtsize.y).xyxy(); - hdr_rt = CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::HDRColor); - if (!hdr_rt) + colclip_rt = CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::ColorClip); + if (!colclip_rt) return; - g_gs_device->SetHDRTexture(hdr_rt); + g_gs_device->SetColorClipTexture(colclip_rt); // Warning: StretchRect must be called before BeginScene otherwise // vertices will be overwritten. Trust me you don't want to do that. - StretchRect(config.rt, sRect, hdr_rt, dRect, ShaderConvert::HDR_INIT, false); + StretchRect(config.rt, sRect, colclip_rt, dRect, ShaderConvert::COLCLIP_INIT, false); g_perfmon.Put(GSPerfMon::TextureCopies, 1); } } @@ -2569,7 +2569,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) if (!primid_tex) return; - StretchRect(hdr_rt ? hdr_rt : config.rt, GSVector4(config.drawarea) / GSVector4(rtsize).xyxy(), + StretchRect(colclip_rt ? colclip_rt : config.rt, GSVector4(config.drawarea) / GSVector4(rtsize).xyxy(), primid_tex, GSVector4(config.drawarea), m_date.primid_init_ps[static_cast(config.datm)].get(), nullptr, false); } else if (config.destination_alpha != GSHWDrawConfig::DestinationAlphaMode::Off) @@ -2585,7 +2585,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) {GSVector4(dst.z, -dst.w, 0.5f, 1.0f), GSVector2(src.z, src.w)}, }; - SetupDATE(hdr_rt ? hdr_rt : config.rt, config.ds, vertices, config.datm); + SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, vertices, config.datm); } if (config.vs.expand != GSHWDrawConfig::VSExpand::None) @@ -2649,7 +2649,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) // Do not always bind the rt when it's not needed, // only bind it when effects use it such as fbmask emulation currently // because we copy the frame buffer and it is quite slow. - CloneTexture(hdr_rt ? hdr_rt : config.rt, &rt_copy, config.drawarea); + CloneTexture(colclip_rt ? colclip_rt : config.rt, &rt_copy, config.drawarea); if (rt_copy) { if (config.require_one_barrier) @@ -2679,7 +2679,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) } SetupOM(config.depth, OMBlendSelector(config.colormask, config.blend), config.blend.constant); - OMSetRenderTargets(hdr_rt ? hdr_rt : config.rt, config.ds, &config.scissor); + OMSetRenderTargets(colclip_rt ? colclip_rt : config.rt, config.ds, &config.scissor); DrawIndexedPrimitive(); if (config.blend_multi_pass.enable) @@ -2714,20 +2714,20 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config) if (primid_tex) Recycle(primid_tex); - if (hdr_rt) + if (colclip_rt) { - config.hdr_update_area = config.hdr_update_area.runion(config.drawarea); + config.colclip_update_area = config.colclip_update_area.runion(config.drawarea); - if (config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve) { const GSVector2i size = config.rt->GetSize(); - const GSVector4 dRect(config.hdr_update_area); + const GSVector4 dRect(config.colclip_update_area); const GSVector4 sRect = dRect / GSVector4(size.x, size.y).xyxy(); - StretchRect(hdr_rt, sRect, config.rt, dRect, ShaderConvert::HDR_RESOLVE, false); + StretchRect(colclip_rt, sRect, config.rt, dRect, ShaderConvert::COLCLIP_RESOLVE, false); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); } } } diff --git a/pcsx2/GS/Renderers/DX11/GSTexture11.cpp b/pcsx2/GS/Renderers/DX11/GSTexture11.cpp index b7ecc85b25..fa9e9b5953 100644 --- a/pcsx2/GS/Renderers/DX11/GSTexture11.cpp +++ b/pcsx2/GS/Renderers/DX11/GSTexture11.cpp @@ -29,7 +29,9 @@ DXGI_FORMAT GSTexture11::GetDXGIFormat(Format format) switch (format) { case GSTexture::Format::Color: return DXGI_FORMAT_R8G8B8A8_UNORM; - case GSTexture::Format::HDRColor: return DXGI_FORMAT_R16G16B16A16_UNORM; + case GSTexture::Format::ColorHQ: return DXGI_FORMAT_R10G10B10A2_UNORM; + case GSTexture::Format::ColorHDR: return DXGI_FORMAT_R16G16B16A16_FLOAT; + case GSTexture::Format::ColorClip: return DXGI_FORMAT_R16G16B16A16_UNORM; case GSTexture::Format::DepthStencil: return DXGI_FORMAT_R32G8X24_TYPELESS; case GSTexture::Format::UNorm8: return DXGI_FORMAT_A8_UNORM; case GSTexture::Format::UInt16: return DXGI_FORMAT_R16_UINT; diff --git a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp index 71996a5413..c6163227d8 100644 --- a/pcsx2/GS/Renderers/DX12/GSDevice12.cpp +++ b/pcsx2/GS/Renderers/DX12/GSDevice12.cpp @@ -1265,13 +1265,17 @@ void GSDevice12::DrawIndexedPrimitive(int offset, int count) void GSDevice12::LookupNativeFormat(GSTexture::Format format, DXGI_FORMAT* d3d_format, DXGI_FORMAT* srv_format, DXGI_FORMAT* rtv_format, DXGI_FORMAT* dsv_format) const { - static constexpr std::array, static_cast(GSTexture::Format::BC7) + 1> + static constexpr std::array, static_cast(GSTexture::Format::Last) + 1> s_format_mapping = {{ {DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN}, // Invalid {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN}, // Color + {DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN}, // ColorHQ + {DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN}, // ColorHDR {DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM, - DXGI_FORMAT_UNKNOWN}, // HDRColor + DXGI_FORMAT_UNKNOWN}, // ColorClip {DXGI_FORMAT_D32_FLOAT_S8X24_UINT, DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_D32_FLOAT_S8X24_UINT}, // DepthStencil {DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_A8_UNORM, DXGI_FORMAT_UNKNOWN}, // UNorm8 @@ -2540,10 +2544,10 @@ bool GSDevice12::CompileConvertPipelines() j & 1u, (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u)); } } - else if (i == ShaderConvert::HDR_INIT || i == ShaderConvert::HDR_RESOLVE) + else if (i == ShaderConvert::COLCLIP_INIT || i == ShaderConvert::COLCLIP_RESOLVE) { - const bool is_setup = i == ShaderConvert::HDR_INIT; - std::array, 2>& arr = is_setup ? m_hdr_setup_pipelines : m_hdr_finish_pipelines; + const bool is_setup = i == ShaderConvert::COLCLIP_INIT; + std::array, 2>& arr = is_setup ? m_colclip_setup_pipelines : m_colclip_finish_pipelines; for (u32 ds = 0; ds < 2; ds++) { pxAssert(!arr[ds]); @@ -2554,7 +2558,7 @@ bool GSDevice12::CompileConvertPipelines() if (!arr[ds]) return false; - D3D12::SetObjectName(arr[ds].get(), TinyString::from_format("HDR {}/copy pipeline (ds={})", is_setup ? "setup" : "finish", ds)); + D3D12::SetObjectName(arr[ds].get(), TinyString::from_format("ColorClip {}/copy pipeline (ds={})", is_setup ? "setup" : "finish", ds)); } } } @@ -2780,8 +2784,8 @@ void GSDevice12::DestroyResources() m_color_copy = {}; m_present = {}; m_convert = {}; - m_hdr_setup_pipelines = {}; - m_hdr_finish_pipelines = {}; + m_colclip_setup_pipelines = {}; + m_colclip_finish_pipelines = {}; m_date_image_setup_pipelines = {}; m_fxaa_pipeline.reset(); m_shadeboost_pipeline.reset(); @@ -2897,7 +2901,7 @@ const ID3DBlob* GSDevice12::GetTFXPixelShader(const GSHWDrawConfig::PSSelector& sm.AddMacro("PS_DST_FMT", sel.dst_fmt); sm.AddMacro("PS_DEPTH_FMT", sel.depth_fmt); sm.AddMacro("PS_PAL_FMT", sel.pal_fmt); - sm.AddMacro("PS_HDR", sel.hdr); + sm.AddMacro("PS_COLCLIP_HW", sel.colclip_hw); sm.AddMacro("PS_RTA_CORRECTION", sel.rta_correction); sm.AddMacro("PS_RTA_SRC_CORRECTION", sel.rta_source_correction); sm.AddMacro("PS_COLCLIP", sel.colclip); @@ -2955,7 +2959,7 @@ GSDevice12::ComPtr GSDevice12::CreateTFXPipeline(const Pipe { const GSTexture::Format format = IsDATEModePrimIDInit(p.ps.date) ? GSTexture::Format::PrimID : - (p.ps.hdr ? GSTexture::Format::HDRColor : GSTexture::Format::Color); + (p.ps.colclip_hw ? GSTexture::Format::ColorClip : GSTexture::Format::Color); DXGI_FORMAT native_format; LookupNativeFormat(format, nullptr, nullptr, &native_format, nullptr); @@ -3817,7 +3821,7 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) const bool stencil_DATE = (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::Stencil || config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::StencilOne); - GSTexture12* hdr_rt = static_cast(g_gs_device->GetHDRTexture()); + GSTexture12* colclip_rt = static_cast(g_gs_device->GetColorClipTexture()); GSTexture12* draw_rt = static_cast(config.rt); GSTexture12* draw_ds = static_cast(config.ds); GSTexture12* draw_rt_clone = nullptr; @@ -3830,15 +3834,15 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) // figure out the pipeline UpdateHWPipelineSelector(config); - // now blit the hdr texture back to the original target - if (hdr_rt) + // now blit the colclip texture back to the original target + if (colclip_rt) { - if (config.hdr_mode == GSHWDrawConfig::HDRMode::EarlyResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::EarlyResolve) { - GL_PUSH("Blit HDR back to RT"); + GL_PUSH("Blit ColorClip back to RT"); EndRenderPass(); - hdr_rt->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + colclip_rt->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); draw_rt = static_cast(config.rt); OMSetRenderTargets(draw_rt, draw_ds, config.scissor); @@ -3850,19 +3854,19 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS, draw_rt->GetUNormClearColor(), 0.0f, 0); - const GSVector4 sRect(GSVector4(config.hdr_update_area) / GSVector4(rtsize.x, rtsize.y).xyxy()); - SetPipeline(m_hdr_finish_pipelines[pipe.ds].get()); - SetUtilityTexture(hdr_rt, m_point_sampler_cpu); - DrawStretchRect(sRect, GSVector4(config.hdr_update_area), rtsize); + const GSVector4 sRect(GSVector4(config.colclip_update_area) / GSVector4(rtsize.x, rtsize.y).xyxy()); + SetPipeline(m_colclip_finish_pipelines[pipe.ds].get()); + SetUtilityTexture(colclip_rt, m_point_sampler_cpu); + DrawStretchRect(sRect, GSVector4(config.colclip_update_area), rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); - g_gs_device->SetHDRTexture(nullptr); + Recycle(colclip_rt); + g_gs_device->SetColorClipTexture(nullptr); } else { - draw_rt = hdr_rt; - pipe.ps.hdr = 1; + draw_rt = colclip_rt; + pipe.ps.colclip_hw = 1; } } @@ -3903,7 +3907,7 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) if (config.require_one_barrier) { // requires a copy of the RT - draw_rt_clone = static_cast(CreateTexture(rtsize.x, rtsize.y, 1, hdr_rt ? GSTexture::Format::HDRColor : GSTexture::Format::Color, true)); + draw_rt_clone = static_cast(CreateTexture(rtsize.x, rtsize.y, 1, colclip_rt ? GSTexture::Format::ColorClip : GSTexture::Format::Color, true)); if (draw_rt_clone) { EndRenderPass(); @@ -3917,19 +3921,19 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) } } - // Switch to hdr target for colclip rendering - if (pipe.ps.hdr) + // Switch to colclip target for colclip hw rendering + if (pipe.ps.colclip_hw) { - if (!hdr_rt) + if (!colclip_rt) { - config.hdr_update_area = config.drawarea; + config.colclip_update_area = config.drawarea; EndRenderPass(); - hdr_rt = static_cast(CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::HDRColor, false)); - if (!hdr_rt) + colclip_rt = static_cast(CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::ColorClip, false)); + if (!colclip_rt) { - Console.WriteLn("D3D12: Failed to allocate HDR render target, aborting draw."); + Console.WriteLn("D3D12: Failed to allocate ColorClip render target, aborting draw."); if (date_image) Recycle(date_image); @@ -3937,17 +3941,17 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) return; } - g_gs_device->SetHDRTexture(static_cast(hdr_rt)); + g_gs_device->SetColorClipTexture(static_cast(colclip_rt)); - // propagate clear value through if the hdr render is the first + // propagate clear value through if the colclip render is the first if (draw_rt->GetState() == GSTexture::State::Cleared) { - hdr_rt->SetState(GSTexture::State::Cleared); - hdr_rt->SetClearColor(draw_rt->GetClearColor()); + colclip_rt->SetState(GSTexture::State::Cleared); + colclip_rt->SetClearColor(draw_rt->GetClearColor()); } else if (draw_rt->GetState() == GSTexture::State::Dirty) { - GL_PUSH_("HDR Render Target Setup"); + GL_PUSH_("ColorClip Render Target Setup"); draw_rt->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); } @@ -3956,7 +3960,7 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) PSSetShaderResource(2, draw_rt, true); } - draw_rt = hdr_rt; + draw_rt = colclip_rt; } // clear texture binding when it's bound to RT or DS @@ -3966,11 +3970,10 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) PSSetShaderResource(0, nullptr, false); } - // avoid restarting the render pass just to switch from rt+depth to rt and vice versa if (m_in_render_pass && (m_current_render_target == draw_rt || m_current_depth_target == draw_ds)) { // avoid restarting the render pass just to switch from rt+depth to rt and vice versa - // keep the depth even if doing HDR draws, because the next draw will probably re-enable depth + // keep the depth even if doing colclip hw draws, because the next draw will probably re-enable depth if (!draw_rt && m_current_render_target && config.tex != m_current_render_target && m_current_render_target->GetSize() == draw_ds->GetSize()) { @@ -3991,9 +3994,9 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) if (!m_in_render_pass) { GSVector4 clear_color = draw_rt ? draw_rt->GetUNormClearColor() : GSVector4::zero(); - if (pipe.ps.hdr) + if (pipe.ps.colclip_hw) { - // Denormalize clear color for HDR. + // Denormalize clear color for hw colclip. clear_color *= GSVector4::cxpr(255.0f / 65535.0f, 255.0f / 65535.0f, 255.0f / 65535.0f, 1.0f); } BeginRenderPass(GetLoadOpForTexture(draw_rt), @@ -4007,13 +4010,13 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) clear_color, draw_ds ? draw_ds->GetClearDepth() : 0.0f, 1); } - // rt -> hdr blit if enabled - if (hdr_rt && (config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve) && config.rt->GetState() == GSTexture::State::Dirty) + // rt -> colclip hw blit if enabled + if (colclip_rt && (config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve) && config.rt->GetState() == GSTexture::State::Dirty) { SetUtilityTexture(static_cast(config.rt), m_point_sampler_cpu); - SetPipeline(m_hdr_setup_pipelines[pipe.ds].get()); + SetPipeline(m_colclip_setup_pipelines[pipe.ds].get()); - const GSVector4 drawareaf = GSVector4((config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); + const GSVector4 drawareaf = GSVector4((config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); const GSVector4 sRect(drawareaf / GSVector4(rtsize.x, rtsize.y).xyxy()); DrawStretchRect(sRect, GSVector4(drawareaf), rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); @@ -4021,9 +4024,9 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) GL_POP(); } - // VB/IB upload, if we did DATE setup and it's not HDR this has already been done + // VB/IB upload, if we did DATE setup and it's not colclip hw this has already been done SetPrimitiveTopology(s_primitive_topology_mapping[static_cast(config.topology)]); - if (!date_image || hdr_rt) + if (!date_image || colclip_rt) UploadHWDrawVerticesAndIndices(config); // now we can do the actual draw @@ -4067,17 +4070,17 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) if (date_image) Recycle(date_image); - // now blit the hdr texture back to the original target - if (hdr_rt) + // now blit the colclip texture back to the original target + if (colclip_rt) { - config.hdr_update_area = config.hdr_update_area.runion(config.drawarea); + config.colclip_update_area = config.colclip_update_area.runion(config.drawarea); - if ((config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve)) + if ((config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve)) { - GL_PUSH("Blit HDR back to RT"); + GL_PUSH("Blit ColorClip back to RT"); EndRenderPass(); - hdr_rt->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + colclip_rt->TransitionToState(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); draw_rt = static_cast(config.rt); OMSetRenderTargets(draw_rt, draw_ds, config.scissor); @@ -4089,14 +4092,14 @@ void GSDevice12::RenderHW(GSHWDrawConfig& config) D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS, D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS, draw_rt->GetUNormClearColor(), 0.0f, 0); - const GSVector4 sRect(GSVector4(config.hdr_update_area) / GSVector4(rtsize.x, rtsize.y).xyxy()); - SetPipeline(m_hdr_finish_pipelines[pipe.ds].get()); - SetUtilityTexture(hdr_rt, m_point_sampler_cpu); - DrawStretchRect(sRect, GSVector4(config.hdr_update_area), rtsize); + const GSVector4 sRect(GSVector4(config.colclip_update_area) / GSVector4(rtsize.x, rtsize.y).xyxy()); + SetPipeline(m_colclip_finish_pipelines[pipe.ds].get()); + SetUtilityTexture(colclip_rt, m_point_sampler_cpu); + DrawStretchRect(sRect, GSVector4(config.colclip_update_area), rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); - g_gs_device->SetHDRTexture(nullptr); + Recycle(colclip_rt); + g_gs_device->SetColorClipTexture(nullptr); } } } diff --git a/pcsx2/GS/Renderers/DX12/GSDevice12.h b/pcsx2/GS/Renderers/DX12/GSDevice12.h index 76af8bc54e..042b79d171 100644 --- a/pcsx2/GS/Renderers/DX12/GSDevice12.h +++ b/pcsx2/GS/Renderers/DX12/GSDevice12.h @@ -315,8 +315,8 @@ private: std::array, 32> m_color_copy{}; std::array, 2> m_merge{}; std::array, NUM_INTERLACE_SHADERS> m_interlace{}; - std::array, 2> m_hdr_setup_pipelines{}; // [depth] - std::array, 2> m_hdr_finish_pipelines{}; // [depth] + std::array, 2> m_colclip_setup_pipelines{}; // [depth] + std::array, 2> m_colclip_finish_pipelines{}; // [depth] std::array, 4>, 2> m_date_image_setup_pipelines{}; // [depth][datm] ComPtr m_fxaa_pipeline; ComPtr m_shadeboost_pipeline; diff --git a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp index 056260f732..7401a2bb29 100644 --- a/pcsx2/GS/Renderers/HW/GSRendererHW.cpp +++ b/pcsx2/GS/Renderers/HW/GSRendererHW.cpp @@ -1135,7 +1135,7 @@ GSVector2i GSRendererHW::GetTargetSize(const GSTextureCache::Source* tex, const return g_texture_cache->GetTargetSize(m_cached_ctx.FRAME.Block(), m_cached_ctx.FRAME.FBW, m_cached_ctx.FRAME.PSM, valid_size.x, valid_size.y, can_expand); } -bool GSRendererHW::NextDrawHDR() const +bool GSRendererHW::NextDrawColClip() const { const int get_next_ctx = (m_state_flush_reason == CONTEXTCHANGE) ? m_env.PRIM.CTXT : m_backed_up_ctx; const GSDrawingContext& next_ctx = m_env.CTXT[get_next_ctx]; @@ -2438,31 +2438,31 @@ void GSRendererHW::Draw() // I hate that I have to do this, but some games (like Pac-Man World Rally) troll us by causing a flush with degenerate triangles, so we don't have all available information about the next draw. // So we have to check when the next draw happens if our frame has changed or if it's become recursive. - const bool has_HDR_texture = g_gs_device->GetHDRTexture() != nullptr; - if (!no_rt && has_HDR_texture && (m_conf.hdr_frame.FBP != m_cached_ctx.FRAME.FBP || m_conf.hdr_frame.Block() == m_cached_ctx.TEX0.TBP0)) + const bool has_colclip_texture = g_gs_device->GetColorClipTexture() != nullptr; + if (!no_rt && has_colclip_texture && (m_conf.colclip_frame.FBP != m_cached_ctx.FRAME.FBP || m_conf.colclip_frame.Block() == m_cached_ctx.TEX0.TBP0)) { GIFRegTEX0 FRAME; - FRAME.TBP0 = m_conf.hdr_frame.Block(); - FRAME.TBW = m_conf.hdr_frame.FBW; - FRAME.PSM = m_conf.hdr_frame.PSM; + FRAME.TBP0 = m_conf.colclip_frame.Block(); + FRAME.TBW = m_conf.colclip_frame.FBW; + FRAME.PSM = m_conf.colclip_frame.PSM; GSTextureCache::Target* old_rt = g_texture_cache->LookupTarget(FRAME, GSVector2i(1, 1), GetTextureScaleFactor(), GSTextureCache::RenderTarget, true, fm, false, false, true, true, GSVector4i(0, 0, 1, 1), true, false, false); if (old_rt) { - GL_CACHE("Pre-draw resolve of HDR! Address: %x", FRAME.TBP0); - GSTexture* hdr_texture = g_gs_device->GetHDRTexture(); - g_gs_device->StretchRect(hdr_texture, GSVector4(m_conf.hdr_update_area) / GSVector4(GSVector4i(hdr_texture->GetSize()).xyxy()), old_rt->m_texture, GSVector4(m_conf.hdr_update_area), - ShaderConvert::HDR_RESOLVE, false); + GL_CACHE("Pre-draw resolve of colclip! Address: %x", FRAME.TBP0); + GSTexture* colclip_texture = g_gs_device->GetColorClipTexture(); + g_gs_device->StretchRect(colclip_texture, GSVector4(m_conf.colclip_update_area) / GSVector4(GSVector4i(colclip_texture->GetSize()).xyxy()), old_rt->m_texture, GSVector4(m_conf.colclip_update_area), + ShaderConvert::COLCLIP_RESOLVE, false); - g_gs_device->Recycle(hdr_texture); + g_gs_device->Recycle(colclip_texture); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); } else - DevCon.Warning("Error resolving HDR texture for pre-draw resolve"); + DevCon.Warning("Error resolving colclip texture for pre-draw resolve"); } const bool draw_sprite_tex = PRIM->TME && (m_vt.m_primclass == GS_SPRITE_CLASS); @@ -4267,12 +4267,12 @@ void GSRendererHW::Draw() if (GSConfig.ShouldDump(s_n, g_perfmon.GetFrame())) { - const bool writeback_HDR_texture = g_gs_device->GetHDRTexture() != nullptr; - if (writeback_HDR_texture) + const bool writeback_colclip_texture = g_gs_device->GetColorClipTexture() != nullptr; + if (writeback_colclip_texture) { - GSTexture* hdr_texture = g_gs_device->GetHDRTexture(); - g_gs_device->StretchRect(hdr_texture, GSVector4(m_conf.hdr_update_area) / GSVector4(GSVector4i(hdr_texture->GetSize()).xyxy()), rt->m_texture, GSVector4(m_conf.hdr_update_area), - ShaderConvert::HDR_RESOLVE, false); + GSTexture* colclip_texture = g_gs_device->GetColorClipTexture(); + g_gs_device->StretchRect(colclip_texture, GSVector4(m_conf.colclip_update_area) / GSVector4(GSVector4i(colclip_texture->GetSize()).xyxy()), rt->m_texture, GSVector4(m_conf.colclip_update_area), + ShaderConvert::COLCLIP_RESOLVE, false); } const u64 frame = g_perfmon.GetFrame(); @@ -5228,10 +5228,10 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Per pixel alpha blending. const bool PABE = m_draw_env->PABE.PABE && GetAlphaMinMax().min < 128; - // HW blend can handle it, no need for sw or hdr colclip, Cd*Alpha or Cd*(1 - Alpha) where Alpha <= 128. + // HW blend can handle it, no need for sw or hw colclip, Cd*Alpha or Cd*(1 - Alpha) where Alpha <= 128. bool color_dest_blend2 = !PABE && ((m_conf.ps.blend_a == 1 && m_conf.ps.blend_b == 2 && m_conf.ps.blend_d == 2) || (m_conf.ps.blend_a == 2 && m_conf.ps.blend_b == 1 && m_conf.ps.blend_d == 1)) && (alpha_eq_less_one || (alpha_c1_eq_less_max_one && new_rt_alpha_scale)); - // HW blend can handle it, no need for sw or hdr colclip, Cs*Alpha + Cd*(1 - Alpha) or Cd*Alpha + Cs*(1 - Alpha) where Alpha <= 128. + // HW blend can handle it, no need for sw or hw colclip, Cs*Alpha + Cd*(1 - Alpha) or Cd*Alpha + Cs*(1 - Alpha) where Alpha <= 128. bool blend_zero_to_one_range = !PABE && ((m_conf.ps.blend_a == 0 && m_conf.ps.blend_b == 1 && m_conf.ps.blend_d == 1) || (blend_flag & BLEND_MIX3)) && (alpha_eq_less_one || (alpha_c1_eq_less_max_one && new_rt_alpha_scale)); @@ -5382,36 +5382,35 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo // Color clip if (COLCLAMP.CLAMP == 0) { - bool has_HDR_texture = g_gs_device->GetHDRTexture() != nullptr; + bool has_colclip_texture = g_gs_device->GetColorClipTexture() != nullptr; - // Don't know any game that resizes the RT mid HDR, but gotta be careful. - if (has_HDR_texture) + // Don't know any game that resizes the RT mid colclip, but gotta be careful. + if (has_colclip_texture) { - GSTexture* hdr_texture = g_gs_device->GetHDRTexture(); + GSTexture* colclip_texture = g_gs_device->GetColorClipTexture(); - if (hdr_texture->GetSize() != rt->m_texture->GetSize()) + if (colclip_texture->GetSize() != rt->m_texture->GetSize()) { + GL_CACHE("Pre-Blend resolve of colclip due to size change! Address: %x", rt->m_TEX0.TBP0); + g_gs_device->StretchRect(colclip_texture, GSVector4(m_conf.colclip_update_area) / GSVector4(GSVector4i(colclip_texture->GetSize()).xyxy()), rt->m_texture, GSVector4(m_conf.colclip_update_area), + ShaderConvert::COLCLIP_RESOLVE, false); - GL_CACHE("Pre-Blend resolve of HDR due to size change! Address: %x", rt->m_TEX0.TBP0); - g_gs_device->StretchRect(hdr_texture, GSVector4(m_conf.hdr_update_area) / GSVector4(GSVector4i(hdr_texture->GetSize()).xyxy()), rt->m_texture, GSVector4(m_conf.hdr_update_area), - ShaderConvert::HDR_RESOLVE, false); + g_gs_device->Recycle(colclip_texture); - g_gs_device->Recycle(hdr_texture); + g_gs_device->SetColorClipTexture(nullptr); - g_gs_device->SetHDRTexture(nullptr); - - has_HDR_texture = false; + has_colclip_texture = false; } } - const bool free_colclip = !has_HDR_texture && (features.framebuffer_fetch || no_prim_overlap || blend_non_recursive); + const bool free_colclip = !has_colclip_texture && (features.framebuffer_fetch || no_prim_overlap || blend_non_recursive); GL_DBG("COLCLIP Info (Blending: %u/%u/%u/%u, OVERLAP: %d)", m_conf.ps.blend_a, m_conf.ps.blend_b, m_conf.ps.blend_c, m_conf.ps.blend_d, m_prim_overlap); if (color_dest_blend || color_dest_blend2 || blend_zero_to_one_range) { // No overflow, disable colclip. GL_INS("COLCLIP mode DISABLED"); sw_blending = false; - m_conf.hdr_mode = (has_HDR_texture && !NextDrawHDR()) ? GSHWDrawConfig::HDRMode::ResolveOnly : GSHWDrawConfig::HDRMode::NoModify; + m_conf.colclip_mode = (has_colclip_texture && !NextDrawColClip()) ? GSHWDrawConfig::ColClipMode::ResolveOnly : GSHWDrawConfig::ColClipMode::NoModify; } else if (free_colclip) { @@ -5419,35 +5418,35 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo GL_INS("COLCLIP Free mode ENABLED"); m_conf.ps.colclip = 1; sw_blending = true; - // Disable the HDR algo + // Disable the colclip hw algo accumulation_blend = false; blend_mix = false; - m_conf.hdr_mode = (has_HDR_texture && !NextDrawHDR()) ? GSHWDrawConfig::HDRMode::ResolveOnly : GSHWDrawConfig::HDRMode::NoModify; + m_conf.colclip_mode = (has_colclip_texture && !NextDrawColClip()) ? GSHWDrawConfig::ColClipMode::ResolveOnly : GSHWDrawConfig::ColClipMode::NoModify; } else if (accumulation_blend) { // A fast algo that requires 2 passes - GL_INS("COLCLIP Fast HDR mode ENABLED"); - m_conf.ps.hdr = 1; - sw_blending = true; // Enable sw blending for the HDR algo + GL_INS("COLCLIP Fast HW mode ENABLED"); + m_conf.ps.colclip_hw = 1; + sw_blending = true; // Enable sw blending for the colclip algo - m_conf.hdr_mode = has_HDR_texture ? (NextDrawHDR() ? GSHWDrawConfig::HDRMode::NoModify : GSHWDrawConfig::HDRMode::ResolveOnly) : (NextDrawHDR() ? GSHWDrawConfig::HDRMode::ConvertOnly : GSHWDrawConfig::HDRMode::ConvertAndResolve); + m_conf.colclip_mode = has_colclip_texture ? (NextDrawColClip() ? GSHWDrawConfig::ColClipMode::NoModify : GSHWDrawConfig::ColClipMode::ResolveOnly) : (NextDrawColClip() ? GSHWDrawConfig::ColClipMode::ConvertOnly : GSHWDrawConfig::ColClipMode::ConvertAndResolve); } else if (sw_blending) { // A slow algo that could requires several passes (barely used) GL_INS("COLCLIP SW mode ENABLED"); m_conf.ps.colclip = 1; - m_conf.hdr_mode = (has_HDR_texture && !NextDrawHDR()) ? GSHWDrawConfig::HDRMode::ResolveOnly : GSHWDrawConfig::HDRMode::NoModify; + m_conf.colclip_mode = (has_colclip_texture && !NextDrawColClip()) ? GSHWDrawConfig::ColClipMode::ResolveOnly : GSHWDrawConfig::ColClipMode::NoModify; } else { - GL_INS("COLCLIP HDR mode ENABLED"); - m_conf.ps.hdr = 1; - m_conf.hdr_mode = has_HDR_texture ? (NextDrawHDR() ? GSHWDrawConfig::HDRMode::NoModify : GSHWDrawConfig::HDRMode::ResolveOnly) : (NextDrawHDR() ? GSHWDrawConfig::HDRMode::ConvertOnly : GSHWDrawConfig::HDRMode::ConvertAndResolve); + GL_INS("COLCLIP HW mode ENABLED"); + m_conf.ps.colclip_hw = 1; + m_conf.colclip_mode = has_colclip_texture ? (NextDrawColClip() ? GSHWDrawConfig::ColClipMode::NoModify : GSHWDrawConfig::ColClipMode::ResolveOnly) : (NextDrawColClip() ? GSHWDrawConfig::ColClipMode::ConvertOnly : GSHWDrawConfig::ColClipMode::ConvertAndResolve); } - m_conf.hdr_frame = m_cached_ctx.FRAME; + m_conf.colclip_frame = m_cached_ctx.FRAME; } // Per pixel alpha blending @@ -5478,13 +5477,13 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo blend_mix = false; m_conf.ps.pabe = 1; - // HDR mode should be disabled when doing sw blend, swap with sw colclip. - if (m_conf.ps.hdr) + // hw colclip mode should be disabled when doing sw blend, swap with sw colclip. + if (m_conf.ps.colclip_hw) { - const bool has_HDR_texture = g_gs_device->GetHDRTexture() != nullptr; - m_conf.ps.hdr = 0; + const bool has_colclip_texture = g_gs_device->GetColorClipTexture() != nullptr; + m_conf.ps.colclip_hw = 0; m_conf.ps.colclip = 1; - m_conf.hdr_mode = has_HDR_texture ? GSHWDrawConfig::HDRMode::EarlyResolve : GSHWDrawConfig::HDRMode::NoModify; + m_conf.colclip_mode = has_colclip_texture ? GSHWDrawConfig::ColClipMode::EarlyResolve : GSHWDrawConfig::ColClipMode::NoModify; } } else @@ -5552,9 +5551,9 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, const boo if (blend.op == GSDevice::OP_REV_SUBTRACT) { pxAssert(m_conf.ps.blend_a == 2); - if (m_conf.ps.hdr) + if (m_conf.ps.colclip_hw) { - // HDR uses unorm, which is always positive + // HW colclip uses unorm, which is always positive // Have the shader do the inversion, then clip to remove the negative m_conf.blend.op = GSDevice::OP_ADD; } @@ -7405,7 +7404,7 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta 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.hdr); + pxAssert(!m_conf.require_full_barrier || !m_conf.ps.colclip_hw); // Swap full barrier for one barrier when there's no overlap, or a texture shuffle. if (m_conf.require_full_barrier && (m_prim_overlap == PRIM_OVERLAP_NO || m_conf.ps.shuffle)) diff --git a/pcsx2/GS/Renderers/HW/GSRendererHW.h b/pcsx2/GS/Renderers/HW/GSRendererHW.h index 047f41a87f..c0b587517f 100644 --- a/pcsx2/GS/Renderers/HW/GSRendererHW.h +++ b/pcsx2/GS/Renderers/HW/GSRendererHW.h @@ -111,7 +111,7 @@ private: void EmulateATST(float& AREF, GSHWDrawConfig::PSSelector& ps, bool pass_2); void SetTCOffset(); - bool NextDrawHDR() const; + bool NextDrawColClip() const; bool IsPossibleChannelShuffle() const; bool IsPageCopy() const; bool NextDrawMatchesShuffle() const; diff --git a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h index 27b39357a8..6e3001fa53 100644 --- a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h +++ b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.h @@ -256,11 +256,9 @@ public: MRCOwned> m_clut_pipeline[2]; MRCOwned> m_stencil_clear_pipeline; MRCOwned> m_primid_init_pipeline[2][4]; - MRCOwned> m_hdr_init_pipeline; - MRCOwned> m_hdr_rta_init_pipeline; - MRCOwned> m_hdr_clear_pipeline; - MRCOwned> m_hdr_resolve_pipeline; - MRCOwned> m_hdr_rta_resolve_pipeline; + MRCOwned> m_colclip_init_pipeline; + MRCOwned> m_colclip_clear_pipeline; + MRCOwned> m_colclip_resolve_pipeline; MRCOwned> m_fxaa_pipeline; MRCOwned> m_shadeboost_pipeline; MRCOwned> m_imgui_pipeline; diff --git a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm index b8e0318378..43badee1f0 100644 --- a/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm +++ b/pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm @@ -510,7 +510,9 @@ static constexpr MTLPixelFormat ConvertPixelFormat(GSTexture::Format format) case GSTexture::Format::UInt16: return MTLPixelFormatR16Uint; case GSTexture::Format::UNorm8: return MTLPixelFormatA8Unorm; case GSTexture::Format::Color: return MTLPixelFormatRGBA8Unorm; - case GSTexture::Format::HDRColor: return MTLPixelFormatRGBA16Unorm; + case GSTexture::Format::ColorHQ: return MTLPixelFormatRGB10A2Unorm; + case GSTexture::Format::ColorHDR: return MTLPixelFormatRGBA16Float; + case GSTexture::Format::ColorClip: return MTLPixelFormatRGBA16Unorm; case GSTexture::Format::DepthStencil: return MTLPixelFormatDepth32Float_Stencil8; case GSTexture::Format::Invalid: return MTLPixelFormatInvalid; case GSTexture::Format::BC1: return MTLPixelFormatBC1_RGBA; @@ -1065,14 +1067,14 @@ bool GSDeviceMTL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle) auto pdesc = [[MTLRenderPipelineDescriptor new] autorelease]; // FS Triangle Pipelines pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::Color); - m_hdr_resolve_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_hdr_resolve"), @"HDR Resolve"); + m_colclip_resolve_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_colclip_resolve"), @"ColorClip Resolve"); m_fxaa_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_fxaa"), @"fxaa"); m_shadeboost_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_shadeboost"), @"shadeboost"); m_clut_pipeline[0] = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_convert_clut_4"), @"4-bit CLUT Update"); m_clut_pipeline[1] = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_convert_clut_8"), @"8-bit CLUT Update"); - pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::HDRColor); - m_hdr_init_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_hdr_init"), @"HDR Init"); - m_hdr_clear_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_clear"), @"HDR Clear"); + pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::ColorClip); + m_colclip_init_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_colclip_init"), @"ColorClip Init"); + m_colclip_clear_pipeline = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_clear"), @"ColorClip Clear"); pdesc.colorAttachments[0].pixelFormat = MTLPixelFormatInvalid; pdesc.stencilAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8; m_datm_pipeline[0] = MakePipeline(pdesc, fs_triangle, LoadShader(@"ps_datm0"), @"datm0"); @@ -1116,8 +1118,8 @@ bool GSDeviceMTL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle) case ShaderConvert::DATM_1_RTA_CORRECTION: case ShaderConvert::CLUT_4: case ShaderConvert::CLUT_8: - case ShaderConvert::HDR_INIT: - case ShaderConvert::HDR_RESOLVE: + case ShaderConvert::COLCLIP_INIT: + case ShaderConvert::COLCLIP_RESOLVE: continue; case ShaderConvert::FLOAT32_TO_32_BITS: pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::UInt32); @@ -1174,7 +1176,7 @@ bool GSDeviceMTL::Create(GSVSyncMode vsync_mode, bool allow_present_throttle) m_present_pipeline[i] = MakePipeline(pdesc, vs_convert, LoadShader(name), [NSString stringWithFormat:@"present_%s", shaderName(conv) + 3]); } - pdesc.colorAttachments[0].pixelFormat = MTLPixelFormatRGBA8Unorm; + pdesc.colorAttachments[0].pixelFormat = ConvertPixelFormat(GSTexture::Format::Color); for (size_t i = 0; i < std::size(m_convert_pipeline_copy_mask); i++) { MTLColorWriteMask mask = MTLColorWriteMaskNone; @@ -1852,7 +1854,7 @@ void GSDeviceMTL::MRESetHWPipelineState(GSHWDrawConfig::VSSelector vssel, GSHWDr setFnConstantI(m_fn_constants, pssel.blend_d, GSMTLConstantIndex_PS_BLEND_D); setFnConstantI(m_fn_constants, pssel.blend_hw, GSMTLConstantIndex_PS_BLEND_HW); setFnConstantB(m_fn_constants, pssel.a_masked, GSMTLConstantIndex_PS_A_MASKED); - setFnConstantB(m_fn_constants, pssel.hdr, GSMTLConstantIndex_PS_HDR); + setFnConstantB(m_fn_constants, pssel.colclip_hw, GSMTLConstantIndex_PS_COLCLIP_HW); setFnConstantB(m_fn_constants, pssel.rta_correction, GSMTLConstantIndex_PS_RTA_CORRECTION); setFnConstantB(m_fn_constants, pssel.rta_source_correction, GSMTLConstantIndex_PS_RTA_SRC_CORRECTION); setFnConstantB(m_fn_constants, pssel.colclip, GSMTLConstantIndex_PS_COLCLIP); @@ -2142,53 +2144,53 @@ void GSDeviceMTL::RenderHW(GSHWDrawConfig& config) GSTexture* stencil = nullptr; GSTexture* primid_tex = nullptr; GSTexture* rt = config.rt; - GSTexture* hdr_rt = g_gs_device->GetHDRTexture(); + GSTexture* colclip_rt = g_gs_device->GetColorClipTexture(); - if (hdr_rt) + if (colclip_rt) { - if (config.hdr_mode == GSHWDrawConfig::HDRMode::EarlyResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::EarlyResolve) { - BeginRenderPass(@"HDR Resolve", config.rt, MTLLoadActionLoad, nullptr, MTLLoadActionDontCare); - RenderCopy(hdr_rt, m_hdr_resolve_pipeline, config.hdr_update_area); + BeginRenderPass(@"ColorClip Resolve", config.rt, MTLLoadActionLoad, nullptr, MTLLoadActionDontCare); + RenderCopy(colclip_rt, m_colclip_resolve_pipeline, config.colclip_update_area); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); - hdr_rt = nullptr; + colclip_rt = nullptr; } else - config.ps.hdr = 1; + config.ps.colclip_hw = 1; } - if (config.ps.hdr) + if (config.ps.colclip_hw) { - if (!hdr_rt) + if (!colclip_rt) { - config.hdr_update_area = config.drawarea; + config.colclip_update_area = config.drawarea; GSVector2i size = config.rt->GetSize(); - rt = hdr_rt = CreateRenderTarget(size.x, size.y, GSTexture::Format::HDRColor, false); + rt = colclip_rt = CreateRenderTarget(size.x, size.y, GSTexture::Format::ColorClip, false); - g_gs_device->SetHDRTexture(hdr_rt); + g_gs_device->SetColorClipTexture(colclip_rt); - const GSVector4i copy_rect = (config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly) ? GSVector4i::loadh(size) : config.drawarea; + const GSVector4i copy_rect = (config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly) ? GSVector4i::loadh(size) : config.drawarea; switch (config.rt->GetState()) { case GSTexture::State::Dirty: - BeginRenderPass(@"HDR Init", hdr_rt, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare); - RenderCopy(config.rt, m_hdr_init_pipeline, copy_rect); + BeginRenderPass(@"ColorClip Init", colclip_rt, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare); + RenderCopy(config.rt, m_colclip_init_pipeline, copy_rect); g_perfmon.Put(GSPerfMon::TextureCopies, 1); break; case GSTexture::State::Cleared: { - BeginRenderPass(@"HDR Clear", hdr_rt, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare); + BeginRenderPass(@"ColorClip Clear", colclip_rt, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare); GSVector4 color = GSVector4::rgba32(config.rt->GetClearColor()) / GSVector4::cxpr(65535, 65535, 65535, 255); [m_current_render.encoder setFragmentBytes:&color length:sizeof(color) atIndex:GSMTLBufferIndexUniforms]; - RenderCopy(nullptr, m_hdr_clear_pipeline, copy_rect); + RenderCopy(nullptr, m_colclip_clear_pipeline, copy_rect); break; } @@ -2197,7 +2199,7 @@ void GSDeviceMTL::RenderHW(GSHWDrawConfig& config) } } - rt = hdr_rt; + rt = colclip_rt; } switch (config.destination_alpha) @@ -2284,19 +2286,19 @@ void GSDeviceMTL::RenderHW(GSHWDrawConfig& config) SendHWDraw(config, mtlenc, index_buffer, index_buffer_offset); } - if (hdr_rt) + if (colclip_rt) { - config.hdr_update_area = config.hdr_update_area.runion(config.drawarea); + config.colclip_update_area = config.colclip_update_area.runion(config.drawarea); - if ((config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve)) + if ((config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve)) { - BeginRenderPass(@"HDR Resolve", config.rt, MTLLoadActionLoad, nullptr, MTLLoadActionDontCare); - RenderCopy(hdr_rt, m_hdr_resolve_pipeline, config.hdr_update_area); + BeginRenderPass(@"ColorClip Resolve", config.rt, MTLLoadActionLoad, nullptr, MTLLoadActionDontCare); + RenderCopy(colclip_rt, m_colclip_resolve_pipeline, config.colclip_update_area); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); } } diff --git a/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h b/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h index 26ccccf393..1773fdc65a 100644 --- a/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h +++ b/pcsx2/GS/Renderers/Metal/GSMTLSharedHeader.h @@ -192,7 +192,7 @@ enum GSMTLFnConstants GSMTLConstantIndex_PS_BLEND_D, GSMTLConstantIndex_PS_BLEND_HW, GSMTLConstantIndex_PS_A_MASKED, - GSMTLConstantIndex_PS_HDR, + GSMTLConstantIndex_PS_COLCLIP_HW, GSMTLConstantIndex_PS_RTA_CORRECTION, GSMTLConstantIndex_PS_RTA_SRC_CORRECTION, GSMTLConstantIndex_PS_COLCLIP, diff --git a/pcsx2/GS/Renderers/Metal/convert.metal b/pcsx2/GS/Renderers/Metal/convert.metal index 6c3aa84356..f2fa5d0491 100644 --- a/pcsx2/GS/Renderers/Metal/convert.metal +++ b/pcsx2/GS/Renderers/Metal/convert.metal @@ -138,13 +138,13 @@ fragment float4 ps_rta_decorrection(ConvertShaderData data [[stage_in]], Convert return float4(in.rgb, in.a * (128.25f / 255.0f)); } -fragment float4 ps_hdr_init(float4 p [[position]], DirectReadTextureIn tex) +fragment float4 ps_colclip_init(float4 p [[position]], DirectReadTextureIn tex) { float4 in = tex.read(p); return float4(round(in.rgb * 255.f) / 65535.f, in.a); } -fragment float4 ps_hdr_resolve(float4 p [[position]], DirectReadTextureIn tex) +fragment float4 ps_colclip_resolve(float4 p [[position]], DirectReadTextureIn tex) { float4 in = tex.read(p); return float4(float3(uint3(in.rgb * 65535.5f) & 255) / 255.f, in.a); diff --git a/pcsx2/GS/Renderers/Metal/tfx.metal b/pcsx2/GS/Renderers/Metal/tfx.metal index 337e0f4b5c..3e364e3558 100644 --- a/pcsx2/GS/Renderers/Metal/tfx.metal +++ b/pcsx2/GS/Renderers/Metal/tfx.metal @@ -47,7 +47,7 @@ constant uint PS_BLEND_C [[function_constant(GSMTLConstantIndex_PS_BL constant uint PS_BLEND_D [[function_constant(GSMTLConstantIndex_PS_BLEND_D)]]; constant uint PS_BLEND_HW [[function_constant(GSMTLConstantIndex_PS_BLEND_HW)]]; constant bool PS_A_MASKED [[function_constant(GSMTLConstantIndex_PS_A_MASKED)]]; -constant bool PS_HDR [[function_constant(GSMTLConstantIndex_PS_HDR)]]; +constant bool PS_COLCLIP_HW [[function_constant(GSMTLConstantIndex_PS_COLCLIP_HW)]]; constant bool PS_RTA_CORRECTION [[function_constant(GSMTLConstantIndex_PS_RTA_CORRECTION)]]; constant bool PS_RTA_SRC_CORRECTION [[function_constant(GSMTLConstantIndex_PS_RTA_SRC_CORRECTION)]]; constant bool PS_COLCLIP [[function_constant(GSMTLConstantIndex_PS_COLCLIP)]]; @@ -858,7 +858,7 @@ struct PSMain { if (PS_FBMASK) { - float multi = PS_HDR ? 65535.0 : 255.5; + float multi = PS_COLCLIP_HW ? 65535.0 : 255.5; C = float4((uint4(int4(C)) & (cb.fbmask ^ 0xff)) | (uint4(current_color * float4(multi, multi, multi, 255)) & cb.fbmask)); } } @@ -898,7 +898,7 @@ struct PSMain C.rgb += 7.f; // Need to round up, not down since the shader will invert // Correct the Color value based on the output format - if (PS_COLCLIP == 0 && PS_HDR == 0) + if (PS_COLCLIP == 0 && PS_COLCLIP_HW == 0) C.rgb = clamp(C.rgb, 0.f, 255.f); // Standard Clamp // FIXME rouding of negative float? @@ -910,7 +910,7 @@ struct PSMain // In 16 bits format, only 5 bits of colors are used. It impacts shadows computation of Castlevania if (PS_DST_FMT == FMT_16 && PS_DITHER != 3 && (PS_BLEND_MIX == 0 || PS_DITHER)) C.rgb = float3(short3(C.rgb) & 0xF8); - else if (PS_COLCLIP == 1 || PS_HDR == 1) + else if (PS_COLCLIP == 1 || PS_COLCLIP_HW == 1) C.rgb = float3(short3(C.rgb) & 0xFF); } else if (PS_DST_FMT == FMT_16 && PS_DITHER != 3 && PS_BLEND_MIX == 0 && PS_BLEND_HW == 0) @@ -963,7 +963,7 @@ struct PSMain current_color.a = float(denorm_rt.g & 0x80); } } - float multi = PS_HDR ? 65535.0 : 255.5; + float multi = PS_COLCLIP_HW ? 65535.0 : 255.5; float3 Cd = trunc(current_color.rgb * multi); float3 Cs = Color.rgb; @@ -1205,7 +1205,7 @@ struct PSMain if (PS_COLOR0) { out.c0.a = PS_RTA_CORRECTION ? C.a / 128.f : C.a / 255.f; - out.c0.rgb = PS_HDR ? float3(C.rgb / 65535.f) : C.rgb / 255.f; + out.c0.rgb = PS_COLCLIP_HW ? float3(C.rgb / 65535.f) : C.rgb / 255.f; if (PS_AFAIL == 3 && !PS_COLOR1 && !atst_pass) // Doing RGB_ONLY without COLOR1 out.c0.a = current_color.a; } diff --git a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp index 8ae9200c95..1775f9caa6 100644 --- a/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp +++ b/pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.cpp @@ -1394,7 +1394,7 @@ std::string GSDeviceOGL::GetPSSource(const PSSelector& sel) + fmt::format("#define PS_READ16_SRC {}\n", sel.real16src) + fmt::format("#define PS_WRITE_RG {}\n", sel.write_rg) + fmt::format("#define PS_FBMASK {}\n", sel.fbmask) - + fmt::format("#define PS_HDR {}\n", sel.hdr) + + fmt::format("#define PS_COLCLIP_HW {}\n", sel.colclip_hw) + fmt::format("#define PS_RTA_CORRECTION {}\n", sel.rta_correction) + fmt::format("#define PS_RTA_SRC_CORRECTION {}\n", sel.rta_source_correction) + fmt::format("#define PS_DITHER {}\n", sel.dither) @@ -2414,43 +2414,43 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) GSVector2i rtsize = (config.rt ? config.rt : config.ds)->GetSize(); GSTexture* primid_texture = nullptr; - GSTexture* hdr_rt = g_gs_device->GetHDRTexture(); + GSTexture* colclip_rt = g_gs_device->GetColorClipTexture(); - if (hdr_rt) + if (colclip_rt) { - if (config.hdr_mode == GSHWDrawConfig::HDRMode::EarlyResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::EarlyResolve) { const GSVector2i size = config.rt->GetSize(); - const GSVector4 dRect(config.hdr_update_area); + const GSVector4 dRect(config.colclip_update_area); const GSVector4 sRect = dRect / GSVector4(size.x, size.y).xyxy(); - StretchRect(hdr_rt, sRect, config.rt, dRect, ShaderConvert::HDR_RESOLVE, false); + StretchRect(colclip_rt, sRect, config.rt, dRect, ShaderConvert::COLCLIP_RESOLVE, false); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); - hdr_rt = nullptr; + colclip_rt = nullptr; } else { - config.ps.hdr = 1; + config.ps.colclip_hw = 1; } } - if (config.ps.hdr) + if (config.ps.colclip_hw) { - if (!hdr_rt) + if (!colclip_rt) { - config.hdr_update_area = config.drawarea; + config.colclip_update_area = config.drawarea; - hdr_rt = CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::HDRColor, false); - OMSetRenderTargets(hdr_rt, config.ds, nullptr); + colclip_rt = CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::ColorClip, false); + OMSetRenderTargets(colclip_rt, config.ds, nullptr); - g_gs_device->SetHDRTexture(hdr_rt); + g_gs_device->SetColorClipTexture(colclip_rt); - const GSVector4 dRect = GSVector4((config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); + const GSVector4 dRect = GSVector4((config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); const GSVector4 sRect = dRect / GSVector4(rtsize.x, rtsize.y).xyxy(); - StretchRect(config.rt, sRect, hdr_rt, dRect, ShaderConvert::HDR_INIT, false); + StretchRect(config.rt, sRect, colclip_rt, dRect, ShaderConvert::COLCLIP_INIT, false); } } @@ -2461,7 +2461,7 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) case GSHWDrawConfig::DestinationAlphaMode::Full: break; // No setup case GSHWDrawConfig::DestinationAlphaMode::PrimIDTracking: - primid_texture = InitPrimDateTexture(hdr_rt ? hdr_rt : config.rt, config.drawarea, config.datm); + primid_texture = InitPrimDateTexture(colclip_rt ? colclip_rt : config.rt, config.drawarea, config.datm); break; case GSHWDrawConfig::DestinationAlphaMode::StencilOne: if (m_features.texture_barrier) @@ -2481,7 +2481,7 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) {GSVector4(dst.x, dst.w, 0.0f, 0.0f), GSVector2(src.x, src.w)}, {GSVector4(dst.z, dst.w, 0.0f, 0.0f), GSVector2(src.z, src.w)}, }; - SetupDATE(hdr_rt ? hdr_rt : config.rt, config.ds, vertices, config.datm); + SetupDATE(colclip_rt ? colclip_rt : config.rt, config.ds, vertices, config.datm); } } @@ -2490,11 +2490,11 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) if (config.require_one_barrier && !m_features.texture_barrier) { // Requires a copy of the RT - draw_rt_clone = CreateTexture(rtsize.x, rtsize.y, 1, hdr_rt ? GSTexture::Format::HDRColor : GSTexture::Format::Color, true); + draw_rt_clone = CreateTexture(rtsize.x, rtsize.y, 1, colclip_rt ? GSTexture::Format::ColorClip : GSTexture::Format::Color, true); GL_PUSH("Copy RT to temp texture for fbmask {%d,%d %dx%d}", config.drawarea.left, config.drawarea.top, config.drawarea.width(), config.drawarea.height()); - CopyRect(hdr_rt ? hdr_rt : config.rt, draw_rt_clone, config.drawarea, config.drawarea.left, config.drawarea.top); + CopyRect(colclip_rt ? colclip_rt : config.rt, draw_rt_clone, config.drawarea, config.drawarea.left, config.drawarea.top); } IASetVertexBuffer(config.verts, config.nverts); @@ -2534,7 +2534,7 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) if (draw_rt_clone) PSSetShaderResource(2, draw_rt_clone); else if (config.require_one_barrier || config.require_full_barrier) - PSSetShaderResource(2, hdr_rt ? hdr_rt : config.rt); + PSSetShaderResource(2, colclip_rt ? colclip_rt : config.rt); SetupSampler(config.sampler); @@ -2622,7 +2622,7 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) } // avoid changing framebuffer just to switch from rt+depth to rt and vice versa - GSTexture* draw_rt = hdr_rt ? hdr_rt : config.rt; + GSTexture* draw_rt = colclip_rt ? colclip_rt : config.rt; GSTexture* draw_ds = config.ds; if (!draw_rt && GLState::rt && GLState::ds == draw_ds && config.tex != GLState::rt && GLState::rt->GetSize() == draw_ds->GetSize()) @@ -2700,20 +2700,20 @@ void GSDeviceOGL::RenderHW(GSHWDrawConfig& config) if (draw_rt_clone) Recycle(draw_rt_clone); - if (hdr_rt) + if (colclip_rt) { - config.hdr_update_area = config.hdr_update_area.runion(config.drawarea); + config.colclip_update_area = config.colclip_update_area.runion(config.drawarea); - if ((config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve)) + if ((config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve)) { const GSVector2i size = config.rt->GetSize(); - const GSVector4 dRect(config.hdr_update_area); + const GSVector4 dRect(config.colclip_update_area); const GSVector4 sRect = dRect / GSVector4(size.x, size.y).xyxy(); - StretchRect(hdr_rt, sRect, config.rt, dRect, ShaderConvert::HDR_RESOLVE, false); + StretchRect(colclip_rt, sRect, config.rt, dRect, ShaderConvert::COLCLIP_RESOLVE, false); - Recycle(hdr_rt); + Recycle(colclip_rt); - g_gs_device->SetHDRTexture(nullptr); + g_gs_device->SetColorClipTexture(nullptr); } } } diff --git a/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp b/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp index 238ad16ea8..9f0e9b00ee 100644 --- a/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp +++ b/pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp @@ -65,6 +65,8 @@ GSTextureOGL::GSTextureOGL(Type type, int width, int height, int levels, Format // 4 channel normalized case Format::Color: + case Format::ColorHQ: + case Format::ColorHDR: gl_fmt = GL_RGBA8; m_int_format = GL_RGBA; m_int_type = GL_UNSIGNED_BYTE; @@ -72,7 +74,7 @@ GSTextureOGL::GSTextureOGL(Type type, int width, int height, int levels, Format break; // 4 channel float - case Format::HDRColor: + case Format::ColorClip: gl_fmt = GL_RGBA16; m_int_format = GL_RGBA; m_int_type = GL_UNSIGNED_SHORT; diff --git a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp index d82df886f6..0f997951ce 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp +++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.cpp @@ -2715,10 +2715,12 @@ void GSDeviceVK::DrawIndexedPrimitive(int offset, int count) VkFormat GSDeviceVK::LookupNativeFormat(GSTexture::Format format) const { - static constexpr std::array(GSTexture::Format::BC7) + 1> s_format_mapping = {{ + static constexpr std::array(GSTexture::Format::Last) + 1> s_format_mapping = {{ VK_FORMAT_UNDEFINED, // Invalid VK_FORMAT_R8G8B8A8_UNORM, // Color - VK_FORMAT_R16G16B16A16_UNORM, // HDRColor + VK_FORMAT_A2B10G10R10_UNORM_PACK32, // ColorHQ + VK_FORMAT_R16G16B16A16_SFLOAT, // ColorHDR + VK_FORMAT_R16G16B16A16_UNORM, // ColorClip VK_FORMAT_D32_SFLOAT_S8_UINT, // DepthStencil VK_FORMAT_R8_UNORM, // UNorm8 VK_FORMAT_R16_UINT, // UInt16 @@ -3820,14 +3822,14 @@ bool GSDeviceVK::CreateRenderPasses() } while (0) const VkFormat rt_format = LookupNativeFormat(GSTexture::Format::Color); - const VkFormat hdr_rt_format = LookupNativeFormat(GSTexture::Format::HDRColor); + const VkFormat colclip_rt_format = LookupNativeFormat(GSTexture::Format::ColorClip); const VkFormat depth_format = LookupNativeFormat(GSTexture::Format::DepthStencil); for (u32 rt = 0; rt < 2; rt++) { for (u32 ds = 0; ds < 2; ds++) { - for (u32 hdr = 0; hdr < 2; hdr++) + for (u32 colclip = 0; colclip < 2; colclip++) { for (u32 stencil = 0; stencil < 2; stencil++) { @@ -3841,12 +3843,12 @@ bool GSDeviceVK::CreateRenderPasses() opb++) { const VkFormat rp_rt_format = - (rt != 0) ? ((hdr != 0) ? hdr_rt_format : rt_format) : VK_FORMAT_UNDEFINED; + (rt != 0) ? ((colclip != 0) ? colclip_rt_format : rt_format) : VK_FORMAT_UNDEFINED; const VkFormat rp_depth_format = (ds != 0) ? depth_format : VK_FORMAT_UNDEFINED; const VkAttachmentLoadOp opc = (!stencil || !m_features.stencil_buffer) ? VK_ATTACHMENT_LOAD_OP_DONT_CARE : VK_ATTACHMENT_LOAD_OP_LOAD; - GET(m_tfx_render_pass[rt][ds][hdr][stencil][fbl][dsp][opa][opb], rp_rt_format, + GET(m_tfx_render_pass[rt][ds][colclip][stencil][fbl][dsp][opa][opb], rp_rt_format, rp_depth_format, (fbl != 0), (dsp != 0), static_cast(opa), static_cast(opb), static_cast(opc)); } @@ -4023,10 +4025,10 @@ bool GSDeviceVK::CompileConvertPipelines() (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u); } } - else if (i == ShaderConvert::HDR_INIT || i == ShaderConvert::HDR_RESOLVE) + else if (i == ShaderConvert::COLCLIP_INIT || i == ShaderConvert::COLCLIP_RESOLVE) { - const bool is_setup = i == ShaderConvert::HDR_INIT; - VkPipeline(&arr)[2][2] = *(is_setup ? &m_hdr_setup_pipelines : &m_hdr_finish_pipelines); + const bool is_setup = i == ShaderConvert::COLCLIP_INIT; + VkPipeline(&arr)[2][2] = *(is_setup ? &m_colclip_setup_pipelines : &m_colclip_finish_pipelines); for (u32 ds = 0; ds < 2; ds++) { for (u32 fbl = 0; fbl < 2; fbl++) @@ -4040,7 +4042,7 @@ bool GSDeviceVK::CompileConvertPipelines() if (!arr[ds][fbl]) return false; - Vulkan::SetObjectName(m_device, arr[ds][fbl], "HDR %s/copy pipeline (ds=%u, fbl=%u)", + Vulkan::SetObjectName(m_device, arr[ds][fbl], "ColorClip %s/copy pipeline (ds=%u, fbl=%u)", is_setup ? "setup" : "finish", i, ds, fbl); } } @@ -4610,10 +4612,10 @@ void GSDeviceVK::DestroyResources() { for (u32 fbl = 0; fbl < 2; fbl++) { - if (m_hdr_setup_pipelines[ds][fbl] != VK_NULL_HANDLE) - vkDestroyPipeline(m_device, m_hdr_setup_pipelines[ds][fbl], nullptr); - if (m_hdr_finish_pipelines[ds][fbl] != VK_NULL_HANDLE) - vkDestroyPipeline(m_device, m_hdr_finish_pipelines[ds][fbl], nullptr); + if (m_colclip_setup_pipelines[ds][fbl] != VK_NULL_HANDLE) + vkDestroyPipeline(m_device, m_colclip_setup_pipelines[ds][fbl], nullptr); + if (m_colclip_finish_pipelines[ds][fbl] != VK_NULL_HANDLE) + vkDestroyPipeline(m_device, m_colclip_finish_pipelines[ds][fbl], nullptr); } } for (u32 ds = 0; ds < 2; ds++) @@ -4782,7 +4784,7 @@ VkShaderModule GSDeviceVK::GetTFXFragmentShader(const GSHWDrawConfig::PSSelector AddMacro(ss, "PS_READ16_SRC", sel.real16src); AddMacro(ss, "PS_WRITE_RG", sel.write_rg); AddMacro(ss, "PS_FBMASK", sel.fbmask); - AddMacro(ss, "PS_HDR", sel.hdr); + AddMacro(ss, "PS_COLCLIP_HW", sel.colclip_hw); AddMacro(ss, "PS_RTA_CORRECTION", sel.rta_correction); AddMacro(ss, "PS_RTA_SRC_CORRECTION", sel.rta_source_correction); AddMacro(ss, "PS_DITHER", sel.dither); @@ -4838,7 +4840,7 @@ VkPipeline GSDeviceVK::CreateTFXPipeline(const PipelineSelector& p) else { gpb.SetRenderPass( - GetTFXRenderPass(p.rt, p.ds, p.ps.hdr, p.dss.date, + GetTFXRenderPass(p.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 ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_DONT_CARE), @@ -5595,7 +5597,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) GSTextureVK* draw_rt = static_cast(config.rt); GSTextureVK* draw_ds = static_cast(config.ds); GSTextureVK* draw_rt_clone = nullptr; - GSTextureVK* hdr_rt = static_cast(g_gs_device->GetHDRTexture()); + GSTextureVK* colclip_rt = static_cast(g_gs_device->GetColorClipTexture()); // stream buffer in first, in case we need to exec SetVSConstantBuffer(config.cb_vs); @@ -5621,11 +5623,11 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) GSTextureVK* date_image = nullptr; if (config.destination_alpha == GSHWDrawConfig::DestinationAlphaMode::PrimIDTracking) { - // If we have a HDR in progress, we need to use the HDR texture, but we can't check this later as there's a chicken/egg problem with the pipe setup. + // If we have a colclip in progress, we need to use the colclip texture, but we can't check this later as there's a chicken/egg problem with the pipe setup. GSTexture* backup_rt = config.rt; - if(hdr_rt) - config.rt = hdr_rt; + if(colclip_rt) + config.rt = colclip_rt; date_image = SetupPrimitiveTrackingDATE(config); if (!date_image) @@ -5645,15 +5647,15 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (InRenderPass() && !pipe.IsRTFeedbackLoop() && (config.tex == m_current_render_target || config.tex == m_current_depth_target)) EndRenderPass(); - // now blit the hdr texture back to the original target - if (hdr_rt) + // now blit the colclip texture back to the original target + if (colclip_rt) { - if (config.hdr_mode == GSHWDrawConfig::HDRMode::EarlyResolve) + if (config.colclip_mode == GSHWDrawConfig::ColClipMode::EarlyResolve) { - GL_PUSH("Blit HDR back to RT"); + GL_PUSH("Blit ColorClip back to RT"); EndRenderPass(); - hdr_rt->TransitionToLayout(GSTextureVK::Layout::ShaderReadOnly); + colclip_rt->TransitionToLayout(GSTextureVK::Layout::ShaderReadOnly); draw_rt = static_cast(config.rt); OMSetRenderTargets(draw_rt, draw_ds, GSVector4i::loadh(rtsize), static_cast(pipe.feedback_loop_flags)); @@ -5681,22 +5683,22 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) draw_rt->GetRect()); } - const GSVector4 drawareaf = GSVector4(config.hdr_update_area); + const GSVector4 drawareaf = GSVector4(config.colclip_update_area); const GSVector4 sRect(drawareaf / GSVector4(rtsize).xyxy()); - SetPipeline(m_hdr_finish_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); - SetUtilityTexture(hdr_rt, m_point_sampler); + SetPipeline(m_colclip_finish_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); + SetUtilityTexture(colclip_rt, m_point_sampler); DrawStretchRect(sRect, drawareaf, rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); - g_gs_device->SetHDRTexture(nullptr); + Recycle(colclip_rt); + g_gs_device->SetColorClipTexture(nullptr); - hdr_rt = nullptr; + colclip_rt = nullptr; } else { - pipe.ps.hdr = 1; - draw_rt = hdr_rt; + pipe.ps.colclip_hw = 1; + draw_rt = colclip_rt; } } @@ -5726,7 +5728,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (config.require_one_barrier && !m_features.texture_barrier) { // requires a copy of the RT - draw_rt_clone = static_cast(CreateTexture(rtsize.x, rtsize.y, 1, hdr_rt ? GSTexture::Format::HDRColor : GSTexture::Format::Color, true)); + draw_rt_clone = static_cast(CreateTexture(rtsize.x, rtsize.y, 1, colclip_rt ? GSTexture::Format::ColorClip : GSTexture::Format::Color, true)); if (draw_rt_clone) { EndRenderPass(); @@ -5739,17 +5741,17 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) } } - // Switch to hdr target for colclip rendering - if (pipe.ps.hdr) + // Switch to colclip target for colclip hw rendering + if (pipe.ps.colclip_hw) { - if (!hdr_rt) + if (!colclip_rt) { - config.hdr_update_area = config.drawarea; + config.colclip_update_area = config.drawarea; EndRenderPass(); - hdr_rt = static_cast(CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::HDRColor, false)); - if (!hdr_rt) + colclip_rt = static_cast(CreateRenderTarget(rtsize.x, rtsize.y, GSTexture::Format::ColorClip, false)); + if (!colclip_rt) { - Console.WriteLn("Failed to allocate HDR render target, aborting draw."); + Console.WriteLn("Failed to allocate ColorClip render target, aborting draw."); if (date_image) Recycle(date_image); @@ -5757,13 +5759,13 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) GL_POP(); return; } - g_gs_device->SetHDRTexture(static_cast(hdr_rt)); + g_gs_device->SetColorClipTexture(static_cast(colclip_rt)); - // propagate clear value through if the hdr render is the first + // propagate clear value through if the colclip render is the first if (draw_rt->GetState() == GSTexture::State::Cleared) { - hdr_rt->SetState(GSTexture::State::Cleared); - hdr_rt->SetClearColor(draw_rt->GetClearColor()); + colclip_rt->SetState(GSTexture::State::Cleared); + colclip_rt->SetClearColor(draw_rt->GetClearColor()); // If depth is cleared, we need to commit it, because we're only going to draw to the active part of the FB. if (draw_ds && draw_ds->GetState() == GSTexture::State::Cleared && !config.drawarea.eq(GSVector4i::loadh(rtsize))) @@ -5771,7 +5773,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) } else if (draw_rt->GetState() == GSTexture::State::Dirty) { - GL_PUSH_("HDR Render Target Setup"); + GL_PUSH_("ColorClip Render Target Setup"); draw_rt->TransitionToLayout(GSTextureVK::Layout::ShaderReadOnly); } @@ -5779,7 +5781,7 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (config.require_one_barrier && !m_features.texture_barrier) PSSetShaderResource(2, draw_rt, true); } - draw_rt = hdr_rt; + draw_rt = colclip_rt; } // clear texture binding when it's bound to RT or DS. @@ -5790,15 +5792,15 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) } // render pass restart optimizations - if (hdr_rt && (config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly)) + if (colclip_rt && (config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly)) { - // HDR requires blitting. + // colclip hw requires blitting. EndRenderPass(); } else if (InRenderPass() && (m_current_render_target == draw_rt || m_current_depth_target == draw_ds)) { // avoid restarting the render pass just to switch from rt+depth to rt and vice versa - // keep the depth even if doing HDR draws, because the next draw will probably re-enable depth + // keep the depth even if doing colclip hw draws, because the next draw will probably re-enable depth if (!draw_rt && m_current_render_target && config.tex != m_current_render_target && m_current_render_target->GetSize() == draw_ds->GetSize()) { @@ -5817,15 +5819,15 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) } // We don't need the very first barrier if this is the first draw after switching to feedback loop, - // because the layout change in itself enforces the execution dependency. HDR needs a barrier between - // setup and the first draw to read it. TODO: Make HDR use subpasses instead. + // because the layout change in itself enforces the execution dependency. colclip hw needs a barrier between + // setup and the first draw to read it. TODO: Make colclip hw use subpasses instead. // However, it turns out *not* doing this causes GPU resets on RDNA3, specifically Windows drivers. // Despite the layout changing enforcing the execution dependency between previous draws and the first // input attachment read, it still wants the region/fragment-local barrier... const bool skip_first_barrier = - (draw_rt && draw_rt->GetLayout() != GSTextureVK::Layout::FeedbackLoop && !pipe.ps.hdr && !IsDeviceAMD()); + (draw_rt && draw_rt->GetLayout() != GSTextureVK::Layout::FeedbackLoop && !pipe.ps.colclip_hw && !IsDeviceAMD()); OMSetRenderTargets(draw_rt, draw_ds, config.scissor, static_cast(pipe.feedback_loop_flags)); if (pipe.IsRTFeedbackLoop()) @@ -5843,14 +5845,14 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) { const VkAttachmentLoadOp rt_op = GetLoadOpForTexture(draw_rt); const VkAttachmentLoadOp ds_op = GetLoadOpForTexture(draw_ds); - const VkRenderPass rp = GetTFXRenderPass(pipe.rt, pipe.ds, pipe.ps.hdr, + const VkRenderPass rp = GetTFXRenderPass(pipe.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); - // Only draw to the active area of the HDR target. Except when depth is cleared, we need to use the full + // 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. - const GSVector4i render_area = (pipe.ps.hdr && (config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve) && ds_op != VK_ATTACHMENT_LOAD_OP_CLEAR) ? config.drawarea : + const GSVector4i render_area = (pipe.ps.colclip_hw && (config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve) && ds_op != VK_ATTACHMENT_LOAD_OP_CLEAR) ? config.drawarea : GSVector4i::loadh(rtsize); if (is_clearing_rt) @@ -5861,9 +5863,9 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (draw_rt) { GSVector4 clear_color = draw_rt->GetUNormClearColor(); - if (pipe.ps.hdr) + if (pipe.ps.colclip_hw) { - // Denormalize clear color for HDR. + // Denormalize clear color for hw colclip. clear_color *= GSVector4::cxpr(255.0f / 65535.0f, 255.0f / 65535.0f, 255.0f / 65535.0f, 1.0f); } GSVector4::store(&cvs[cv_count++].color, clear_color); @@ -5888,14 +5890,14 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) vkCmdClearAttachments(m_current_command_buffer, 1, &ca, 1, &rc); } - // rt -> hdr blit if enabled - if (hdr_rt && (config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve) && config.rt->GetState() == GSTexture::State::Dirty) + // rt -> colclip hw blit if enabled + if (colclip_rt && (config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve) && config.rt->GetState() == GSTexture::State::Dirty) { OMSetRenderTargets(draw_rt, draw_ds, GSVector4i::loadh(rtsize), static_cast(pipe.feedback_loop_flags)); SetUtilityTexture(static_cast(config.rt), m_point_sampler); - SetPipeline(m_hdr_setup_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); + SetPipeline(m_colclip_setup_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); - const GSVector4 drawareaf = GSVector4((config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); + const GSVector4 drawareaf = GSVector4((config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertOnly) ? GSVector4i::loadh(rtsize) : config.drawarea); const GSVector4 sRect(drawareaf / GSVector4(rtsize).xyxy()); DrawStretchRect(sRect, drawareaf, rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); @@ -5904,8 +5906,8 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) OMSetRenderTargets(draw_rt, draw_ds, config.scissor, static_cast(pipe.feedback_loop_flags)); } - // VB/IB upload, if we did DATE setup and it's not HDR this has already been done - if (!date_image || hdr_rt) + // VB/IB upload, if we did DATE setup and it's not colclip hw this has already been done + if (!date_image || colclip_rt) UploadHWDrawVerticesAndIndices(config); // now we can do the actual draw @@ -5955,21 +5957,21 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) if (date_image) Recycle(date_image); - // now blit the hdr texture back to the original target - if (hdr_rt) + // now blit the colclip texture back to the original target + if (colclip_rt) { - config.hdr_update_area = config.hdr_update_area.runion(config.drawarea); + config.colclip_update_area = config.colclip_update_area.runion(config.drawarea); - if ((config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly || config.hdr_mode == GSHWDrawConfig::HDRMode::ConvertAndResolve)) + if ((config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly || config.colclip_mode == GSHWDrawConfig::ColClipMode::ConvertAndResolve)) { - GL_PUSH("Blit HDR back to RT"); + GL_PUSH("Blit ColorClip back to RT"); EndRenderPass(); - hdr_rt->TransitionToLayout(GSTextureVK::Layout::ShaderReadOnly); + colclip_rt->TransitionToLayout(GSTextureVK::Layout::ShaderReadOnly); draw_rt = static_cast(config.rt); - OMSetRenderTargets(draw_rt, draw_ds, (config.hdr_mode == GSHWDrawConfig::HDRMode::ResolveOnly) ? GSVector4i::loadh(rtsize) : config.scissor, static_cast(pipe.feedback_loop_flags)); + OMSetRenderTargets(draw_rt, draw_ds, (config.colclip_mode == GSHWDrawConfig::ColClipMode::ResolveOnly) ? GSVector4i::loadh(rtsize) : config.scissor, static_cast(pipe.feedback_loop_flags)); // if this target was cleared and never drawn to, perform the clear as part of the resolve here. if (draw_rt->GetState() == GSTexture::State::Cleared) @@ -5994,19 +5996,19 @@ void GSDeviceVK::RenderHW(GSHWDrawConfig& config) draw_rt->GetRect()); } - const GSVector4 drawareaf = GSVector4(config.hdr_update_area); + const GSVector4 drawareaf = GSVector4(config.colclip_update_area); const GSVector4 sRect(drawareaf / GSVector4(rtsize).xyxy()); - SetPipeline(m_hdr_finish_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); - SetUtilityTexture(hdr_rt, m_point_sampler); + SetPipeline(m_colclip_finish_pipelines[pipe.ds][pipe.IsRTFeedbackLoop()]); + SetUtilityTexture(colclip_rt, m_point_sampler); DrawStretchRect(sRect, drawareaf, rtsize); g_perfmon.Put(GSPerfMon::TextureCopies, 1); - Recycle(hdr_rt); - g_gs_device->SetHDRTexture(nullptr); + Recycle(colclip_rt); + g_gs_device->SetColorClipTexture(nullptr); } } - config.hdr_mode = GSHWDrawConfig::HDRMode::NoModify; + config.colclip_mode = GSHWDrawConfig::ColClipMode::NoModify; } void GSDeviceVK::UpdateHWPipelineSelector(GSHWDrawConfig& config, PipelineSelector& pipe) diff --git a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h index 153d075a25..975b45f167 100644 --- a/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h +++ b/pcsx2/GS/Renderers/Vulkan/GSDeviceVK.h @@ -394,8 +394,8 @@ private: std::array m_color_copy{}; std::array m_merge{}; std::array m_interlace{}; - VkPipeline m_hdr_setup_pipelines[2][2] = {}; // [depth][feedback_loop] - VkPipeline m_hdr_finish_pipelines[2][2] = {}; // [depth][feedback_loop] + VkPipeline m_colclip_setup_pipelines[2][2] = {}; // [depth][feedback_loop] + VkPipeline m_colclip_finish_pipelines[2][2] = {}; // [depth][feedback_loop] VkRenderPass m_date_image_setup_render_passes[2][2] = {}; // [depth][clear] VkPipeline m_date_image_setup_pipelines[2][4] = {}; // [depth][datm] VkPipeline m_fxaa_pipeline = {}; @@ -415,7 +415,7 @@ private: VkRenderPass m_date_setup_render_pass = VK_NULL_HANDLE; VkRenderPass m_swap_chain_render_pass = VK_NULL_HANDLE; - VkRenderPass m_tfx_render_pass[2][2][2][3][2][2][3][3] = {}; // [rt][ds][hdr][date][fbl][dsp][rt_op][ds_op] + VkRenderPass m_tfx_render_pass[2][2][2][3][2][2][3][3] = {}; // [rt][ds][colclip][date][fbl][dsp][rt_op][ds_op] VkDescriptorSetLayout m_cas_ds_layout = VK_NULL_HANDLE; VkPipelineLayout m_cas_pipeline_layout = VK_NULL_HANDLE; @@ -486,10 +486,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 hdr, bool stencil, bool fbl, bool dsp, + __fi VkRenderPass GetTFXRenderPass(bool rt, bool ds, bool colclip, bool stencil, bool fbl, bool dsp, VkAttachmentLoadOp rt_op, VkAttachmentLoadOp ds_op) const { - return m_tfx_render_pass[rt][ds][hdr][stencil][fbl][dsp][rt_op][ds_op]; + return m_tfx_render_pass[rt][ds][colclip][stencil][fbl][dsp][rt_op][ds_op]; } __fi VkSampler GetPointSampler() const { return m_point_sampler; } __fi VkSampler GetLinearSampler() const { return m_linear_sampler; } diff --git a/pcsx2/ShaderCacheVersion.h b/pcsx2/ShaderCacheVersion.h index 6e66cc63cb..75899116da 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 = 62; +static constexpr u32 SHADER_CACHE_VERSION = 63;