GS/DX12/GL: Implement depth feedback with temp color target.

Author: TJnotJT

bin/resources/shaders/dx11/convert.fx

@@ -214,6 +214,16 @@ float rgb5a1_to_depth16(float4 val)
 	return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-32.0f);
 }
 
+float ps_convert_float32_depth_to_color(PS_INPUT input) : SV_Target0
+{
+	return sample_c(input.t).r;
+}
+
+float ps_convert_float32_color_to_depth(PS_INPUT input) : SV_Depth
+{
+	return sample_c(input.t).r;
+}
+
 float ps_convert_float32_float24(PS_INPUT input) : SV_Depth
 {
 	// Truncates depth value to 24bits

bin/resources/shaders/dx11/tfx.fx

@@ -153,19 +153,31 @@ struct PS_INPUT
 
 struct PS_OUTPUT
 {
+#define NUM_RTS 0
 #if !PS_NO_COLOR
 #if PS_DATE == 1 || PS_DATE == 2
 	float c : SV_Target;
 #else
 	float4 c0 : SV_Target0;
+	#undef NUM_RTS
+	#define NUM_RTS 1
 #if !PS_NO_COLOR1
 	float4 c1 : SV_Target1;
 #endif
 #endif
 #endif
 #if PS_ZCLAMP
-	float depth : SV_Depth;
+	#if PS_DEPTH_FEEDBACK && PS_NO_COLOR1 && DX12
+		#if NUM_RTS > 0
+			float depth : SV_Target1;
+		#else
+			float depth : SV_Target0;
+		#endif
+	#else
+		float depth : SV_Depth;
+	#endif
 #endif
+#undef NUM_RTS
 };
 
 Texture2D<float4> Texture : register(t0);
@@ -1043,7 +1055,6 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
 
 PS_OUTPUT ps_main(PS_INPUT input)
 {
-
 #if PS_DEPTH_FEEDBACK && (PS_ZTST == ZTST_GEQUAL || PS_ZTST == ZTST_GREATER)
 	#if PS_ZTST == ZTST_GEQUAL
 		if (input.p.z < DepthTexture.Load(int3(input.p.xy, 0)).r)
@@ -1257,7 +1268,7 @@ PS_OUTPUT ps_main(PS_INPUT input)
 #endif // PS_DATE != 1/2
 
 #if PS_ZCLAMP
-	output.depth = min(input.p.z, MaxDepthPS);
+	output.depth = min(input.p.z, MaxDepthPS);	
 #endif
 
 	return output;

bin/resources/shaders/opengl/convert.glsl

@@ -43,6 +43,8 @@ layout(binding = 0) uniform sampler2D TextureSampler;
 // Give a different name so I remember there is a special case!
 #if defined(ps_convert_rgba8_16bits) || defined(ps_convert_float32_32bits)
 layout(location = 0) out uint SV_Target1;
+#elif defined(ps_convert_float32_depth_to_color)
+layout(location = 0) out float SV_Target0;
 #else
 layout(location = 0) out vec4 SV_Target0;
 #endif
@@ -145,6 +147,20 @@ float rgb5a1_to_depth16(vec4 unorm)
 	return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-32.0f);
 }
 
