GS:MTL: Port oneshot ROV to Metal.

Author: TJnotJT

pcsx2/GS/Renderers/Metal/GSDeviceMTL.h

@@ -250,6 +250,8 @@ class GSDeviceMTL final : public GSDevice
 	// Functions and Pipeline States
 	MRCOwned<id<MTLComputePipelineState>> m_cas_pipeline[2];
 	std::vector<MRCOwned<id<MTLRenderPipelineState>>> m_convert_pipeline;
+	MRCOwned<id<MTLRenderPipelineState>> m_rov_copy_one_pipeline[2]; // [color]
+	MRCOwned<id<MTLRenderPipelineState>> m_rov_copy_both_pipeline;
 	MRCOwned<id<MTLRenderPipelineState>> m_present_pipeline[static_cast<int>(PresentShader::Count)];
 	MRCOwned<id<MTLRenderPipelineState>> m_merge_pipeline[4];
 	MRCOwned<id<MTLRenderPipelineState>> m_interlace_pipeline[NUM_INTERLACE_SHADERS];
@@ -335,6 +337,8 @@ class GSDeviceMTL final : public GSDevice
 	GSTexture* m_ds_as_rt_gstexture = nullptr;
 	MRCOwned<id<MTLTexture>> m_rov_dummy_texture;
 	struct { u32 w, h; } m_rov_dummy_texture_size = {};
+	std::unique_ptr<GSTextureMTL> m_rov_rt;
+	std::unique_ptr<GSTextureMTL> m_rov_ds;
 
 	struct DebugEntry
 	{
@@ -383,6 +387,8 @@ class GSDeviceMTL final : public GSDevice
 	void BeginRenderPass(NSString* name, GSTexture* color, MTLLoadAction color_load, GSTexture* depth, MTLLoadAction depth_load, GSTexture* stencil = nullptr, MTLLoadAction stencil_load = MTLLoadActionDontCare, bool rt1 = false);
 	/// Begin a new full-ROV render pass (may reuse existing)
 	void BeginFullROV(NSString* name, uint32_t width, uint32_t height);
+	/// Begin a render pass for combined color+depth ROV copy
+	void BeginROVCopy(GSTexture* color, GSTexture* depth);
 	/// Call at the end of each frame
 	void FrameCompleted();
 
@@ -464,6 +470,7 @@ class GSDeviceMTL final : public GSDevice
 
 	// MARK: Render HW
 
+	void SetupOneshotROV(const GSHWDrawConfig& config, GSTextureMTL* rt, GSTextureMTL* ds, const std::vector<GSVector4i>& rects, const GSVector2i& size);
 	void SetupDestinationAlpha(GSTexture* rt, GSTexture* ds, const GSVector4i& r, SetDATM datm);
 	void PrepareROVTexture(GSTexture** ptex);
 	void RenderHW(GSHWDrawConfig& config) override;

pcsx2/GS/Renderers/Metal/GSDeviceMTL.mm

@@ -505,6 +505,8 @@ static GSVector4 GetRTLoadInfo(GSTextureMTL* tex, MTLLoadAction* load_action)
 		color1.texture = GetRT1DepthTexture(md);
 		if (m_features.framebuffer_fetch)
 			color1.clearColor = MTLClearColorMake(depth_load == MTLLoadActionClear ? depth_clear.x : -1, 0, 0, 0);
+		else
+			color1.loadAction = MTLLoadActionLoad;
 	}
 
 	PrepareBeginRenderPass();
@@ -576,6 +578,25 @@ static GSVector4 GetRTLoadInfo(GSTextureMTL* tex, MTLLoadAction* load_action)
 		                          beforeStages:MTLRenderStageVertex];
 }
 
