GS: Accurate UV rounding for axis-aligned prims.

Author: TJnotJT

bin/resources/shaders/dx11/tfx.fx

@@ -13,6 +13,7 @@
 #define VS_IIP 0
 #define VS_TME 1
 #define VS_FST 1
+#define VS_ROUND_UV 0
 #endif
 
 #ifndef GS_IIP
@@ -79,6 +80,7 @@
 #define PS_NO_COLOR 0
 #define PS_NO_COLOR1 0
 #define PS_DATE 0
+#define PS_ROUND_UV 0
 #endif
 
 #define SW_BLEND (PS_BLEND_A || PS_BLEND_B || PS_BLEND_D)
@@ -108,6 +110,10 @@ struct VS_OUTPUT
 #else
 	nointerpolation float4 c : COLOR0;
 #endif
+
+#if VS_ROUND_UV
+	nointerpolation uint4 rounduv : TEXCOORD3;
+#endif
 };
 
 struct PS_INPUT
@@ -120,6 +126,9 @@ struct PS_INPUT
 #else
 	nointerpolation float4 c : COLOR0;
 #endif
+#if PS_ROUND_UV
+	nointerpolation uint4 rounduv : TEXCOORD3;
+#endif
 #if (PS_DATE >= 1 && PS_DATE <= 3) || GS_FORWARD_PRIMID
 	uint primid : SV_PrimitiveID;
 #endif
@@ -322,6 +331,35 @@ float4 clamp_wrap_uv(float4 uv)
 	return uv;
 }
 
+float4 round_uv(PS_INPUT input)
+{
+#if PS_ROUND_UV
+	// Top-left X, Y of the prim saved in unused texture coords.
+	int2 topleft = int2(int2(input.p.xy) == int2(input.rounduv.xy));
+
+	// Get flags for whether to round U, V.
+	int2 round_flags = int2(input.rounduv.zw);
+
+	// Being on the top or left pixels converts round down to round up.
+	int2 round_down = int2(round_flags == PS_ROUND_UV_DOWN) & ~topleft;
+	int2 round_up = int2(round_flags == PS_ROUND_UV_UP) |
+	                (int2(round_flags == PS_ROUND_UV_DOWN) & topleft);
+
+	float2 uv = input.ti.zw; // Unnormalized UVs.
+	float2 uvi = round(input.ti.zw / 8.0f) * 8.0f; // Nearest half texel.
+	
+	int2 close = int2(abs(uv - uvi) < PS_ROUND_UV_THRESHOLD);
+
+	// Round only if close to a half texel.
+	uv = bool2(close & round_down) ? uvi - PS_ROUND_UV_THRESHOLD : uv;
+	uv = bool2(close & round_up) ? uvi + PS_ROUND_UV_THRESHOLD : uv;
+
+	return float4(uv / 16.0f / WH.xy, uv); // Return normalized and unnormalized coords.
+#else
+	return float4(0.0f, 0.0f, 0.0f, 0.0f);
+#endif
+}
+
 float4x4 sample_4c(float4 uv, float uv_w, int2 xy)
 {
 	float4x4 c;
@@ -756,6 +794,10 @@ float4 ps_color(PS_INPUT input)
 #if PS_FST == 0
 	float2 st = input.t.xy / input.t.w;
 	float2 st_int = input.ti.zw / input.t.w;
+#elif PS_ROUND_UV != 0
+	float4 ti_rounded = round_uv(input);
+	float2 st = ti_rounded.xy;
+	float2 st_int = ti_rounded.zw;
 #else
 	float2 st = input.ti.xy;
 	float2 st_int = input.ti.zw;
@@ -1253,6 +1295,17 @@ cbuffer cb0
 	uint BaseVertex; // Only used in DX11.
 };
 
+uint4 extract_round_uv_bits(float q)
+{
+	uint qi = asuint(q);
+	return uint4(
+		(qi >> 0) & 0xFFF,  // Prim left
+		(qi >> 12) & 0xFFF, // Prim top
+		(qi >> 24) & 0xF,   // Round U flags
+		(qi >> 28) & 0xF    // Round V flags
+	);
+}
+
 VS_OUTPUT vs_main(VS_INPUT input)
 {
 	// Clamp to max depth, gs doesn't wrap
@@ -1302,6 +1355,10 @@ VS_OUTPUT vs_main(VS_INPUT input)
 	output.c = input.c;
 	output.t.z = input.f.r;
 
+#if VS_ROUND_UV
+	output.rounduv = extract_round_uv_bits(input.q);
+#endif
+
 	return output;
 }
 

bin/resources/shaders/opengl/tfx_fs.glsl

@@ -70,6 +70,9 @@ in SHADER
 	#else
 		flat vec4 c;
 	#endif
+	#if PS_ROUND_UV
+		flat uvec4 rounduv;
+	#endif
 } PSin;
 
 #define TARGET_0_QUALIFIER out
@@ -252,6 +255,35 @@ vec4 clamp_wrap_uv(vec4 uv)
 	return uv_out;
 }
 
