GS: Remove depth feedback none option

Depth feedback doesn't get used most of the time anyways

Author: TellowKrinkle

pcsx2/GS/Renderers/Common/GSDevice.h

@@ -930,8 +930,6 @@ class GSDevice : public GSAlignedClass<32>
 		Performance
 	};
 
-	using DepthFeedbackSupport = GSShader::DepthFeedbackSupport;
-
 	// clang-format off
 	struct FeatureSupport
 	{
@@ -950,7 +948,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.
-		DepthFeedbackSupport depth_feedback : 2; ///< Support for depth feedback loops.
+		bool depth_feedback       : 1; ///< Depth feedback loops can be done with DS directly (otherwise need to copy to separate RT).
 		bool aa1                  : 1; ///< Supports the GS AA1 feature.
 		FeatureSupport()
 		{

pcsx2/GS/Renderers/Common/GSShaderEnums.h

@@ -19,13 +19,6 @@ enum class VSExpand : uint8_t
 	TriangleAA1 = 5,
 };
 
-enum class DepthFeedbackSupport : uint32_t
-{
-	None      = 0, ///< No support for depth feedback loops.
-	Depth     = 1, ///< Implement depth feedback loops directly on the depth buffer.
-	DepthAsRT = 2, ///< Implement depth feedback loops by first converting depth to a color RT.
-};
-
 enum class PS_ATST : uint32_t
 {
 	NONE = 0,

pcsx2/GS/Renderers/DX11/GSDevice11.cpp

@@ -68,15 +68,7 @@ GSDevice11::GSDevice11()
 	m_features.stencil_buffer = true;
 	m_features.cas_sharpening = true;
 	m_features.test_and_sample_depth = false;
-	if (m_features.multidraw_fb_copy && (GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::Auto ||
-		GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::Depth))
-	{
-		m_features.depth_feedback = GSDevice::DepthFeedbackSupport::Depth;
-	}
-	else
-	{
-		m_features.depth_feedback = GSDevice::DepthFeedbackSupport::None;
-	}
+	m_features.depth_feedback = true;
 }
 
 GSDevice11::~GSDevice11() = default;
@@ -654,7 +646,7 @@ void GSDevice11::SetFeatures(IDXGIAdapter1* adapter)
 	m_features.vs_expand = (!GSConfig.DisableVertexShaderExpand && m_feature_level >= D3D_FEATURE_LEVEL_11_0);
 	m_features.cas_sharpening = (m_feature_level >= D3D_FEATURE_LEVEL_11_0);
 	m_features.test_and_sample_depth = (m_feature_level >= D3D_FEATURE_LEVEL_11_0);
-	m_features.aa1 = GSConfig.HWAA1 && m_features.vs_expand && (m_features.depth_feedback != GSDevice::DepthFeedbackSupport::None);
+	m_features.aa1 = GSConfig.HWAA1 && m_features.vs_expand && m_features.multidraw_fb_copy;
 
 	m_max_texture_size = (m_feature_level >= D3D_FEATURE_LEVEL_11_0) ?
 	                         D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION :
@@ -2961,7 +2953,7 @@ void GSDevice11::RenderHW(GSHWDrawConfig& config)
 	}
 
 	if (draw_ds && (config.require_one_barrier || (config.require_full_barrier && m_features.multidraw_fb_copy)) &&
-		m_features.depth_feedback == GSDevice::DepthFeedbackSupport::Depth && config.ps.IsFeedbackLoopDepth())
+		m_features.depth_feedback && config.ps.IsFeedbackLoopDepth())
 	{
 		// Requires a copy of the DS.
 		draw_ds_clone = CreateTexture(rtsize.x, rtsize.y, 1, draw_ds->GetFormat(), true);

pcsx2/GS/Renderers/DX12/GSDevice12.cpp

@@ -1405,17 +1405,8 @@ bool GSDevice12::CheckFeatures(const u32& vendor_id)
 	m_features.cas_sharpening = true;
 	m_features.test_and_sample_depth = true;
 	m_features.vs_expand = !GSConfig.DisableVertexShaderExpand;
-	if (m_features.texture_barrier && (GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::Auto ||
-		GSConfig.DepthFeedbackMode == GSDepthFeedbackMode::DepthAsRT))
-	{
-		m_features.depth_feedback = GSDevice::DepthFeedbackSupport::DepthAsRT;
-	}
-	else
-	{
-		m_features.depth_feedback = GSDevice::DepthFeedbackSupport::None;
-	}
-		
-	m_features.aa1 = GSConfig.HWAA1 && m_features.vs_expand && (m_features.depth_feedback != GSDevice::DepthFeedbackSupport::None);
+	m_features.depth_feedback = false;
+	m_features.aa1 = GSConfig.HWAA1 && m_features.vs_expand && m_features.texture_barrier;
 
 	m_features.dxt_textures = SupportsTextureFormat(DXGI_FORMAT_BC1_UNORM) &&
 	                          SupportsTextureFormat(DXGI_FORMAT_BC2_UNORM) &&

pcsx2/GS/Renderers/HW/GSRendererHW.cpp

@@ -5796,7 +5796,7 @@ void GSRendererHW::EmulateZbufferAA1()
 {
 	const GSDevice::FeatureSupport& features = g_gs_device->Features();
 
-	pxAssert(!features.aa1 || features.depth_feedback != GSDevice::DepthFeedbackSupport::None);
+	pxAssert(!features.aa1 || features.texture_barrier || features.multidraw_fb_copy);
 
 	if (IsCoverageAlphaSupported())
 	{
@@ -6149,8 +6149,7 @@ void GSRendererHW::DetermineBarriers(GSTextureCache::Target* rt)
 
 		// If we use depth feedback directly, we must use barriers for the depth texture.
 		// If we use depth-as-color feedback, then FB fetch can be used for depth also.
-		bool need_barriers_for_depth = m_conf.ps.IsFeedbackLoopDepth() &&
-			(features.depth_feedback == GSDevice::DepthFeedbackSupport::Depth);
+		bool need_barriers_for_depth = m_conf.ps.IsFeedbackLoopDepth() && features.depth_feedback;
 
 		if (!need_barriers_for_depth)
 		{
@@ -6952,8 +6951,7 @@ void GSRendererHW::EmulateBlending(int rt_alpha_min, int rt_alpha_max, DATEOptio
 		}
 	}
 
-	if (m_conf.alpha_test == GSHWDrawConfig::AlphaTestMode::FEEDBACK &&
-		features.depth_feedback == GSDevice::DepthFeedbackSupport::DepthAsRT)
+	if (m_conf.alpha_test == GSHWDrawConfig::AlphaTestMode::FEEDBACK && !features.depth_feedback)
 	{
 		// If we are doing feedback alpha test with a second RT we must use SW blending to avoid
 		// mixing dual source blending with multiple render targets.
@@ -8435,7 +8433,7 @@ void GSRendererHW::EmulateAlphaTest(DATEOptions& date_options)
 	const bool free_fbfetch_feedback = features.framebuffer_fetch && !afail_needs_depth;
 
 	// Determine if we have the correct features for depth feedback.
-	const bool depth_feedback_supported = features.depth_feedback != GSDevice::DepthFeedbackSupport::None;
+	const bool depth_feedback_supported = features.texture_barrier || features.multidraw_fb_copy;
 
 	// We need depth feedback but do not have the correct features.
 	const bool avoid_feedback = afail_needs_depth && !depth_feedback_supported;
@@ -8929,7 +8927,7 @@ __ri void GSRendererHW::DrawPrims(GSTextureCache::Target* rt, GSTextureCache::Ta
 
 	SetupIA(rtscale, vs_scale_x, vs_scale_y, m_channel_shuffle_width != 0);
 
-	if (m_conf.ds && m_conf.ps.IsFeedbackLoopDepth() && g_gs_device->Features().depth_feedback == GSDevice::DepthFeedbackSupport::DepthAsRT)
+	if (m_conf.ds && m_conf.ps.IsFeedbackLoopDepth() && !g_gs_device->Features().depth_feedback)
 	{
 		GL_PUSH("HW: Creating temporary R32 RT for depth feedback");
 

pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm

@@ -870,18 +870,17 @@ static void OnMainThread(Fn&& fn)
 	return ret;
 }
 
-static GSDevice::DepthFeedbackSupport getDepthFeedback(const GSMTLDevice& dev, bool fbfetch)
+static bool getDepthFeedback(const GSMTLDevice& dev, bool fbfetch)
 {
 	switch (GSConfig.DepthFeedbackMode)
 	{
-		case GSDepthFeedbackMode::None:      return GSDevice::DepthFeedbackSupport::None;
-		case GSDepthFeedbackMode::Auto:      return dev.features.preferred_depth_feedback;
-		case GSDepthFeedbackMode::DepthAsRT: return GSDevice::DepthFeedbackSupport::DepthAsRT;
+		case GSDepthFeedbackMode::Auto:
+			return dev.features.depth_feedback;
 		case GSDepthFeedbackMode::Depth:
-			if (!fbfetch)
-				return GSDevice::DepthFeedbackSupport::Depth;
-			else
-				return GSDevice::DepthFeedbackSupport::DepthAsRT; // Depth + FBFetch not supported
+			// Depth feedback + FBFetch not supported
+			return !fbfetch;
+		default:
+			return false;
 	}
 }
 
@@ -977,7 +976,7 @@ static void OnMainThread(Fn&& fn)
 	// Init metal stuff
 	m_fn_constants = MRCTransfer([MTLFunctionConstantValues new]);
 	setFnConstantB(m_fn_constants, m_features.framebuffer_fetch, GSMTLConstantIndex_FRAMEBUFFER_FETCH);
-	setFnConstantI(m_fn_constants, m_features.depth_feedback, GSMTLConstantIndex_DEPTH_FEEDBACK);
+	setFnConstantB(m_fn_constants, m_features.depth_feedback,    GSMTLConstantIndex_DEPTH_FEEDBACK);
 
 	m_draw_sync_fence = MRCTransfer([m_dev.dev newFence]);
 	[m_draw_sync_fence setLabel:@"Draw Sync Fence"];
@@ -1018,7 +1017,7 @@ static void OnMainThread(Fn&& fn)
 		const bool depth   = i & 2;
 		const bool stencil = i & 4;
 		const bool rt1     = i & 8;
-		if (rt1 && m_features.depth_feedback != GSDevice::DepthFeedbackSupport::DepthAsRT)
+		if (rt1 && m_features.depth_feedback)
 			continue;
 		if (rt1 && !depth)
 			continue;
@@ -1332,6 +1331,7 @@ static void OnMainThread(Fn&& fn)
 	desc += "\n    Framebuffer Fetch:   " + std::string(m_dev.features.framebuffer_fetch   ? "Supported" : "Unsupported");
 	desc += "\n    Memoryless Textures: " + std::string(m_dev.features.memoryless_textures ? "Supported" : "Unsupported");
 	desc += "\n    Primitive ID:        " + std::string(m_dev.features.primid              ? "Supported" : "Unsupported");
+	desc += "\n    Depth Feedback:      " + std::string(m_dev.features.depth_feedback      ? "Supported" : "Unsupported");
 	desc += "\n    Shader Version:      " + std::string(to_string(m_dev.features.shader_version));
 	desc += "\n    Max Texture Size:    " + std::to_string(m_dev.features.max_texsize);
 	return desc;
@@ -2380,7 +2380,7 @@ static bool usesStencil(GSHWDrawConfig::DestinationAlphaMode dstalpha)
 	}
 
 	const bool feedback_depth = config.ps.IsFeedbackLoopDepth();
-	const bool rt1 = feedback_depth && m_features.depth_feedback == GSDevice::DepthFeedbackSupport::DepthAsRT;
+	const bool rt1 = feedback_depth && !m_features.depth_feedback;
 	BeginRenderPass(@"RenderHW", rt, MTLLoadActionLoad, config.ds, MTLLoadActionLoad, stencil, MTLLoadActionLoad, rt1);
 	id<MTLRenderCommandEncoder> mtlenc = m_current_render.encoder;
 	FlushDebugEntries(mtlenc);
@@ -2391,8 +2391,7 @@ static bool usesStencil(GSHWDrawConfig::DestinationAlphaMode dstalpha)
 		MRESetTexture(rt, GSMTLTextureIndexRenderTarget);
 	if (feedback_depth)
 	{
-		bool depth_as_rt = m_features.depth_feedback == GSDevice::DepthFeedbackSupport::DepthAsRT;
-		GSTexture* tex = depth_as_rt && !m_features.framebuffer_fetch ? m_ds_as_rt : config.ds;
+		GSTexture* tex = !m_features.depth_feedback && !m_features.framebuffer_fetch ? m_ds_as_rt : config.ds;
 		MRESetTexture(tex, GSMTLTextureIndexDepthTarget);
 	}
 	if (primid_tex)

pcsx2/GS/Renderers/Metal/GSMTLDeviceInfo.h

@@ -24,8 +24,6 @@ struct GSMTLDevice
 		Metal23, ///< Metal 2.3 (macOS 11, iOS 14)
 	};
 
-	using DepthFeedbackSupport = GSShader::DepthFeedbackSupport;
-
 	struct Features
 	{
 		bool unified_memory         : 1;
@@ -35,8 +33,8 @@ struct GSMTLDevice
 		bool slow_color_compression : 1; ///< Color compression seems to slow down rt read on AMD
 		bool has_fast_half          : 1;
 		bool memoryless_textures    : 1;
+		bool depth_feedback         : 1;
 		MetalVersion shader_version;
-		DepthFeedbackSupport preferred_depth_feedback : 8;
 		int max_texsize;
 	};
 

pcsx2/GS/Renderers/Metal/GSMTLDeviceInfo.mm

@@ -164,7 +164,7 @@ static DetectionResult detectIntelGPU(id<MTLDevice> dev, id<MTLLibrary> lib)
 	if (features.primid && !detectPrimIDSupport(dev, shaders))
 		features.primid = false;
 
-	features.preferred_depth_feedback = DepthFeedbackSupport::DepthAsRT;
+	features.depth_feedback = false;
 
 	NSString* name = [dev name];
 	if ([name containsString:@"Intel"])
@@ -175,7 +175,7 @@ static DetectionResult detectIntelGPU(id<MTLDevice> dev, id<MTLLibrary> lib)
 			{
 				case DetectionResult::HaswellOrNotIntel:
 					// Older Intel GPUs seem to be fine with depth feedback
-					features.preferred_depth_feedback = DepthFeedbackSupport::Depth;
+					features.depth_feedback = true;
 					break;
 				case DetectionResult::Broadwell:
 					features.primid = false; // Broken
@@ -192,12 +192,12 @@ static DetectionResult detectIntelGPU(id<MTLDevice> dev, id<MTLLibrary> lib)
 		// RDNA+ seems to work fine with depth feedback
 		if (@available(macOS 13, iOS 16, *))
 			if ([dev supportsFamily:MTLGPUFamilyMetal3])
-				features.preferred_depth_feedback = DepthFeedbackSupport::Depth;
+				features.depth_feedback = true;
 	}
 	else if ([name containsString:@"NVIDIA"])
 	{
 		// macOS only supports Kepler, which seems to work fine with depth feedback
-		features.preferred_depth_feedback = DepthFeedbackSupport::Depth;
+		features.depth_feedback = true;
 	}
 	else if ([name containsString:@"Apple"])
 	{

pcsx2/GS/Renderers/Metal/tfx.metal

@@ -12,7 +12,7 @@ constant uint SHUFFLE_READ = 1;
 constant uint SHUFFLE_READWRITE = 3;
 
 constant bool HAS_FBFETCH           [[function_constant(GSMTLConstantIndex_FRAMEBUFFER_FETCH)]];
-constant uint DEPTH_FEEDBACK_RAW    [[function_constant(GSMTLConstantIndex_DEPTH_FEEDBACK)]];
+constant bool DEPTH_FEEDBACK        [[function_constant(GSMTLConstantIndex_DEPTH_FEEDBACK)]];
 constant bool FST                   [[function_constant(GSMTLConstantIndex_FST)]];
 constant bool IIP                   [[function_constant(GSMTLConstantIndex_IIP)]];
 constant bool VS_POINT_SIZE         [[function_constant(GSMTLConstantIndex_VS_POINT_SIZE)]];
@@ -74,12 +74,10 @@ constant bool PS_REGION_RECT        [[function_constant(GSMTLConstantIndex_PS_RE
 constant uint PS_SCANMSK            [[function_constant(GSMTLConstantIndex_PS_SCANMSK)]];
 constant uint PS_SW_ANISO           [[function_constant(GSMTLConstantIndex_PS_SW_ANISO)]];
 
-using GSShader::DepthFeedbackSupport;
 using GSShader::VSExpand;
 using AFAIL = GSShader::PS_AFAIL;
 using ATST = GSShader::PS_ATST;
 using GSShader::ZTST;
-constant DepthFeedbackSupport DEPTH_FEEDBACK = static_cast<DepthFeedbackSupport>(DEPTH_FEEDBACK_RAW);
 constant VSExpand VS_EXPAND_TYPE = static_cast<VSExpand>(VS_EXPAND_TYPE_RAW);
 constant AFAIL PS_AFAIL = static_cast<AFAIL>(PS_AFAIL_RAW);
 constant ATST  PS_ATST  = static_cast<ATST>(PS_ATST_RAW);
@@ -121,7 +119,7 @@ constant bool PS_COLOR1 = !PS_NO_COLOR1;
 constant bool PS_ZOUTPUT = PS_ZCLAMP || PS_ZFLOOR || SW_DEPTH;
 constant bool PS_ZOUTPUT_LESS = PS_ZOUTPUT && !SW_DEPTH;
 constant bool PS_ZOUTPUT_ANY  = PS_ZOUTPUT && SW_DEPTH;
-constant bool PS_ZOUTPUT_COLOR = PS_ZOUTPUT_ANY && DEPTH_FEEDBACK == DepthFeedbackSupport::DepthAsRT;
+constant bool PS_ZOUTPUT_COLOR = PS_ZOUTPUT_ANY && !DEPTH_FEEDBACK;
 
 struct MainVSIn
 {
@@ -1406,14 +1404,14 @@ fragment float4 fbfetch_test(float4 in [[color(0), raster_order_group(0)]])
 
 constant bool NEEDS_RT_TEX = NEEDS_RT && !HAS_FBFETCH;
 constant bool NEEDS_RT_FBF = NEEDS_RT &&  HAS_FBFETCH;
-constant bool NEEDS_DS_FBF = SW_DEPTH &&  HAS_FBFETCH && DEPTH_FEEDBACK == DepthFeedbackSupport::DepthAsRT;
+constant bool NEEDS_DS_FBF = SW_DEPTH &&  HAS_FBFETCH && !DEPTH_FEEDBACK;
 #else
 constant bool NEEDS_RT_TEX = NEEDS_RT;
 constant bool NEEDS_DS_FBF = false;
 constant float ds_fbf = 0;
 #endif
-constant bool NEEDS_DS_TEX   = SW_DEPTH && DEPTH_FEEDBACK == DepthFeedbackSupport::DepthAsRT && !NEEDS_DS_FBF;
-constant bool NEEDS_DS_DEPTH = SW_DEPTH && DEPTH_FEEDBACK == DepthFeedbackSupport::Depth || NEEDS_DS_FBF;
+constant bool NEEDS_DS_TEX   = SW_DEPTH && !DEPTH_FEEDBACK && !NEEDS_DS_FBF;
+constant bool NEEDS_DS_DEPTH = SW_DEPTH && DEPTH_FEEDBACK || NEEDS_DS_FBF;
 
 fragment MainPSOut ps_main(
 	MainPSIn in [[stage_in]],
@@ -1453,22 +1451,12 @@ fragment MainPSOut ps_main(
 
 	if (SW_DEPTH)
 	{
-		switch (DEPTH_FEEDBACK)
-		{
-			case DepthFeedbackSupport::Depth:
-				main.current_depth = ds_depth.read(coord);
-				break;
-			case DepthFeedbackSupport::DepthAsRT:
-				if (NEEDS_DS_FBF)
-					main.current_depth = ds_fbf < 0 ? ds_depth.read(coord) : ds_fbf;
-				else
-					main.current_depth = ds_tex.read(coord).x;
-				break;
-			case DepthFeedbackSupport::None:
-				// Should never happen
-				main.current_depth = 0;
-				break;
-		}
+		if (DEPTH_FEEDBACK)
+			main.current_depth = ds_depth.read(coord);
+		else if (NEEDS_DS_FBF)
+			main.current_depth = ds_fbf < 0 ? ds_depth.read(coord) : ds_fbf;
+		else
+			main.current_depth = ds_tex.read(coord).x;
 	}
 
 	if (NEEDS_RT)