+void GSDeviceMTL::BeginROVCopy(GSTexture* color, GSTexture* depth)
+{
+	pxAssert(!m_features.framebuffer_fetch);
+	MTLRenderPassDescriptor* desc = m_render_pass_desc[1 | 8];
+	MTLRenderPassColorAttachmentDescriptor* color0 = desc.colorAttachments[0];
+	color0.loadAction = MTLLoadActionDontCare;
+	color0.texture = static_cast<GSTextureMTL*>(color)->GetTexture();
+	MTLRenderPassColorAttachmentDescriptor* color1 = desc.colorAttachments[1];
+	color1.loadAction = MTLLoadActionDontCare;
+	color1.storeAction = MTLStoreActionStore;
+	color1.texture = static_cast<GSTextureMTL*>(depth)->GetTexture();
+	PrepareBeginRenderPass();
+	m_current_render.encoder = MRCRetain([GetRenderCmdBuf() renderCommandEncoderWithDescriptor:desc]);
+	[m_current_render.encoder setLabel:@"ROV Clear"];
+	if (!m_dev.features.unified_memory)
+		[m_current_render.encoder waitForFence:m_draw_sync_fence
+		                          beforeStages:MTLRenderStageVertex];
+}
+
 void GSDeviceMTL::FrameCompleted()
 {
 	if (m_spin_timer)
@@ -1125,11 +1146,11 @@ static bool ConvertShaderNotNeeded(ShaderConvert shader)
 		auto desc = MRCTransfer([MTLRenderPassDescriptor new]);
 		[[desc   depthAttachment] setStoreAction:MTLStoreActionStore];
 		[[desc stencilAttachment] setStoreAction:MTLStoreActionStore];
-		if (rt1)
+		if (rt1 && m_features.framebuffer_fetch)
 		{
 			MTLRenderPassColorAttachmentDescriptor* color1 = [[desc colorAttachments] objectAtIndexedSubscript:1];
 			[color1 setStoreAction:MTLStoreActionDontCare];
-			[color1 setLoadAction:m_features.framebuffer_fetch ? MTLLoadActionClear : MTLLoadActionLoad];
+			[color1 setLoadAction:MTLLoadActionClear];
 		}
 		m_render_pass_desc[i] = desc;
 	}
@@ -1304,8 +1325,22 @@ static bool ConvertShaderNotNeeded(ShaderConvert shader)
 		setFnConstantB(m_fn_constants, shader.DepthOutput(), GSMTLConstantIndex_DEPTH_OUT);
 		m_convert_pipeline[shader.Index()] = MakePipeline(pdesc, vs_convert, LoadShader(shader_name), name);
 	}
+
 	pdesc.colorAttachments[0].writeMask = MTLColorWriteMaskAll;
 	pdesc.depthAttachmentPixelFormat = MTLPixelFormatInvalid;
+	pdesc.stencilAttachmentPixelFormat = MTLPixelFormatInvalid;
+
+	if (m_features.rov)
+	{
+		pdesc.colorAttachments[0].pixelFormat = MTLPixelFormatRGBA8Unorm;
+		pdesc.colorAttachments[1].pixelFormat = MTLPixelFormatR32Float;
+		m_rov_copy_both_pipeline = MakePipeline(pdesc, vs_convert, LoadShader(@"ps_rov_copy_both"), @"ROV Copy Both");
+		pdesc.colorAttachments[1].pixelFormat = MTLPixelFormatInvalid;
+		m_rov_copy_one_pipeline[1] = MakePipeline(pdesc, vs_convert, LoadShader(@"ps_rov_copy_color"), @"ROV Copy Color");
+		pdesc.colorAttachments[0].pixelFormat = MTLPixelFormatR32Float;
+		m_rov_copy_one_pipeline[0] = MakePipeline(pdesc, vs_convert, LoadShader(@"ps_rov_copy_depth"), @"ROV Copy Depth");
+	}
+
 	for (size_t i = 0; i < std::size(m_present_pipeline); i++)
 	{
 		PresentShader conv = static_cast<PresentShader>(i);
@@ -1845,6 +1880,101 @@ static bool ConvertShaderNotNeeded(ShaderConvert shader)
 	flush(num_rects);
 }}
 
