diff --git a/bin/resources/shaders/dx11/present.fx b/bin/resources/shaders/dx11/present.fx
index 2456fff3a2..043097d240 100644
--- a/bin/resources/shaders/dx11/present.fx
+++ b/bin/resources/shaders/dx11/present.fx
@@ -66,7 +66,7 @@ VS_OUTPUT vs_main(VS_INPUT input)
 PS_OUTPUT ps_copy(PS_INPUT input)
 {
 	PS_OUTPUT output;
-	
+
 	output.c = sample_c(input.t);
 
 	return output;
@@ -74,24 +74,24 @@ PS_OUTPUT ps_copy(PS_INPUT input)
 
 float4 ps_crt(PS_INPUT input, int i)
 {
-	float4 mask[4] = 
-	{
-		float4(1, 0, 0, 0), 
-		float4(0, 1, 0, 0), 
-		float4(0, 0, 1, 0), 
-		float4(1, 1, 1, 0)
-	};
-	
+	float4 mask[4] =
+		{
+			float4(1, 0, 0, 0),
+			float4(0, 1, 0, 0),
+			float4(0, 0, 1, 0),
+			float4(1, 1, 1, 0)
+		};
+
 	return sample_c(input.t) * saturate(mask[i] + 0.5f);
 }
 
 float4 ps_scanlines(PS_INPUT input, int i)
 {
 	float4 mask[2] =
-	{
-		float4(1, 1, 1, 0),
-		float4(0, 0, 0, 0)
-	};
+		{
+			float4(1, 1, 1, 0),
+			float4(0, 0, 0, 0)
+		};
 
 	return sample_c(input.t) * saturate(mask[i] + 0.5f);
 }
@@ -99,7 +99,7 @@ float4 ps_scanlines(PS_INPUT input, int i)
 PS_OUTPUT ps_filter_scanlines(PS_INPUT input)
 {
 	PS_OUTPUT output;
-	
+
 	uint4 p = (uint4)input.p;
 
 	output.c = ps_scanlines(input, p.y % 2);
@@ -124,7 +124,7 @@ PS_OUTPUT ps_filter_triangular(PS_INPUT input)
 
 	uint4 p = (uint4)input.p;
 
-	// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3); 
+	// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
 	output.c = ps_crt(input, ((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
 
 	return output;
@@ -143,4 +143,257 @@ PS_OUTPUT ps_filter_complex(PS_INPUT input) // triangular
 	return output;
 }
 
+//Lottes CRT
+#define MaskingType 4                      //[1|2|3|4] The type of CRT shadow masking used. 1: compressed TV style, 2: Aperture-grille, 3: Stretched VGA style, 4: VGA style.
+#define ScanBrightness -8.00               //[-16.0 to 1.0] The overall brightness of the scanline effect. Lower for darker, higher for brighter.
+#define FilterCRTAmount -1.00              //[-4.0 to 1.0] The amount of filtering used, to replicate the TV CRT look. Lower for less, higher for more.
+#define HorizontalWarp 0.00                //[0.0 to 0.1] The distortion warping effect for the horizontal (x) axis of the screen. Use small increments.
+#define VerticalWarp 0.00                  //[0.0 to 0.1] The distortion warping effect for the verticle (y) axis of the screen. Use small increments.
+#define MaskAmountDark 0.80                //[0.0 to 1.0] The value of the dark masking line effect used. Lower for darker lower end masking, higher for brighter.
+#define MaskAmountLight 1.50               //[0.0 to 2.0] The value of the light masking line effect used. Lower for darker higher end masking, higher for brighter.
+#define ResolutionScale 2.00               //[0.1 to 4.0] The scale of the image resolution. Lowering this can give off a nice retro TV look. Raising it can clear up the image.
+#define MaskResolutionScale 0.80           //[0.1 to 2.0] The scale of the CRT mask resolution. Use this for balancing the scanline mask scale for difference resolution scaling.
+#define UseShadowMask 1                    //[0 or 1] Enables, or disables the use of the CRT shadow mask. 0 is disabled, 1 is enabled.
+
+float ToLinear1(float c)
+{
+	c = saturate(c);
+	return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
+}
+
+float3 ToLinear(float3 c)
+{
+	return float3(ToLinear1(c.r), ToLinear1(c.g), ToLinear1(c.b));
+}
+
+float ToSrgb1(float c)
+{
+	c = saturate(c);
+	return c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055;
+}
+
+float3 ToSrgb(float3 c)
+{
+	return float3(ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
+}
+
+float3 Fetch(float2 pos, float2 off)
+{
+	float2 screenSize = u_source_resolution;
+	float2 res = (screenSize * ResolutionScale);
+	pos = round(pos * res + off) / res;
+	if (max(abs(pos.x - 0.5), abs(pos.y - 0.5)) > 0.5)
+	{
+		return float3(0.0, 0.0, 0.0);
+	}
+	else
+	{
+		return ToLinear(Texture.Sample(TextureSampler, pos.xy).rgb);
+	}
+}
+
+float2 Dist(float2 pos)
+{
+	float2 crtRes = u_rcp_target_resolution;
+	float2 res = (crtRes * MaskResolutionScale);
+	pos = (pos * res);
+
+	return -((pos - floor(pos)) - float2(0.5, 0.5));
+}
+
+float Gaus(float pos, float scale)
+{
+	return exp2(scale * pos * pos);
+}
+
+float3 Horz3(float2 pos, float off)
+{
+	float3 b = Fetch(pos, float2(-1.0, off));
+	float3 c = Fetch(pos, float2(0.0, off));
+	float3 d = Fetch(pos, float2(1.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+
+	return (b * wb) + (c * wc) + (d * wd) / (wb + wc + wd);
+}
+
+float3 Horz5(float2 pos, float off)
+{
+	float3 a = Fetch(pos, float2(-2.0, off));
+	float3 b = Fetch(pos, float2(-1.0, off));
+	float3 c = Fetch(pos, float2(0.0, off));
+	float3 d = Fetch(pos, float2(1.0, off));
+	float3 e = Fetch(pos, float2(2.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+
+	float wa = Gaus(dst - 2.0, scale);
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+	float we = Gaus(dst + 2.0, scale);
+
+	return (a * wa) + (b * wb) + (c * wc) + (d * wd) + (e * we) / (wa + wb + wc + wd + we);
+}
+
+// Return scanline weight.
+float Scan(float2 pos, float off)
+{
+	float dst = Dist(pos).y;
+	return Gaus(dst + off, ScanBrightness);
+}
+
+float3 Tri(float2 pos)
+{
+	float3 a = Horz3(pos, -1.0);
+	float3 b = Horz5(pos, 0.0);
+	float3 c = Horz3(pos, 1.0);
+
+	float wa = Scan(pos, -1.0);
+	float wb = Scan(pos, 0.0);
+	float wc = Scan(pos, 1.0);
+
+	return (a * wa) + (b * wb) + (c * wc);
+}
+
+float2 Warp(float2 pos)
+{
+	pos = pos * 2.0 - 1.0;
+	pos *= float2(1.0 + (pos.y * pos.y) * HorizontalWarp, 1.0 + (pos.x * pos.x) * VerticalWarp);
+	return pos * 0.5 + 0.5;
+}
+
+float3 Mask(float2 pos)
+{
+#if MaskingType == 1
+	// Very compressed TV style shadow mask.
+	float lines = MaskAmountLight;
+	float odd = 0.0;
+
+	if (frac(pos.x / 6.0) < 0.5)
+	{
+		odd = 1.0;
+	}
+	if (frac((pos.y + odd) / 2.0) < 0.5)
+	{
+		lines = MaskAmountDark;
+	}
+	pos.x = frac(pos.x / 3.0);
+	float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	mask *= lines;
+
+	return mask;
+
+#elif MaskingType == 2
+	// Aperture-grille.
+	pos.x = frac(pos.x / 3.0);
+	float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#elif MaskingType == 3
+	// Stretched VGA style shadow mask (same as prior shaders).
+	pos.x += pos.y * 3.0;
+	float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = frac(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#else
+	// VGA style shadow mask.
+	pos.xy = floor(pos.xy * float2(1.0, 0.5));
+	pos.x += pos.y * 3.0;
+
+	float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = frac(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+	return mask;
+#endif
+}
+
+float4 LottesCRTPass(float4 fragcoord)
+{
+	fragcoord -= u_target_rect;
+	float2 inSize = u_target_resolution - (2 * u_target_rect.xy);
+	float4 color;
+	float2 pos = Warp(fragcoord.xy / inSize);
+
+#if UseShadowMask == 0
+	color.rgb = Tri(pos);
+#else
+	color.rgb = Tri(pos) * Mask(fragcoord.xy);
+#endif
+	color.rgb = ToSrgb(color.rgb);
+	color.a = 1.0;
+
+	return color;
+}
+
+PS_OUTPUT ps_filter_lottes(PS_INPUT input)
+{
+	PS_OUTPUT output;
+	output.c = LottesCRTPass(input.p);
+
+	return output;
+}
+
 #endif
diff --git a/bin/resources/shaders/opengl/present.glsl b/bin/resources/shaders/opengl/present.glsl
index 911dd01f4a..3e2b07ceec 100644
--- a/bin/resources/shaders/opengl/present.glsl
+++ b/bin/resources/shaders/opengl/present.glsl
@@ -21,10 +21,10 @@ out vec4 PSin_c;
 
 void vs_main()
 {
-    PSin_p = vec4(POSITION, 0.5f, 1.0f);
-    PSin_t = TEXCOORD0;
-    PSin_c = COLOR;
-    gl_Position = vec4(POSITION, 0.5f, 1.0f); // NOTE I don't know if it is possible to merge POSITION_OUT and gl_Position
+	PSin_p = vec4(POSITION, 0.5f, 1.0f);
+	PSin_t = TEXCOORD0;
+	PSin_c = COLOR;
+	gl_Position = vec4(POSITION, 0.5f, 1.0f); // NOTE I don't know if it is possible to merge POSITION_OUT and gl_Position
 }
 
 #endif
@@ -50,69 +50,66 @@ layout(location = 0) out vec4 SV_Target0;
 
 vec4 sample_c()
 {
-    return texture(TextureSampler, PSin_t);
+	return texture(TextureSampler, PSin_t);
 }
 
 vec4 ps_crt(uint i)
 {
-    vec4 mask[4] = vec4[4]
-        (
-         vec4(1, 0, 0, 0),
-         vec4(0, 1, 0, 0),
-         vec4(0, 0, 1, 0),
-         vec4(1, 1, 1, 0)
-        );
-    return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
+	vec4 mask[4] = vec4[4](
+		vec4(1, 0, 0, 0),
+		vec4(0, 1, 0, 0),
+		vec4(0, 0, 1, 0),
+		vec4(1, 1, 1, 0));
+	return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
 }
 
 #ifdef ps_copy
 void ps_copy()
 {
-    SV_Target0 = sample_c();
+	SV_Target0 = sample_c();
 }
 #endif
 
 #ifdef ps_filter_scanlines
 vec4 ps_scanlines(uint i)
 {
-    vec4 mask[2] =
-    {
-        vec4(1, 1, 1, 0),
-        vec4(0, 0, 0, 0)
-    };
+	vec4 mask[2] =
+		{
+			vec4(1, 1, 1, 0),
+			vec4(0, 0, 0, 0)};
 
-    return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
+	return sample_c() * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
 }
 
 void ps_filter_scanlines() // scanlines
 {
-    highp uvec4 p = uvec4(gl_FragCoord);
+	highp uvec4 p = uvec4(gl_FragCoord);
 
-    vec4 c = ps_scanlines(p.y % 2u);
+	vec4 c = ps_scanlines(p.y % 2u);
 
-    SV_Target0 = c;
+	SV_Target0 = c;
 }
 #endif
 
 #ifdef ps_filter_diagonal
 void ps_filter_diagonal() // diagonal
 {
-    highp uvec4 p = uvec4(gl_FragCoord);
+	highp uvec4 p = uvec4(gl_FragCoord);
 
-    vec4 c = ps_crt((p.x + (p.y % 3u)) % 3u);
+	vec4 c = ps_crt((p.x + (p.y % 3u)) % 3u);
 
-    SV_Target0 = c;
+	SV_Target0 = c;
 }
 #endif
 
 #ifdef ps_filter_triangular
 void ps_filter_triangular() // triangular
 {
-    highp uvec4 p = uvec4(gl_FragCoord);
+	highp uvec4 p = uvec4(gl_FragCoord);
 
-    vec4 c = ps_crt(((p.x + ((p.y >> 1u) & 1u) * 3u) >> 1u) % 3u);
+	vec4 c = ps_crt(((p.x + ((p.y >> 1u) & 1u) * 3u) >> 1u) % 3u);
 
-    SV_Target0 = c;
+	SV_Target0 = c;
 }
 #endif
 
@@ -124,8 +121,265 @@ void ps_filter_complex()
     float factor = (0.9f - 0.4f * cos(2.0f * PI * PSin_t.y * texdim.y));
     vec4 c =  factor * texture(TextureSampler, vec2(PSin_t.x, (floor(PSin_t.y * texdim.y) + 0.5f) / texdim.y));
 
-    SV_Target0 = c;
+	SV_Target0 = c;
 }
 #endif
 
+#ifdef ps_filter_lottes
+
+#define MaskingType 4                      //[1|2|3|4] The type of CRT shadow masking used. 1: compressed TV style, 2: Aperture-grille, 3: Stretched VGA style, 4: VGA style.
+#define ScanBrightness -8.00               //[-16.0 to 1.0] The overall brightness of the scanline effect. Lower for darker, higher for brighter.
+#define FilterCRTAmount -1.00              //[-4.0 to 1.0] The amount of filtering used, to replicate the TV CRT look. Lower for less, higher for more.
+#define HorizontalWarp 0.00                //[0.0 to 0.1] The distortion warping effect for the horizontal (x) axis of the screen. Use small increments.
+#define VerticalWarp 0.00                  //[0.0 to 0.1] The distortion warping effect for the verticle (y) axis of the screen. Use small increments.
+#define MaskAmountDark 0.80                //[0.0 to 1.0] The value of the dark masking line effect used. Lower for darker lower end masking, higher for brighter.
+#define MaskAmountLight 1.50               //[0.0 to 2.0] The value of the light masking line effect used. Lower for darker higher end masking, higher for brighter.
+#define ResolutionScale 2.00               //[0.1 to 4.0] The scale of the image resolution. Lowering this can give off a nice retro TV look. Raising it can clear up the image.
+#define MaskResolutionScale 0.80           //[0.1 to 2.0] The scale of the CRT mask resolution. Use this for balancing the scanline mask scale for difference resolution scaling.
+#define UseShadowMask 1                    //[0 or 1] Enables, or disables the use of the CRT shadow mask. 0 is disabled, 1 is enabled.
+
+#define saturate(x) clamp(x, 0.0, 1.0)
+
+float ToLinear1(float c)
+{
+	c = saturate(c);
+	return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
+}
+
+vec3 ToLinear(vec3 c)
+{
+	return vec3(ToLinear1(c.r), ToLinear1(c.g), ToLinear1(c.b));
+}
+
+float ToSrgb1(float c)
+{
+	c = saturate(c);
+	return c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055;
+}
+
+vec3 ToSrgb(vec3 c)
+{
+	return vec3(ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
+}
+
+vec3 Fetch(vec2 pos, vec2 off)
+{
+	vec2 screenSize = u_source_resolution;
+	vec2 res = (screenSize * ResolutionScale);
+	pos = round(pos * res + off) / res;
+	if (max(abs(pos.x - 0.5), abs(pos.y - 0.5)) > 0.5)
+	{
+		return vec3(0.0, 0.0, 0.0);
+	}
+	else
+	{
+		return ToLinear(texture(TextureSampler, pos.xy).rgb);
+	}
+}
+
+vec2 Dist(vec2 pos)
+{
+	vec2 crtRes = u_rcp_target_resolution;
+	vec2 res = (crtRes * MaskResolutionScale);
+	pos = (pos * res);
+
+	return -((pos - floor(pos)) - vec2(0.5, 0.5));
+}
+
+float Gaus(float pos, float scale)
+{
+	return exp2(scale * pos * pos);
+}
+
+vec3 Horz3(vec2 pos, float off)
+{
+	vec3 b = Fetch(pos, vec2(-1.0, off));
+	vec3 c = Fetch(pos, vec2(0.0, off));
+	vec3 d = Fetch(pos, vec2(1.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+
+	return (b * wb) + (c * wc) + (d * wd) / (wb + wc + wd);
+}
+
+vec3 Horz5(vec2 pos, float off)
+{
+	vec3 a = Fetch(pos, vec2(-2.0, off));
+	vec3 b = Fetch(pos, vec2(-1.0, off));
+	vec3 c = Fetch(pos, vec2(0.0, off));
+	vec3 d = Fetch(pos, vec2(1.0, off));
+	vec3 e = Fetch(pos, vec2(2.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+
+	float wa = Gaus(dst - 2.0, scale);
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+	float we = Gaus(dst + 2.0, scale);
+
+	return (a * wa) + (b * wb) + (c * wc) + (d * wd) + (e * we) / (wa + wb + wc + wd + we);
+}
+
+// Return scanline weight.
+float Scan(vec2 pos, float off)
+{
+	float dst = Dist(pos).y;
+	return Gaus(dst + off, ScanBrightness);
+}
+
+vec3 Tri(vec2 pos)
+{
+	vec3 a = Horz3(pos, -1.0);
+	vec3 b = Horz5(pos, 0.0);
+	vec3 c = Horz3(pos, 1.0);
+
+	float wa = Scan(pos, -1.0);
+	float wb = Scan(pos, 0.0);
+	float wc = Scan(pos, 1.0);
+
+	return (a * wa) + (b * wb) + (c * wc);
+}
+
+vec2 Warp(vec2 pos)
+{
+	pos = pos * 2.0 - 1.0;
+	pos *= vec2(1.0 + (pos.y * pos.y) * HorizontalWarp, 1.0 + (pos.x * pos.x) * VerticalWarp);
+	return pos * 0.5 + 0.5;
+}
+
+vec3 Mask(vec2 pos)
+{
+#if MaskingType == 1
+	// Very compressed TV style shadow mask.
+	float lines = MaskAmountLight;
+	float odd = 0.0;
+
+	if (fract(pos.x / 6.0) < 0.5)
+	{
+		odd = 1.0;
+	}
+	if (fract((pos.y + odd) / 2.0) < 0.5)
+	{
+		lines = MaskAmountDark;
+	}
+	pos.x = fract(pos.x / 3.0);
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	mask *= lines;
+
+	return mask;
+
+#elif MaskingType == 2
+	// Aperture-grille.
+	pos.x = fract(pos.x / 3.0);
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#elif MaskingType == 3
+	// Stretched VGA style shadow mask (same as prior shaders).
+	pos.x += pos.y * 3.0;
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = fract(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#else
+	// VGA style shadow mask.
+	pos.xy = floor(pos.xy * vec2(1.0, 0.5));
+	pos.x += pos.y * 3.0;
+
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = fract(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+	return mask;
+#endif
+}
+
+vec4 LottesCRTPass()
+{
+	//flipped y axis in opengl
+	vec2 fragcoord = vec2(gl_FragCoord.x, u_target_resolution.y - gl_FragCoord.y) - u_target_rect.xy;
+	vec4 color;
+	vec2 inSize = u_target_resolution - (2 * u_target_rect.xy);
+
+	vec2 pos = Warp(fragcoord.xy / inSize);
+
+#if UseShadowMask == 0
+	color.rgb = Tri(pos);
+#else
+	color.rgb = Tri(pos) * Mask(fragcoord.xy);
+#endif
+	color.rgb = ToSrgb(color.rgb);
+	color.a = 1.0;
+
+	return color;
+}
+
+void ps_filter_lottes()
+{
+	SV_Target0 = LottesCRTPass();
+}
+
+#endif
+
 #endif
diff --git a/bin/resources/shaders/vulkan/present.glsl b/bin/resources/shaders/vulkan/present.glsl
index 68c1d438e5..33cd93d690 100644
--- a/bin/resources/shaders/vulkan/present.glsl
+++ b/bin/resources/shaders/vulkan/present.glsl
@@ -46,25 +46,22 @@ vec4 sample_c(vec2 uv)
 
 vec4 ps_crt(uint i)
 {
-		vec4 mask[4] = vec4[4]
-				(
-				 vec4(1, 0, 0, 0),
-				 vec4(0, 1, 0, 0),
-				 vec4(0, 0, 1, 0),
-				 vec4(1, 1, 1, 0)
-				);
-		return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
+	vec4 mask[4] = vec4[4](
+		vec4(1, 0, 0, 0),
+		vec4(0, 1, 0, 0),
+		vec4(0, 0, 1, 0),
+		vec4(1, 1, 1, 0));
+	return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
 }
 
 vec4 ps_scanlines(uint i)
 {
-		vec4 mask[2] =
+	vec4 mask[2] =
 		{
-				vec4(1, 1, 1, 0),
-				vec4(0, 0, 0, 0)
-		};
+			vec4(1, 1, 1, 0),
+			vec4(0, 0, 0, 0)};
 
-		return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
+	return sample_c(v_tex) * clamp((mask[i] + 0.5f), 0.0f, 1.0f);
 }
 
 #ifdef ps_copy
@@ -96,7 +93,7 @@ void ps_filter_triangular() // triangular
 {
 	uvec4 p = uvec4(gl_FragCoord);
 
-	// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3); 
+	// output.c = ps_crt(input, ((p.x + (p.y & 1) * 3) >> 1) % 3);
 	o_col0 = ps_crt(((p.x + ((p.y >> 1) & 1) * 3) >> 1) % 3);
 }
 #endif
@@ -111,4 +108,260 @@ void ps_filter_complex() // triangular
 }
 #endif
 
+#ifdef ps_filter_lottes
+
+#define MaskingType 4                      //[1|2|3|4] The type of CRT shadow masking used. 1: compressed TV style, 2: Aperture-grille, 3: Stretched VGA style, 4: VGA style.
+#define ScanBrightness -8.00               //[-16.0 to 1.0] The overall brightness of the scanline effect. Lower for darker, higher for brighter.
+#define FilterCRTAmount -1.00              //[-4.0 to 1.0] The amount of filtering used, to replicate the TV CRT look. Lower for less, higher for more.
+#define HorizontalWarp 0.00                //[0.0 to 0.1] The distortion warping effect for the horizontal (x) axis of the screen. Use small increments.
+#define VerticalWarp 0.00                  //[0.0 to 0.1] The distortion warping effect for the verticle (y) axis of the screen. Use small increments.
+#define MaskAmountDark 0.80                //[0.0 to 1.0] The value of the dark masking line effect used. Lower for darker lower end masking, higher for brighter.
+#define MaskAmountLight 1.50               //[0.0 to 2.0] The value of the light masking line effect used. Lower for darker higher end masking, higher for brighter.
+#define ResolutionScale 2.00               //[0.1 to 4.0] The scale of the image resolution. Lowering this can give off a nice retro TV look. Raising it can clear up the image.
+#define MaskResolutionScale 0.80           //[0.1 to 2.0] The scale of the CRT mask resolution. Use this for balancing the scanline mask scale for difference resolution scaling.
+#define UseShadowMask 1                    //[0 or 1] Enables, or disables the use of the CRT shadow mask. 0 is disabled, 1 is enabled.
+
+#define saturate(x) clamp(x, 0.0, 1.0)
+
+float ToLinear1(float c)
+{
+	c = saturate(c);
+	return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
+}
+
+vec3 ToLinear(vec3 c)
+{
+	return vec3(ToLinear1(c.r), ToLinear1(c.g), ToLinear1(c.b));
+}
+
+float ToSrgb1(float c)
+{
+	c = saturate(c);
+	return c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055;
+}
+
+vec3 ToSrgb(vec3 c)
+{
+	return vec3(ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
+}
+
+vec3 Fetch(vec2 pos, vec2 off)
+{
+	vec2 screenSize = u_source_resolution;
+	vec2 res = (screenSize * ResolutionScale);
+	pos = round(pos * res + off) / res;
+	if (max(abs(pos.x - 0.5), abs(pos.y - 0.5)) > 0.5)
+	{
+		return vec3(0.0, 0.0, 0.0);
+	}
+	else
+	{
+		return ToLinear(texture(samp0, pos.xy).rgb);
+	}
+}
+
+vec2 Dist(vec2 pos)
+{
+	vec2 crtRes = u_rcp_target_resolution;
+	vec2 res = (crtRes * MaskResolutionScale);
+	pos = (pos * res);
+
+	return -((pos - floor(pos)) - vec2(0.5, 0.5));
+}
+
+float Gaus(float pos, float scale)
+{
+	return exp2(scale * pos * pos);
+}
+
+vec3 Horz3(vec2 pos, float off)
+{
+	vec3 b = Fetch(pos, vec2(-1.0, off));
+	vec3 c = Fetch(pos, vec2(0.0, off));
+	vec3 d = Fetch(pos, vec2(1.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+
+	return (b * wb) + (c * wc) + (d * wd) / (wb + wc + wd);
+}
+
+vec3 Horz5(vec2 pos, float off)
+{
+	vec3 a = Fetch(pos, vec2(-2.0, off));
+	vec3 b = Fetch(pos, vec2(-1.0, off));
+	vec3 c = Fetch(pos, vec2(0.0, off));
+	vec3 d = Fetch(pos, vec2(1.0, off));
+	vec3 e = Fetch(pos, vec2(2.0, off));
+	float dst = Dist(pos).x;
+
+	// Convert distance to weight.
+	float scale = FilterCRTAmount;
+
+	float wa = Gaus(dst - 2.0, scale);
+	float wb = Gaus(dst - 1.0, scale);
+	float wc = Gaus(dst + 0.0, scale);
+	float wd = Gaus(dst + 1.0, scale);
+	float we = Gaus(dst + 2.0, scale);
+
+	return (a * wa) + (b * wb) + (c * wc) + (d * wd) + (e * we) / (wa + wb + wc + wd + we);
+}
+
+// Return scanline weight.
+float Scan(vec2 pos, float off)
+{
+	float dst = Dist(pos).y;
+	return Gaus(dst + off, ScanBrightness);
+}
+
+vec3 Tri(vec2 pos)
+{
+	vec3 a = Horz3(pos, -1.0);
+	vec3 b = Horz5(pos, 0.0);
+	vec3 c = Horz3(pos, 1.0);
+
+	float wa = Scan(pos, -1.0);
+	float wb = Scan(pos, 0.0);
+	float wc = Scan(pos, 1.0);
+
+	return (a * wa) + (b * wb) + (c * wc);
+}
+
+vec2 Warp(vec2 pos)
+{
+	pos = pos * 2.0 - 1.0;
+	pos *= vec2(1.0 + (pos.y * pos.y) * HorizontalWarp, 1.0 + (pos.x * pos.x) * VerticalWarp);
+	return pos * 0.5 + 0.5;
+}
+
+vec3 Mask(vec2 pos)
+{
+#if MaskingType == 1
+	// Very compressed TV style shadow mask.
+	float lines = MaskAmountLight;
+	float odd = 0.0;
+
+	if (fract(pos.x / 6.0) < 0.5)
+	{
+		odd = 1.0;
+	}
+	if (fract((pos.y + odd) / 2.0) < 0.5)
+	{
+		lines = MaskAmountDark;
+	}
+	pos.x = fract(pos.x / 3.0);
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	mask *= lines;
+
+	return mask;
+
+#elif MaskingType == 2
+	// Aperture-grille.
+	pos.x = fract(pos.x / 3.0);
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#elif MaskingType == 3
+	// Stretched VGA style shadow mask (same as prior shaders).
+	pos.x += pos.y * 3.0;
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = fract(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+
+	return mask;
+
+#else
+	// VGA style shadow mask.
+	pos.xy = floor(pos.xy * vec2(1.0, 0.5));
+	pos.x += pos.y * 3.0;
+
+	vec3 mask = vec3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+	pos.x = fract(pos.x / 6.0);
+
+	if (pos.x < 0.333)
+	{
+		mask.r = MaskAmountLight;
+	}
+	else if (pos.x < 0.666)
+	{
+		mask.g = MaskAmountLight;
+	}
+	else
+	{
+		mask.b = MaskAmountLight;
+	}
+	return mask;
+#endif
+}
+
+vec4 LottesCRTPass()
+{
+	vec4 fragcoord = gl_FragCoord - u_target_rect;
+	vec4 color;
+	vec2 inSize = u_target_resolution - (2 * u_target_rect.xy);
+
+	vec2 pos = Warp(fragcoord.xy / inSize);
+
+#if UseShadowMask == 0
+	color.rgb = Tri(pos);
+#else
+	color.rgb = Tri(pos) * Mask(fragcoord.xy);
+#endif
+	color.rgb = ToSrgb(color.rgb);
+	color.a = 1.0;
+
+	return color;
+}
+
+void ps_filter_lottes()
+{
+	o_col0 = LottesCRTPass();
+}
+
+#endif
+
 #endif
\ No newline at end of file
diff --git a/pcsx2-qt/Settings/GraphicsSettingsWidget.ui b/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
index 46aa3a5311..835c79a72b 100644
--- a/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
+++ b/pcsx2-qt/Settings/GraphicsSettingsWidget.ui
@@ -1240,6 +1240,11 @@
               <string>Wave Filter</string>
              </property>
             </item>
+            <item>
+             <property name="text">
+              <string>Lottes CRT</string>
+             </property>
+            </item>
            </widget>
           </item>
          </layout>
diff --git a/pcsx2/GS/GS.cpp b/pcsx2/GS/GS.cpp
index ddf1823a82..a4791cf772 100644
--- a/pcsx2/GS/GS.cpp
+++ b/pcsx2/GS/GS.cpp
@@ -1325,6 +1325,7 @@ void GSApp::Init()
 	m_gs_tv_shaders.push_back(GSSetting(2, "Diagonal filter", ""));
 	m_gs_tv_shaders.push_back(GSSetting(3, "Triangular filter", ""));
 	m_gs_tv_shaders.push_back(GSSetting(4, "Wave filter", ""));
+	m_gs_tv_shaders.push_back(GSSetting(5, "Lottes CRT filter", ""));
 
 	m_gs_dump_compression.push_back(GSSetting(static_cast<u32>(GSDumpCompressionMethod::Uncompressed), "Uncompressed", ""));
 	m_gs_dump_compression.push_back(GSSetting(static_cast<u32>(GSDumpCompressionMethod::LZMA), "LZMA (xz)", ""));
diff --git a/pcsx2/GS/Renderers/Common/GSDevice.cpp b/pcsx2/GS/Renderers/Common/GSDevice.cpp
index 29d463da14..869217fc14 100644
--- a/pcsx2/GS/Renderers/Common/GSDevice.cpp
+++ b/pcsx2/GS/Renderers/Common/GSDevice.cpp
@@ -57,6 +57,7 @@ const char* shaderName(PresentShader value)
 		case PresentShader::DIAGONAL_FILTER:   return "ps_filter_diagonal";
 		case PresentShader::TRIANGULAR_FILTER: return "ps_filter_triangular";
 		case PresentShader::COMPLEX_FILTER:    return "ps_filter_complex";
+		case PresentShader::LOTTES_FILTER:     return "ps_filter_lottes";
 			// clang-format on
 		default:
 			ASSERT(0);
diff --git a/pcsx2/GS/Renderers/Common/GSDevice.h b/pcsx2/GS/Renderers/Common/GSDevice.h
index 69cff9e49f..8cb97ffe2e 100644
--- a/pcsx2/GS/Renderers/Common/GSDevice.h
+++ b/pcsx2/GS/Renderers/Common/GSDevice.h
@@ -58,6 +58,7 @@ enum class PresentShader
 	DIAGONAL_FILTER,
 	TRIANGULAR_FILTER,
 	COMPLEX_FILTER,
+	LOTTES_FILTER,
 	Count
 };
 
diff --git a/pcsx2/GS/Renderers/Common/GSRenderer.cpp b/pcsx2/GS/Renderers/Common/GSRenderer.cpp
index 9ff542c8ed..4018d9c759 100644
--- a/pcsx2/GS/Renderers/Common/GSRenderer.cpp
+++ b/pcsx2/GS/Renderers/Common/GSRenderer.cpp
@@ -56,10 +56,10 @@ static std::string GetDumpSerial()
 }
 #endif
 
-static constexpr std::array<PresentShader, 5> s_tv_shader_indices = {
+static constexpr std::array<PresentShader, 6> s_tv_shader_indices = {
 	PresentShader::COPY, PresentShader::SCANLINE,
 	PresentShader::DIAGONAL_FILTER, PresentShader::TRIANGULAR_FILTER,
-	PresentShader::COMPLEX_FILTER};
+	PresentShader::COMPLEX_FILTER, PresentShader::LOTTES_FILTER};
 
 std::unique_ptr<GSRenderer> g_gs_renderer;
 
diff --git a/pcsx2/GS/Renderers/Metal/present.metal b/pcsx2/GS/Renderers/Metal/present.metal
index 179b38f7f8..899a046508 100644
--- a/pcsx2/GS/Renderers/Metal/present.metal
+++ b/pcsx2/GS/Renderers/Metal/present.metal
@@ -71,3 +71,260 @@ fragment float4 ps_filter_complex(ConvertShaderData data [[stage_in]], ConvertPS
 	
 	return factor * res.sample(float2(data.t.x, ycoord));
 }
+
+#define MaskingType 4                      //[1|2|3|4] The type of CRT shadow masking used. 1: compressed TV style, 2: Aperture-grille, 3: Stretched VGA style, 4: VGA style.
+#define ScanBrightness -8.00               //[-16.0 to 1.0] The overall brightness of the scanline effect. Lower for darker, higher for brighter.
+#define FilterCRTAmount -1.00              //[-4.0 to 1.0] The amount of filtering used, to replicate the TV CRT look. Lower for less, higher for more.
+#define HorizontalWarp 0.00                //[0.0 to 0.1] The distortion warping effect for the horizontal (x) axis of the screen. Use small increments.
+#define VerticalWarp 0.00                  //[0.0 to 0.1] The distortion warping effect for the verticle (y) axis of the screen. Use small increments.
+#define MaskAmountDark 0.80                //[0.0 to 1.0] The value of the dark masking line effect used. Lower for darker lower end masking, higher for brighter.
+#define MaskAmountLight 1.50               //[0.0 to 2.0] The value of the light masking line effect used. Lower for darker higher end masking, higher for brighter.
+#define ResolutionScale 2.00               //[0.1 to 4.0] The scale of the image resolution. Lowering this can give off a nice retro TV look. Raising it can clear up the image.
+#define MaskResolutionScale 0.80           //[0.1 to 2.0] The scale of the CRT mask resolution. Use this for balancing the scanline mask scale for difference resolution scaling.
+#define UseShadowMask 1                    //[0 or 1] Enables, or disables the use of the CRT shadow mask. 0 is disabled, 1 is enabled.
+
+struct LottesCRTPass
+{
+	thread ConvertPSRes& res;
+	constant GSMTLPresentPSUniform& uniform;
+	LottesCRTPass(thread ConvertPSRes& res, constant GSMTLPresentPSUniform& uniform): res(res), uniform(uniform) {}
+
+	float ToLinear1(float c)
+	{
+		c = saturate(c);
+		return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
+	}
+
+	float3 ToLinear(float3 c)
+	{
+		return float3(ToLinear1(c.r), ToLinear1(c.g), ToLinear1(c.b));
+	}
+
+	float ToSrgb1(float c)
+	{
+		c = saturate(c);
+		return c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055;
+	}
+
+	float3 ToSrgb(float3 c)
+	{
+		return float3(ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
+	}
+
+	float3 Fetch(float2 pos, float2 off)
+	{
+		float2 screenSize = uniform.source_resolution;
+		float2 scaledRes = (screenSize * ResolutionScale);
+		pos = round(pos * scaledRes + off) / scaledRes;
+		if (max(abs(pos.x - 0.5), abs(pos.y - 0.5)) > 0.5)
+		{
+			return float3(0.0, 0.0, 0.0);
+		}
+		else
+		{
+			return ToLinear(res.sample(pos.xy).rgb);
+		}
+	}
+
+	float2 Dist(float2 pos)
+	{
+		float2 crtRes = uniform.rcp_target_resolution;
+		float2 res = (crtRes * MaskResolutionScale);
+		pos = (pos * res);
+
+		return -((pos - floor(pos)) - float2(0.5, 0.5));
+	}
+
+	float Gaus(float pos, float scale)
+	{
+		return exp2(scale * pos * pos);
+	}
+
+	float3 Horz3(float2 pos, float off)
+	{
+		float3 b = Fetch(pos, float2(-1.0, off));
+		float3 c = Fetch(pos, float2(0.0, off));
+		float3 d = Fetch(pos, float2(1.0, off));
+		float dst = Dist(pos).x;
+
+		// Convert distance to weight.
+		float scale = FilterCRTAmount;
+		float wb = Gaus(dst - 1.0, scale);
+		float wc = Gaus(dst + 0.0, scale);
+		float wd = Gaus(dst + 1.0, scale);
+
+		return (b * wb) + (c * wc) + (d * wd) / (wb + wc + wd);
+	}
+
+	float3 Horz5(float2 pos, float off)
+	{
+		float3 a = Fetch(pos, float2(-2.0, off));
+		float3 b = Fetch(pos, float2(-1.0, off));
+		float3 c = Fetch(pos, float2(0.0, off));
+		float3 d = Fetch(pos, float2(1.0, off));
+		float3 e = Fetch(pos, float2(2.0, off));
+		float dst = Dist(pos).x;
+
+		// Convert distance to weight.
+		float scale = FilterCRTAmount;
+
+		float wa = Gaus(dst - 2.0, scale);
+		float wb = Gaus(dst - 1.0, scale);
+		float wc = Gaus(dst + 0.0, scale);
+		float wd = Gaus(dst + 1.0, scale);
+		float we = Gaus(dst + 2.0, scale);
+
+		return (a * wa) + (b * wb) + (c * wc) + (d * wd) + (e * we) / (wa + wb + wc + wd + we);
+	}
+
+	// Return scanline weight.
+	float Scan(float2 pos, float off)
+	{
+		float dst = Dist(pos).y;
+		return Gaus(dst + off, ScanBrightness);
+	}
+
+	float3 Tri(float2 pos)
+	{
+		float3 a = Horz3(pos, -1.0);
+		float3 b = Horz5(pos, 0.0);
+		float3 c = Horz3(pos, 1.0);
+
+		float wa = Scan(pos, -1.0);
+		float wb = Scan(pos, 0.0);
+		float wc = Scan(pos, 1.0);
+
+		return (a * wa) + (b * wb) + (c * wc);
+	}
+
+	float2 Warp(float2 pos)
+	{
+		pos = pos * 2.0 - 1.0;
+		pos *= float2(1.0 + (pos.y * pos.y) * HorizontalWarp, 1.0 + (pos.x * pos.x) * VerticalWarp);
+		return pos * 0.5 + 0.5;
+	}
+
+	float3 Mask(float2 pos)
+	{
+#if MaskingType == 1
+		// Very compressed TV style shadow mask.
+		float lines = MaskAmountLight;
+		float odd = 0.0;
+
+		if (fract(pos.x / 6.0) < 0.5)
+		{
+			odd = 1.0;
+		}
+		if (fract((pos.y + odd) / 2.0) < 0.5)
+		{
+			lines = MaskAmountDark;
+		}
+		pos.x = fract(pos.x / 3.0);
+		float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+		if (pos.x < 0.333)
+		{
+			mask.r = MaskAmountLight;
+		}
+		else if (pos.x < 0.666)
+		{
+			mask.g = MaskAmountLight;
+		}
+		else
+		{
+			mask.b = MaskAmountLight;
+		}
+
+		mask *= lines;
+
+		return mask;
+
+#elif MaskingType == 2
+		// Aperture-grille.
+		pos.x = fract(pos.x / 3.0);
+		float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+
+		if (pos.x < 0.333)
+		{
+			mask.r = MaskAmountLight;
+		}
+		else if (pos.x < 0.666)
+		{
+			mask.g = MaskAmountLight;
+		}
+		else
+		{
+			mask.b = MaskAmountLight;
+		}
+
+		return mask;
+
+#elif MaskingType == 3
+		// Stretched VGA style shadow mask (same as prior shaders).
+		pos.x += pos.y * 3.0;
+		float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+		pos.x = fract(pos.x / 6.0);
+
+		if (pos.x < 0.333)
+		{
+			mask.r = MaskAmountLight;
+		}
+		else if (pos.x < 0.666)
+		{
+			mask.g = MaskAmountLight;
+		}
+		else
+		{
+			mask.b = MaskAmountLight;
+		}
+
+		return mask;
+
+#else
+		// VGA style shadow mask.
+		pos.xy = floor(pos.xy * float2(1.0, 0.5));
+		pos.x += pos.y * 3.0;
+
+		float3 mask = float3(MaskAmountDark, MaskAmountDark, MaskAmountDark);
+		pos.x = fract(pos.x / 6.0);
+
+		if (pos.x < 0.333)
+		{
+			mask.r = MaskAmountLight;
+		}
+		else if (pos.x < 0.666)
+		{
+			mask.g = MaskAmountLight;
+		}
+		else
+		{
+			mask.b = MaskAmountLight;
+		}
+		return mask;
+#endif
+	}
+
+	float4 Run(float4 fragcoord)
+	{
+		fragcoord -= uniform.target_rect;
+		float2 inSize = uniform.target_resolution - (2 * uniform.target_rect.xy);
+		float4 color;
+		float2 pos = Warp(fragcoord.xy / inSize);
+
+#if UseShadowMask == 0
+		color.rgb = Tri(pos);
+#else
+		color.rgb = Tri(pos) * Mask(fragcoord.xy);
+#endif
+		color.rgb = ToSrgb(color.rgb);
+		color.a = 1.0;
+
+		return color;
+	}
+};
+
+fragment float4 ps_filter_lottes(ConvertShaderData data [[stage_in]], ConvertPSRes res,
+	constant GSMTLPresentPSUniform& uniform [[buffer(GSMTLBufferIndexUniforms)]])
+{
+	return LottesCRTPass(res, uniform).Run(data.p);
+}