+vec4 round_uv()
+{
+#if PS_ROUND_UV
+	// Top-left X, Y of the prim saved in unused texture coords.
+	ivec2 topleft = ivec2(equal(ivec2(gl_FragCoord.xy), ivec2(PSin.rounduv.xy)));
+
+	// Get flags for whether to round U, V.
+	ivec2 round_flags = ivec2(PSin.rounduv.zw);
+
+	// Being on the top or left pixels converts round down to round up.
+	ivec2 round_down = ivec2(equal(round_flags, ivec2(PS_ROUND_UV_DOWN))) & ~topleft;
+	ivec2 round_up = ivec2(equal(round_flags, ivec2(PS_ROUND_UV_UP))) |
+	                 (ivec2(equal(round_flags, ivec2(PS_ROUND_UV_DOWN))) & topleft);
+
+	vec2 uv = PSin.t_int.zw; // Unnormalized UVs.
+	vec2 uvi = round(PSin.t_int.zw / 8.0f) * 8.0f; // Nearest half texel.
+	
+	ivec2 close = ivec2(lessThan(abs(uv - uvi), vec2(PS_ROUND_UV_THRESHOLD)));
+
+	// Round only if close to a half texel.
+	uv = mix(uv, uvi - PS_ROUND_UV_THRESHOLD, bvec2(close & round_down));
+	uv = mix(uv, uvi + PS_ROUND_UV_THRESHOLD, bvec2(close & round_up));
+
+	return vec4(uv / 16.0f / WH.xy, uv); // Return normalized and unnormalized coords.
+#else
+	return vec4(0.0f);
+#endif
+}
+
 mat4 sample_4c(vec4 uv)
 {
 	mat4 c;
@@ -661,6 +693,10 @@ vec4 ps_color()
 #if (PS_FST == 0)
 	vec2 st = PSin.t_float.xy / vec2(PSin.t_float.w);
 	vec2 st_int = PSin.t_int.zw / vec2(PSin.t_float.w);
+#elif PS_ROUND_UV != 0
+	vec4 t_int_rounded = round_uv();
+	vec2 st = t_int_rounded.xy;
+	vec2 st_int = t_int_rounded.zw;
 #else
 	// Note xy are normalized coordinate
 	vec2 st = PSin.t_int.xy;

bin/resources/shaders/opengl/tfx_vgs.glsl

@@ -27,10 +27,24 @@ out SHADER
 	#else
 		flat vec4 c;
 	#endif
+	#if VS_ROUND_UV
+		flat uvec4 rounduv;
+	#endif
 } VSout;
 
 const float exp_min32 = exp2(-32.0f);
 
+uvec4 extract_round_uv_bits(float q)
+{
+	uint qi = floatBitsToUint(q);
+	return uvec4(
+		(qi >> 0) & 0xFFF,  // Prim left
+		(qi >> 12) & 0xFFF, // Prim top
+		(qi >> 24) & 0xF,   // Round U flags
+		(qi >> 28) & 0xF    // Round V flags
+	);
+}
+
 #if VS_EXPAND == 0
 
 layout(location = 0) in vec2  i_st;
@@ -78,11 +92,15 @@ void vs_main()
 	texture_coord();
 
 	VSout.c = i_c;
-	VSout.t_float.z = i_f.x; // pack for with texture
+	VSout.t_float.z = i_f.x; // pack fog with texture
 
 	#if VS_POINT_SIZE
 		gl_PointSize = PointSize.x;
 	#endif
+
+	#if VS_ROUND_UV
+		VSout.rounduv = extract_round_uv_bits(i_q);
+	#endif
 }
 
 #else // VS_EXPAND
@@ -108,6 +126,9 @@ struct ProcessedVertex
 	vec4 t_float;
 	vec4 t_int;
 	vec4 c;
+#if VS_ROUND_UV
+	uvec4 rounduv;
+#endif
 };
 
 ProcessedVertex load_vertex(uint index)
@@ -147,6 +168,10 @@ ProcessedVertex load_vertex(uint index)
 	vtx.c = i_c;
 	vtx.t_float.z = i_f.x;
 
+#if VS_ROUND_UV
+	vtx.rounduv = extract_round_uv_bits(i_q);
+#endif
+
 	return vtx;
 }
 
@@ -210,6 +235,9 @@ void main()
 	VSout.t_float = vtx.t_float;
 	VSout.t_int = vtx.t_int;
 	VSout.c = vtx.c;
+#if VS_ROUND_UV
+	VSout.rounduv = vtx.rounduv;
+#endif
 }
 
 #endif // VS_EXPAND

bin/resources/shaders/vulkan/tfx.glsl

@@ -28,8 +28,22 @@ layout(location = 0) out VSOutput
 	#else
 		flat vec4 c;
 	#endif
+	#if VS_ROUND_UV
+		flat uvec4 rounduv;
+	#endif
 } vsOut;
 