+#ifdef ps_convert_float32_depth_to_color
+void ps_convert_float32_depth_to_color()
+{
+	SV_Target0 = sample_c().r;
+}
+#endif
+
+#ifdef ps_convert_float32_color_to_depth
+void ps_convert_float32_color_to_depth()
+{
+	gl_FragDepth = sample_c().r;
+}
+#endif
+
 #ifdef ps_convert_float32_float24
 void ps_convert_float32_float24()
 {

bin/resources/shaders/opengl/tfx_fs.glsl

@@ -121,6 +121,14 @@ in SHADER
 	layout(location = 0) TARGET_0_QUALIFIER vec4 SV_Target0;
 #endif
 
+#if NEEDS_DEPTH && PS_NO_COLOR1
+#if HAS_FRAMEBUFFER_FETCH
+	layout(location = 1, index = 0) inout float SV_Target1;
+#else
+	layout(location = 1, index = 0) out float SV_Target1;
+#endif
+#endif
+
 #if NEEDS_TEX
 layout(binding = 0) uniform sampler2D TextureSampler;
 layout(binding = 1) uniform sampler2D PaletteSampler;
@@ -134,7 +142,7 @@ layout(binding = 2) uniform sampler2D RtSampler; // note 2 already use by the im
 layout(binding = 3) uniform sampler2D img_prim_min;
 #endif
 
-#if NEEDS_DEPTH
+#if !HAS_FRAMEBUFFER_FETCH && NEEDS_DEPTH
 layout(binding = 4) uniform sampler2D DepthSampler;
 #endif
 
@@ -153,6 +161,8 @@ vec4 sample_from_depth()
 {
 #if !NEEDS_DEPTH
 	return vec4(0.0);
+#elif HAS_FRAMEBUFFER_FETCH
+	return SV_Target1;
 #else
 	return texelFetch(DepthSampler, ivec2(FragCoord.xy), 0);
 #endif
@@ -1218,6 +1228,13 @@ void ps_main()
 #endif
 
 #if PS_ZCLAMP
-	gl_FragDepth = min(FragCoord.z, MaxDepthPS);
+	FragCoord.z = min(FragCoord.z, MaxDepthPS);
+	#if NEEDS_DEPTH && PS_NO_COLOR1
+		// Warning: do not write SV_Target1 until the end since the value might be needed for
+		// FB fetch in sample_from_depth().
+		SV_Target1 = FragCoord.z;
+	#else
+		gl_FragDepth = FragCoord.z;
+	#endif
 #endif
 }

bin/resources/shaders/vulkan/convert.glsl

@@ -22,6 +22,8 @@ layout(location = 0) in vec2 v_tex;
 
 #if defined(ps_convert_rgba8_16bits) || defined(ps_convert_float32_32bits)
 layout(location = 0) out uint o_col0;
+#elif defined(ps_convert_float32_depth_to_color)
+layout(location = 0) out float o_col0;
 #elif !defined(ps_datm1) && \
 	!defined(ps_datm0) && \
 	!defined(ps_datm1_rta_correction) && \
@@ -166,6 +168,20 @@ void ps_colclip_resolve()
 }
 #endif
 
+#ifdef ps_convert_float32_depth_to_color
+void ps_convert_float32_depth_to_color()
+{
+	o_col0 = sample_c(v_tex).r;
+}
+#endif
+
+#ifdef ps_convert_float32_color_to_depth
+void ps_convert_float32_color_to_depth()
+{
+	gl_FragDepth = sample_c(v_tex).r;
+}
+#endif
+
 #ifdef ps_convert_float32_32bits
 void ps_convert_float32_32bits()
 {

pcsx2/GS/Renderers/Common/GSDevice.cpp

@@ -64,6 +64,8 @@ const char* shaderName(ShaderConvert value)
 		case ShaderConvert::RGBA8_TO_FLOAT24_BILN:  return "ps_convert_rgba8_float24_biln";
 		case ShaderConvert::RGBA8_TO_FLOAT16_BILN:  return "ps_convert_rgba8_float16_biln";
 		case ShaderConvert::RGB5A1_TO_FLOAT16_BILN: return "ps_convert_rgb5a1_float16_biln";
+		case ShaderConvert::FLOAT32_DEPTH_TO_COLOR: return "ps_convert_float32_depth_to_color";
+		case ShaderConvert::FLOAT32_COLOR_TO_DEPTH: return "ps_convert_float32_color_to_depth";
 		case ShaderConvert::FLOAT32_TO_FLOAT24:     return "ps_convert_float32_float24";
 		case ShaderConvert::DEPTH_COPY:             return "ps_depth_copy";
 		case ShaderConvert::DOWNSAMPLE_COPY:        return "ps_downsample_copy";

pcsx2/GS/Renderers/Common/GSDevice.h

@@ -39,6 +39,8 @@ enum class ShaderConvert
 	RGBA8_TO_FLOAT24_BILN,
 	RGBA8_TO_FLOAT16_BILN,
 	RGB5A1_TO_FLOAT16_BILN,
+	FLOAT32_DEPTH_TO_COLOR,
+	FLOAT32_COLOR_TO_DEPTH,
 	FLOAT32_TO_FLOAT24,
 	DEPTH_COPY,
 	DOWNSAMPLE_COPY,
@@ -101,6 +103,7 @@ static inline bool HasDepthOutput(ShaderConvert shader)
 		case ShaderConvert::RGBA8_TO_FLOAT24_BILN:
 		case ShaderConvert::RGBA8_TO_FLOAT16_BILN:
 		case ShaderConvert::RGB5A1_TO_FLOAT16_BILN:
+		case ShaderConvert::FLOAT32_COLOR_TO_DEPTH:
 		case ShaderConvert::FLOAT32_TO_FLOAT24:
 		case ShaderConvert::DEPTH_COPY:
 			return true;
@@ -767,6 +770,7 @@ struct alignas(16) GSHWDrawConfig
 	};
 
 	GSTexture* rt;        ///< Render target