+void GSDeviceMTL::SetupOneshotROV(const GSHWDrawConfig& config, GSTextureMTL* rt, GSTextureMTL* ds, const std::vector<GSVector4i>& rects, const GSVector2i& size_i)
+{
+	g_perfmon.Put(GSPerfMon::TextureCopies, 1);
+	g_perfmon.Put(GSPerfMon::TextureCopiesROV, 1);
+	g_perfmon.Put(GSPerfMon::DrawCallsROV, 1);
+
+	bool rt_copy = config.ps.HasOneshotColorROV();
+	bool ds_copy = config.ps.HasOneshotDepthROV();
+
+	// Create ROV textures
+	if (rt_copy && (!m_rov_rt || m_rov_rt->GetSize() != size_i))
+	{
+		if (m_rov_rt)
+			Recycle(m_rov_rt.release());
+		m_rov_rt.reset(static_cast<GSTextureMTL*>(CreateShaderWriteTarget(size_i, GSTexture::Format::Color, false)));
+#if PCSX2_DEVBUILD
+		m_rov_rt->SetDebugName(fmt::format("RT for oneshot ROV {}x{}", size_i.x, size_i.y));
+#endif
+	}
+	if (ds_copy && (!m_rov_ds || m_rov_ds->GetSize() != size_i))
+	{
+		if (m_rov_ds)
+			Recycle(m_rov_ds.release());
+		m_rov_ds.reset(static_cast<GSTextureMTL*>(CreateShaderWriteTarget(size_i, GSTexture::Format::DepthColor, false)));
+#if PCSX2_DEVBUILD
+		m_rov_ds->SetDebugName(fmt::format("DS for oneshot ROV {}x{}", size_i.x, size_i.y));
+#endif
+	}
+
+	// Avoid copies if the original is cleared.
+	if (rt_copy && rt->GetState() == GSTexture::State::Cleared)
+	{
+		m_rov_rt->SetClearColor(rt->GetClearColor());
+		m_rov_rt->FlushClears();
+		rt_copy = false;
+	}
+	if (ds_copy && ds->GetState() == GSTexture::State::Cleared)
+	{
+		m_rov_ds->SetClearDepth(ds->GetClearDepth());
+		m_rov_ds->FlushClears();
+		ds_copy = false;
+	}
+
+	if (!(rt_copy || ds_copy))
+		return; // Copy handled with clear.
+
+	// Vertices / IA
+	const u32 num_rects = static_cast<u32>(rects.size());
+	const Map allocation = Allocate(m_vertex_upload_buf, sizeof(ConvertShaderVertex) * 4 * num_rects);
+	std::array<GSVector4, 4>* write = static_cast<std::array<GSVector4, 4>*>(allocation.cpu_buffer);
+	const id<MTLRenderCommandEncoder> enc = m_current_render.encoder;
+	[enc setVertexBuffer:allocation.gpu_buffer
+	              offset:allocation.gpu_offset
+	             atIndex:GSMTLBufferIndexVertices];
+
+	const GSVector2 size(static_cast<float>(size_i.x), static_cast<float>(size_i.y));
+	for (const GSVector4i& rect_i : rects)
+	{
+		GSVector4 rect(rect_i);
+		*write++ = CalcStrechRectPoints(rect, rect, size);
+	}
+
+	// Render pass
+	if (rt_copy && ds_copy)
+	{
+		BeginROVCopy(m_rov_rt.get(), m_rov_ds.get());
+		MRESetTexture(rt, 0);
+		MRESetTexture(ds, 1);
+		MRESetPipeline(m_rov_copy_both_pipeline);
+	}
+	else
+	{
+		GSTextureMTL* src = rt_copy ? rt : ds;
+		GSTextureMTL* dst = rt_copy ? m_rov_rt.get() : m_rov_ds.get();
+		BeginRenderPass(@"ROV Copy", dst, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare, nullptr, MTLLoadActionDontCare, false);
+		MRESetTexture(src, GSMTLTextureIndexNonHW);
+		MRESetPipeline(m_rov_copy_one_pipeline[rt_copy]);
+	}
+
+	FlushDebugEntries(m_current_render.encoder);
+	MREClearScissor();
+	MRESetDSS(DepthStencilSelector::NoDepth());
+
+	[enc drawIndexedPrimitives:MTLPrimitiveTypeTriangle
+	                indexCount:num_rects * 6
+	                 indexType:MTLIndexTypeUInt16
+	               indexBuffer:m_expand_index_buffer
+	         indexBufferOffset:0
+	             instanceCount:1
+	                baseVertex:0
+	              baseInstance:0];
+
+	EndRenderPass();
+}
+
 void GSDeviceMTL::UpdateCLUTTexture(GSTexture* sTex, float sScale, u32 offsetX, u32 offsetY, GSTexture* dTex, u32 dOffset, u32 dSize)
 {
 	GSMTLCLUTConvertPSUniform uniform = { sScale, {offsetX, offsetY}, dOffset };
@@ -2060,7 +2190,7 @@ static MTLBlendOperation ConvertBlendOp(GSDevice::BlendOp generic)
 		setFnConstantI(m_fn_constants, pssel.aa1,                   GSMTLConstantIndex_PS_AA1);
 		setFnConstantB(m_fn_constants, pssel.abe,                   GSMTLConstantIndex_PS_ABE);
 		setFnConstantI(m_fn_constants, pssel.sw_aniso,              GSMTLConstantIndex_PS_SW_ANISO);
-		setFnConstantB(m_fn_constants, pssel.rov_color,             GSMTLConstantIndex_PS_ROV_COLOR);
+		setFnConstantI(m_fn_constants, pssel.rov_color,             GSMTLConstantIndex_PS_ROV_COLOR);
 		setFnConstantI(m_fn_constants, pssel.rov_depth,             GSMTLConstantIndex_PS_ROV_DEPTH);
 		bool eft = pssel.HasColorROV() && !pssel.HasDepthROV() && !pssel.HasDepthOutput();
 		auto newps = LoadShader(eft ? @"ps_main_rov_eft" : @"ps_main");
@@ -2347,6 +2477,14 @@ static bool usesStencil(GSHWDrawConfig::DestinationAlphaMode dstalpha)
 
 void GSDeviceMTL::RenderHW(GSHWDrawConfig& config)
 { @autoreleasepool {
+	if (config.ps.HasOneshotROV())
+	{
+		// Do this first since it requires a different vertex upload from the main draw.
+		const GSVector2i rtsize = (config.rt ? config.rt : config.ds)->GetSize();
+		SetupOneshotROV(config, static_cast<GSTextureMTL*>(config.rt), static_cast<GSTextureMTL*>(config.ds),
+			*config.draw_coarse_rasterize, rtsize);
+	}
+
 	if (config.tex && (config.ds == config.tex || config.rt == config.tex))
 		EndRenderPass(); // Barrier
 

pcsx2/GS/Renderers/Metal/convert.metal

@@ -564,3 +564,23 @@ fragment float4 ps_shadeboost(float4 p [[position]], DirectReadTextureIn<float>
 
 	return float4(csb, 1);
 }
+
+struct ROVCopyBothOut
+{
+	float4 color [[color(0)]];
+	float  depth [[color(1)]];
+};
+
+fragment float4 ps_rov_copy_color(float4 p [[position]], texture2d<float> tex [[texture(GSMTLTextureIndexNonHW)]])
+{
+	return tex.read(uint2(p.xy));
+}
+fragment float ps_rov_copy_depth(float4 p [[position]], depth2d<float> tex [[texture(GSMTLTextureIndexNonHW)]])
+{
+	return tex.read(uint2(p.xy));
+}
+fragment ROVCopyBothOut ps_rov_copy_both(float4 p [[position]], texture2d<float> ctex [[texture(0)]], depth2d<float> dtex [[texture(1)]])
+{
+	uint2 pos = uint2(p.xy);
+	return { ctex.read(pos), dtex.read(pos) };
+}

pcsx2/GS/Renderers/Metal/tfx.metal

@@ -76,20 +76,22 @@ constant uint PS_SCANMSK            [[function_constant(GSMTLConstantIndex_PS_SC
 constant uint PS_AA1_RAW            [[function_constant(GSMTLConstantIndex_PS_AA1)]];
 constant bool PS_ABE                [[function_constant(GSMTLConstantIndex_PS_ABE)]];
 constant uint PS_SW_ANISO           [[function_constant(GSMTLConstantIndex_PS_SW_ANISO)]];
-constant bool PS_ROV_COLOR          [[function_constant(GSMTLConstantIndex_PS_ROV_COLOR)]];
+constant uint PS_ROV_COLOR_RAW      [[function_constant(GSMTLConstantIndex_PS_ROV_COLOR)]];
 constant uint PS_ROV_DEPTH_RAW      [[function_constant(GSMTLConstantIndex_PS_ROV_DEPTH)]];
 
 using GSShader::VSExpand;
 using AFAIL = GSShader::PS_AFAIL;
 using ATST = GSShader::PS_ATST;
 using GSShader::ZTST;
 using AA1 = GSShader::PS_AA1;
+using ROV_COLOR = GSShader::PS_ROV_COLOR;
 using ROV_DEPTH = GSShader::PS_ROV_DEPTH;
 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);
 constant ZTST  PS_ZTST  = static_cast<ZTST>(PS_ZTST_RAW);
 constant AA1   PS_AA1   = static_cast<AA1>(PS_AA1_RAW);
+constant ROV_COLOR PS_ROV_COLOR = static_cast<ROV_COLOR>(PS_ROV_COLOR_RAW);
 constant ROV_DEPTH PS_ROV_DEPTH = static_cast<ROV_DEPTH>(PS_ROV_DEPTH_RAW);
 
 #if defined(__METAL_MACOS__) && __METAL_VERSION__ >= 220
@@ -124,9 +126,9 @@ constant bool NEEDS_DEPTH_FOR_ZTST  = PS_ZTST == ZTST::GEQUAL || PS_ZTST == ZTST
 constant bool NEEDS_DEPTH_FOR_AA1   = PS_AA1 == AA1::TRIANGLE_SW_Z;
 constant bool SW_DEPTH = NEEDS_DEPTH_FOR_AFAIL || NEEDS_DEPTH_FOR_ZTST || NEEDS_DEPTH_FOR_AA1;
 
-constant bool PS_OUTPUT_COLOR0 = !PS_NO_COLOR  && !PS_ROV_COLOR;
-constant bool PS_OUTPUT_COLOR1 = !PS_NO_COLOR1 && !PS_ROV_COLOR;
-constant bool PS_ZOUTPUT = (PS_ZCLAMP || PS_ZFLOOR || SW_DEPTH) && PS_ROV_DEPTH == ROV_DEPTH::NONE;
+constant bool PS_OUTPUT_COLOR0 = !PS_NO_COLOR  && (PS_ROV_COLOR != ROV_COLOR::ENABLED);
+constant bool PS_OUTPUT_COLOR1 = !PS_NO_COLOR1 && (PS_ROV_COLOR != ROV_COLOR::NONE);
+constant bool PS_ZOUTPUT = (PS_ZCLAMP || PS_ZFLOOR || SW_DEPTH) && PS_ROV_DEPTH != ROV_DEPTH::READ_WRITE && PS_ROV_DEPTH != ROV_DEPTH::READ_ONLY;
 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;
@@ -583,23 +585,23 @@ struct PSMain
 
 	void discard()
 	{
-		if (PS_ROV_COLOR || PS_ROV_DEPTH != ROV_DEPTH::NONE)
+		if (PS_ROV_COLOR != ROV_COLOR::NONE || PS_ROV_DEPTH != ROV_DEPTH::NONE)
 			color_discarded = depth_discarded = true;
 		else
 			discard_fragment();
 	}
 
 	void discard_color(thread float4& output)
 	{
-		if (PS_ROV_COLOR)
+		if (PS_ROV_COLOR != ROV_COLOR::NONE)
 			color_discarded = true;
 		else
 			output = current_color;
 	}
 
 	void discard_depth(thread float& output)
 	{
-		if (PS_ROV_DEPTH == ROV_DEPTH::READ_WRITE)
+		if (PS_ROV_DEPTH == ROV_DEPTH::READ_WRITE || PS_ROV_DEPTH == ROV_DEPTH::ONESHOT_READ_WRITE)
 			depth_discarded = true;
 		else
 			output = current_depth;
@@ -1693,18 +1695,18 @@ fragment float4 fbfetch_test(float4 in [[color(0), raster_order_group(0)]])
 	return in * 2;
 }
 
-constant bool NEEDS_RT_TEX = NEEDS_RT && !HAS_FBFETCH && !PS_ROV_COLOR;
-constant bool NEEDS_RT_FBF = NEEDS_RT &&  HAS_FBFETCH && !PS_ROV_COLOR;
+constant bool NEEDS_RT_TEX = NEEDS_RT && !HAS_FBFETCH && (PS_ROV_COLOR != ROV_COLOR::NONE);
+constant bool NEEDS_RT_FBF = NEEDS_RT &&  HAS_FBFETCH && (PS_ROV_COLOR != ROV_COLOR::NONE);
 constant bool NEEDS_DS_FBF = SW_DEPTH &&  HAS_FBFETCH && !DEPTH_FEEDBACK && PS_ROV_DEPTH == ROV_DEPTH::NONE;
 #else
-constant bool NEEDS_RT_TEX = NEEDS_RT && !PS_ROV_COLOR;
+constant bool NEEDS_RT_TEX = NEEDS_RT && (PS_ROV_COLOR != ROV_COLOR::NONE);
 constant bool NEEDS_DS_FBF = false;
 constant float ds_fbf = 0;
 #endif
 constant bool NEEDS_DS_TEX   = SW_DEPTH && !DEPTH_FEEDBACK && !NEEDS_DS_FBF && PS_ROV_DEPTH == ROV_DEPTH::NONE;
 constant bool NEEDS_DS_DEPTH = (SW_DEPTH && DEPTH_FEEDBACK || NEEDS_DS_FBF) && PS_ROV_DEPTH == ROV_DEPTH::NONE;
-constant bool NEEDS_RT_ROV = PS_ROV_COLOR && !ROV_NEEDS_R32;
-constant bool NEEDS_RT_U32 = PS_ROV_COLOR &&  ROV_NEEDS_R32;
+constant bool NEEDS_RT_ROV = (PS_ROV_COLOR != ROV_COLOR::NONE) && !ROV_NEEDS_R32;
+constant bool NEEDS_RT_U32 = (PS_ROV_COLOR != ROV_COLOR::NONE) &&  ROV_NEEDS_R32;
 constant bool NEEDS_DS_ROV = PS_ROV_DEPTH != ROV_DEPTH::NONE;
 
 fragment MainPSOut ps_main(
@@ -1758,9 +1760,9 @@ fragment MainPSOut ps_main(
 			main.current_depth = ds_tex.read(coord).x;
 	}
 
-	if (NEEDS_RT || (PS_ROV_COLOR && any(cb.fbmask == 0xff)))
+	if (NEEDS_RT || (PS_ROV_COLOR != ROV_COLOR::NONE && any(cb.fbmask == 0xff)))
 	{
-		if (PS_ROV_COLOR)
+		if (PS_ROV_COLOR != ROV_COLOR::NONE)
 		{
 			if (ROV_NEEDS_R32)
 				main.current_color = unpack_unorm4x8_to_float(rt_u32.read(coord).x);
@@ -1782,9 +1784,9 @@ fragment MainPSOut ps_main(
 	}
 
 	MainResult out = main.ps_main();
-	if (PS_ROV_DEPTH == ROV_DEPTH::READ_WRITE && !main.depth_discarded)
+	if ((PS_ROV_DEPTH == ROV_DEPTH::READ_WRITE || PS_ROV_DEPTH == ROV_DEPTH::ONESHOT_READ_WRITE) && !main.depth_discarded)
 		ds_rov.write(out.depth, coord);
-	if (PS_ROV_COLOR && !main.color_discarded)
+	if ((PS_ROV_COLOR != ROV_COLOR::NONE) && !main.color_discarded)
 	{
 		if (!PS_FBMASK)
 			out.c0 = select(out.c0, main.current_color, cb.fbmask == 0xff);