+uvec4 extract_round_uv_bits(float q)
+{
+	uint qi = floatBitsToUint(q);
+	return uvec4(
+		(qi >> 0) & 0xFFF,  // Prim left
+		(qi >> 12) & 0xFFF, // Prim top
+		(qi >> 24) & 0xF,   // Round U flags
+		(qi >> 28) & 0xF    // Round V flags
+	);
+}
+
 #if VS_EXPAND == 0
 
 layout(location = 0) in vec2 a_st;
@@ -84,6 +98,10 @@ void main()
 
 	vsOut.c = vec4(a_c);
 	vsOut.t.z = a_f.r;
+
+#if VS_ROUND_UV
+	vsOut.rounduv = extract_round_uv_bits(a_q);
+#endif
 }
 
 #else // VS_EXPAND
@@ -109,6 +127,9 @@ struct ProcessedVertex
 	vec4 t;
 	vec4 ti;
 	vec4 c;
+#if VS_ROUND_UV
+	uvec4 rounduv;
+#endif
 };
 
 ProcessedVertex load_vertex(uint index)
@@ -153,6 +174,10 @@ ProcessedVertex load_vertex(uint index)
 	vtx.c = a_c;
 	vtx.t.z = a_f.r;
 
+#if VS_ROUND_UV
+	vtx.rounduv = extract_round_uv_bits(a_q);
+#endif
+
 	return vtx;
 }
 
@@ -217,6 +242,9 @@ void main()
 	vsOut.t = vtx.t;
 	vsOut.ti = vtx.ti;
 	vsOut.c = vtx.c;
+#if VS_ROUND_UV
+	vsOut.rounduv = vtx.rounduv;
+#endif
 }
 
 #endif // VS_EXPAND
@@ -291,6 +319,7 @@ void main()
 #define PS_ZFLOOR 0
 #define PS_FEEDBACK_LOOP 0
 #define PS_TEX_IS_FB 0
+#define PS_ROUND_UV 0
 #endif
 
 #define SW_BLEND (PS_BLEND_A || PS_BLEND_B || PS_BLEND_D)
@@ -333,6 +362,9 @@ layout(location = 0) in VSOutput
 	#else
 		flat vec4 c;
 	#endif
+	#if PS_ROUND_UV
+		flat uvec4 rounduv;
+	#endif
 } vsIn;
 
 #if !PS_NO_COLOR && !PS_NO_COLOR1
@@ -503,6 +535,35 @@ vec4 clamp_wrap_uv(vec4 uv)
 	return uv;
 }
 
+vec4 round_uv()
+{
+#if PS_ROUND_UV
+	// Whether we are at the top or left of the prim.
+	ivec2 topleft = ivec2(equal(ivec2(gl_FragCoord.xy), ivec2(vsIn.rounduv.xy)));
+
+	// Extract flags for whether to round U, V.
+	ivec2 round_flags = ivec2(vsIn.rounduv.zw);
+
+	// Being on the top or left pixels converts round down to round up.
+	ivec2 round_down = ivec2(equal(round_flags, ivec2(PS_ROUND_UV_DOWN))) & ~topleft;
+	ivec2 round_up = ivec2(equal(round_flags, ivec2(PS_ROUND_UV_UP))) |
+	                 (ivec2(equal(round_flags, ivec2(PS_ROUND_UV_DOWN))) & topleft);
+
+	vec2 uv = vsIn.ti.zw; // Unnormalized UVs.
+	vec2 uvi = round(vsIn.ti.zw / 8.0f) * 8.0f; // Nearest half texel.
+	
+	ivec2 close = ivec2(lessThan(abs(uv - uvi), vec2(PS_ROUND_UV_THRESHOLD)));
+
+	// Round only if close to a half texel.
+	uv = mix(uv, uvi - PS_ROUND_UV_THRESHOLD, bvec2(close & round_down));
+	uv = mix(uv, uvi + PS_ROUND_UV_THRESHOLD, bvec2(close & round_up));
+
+	return vec4(uv / 16.0f / WH.xy, uv); // Return normalized and unnormalized coords.
+#else
+	return vec4(0.0f);
+#endif
+}
+
 mat4 sample_4c(vec4 uv)
 {
 	mat4 c;
@@ -923,6 +984,10 @@ vec4 ps_color()
 #if PS_FST == 0
 	vec2 st = vsIn.t.xy / vsIn.t.w;
 	vec2 st_int = vsIn.ti.zw / vsIn.t.w;
+#elif PS_ROUND_UV != 0
+	vec4 ti_rounded = round_uv();
+	vec2 st = ti_rounded.xy;
+	vec2 st_int = ti_rounded.zw;
 #else
 	vec2 st = vsIn.ti.xy;
 	vec2 st_int = vsIn.ti.zw;

pcsx2/Config.h

@@ -764,6 +764,7 @@ struct Pcsx2Config
 					PreloadFrameWithGSData : 1,
 					Mipmap : 1,
 					HWMipmap : 1,
+					AccurateUVRounding : 1,
 					ManualUserHacks : 1,
 					UserHacks_AlignSpriteX : 1,
 					UserHacks_CPUFBConversion : 1,