+	GSTexture* ds_as_rt;  ///< Depth stencil as color (if supported)
 	GSTexture* ds;        ///< Depth stencil
 	GSTexture* tex;       ///< Source texture
 	GSTexture* pal;       ///< Palette texture
@@ -896,6 +900,7 @@ class GSDevice : public GSAlignedClass<32>
 		bool stencil_buffer       : 1; ///< Supports stencil buffer, and can use for DATE.
 		bool cas_sharpening       : 1; ///< Supports sufficient functionality for contrast adaptive sharpening.
 		bool test_and_sample_depth: 1; ///< Supports concurrently binding the depth-stencil buffer for sampling and depth testing.
+		bool depth_as_rt_feedback : 1; ///< Depth feedback loops/barriers by converting depth to a temporary color target.
 		FeatureSupport()
 		{
 			memset(this, 0, sizeof(*this));

pcsx2/GS/Renderers/Common/GSTexture.cpp

@@ -20,7 +20,7 @@ bool GSTexture::Save(const std::string& fn)
 {
 	// Depth textures need special treatment - we have a stencil component.
 	// Just re-use the existing conversion shader instead.
-	if (m_format == Format::DepthStencil)
+	if (m_format == Format::DepthStencil || m_format == Format::Float32)
 	{
 		GSTexture* temp = g_gs_device->CreateRenderTarget(GetWidth(), GetHeight(), Format::Color, false);
 		if (!temp)
@@ -63,23 +63,40 @@ bool GSTexture::Save(const std::string& fn)
 
 const char* GSTexture::GetFormatName(Format format)
 {
-	static constexpr const char* format_names[] = {
-		"Invalid",
-		"Color",
-		"ColorHQ",
-		"ColorHDR",
-		"ColorClip",
-		"DepthStencil",
-		"UNorm8",
-		"UInt16",
-		"UInt32",
-		"PrimID",
-		"BC1",
-		"BC2",
-		"BC3",
-		"BC7",
-	};
-	return format_names[(static_cast<u32>(format) < std::size(format_names)) ? static_cast<u32>(format) : 0];
+	switch (format)
+	{
+		default:
+			pxFailRel("Invalid texture format");
+		case Format::Invalid:      return "Invalid";
+		case Format::Color:        return "Color";
+		case Format::ColorHQ:      return "ColorHQ";
+		case Format::ColorHDR:     return "ColorHDR";
+		case Format::ColorClip:    return "ColorClip";
+		case Format::DepthStencil: return "DepthStencil";
+		case Format::Float32:      return "Float32";
+		case Format::UNorm8:       return "UNorm8";
+		case Format::UInt16:       return "UInt16";
+		case Format::UInt32:       return "UInt32";
+		case Format::PrimID:       return "PrimID";
+		case Format::BC1:          return "BC1";
+		case Format::BC2:          return "BC2";
+		case Format::BC3:          return "BC3";
+		case Format::BC7:          return "BC7";
+	}
+}
+
+bool GSTexture::IsBlockCompressedFormat(Format format)
+{
+	switch (format)
+	{
+		case Format::BC1:
+		case Format::BC2:
+		case Format::BC3:
+		case Format::BC7:
+			return true;
+		default:
+			return false;
+	}
 }
 
 u32 GSTexture::GetCompressedBytesPerBlock() const
@@ -89,24 +106,26 @@ u32 GSTexture::GetCompressedBytesPerBlock() const
 
 u32 GSTexture::GetCompressedBytesPerBlock(Format format)
 {
-	static constexpr u32 bytes_per_block[] = {
-		1, // Invalid
-		4, // Color/RGBA8
-		4, // ColorHQ/RGB10A2
-		8, // ColorHDR/RGBA16F
-		8, // ColorClip/RGBA16
-		4, // DepthStencil
-		1, // UNorm8/R8
-		2, // UInt16/R16UI
-		4, // UInt32/R32UI
-		4, // Int32/R32I
-		8, // BC1 - 16 pixels in 64 bits
-		16, // BC2 - 16 pixels in 128 bits
-		16, // BC3 - 16 pixels in 128 bits
-		16, // BC7 - 16 pixels in 128 bits
-	};
-
-	return bytes_per_block[static_cast<u32>(format)];
+	switch (format)
+	{
+		default:
+			pxFailRel("Invalid texture format");
+		case Format::Invalid:      return 1;  // Invalid
+		case Format::Color:        return 4;  // Color/RGBA8
+		case Format::ColorHQ:      return 4;  // ColorHQ/RGB10A2
+		case Format::ColorHDR:     return 8;  // ColorHDR/RGBA16F
+		case Format::ColorClip:    return 8;  // ColorClip/RGBA16
+		case Format::DepthStencil: return 4;  // DepthStencil
+		case Format::Float32:      return 4;  // Float32/R32
+		case Format::UNorm8:       return 1;  // UNorm8/R8
+		case Format::UInt16:       return 2;  // UInt16/R16UI
+		case Format::UInt32:       return 4;  // UInt32/R32UI
+		case Format::PrimID:       return 4;  // Int32/R32I
+		case Format::BC1:          return 8;  // BC1 - 16 pixels in 64 bits
+		case Format::BC2:          return 16; // BC2 - 16 pixels in 128 bits
+		case Format::BC3:          return 16; // BC3 - 16 pixels in 128 bits
+		case Format::BC7:          return 16; // BC7 - 16 pixels in 128 bits
+	}
 }
 
 u32 GSTexture::GetCompressedBlockSize() const
@@ -116,10 +135,7 @@ u32 GSTexture::GetCompressedBlockSize() const
 
 u32 GSTexture::GetCompressedBlockSize(Format format)
 {
-	if (format >= Format::BC1 && format <= Format::BC7)
-		return 4;
-	else
-		return 1;
+	return IsBlockCompressedFormat(format) ? 4 : 1;
 }
 
 u32 GSTexture::CalcUploadPitch(Format format, u32 width)

pcsx2/GS/Renderers/Common/GSTexture.h

@@ -34,6 +34,7 @@ class GSTexture
 		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
+		Float32,      ///< For treating depth texture as RT
 		UNorm8,       ///< A8UNorm texture for paletted textures and the OSD font
 		UInt16,       ///< UInt16 texture for reading back 16-bit depth
 		UInt32,       ///< UInt32 texture for reading back 24 and 32-bit depth
@@ -103,6 +104,7 @@ class GSTexture
 	__fi bool IsCompressedFormat() const { return IsCompressedFormat(m_format); }
 
 	static const char* GetFormatName(Format format);
+	static bool IsBlockCompressedFormat(Format format);
 	static u32 GetCompressedBytesPerBlock(Format format);
 	static u32 GetCompressedBlockSize(Format format);
 	static u32 CalcUploadPitch(Format format, u32 width);