From ce35f910f3a66e77e49d6b044cd1b0bbaf30f3f8 Mon Sep 17 00:00:00 2001 From: cosmo0 Date: Tue, 6 Feb 2018 09:47:10 +0100 Subject: [PATCH] Changes shaders structure to match the (probably) future retropie versions --- .../all/retroarch/overlay_cfg/n64.cfg | 2 +- .../all/retroarch/overlay_cfg/psx.cfg | 2 +- .../all/retroarch/shaders/README.md | 3 + .../all/retroarch/shaders/resources/iqLUT.png | Bin 468 -> 0 bytes .../retroarch/shaders/resources/scanLUT.png | Bin 595 -> 0 bytes .../shaders/shaders/sharp_quilez_gamma.glsl | 120 --------- .../shaders/shaders/zfast_crt_curve.glsl | 45 ++-- .../shaders/zfast_crt_curve_vertical.glsl | 229 ++++++++++++++++++ .../shaders/shaders/zfast_crt_standard.glsl | 11 +- ....glsl => zfast_crt_standard_vertical.glsl} | 104 ++++---- .../shaders/shaders/zfast_lcd_720p.glsl | 163 ------------- .../shaders/zfast_resources/zfast_iqlut.png | Bin 0 -> 275 bytes .../shaders/zfast_resources/zfast_scanlut.png | Bin 0 -> 723 bytes .../shaders/zfast_crt_720p_PI3.glslp | 8 - .../retroarch/shaders/zfast_crt_curve.glslp | 4 +- .../shaders/zfast_crt_curve_vertical.glslp | 17 ++ .../shaders/zfast_crt_standard.glslp | 1 + ...lslp => zfast_crt_standard_vertical.glslp} | 3 +- .../retroarch/shaders/zfast_lcd_720p.glslp | 8 - .../shaders/zfast_lcd_standard.glslp | 1 + .../all/retroarch/shaders/zfast_readme.txt | 52 ---- 21 files changed, 344 insertions(+), 429 deletions(-) create mode 100644 overlays_shaders/all/retroarch/shaders/README.md delete mode 100644 overlays_shaders/all/retroarch/shaders/resources/iqLUT.png delete mode 100644 overlays_shaders/all/retroarch/shaders/resources/scanLUT.png delete mode 100644 overlays_shaders/all/retroarch/shaders/shaders/sharp_quilez_gamma.glsl create mode 100644 overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve_vertical.glsl rename overlays_shaders/all/retroarch/shaders/shaders/{zfast_crt_720p_PI3.glsl => zfast_crt_standard_vertical.glsl} (59%) delete mode 100644 overlays_shaders/all/retroarch/shaders/shaders/zfast_lcd_720p.glsl create mode 100644 overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_iqlut.png create mode 100644 overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_scanlut.png delete mode 100644 overlays_shaders/all/retroarch/shaders/zfast_crt_720p_PI3.glslp create mode 100644 overlays_shaders/all/retroarch/shaders/zfast_crt_curve_vertical.glslp rename overlays_shaders/all/retroarch/shaders/{sharp_quilez_gamma.glslp => zfast_crt_standard_vertical.glslp} (75%) delete mode 100644 overlays_shaders/all/retroarch/shaders/zfast_lcd_720p.glslp delete mode 100644 overlays_shaders/all/retroarch/shaders/zfast_readme.txt diff --git a/overlays_shaders/all/retroarch/overlay_cfg/n64.cfg b/overlays_shaders/all/retroarch/overlay_cfg/n64.cfg index 0df4ca8..f85205c 100755 --- a/overlays_shaders/all/retroarch/overlay_cfg/n64.cfg +++ b/overlays_shaders/all/retroarch/overlay_cfg/n64.cfg @@ -1,7 +1,7 @@ # N64 # overwrite shader to a non-curved one -video_shader = "/opt/retropie/configs/all/retroarch/shaders/zfast_crt_720p_PI3.glslp" +video_shader = "/opt/retropie/configs/all/retroarch/shaders/zfast_crt_standard.glslp" #include "/opt/retropie/configs/all/retroarch/overlay_cfg/common_crt.cfg" diff --git a/overlays_shaders/all/retroarch/overlay_cfg/psx.cfg b/overlays_shaders/all/retroarch/overlay_cfg/psx.cfg index f99dc2b..b805015 100755 --- a/overlays_shaders/all/retroarch/overlay_cfg/psx.cfg +++ b/overlays_shaders/all/retroarch/overlay_cfg/psx.cfg @@ -1,7 +1,7 @@ # PSX # overwrite shader to non-curved one -video_shader = "/opt/retropie/configs/all/retroarch/shaders/zfast_crt_720p_PI3.glslp" +video_shader = "/opt/retropie/configs/all/retroarch/shaders/zfast_crt_standard.glslp" #include "/opt/retropie/configs/all/retroarch/overlay_cfg/common_crt.cfg" diff --git a/overlays_shaders/all/retroarch/shaders/README.md b/overlays_shaders/all/retroarch/shaders/README.md new file mode 100644 index 0000000..984a283 --- /dev/null +++ b/overlays_shaders/all/retroarch/shaders/README.md @@ -0,0 +1,3 @@ +ZFast shaders by G. Hogan + +https://retropie.org.uk/forum/topic/13356/ diff --git a/overlays_shaders/all/retroarch/shaders/resources/iqLUT.png b/overlays_shaders/all/retroarch/shaders/resources/iqLUT.png deleted file mode 100644 index 11d3920f8b8033ea99b1478e6152c77def92eb49..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 468 zcmV;_0W1EAP)dr9I4byB=YrMqMJm3L$xc&b-i=#P0gCp!fLa+zS z4)$>9e@D2$6|O^*p`m!0rWd0yhz^07her#c`T4mlz(}FCq+k^@8U*zC^yvC^8=|iH z0Tl|~N$r!(ltZ^Q19baQ2RbKtCY|AtbjKUj3_V5=S8g05}`?0UsZR0rSYb%_W3U(yC zaZ0L&Tm-}yh>?a~laksQTPM^1TteQDv;Eu4oU6axm+`vJ#BumFPlT*3@j8+yBg(6b z_$3_LjYD2$H=oSY<+GOxkxR=-6Msu=2GB?Ioki%7CvSqZq$4bga1cE&rQkx97w zllz1{2x#Dc3l09NZqxJgkw$TX)&LfcB2l7hetma43$g|NS@{DSu&;FO0KGo|0000< KMNUMnLSTZ+WZAp` diff --git a/overlays_shaders/all/retroarch/shaders/resources/scanLUT.png b/overlays_shaders/all/retroarch/shaders/resources/scanLUT.png deleted file mode 100644 index 58b7f5b8093733b0120d2172a738422e55e02275..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 595 zcmV-Z0<8UsP)n4oRfG3E(%31FVs`0mInHYRZYw)&Es(td?1-RV-^7_-%ND4oVb< zQ%f!$sKN+cZ&t9l3XQka0QVUdFM!+^I?zSk?+-Eu_)EHuI_9+kL!^g8Bml1FGA&kC z8sH^){bYb75@@4y(rlECg^ZpZ8J9rEju7nw4@d|5yoO&|p1Rg54!YazWDYit0`wo{ zS!w|6tzlY~R?*F7BMS;P&U>ahRzb@c+=_waW5dH+zP8vb9QXd}= z=rPJ4M|ygC3cATo>dzv*yu1YLSWEH^q;VVr0r@s^(1)0OSD-Ef8sCH>M87x5%2mXb z%3=cAhHf2SQ__crhYxNv3Vd!S-`?H^0`o_OSo*vGBjmAk*!jaMj+kCuU9rMv1w!rx z3@rC&YEIrG>cI%TzP@JHNudhf8N3gu;mckIFlrX4q37r4!5nngnSWY&pQyyZ(jAQj zaHmhqU`Mrh4XVPR{?d;H$iDb&Q8kh1*>Z7lAv5^I!;2a|fON%AvPb`Pe13U$&&OdL zUnatK(zLIXaY8|10=&_?ySq91mTWZF1NIjRyy6y*jUh hRIzd@U_(*`UIASHFdSKM;1U1;002ovPDHLkV1mtB2x= 130 -#define COMPAT_VARYING out -#define COMPAT_ATTRIBUTE in -#define COMPAT_TEXTURE texture -#else -#define COMPAT_VARYING varying -#define COMPAT_ATTRIBUTE attribute -#define COMPAT_TEXTURE texture2D -#endif - -#ifdef GL_ES -#define COMPAT_PRECISION mediump -#else -#define COMPAT_PRECISION -#endif -COMPAT_VARYING float _frame_rotation; -COMPAT_VARYING vec4 _color1; -struct output_dummy { - vec4 _color1; -}; -struct input_dummy { - vec2 _video_size; - vec2 _texture_size; - vec2 _output_dummy_size; - float _frame_count; - float _frame_direction; - float _frame_rotation; -}; -vec4 _oPosition1; -vec4 _r0005; -COMPAT_ATTRIBUTE vec4 VertexCoord; -COMPAT_ATTRIBUTE vec4 COLOR; -COMPAT_ATTRIBUTE vec4 TexCoord; -COMPAT_VARYING vec4 COL0; -COMPAT_VARYING vec4 TEX0; - -uniform mat4 MVPMatrix; -uniform int FrameDirection; -uniform int FrameCount; -uniform COMPAT_PRECISION vec2 OutputSize; -uniform COMPAT_PRECISION vec2 TextureSize; -uniform COMPAT_PRECISION vec2 InputSize; -void main() -{ - vec4 _oColor; - vec2 _otexCoord; - _r0005 = VertexCoord.x*MVPMatrix[0]; - _r0005 = _r0005 + VertexCoord.y*MVPMatrix[1]; - _r0005 = _r0005 + VertexCoord.z*MVPMatrix[2]; - _r0005 = _r0005 + VertexCoord.w*MVPMatrix[3]; - _oPosition1 = _r0005; - _oColor = COLOR; - _otexCoord = TexCoord.xy; - gl_Position = _r0005; - COL0 = COLOR; - TEX0.xy = TexCoord.xy; -} -#elif defined(FRAGMENT) - -#if __VERSION__ >= 130 -#define COMPAT_VARYING in -#define COMPAT_TEXTURE texture -out vec4 FragColor; -#else -#define COMPAT_VARYING varying -#define FragColor gl_FragColor -#define COMPAT_TEXTURE texture2D -#endif - -#ifdef GL_ES -#ifdef GL_FRAGMENT_PRECISION_HIGH -precision highp float; -#else -precision mediump float; -#endif -#define COMPAT_PRECISION mediump -#else -#define COMPAT_PRECISION -#endif -COMPAT_VARYING float _frame_rotation; -COMPAT_VARYING vec4 _color; -struct output_dummy { - vec4 _color; -}; -struct input_dummy { - vec2 _video_size; - vec2 _texture_size; - vec2 _output_dummy_size; - float _frame_count; - float _frame_direction; - float _frame_rotation; -}; -input_dummy _IN1; -uniform sampler2D Texture; -COMPAT_VARYING vec4 TEX0; - -uniform int FrameDirection; -uniform int FrameCount; -uniform COMPAT_PRECISION vec2 OutputSize; -uniform COMPAT_PRECISION vec2 TextureSize; -uniform COMPAT_PRECISION vec2 InputSize; -void main() -{ - vec2 p; - vec2 i; - vec2 f; - output_dummy _OUT; - p = TEX0.xy*TextureSize; - i = floor(p); - f = p - i - 0.5; - p = (i + f*f*f*f*f*16.0 + 0.5)/TextureSize; - _OUT._color = COMPAT_TEXTURE(Texture, p); - _OUT._color.rgb *= (0.84+0.16*_OUT._color.rgb); - FragColor = _OUT._color; - return; -} -#endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve.glsl b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve.glsl index 3439e2e..27b1f1c 100644 --- a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve.glsl +++ b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve.glsl @@ -27,11 +27,8 @@ Notes: This shader does sharp scaling on the x and y axes based on the //This can't be an option without slowing the shader down //Comment this out for a coarser 3 pixel mask...which is currently broken //on SNES Classic Edition due to Mali 400 gpu precision -#define FINEMASK -//Some drivers don't return black with texture coordinates out of bounds -//SNES Classic is too slow to black these areas out when using fullscreen -//overlays. But you can uncomment the below to black them out if necessary -#define BLACK_OUT_BORDER +//#define FINEMASK +//#define VERTICAL // Compatibility #ifdefs needed for parameters #ifdef GL_ES @@ -41,11 +38,10 @@ Notes: This shader does sharp scaling on the x and y axes based on the #endif // Parameter lines go here: -#pragma parameter CURVE "Curvature" 0.025 0.0 0.05 0.002 -#pragma parameter CORNER "Corner" 0.6 0.0 5.0 0.2 -#pragma parameter LOWLUMSCAN "Scanline Darkness" 3.0 0.0 10.0 0.5 -#pragma parameter BRIGHTBOOST "Brightness Boost" 1.0 0.5 1.5 0.05 -#pragma parameter MASK_DARK "Mask Effect Amount" 0.1 0.0 1.0 0.05 +#pragma parameter CURVE "Curvature" 0.016 0.0 0.3 0.002 +#pragma parameter CORNER "Corner" 0.3 0.0 20.0 0.1 +#pragma parameter LOWLUMSCAN "Scanline Darkness" 2.0 0.0 6.0 0.1 +#pragma parameter MASK_DARK "Mask Effect Amount" 0.05 0.0 1.0 0.01 #ifdef PARAMETER_UNIFORM // All parameter floats need to have COMPAT_PRECISION in front of them @@ -170,9 +166,12 @@ COMPAT_VARYING vec2 iscreenScale; vec2 warp(vec2 pos){ pos = -1.0 + 2.0*pos; vec2 p = pos*pos; - pos*=vec2(1.0+1.33*CURVE*p.y ,1.0+CURVE*p.x); - //return clamp(pos*0.5+0.5 , 0.0 , 1.0); - return clamp(pos*0.5+0.5,0.0,1.0); +#if defined(VERTICAL) + pos*=vec2(1.0 + CURVE*p.y ,1.0 + 1.3333*CURVE*p.x); +#else + pos*=vec2(1.0 + 1.3333*CURVE*p.y ,1.0 + CURVE*p.x); +#endif + return clamp(pos*0.5+0.5, 0.0, 1.0); } void main() @@ -197,12 +196,21 @@ void main() colour = texture(Source, p).rgb; //fix tc to p //compute the aperture mask + #if defined(FINEMASK) - COMPAT_PRECISION float whichmask = fract( gl_FragCoord.x*0.5); - COMPAT_PRECISION float mask = BRIGHTBOOST + float(whichmask < 0.5) * -MASK_DARK; +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract( gl_FragCoord.y*-0.4999); +#else + COMPAT_PRECISION float whichmask = fract( gl_FragCoord.x*-0.4999); +#endif + COMPAT_PRECISION float mask = 1.0 + float(whichmask < 0.5) * -MASK_DARK; +#else +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract(gl_FragCoord.y * -0.3333); #else COMPAT_PRECISION float whichmask = fract(gl_FragCoord.x * -0.3333); - COMPAT_PRECISION float mask = BRIGHTBOOST + float(whichmask <= 0.33333) * -MASK_DARK; +#endif + COMPAT_PRECISION float mask = 1.0 + float(whichmask <= 0.33333) * -MASK_DARK; #endif //Compute the scanlines. It was actually slower to use a texture LUT for @@ -211,7 +219,8 @@ void main() f -= 0.5; COMPAT_PRECISION float Y = f.y*f.y; COMPAT_PRECISION float YY = Y*Y; - FragColor.rgb = colour.rgb*(mask - LOWLUMSCAN*(Y - 2.05*YY)); - + //FragColor.rgb = colour.rgb*(mask - LOWLUMSCAN*(Y - 2.05*YY)); //Original + FragColor.rgb = colour.rgb*(mask - LOWLUMSCAN*(Y - 5.5*YY*Y)); + } #endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve_vertical.glsl b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve_vertical.glsl new file mode 100644 index 0000000..3faa983 --- /dev/null +++ b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_curve_vertical.glsl @@ -0,0 +1,229 @@ +/* + zfast_crt_curve_vertical - A simple, fast CRT shader for vertical monitor games. + + Copyright (C) 2017 Greg Hogan (SoltanGris42) + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + +Notes: This shader does sharp scaling on the x and y axes based on the + algorithm by Inigo Quilez here: + http://http://www.iquilezles.org/www/articles/texture/texture.htm + but modified to be somewhat sharper. Then a scanline effect is applied + along with a monochrome aperture mask. This shader is a simplified version + of my zfast_crt_standard shader that has an adjustable curvature effect + added. It is slower that the standard version of the filter, but still + generally runs as 60fps on the Raspberry Pi 3 hardware at a resolution + of 1440x1080px. + + The vertical version adds a rotated aperture mask for vertical games + on horizontal monitors. +*/ + +//For testing compilation +//#define FRAGMENT +//#define VERTEX + +//This can't be an option without slowing the shader down +//Comment this out for a coarser 3 pixel mask...which is currently broken +//on SNES Classic Edition due to Mali 400 gpu precision +#define FINEMASK +#define VERTICAL + +// Compatibility #ifdefs needed for parameters +#ifdef GL_ES +#define COMPAT_PRECISION mediump +#else +#define COMPAT_PRECISION +#endif + +// Parameter lines go here: +#pragma parameter CURVE "Curvature" 0.016 0.0 0.3 0.002 +#pragma parameter CORNER "Corner" 0.3 0.0 20.0 0.1 +#pragma parameter LOWLUMSCAN "Scanline Darkness" 1.6 0.0 6.0 0.1 +#pragma parameter MASK_DARK "Mask Effect Amount" 0.05 0.0 1.0 0.01 + +#ifdef PARAMETER_UNIFORM +// All parameter floats need to have COMPAT_PRECISION in front of them +uniform COMPAT_PRECISION float LOWLUMSCAN; +uniform COMPAT_PRECISION float BRIGHTBOOST; +uniform COMPAT_PRECISION float MASK_DARK; +uniform COMPAT_PRECISION float CURVE; +uniform COMPAT_PRECISION float CORNER; + +#else +#define LOWLUMSCAN 2.5 +#define BRIGHTBOOST 1.1 +#define MASK_DARK 0.25 +#define CURVE 0.025 +#define CORNER 1.6 +#endif + +#if defined(VERTEX) + +#if __VERSION__ >= 130 +#define COMPAT_VARYING out +#define COMPAT_ATTRIBUTE in +#define COMPAT_TEXTURE texture +#else +#define COMPAT_VARYING varying +#define COMPAT_ATTRIBUTE attribute +#define COMPAT_TEXTURE texture2D +#endif + +#ifdef GL_ES +#define COMPAT_PRECISION mediump +#else +#define COMPAT_PRECISION +#endif + +COMPAT_ATTRIBUTE vec4 VertexCoord; +COMPAT_ATTRIBUTE vec4 COLOR; +COMPAT_ATTRIBUTE vec4 TexCoord; +COMPAT_VARYING vec4 COL0; +COMPAT_VARYING vec4 TEX0; +// out variables go here as COMPAT_VARYING whatever +COMPAT_VARYING float maskFade; +COMPAT_VARYING float cornerConst; +COMPAT_VARYING vec2 invDims; +COMPAT_VARYING vec2 screenScale; +COMPAT_VARYING vec2 iscreenScale; + +vec4 _oPosition1; +uniform mat4 MVPMatrix; +uniform COMPAT_PRECISION int FrameDirection; +uniform COMPAT_PRECISION int FrameCount; +uniform COMPAT_PRECISION vec2 OutputSize; +uniform COMPAT_PRECISION vec2 TextureSize; +uniform COMPAT_PRECISION vec2 InputSize; + +// compatibility #defines +#define vTexCoord TEX0.xy +#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize +#define OutSize vec4(OutputSize, 1.0 / OutputSize) + + +void main() +{ + gl_Position = MVPMatrix * VertexCoord; + + TEX0.xy = (TexCoord.xy); + cornerConst = CORNER*0.0001; + invDims = 1.0/TextureSize.xy; + screenScale = TextureSize.xy/InputSize.xy; + iscreenScale = 1.0/screenScale; +} + +#elif defined(FRAGMENT) + +#if __VERSION__ >= 130 +#define COMPAT_VARYING in +#define COMPAT_TEXTURE texture +out vec4 FragColor; +#else +#define COMPAT_VARYING varying +#define FragColor gl_FragColor +#define COMPAT_TEXTURE texture2D +#endif + +#ifdef GL_ES +#ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +#else +precision mediump float; +#endif +#define COMPAT_PRECISION mediump +#else +#define COMPAT_PRECISION +#endif + +uniform COMPAT_PRECISION int FrameDirection; +uniform COMPAT_PRECISION int FrameCount; +uniform COMPAT_PRECISION vec2 OutputSize; +uniform COMPAT_PRECISION vec2 TextureSize; +uniform COMPAT_PRECISION vec2 InputSize; +uniform sampler2D Texture; +uniform sampler2D iqLUT; +uniform sampler2D scanLUT; + + +COMPAT_VARYING vec4 TEX0; +// in variables go here as COMPAT_VARYING whatever +COMPAT_VARYING float maskFade; +COMPAT_VARYING float cornerConst; +COMPAT_VARYING vec2 invDims; +COMPAT_VARYING vec2 screenScale; +COMPAT_VARYING vec2 iscreenScale; + + +// compatibility #defines +#define Source Texture +#define vTexCoord TEX0.xy +#define texture(c, d) COMPAT_TEXTURE(c, d) +#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize +#define OutSize vec4(OutputSize, 1.0 / OutputSize) + +vec2 warp(vec2 pos){ + pos = -1.0 + 2.0*pos; + vec2 p = pos*pos; +#if defined(VERTICAL) + pos*=vec2(1.0 + CURVE*p.y ,1.0 + 1.3333*CURVE*p.x); +#else + pos*=vec2(1.0 + 1.3333*CURVE*p.y ,1.0 + CURVE*p.x); +#endif + return clamp(pos*0.5+0.5, 0.0, 1.0); +} + +void main() +{ + //vec2 tc =TEX0.xy*screenScale; + vec2 tc = warp(TEX0.xy*screenScale); + + vec2 corn = min(tc,vec2(1.0)-tc); //This is used to mask the rounded + corn.x = cornerConst/corn.x; //corners later on + + tc*=iscreenScale; + COMPAT_PRECISION vec2 p = tc * TextureSize; + COMPAT_PRECISION vec2 f = fract(p); + +//We get the adjusted texture coordinates from a texture instead of math +//for speed now. It's still basically Quilez's "Improved Texture Filtering" + p = (floor(p) + texture(iqLUT,f).rg )*invDims; + +//This is how will black out the rounded corners + vec3 colour = vec3(0.0); + if (corn.y >= corn.x) + colour = texture(Source, p).rgb; //fix tc to p + +//compute the aperture mask + +#if defined(FINEMASK) +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract( gl_FragCoord.y*-0.4999); +#else + COMPAT_PRECISION float whichmask = fract( gl_FragCoord.x*-0.4999); +#endif + COMPAT_PRECISION float mask = 1.0 + float(whichmask < 0.5) * -MASK_DARK; +#else +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract(gl_FragCoord.y * -0.3333); +#else + COMPAT_PRECISION float whichmask = fract(gl_FragCoord.x * -0.3333); +#endif + COMPAT_PRECISION float mask = 1.0 + float(whichmask <= 0.33333) * -MASK_DARK; +#endif + +//Compute the scanlines. It was actually slower to use a texture LUT for +//the scanline profile so we're still using math + + f -= 0.5; + COMPAT_PRECISION float Y = f.y*f.y; + COMPAT_PRECISION float YY = Y*Y; + //FragColor.rgb = colour.rgb*(mask - LOWLUMSCAN*(Y - 2.05*YY)); //Original + FragColor.rgb = colour.rgb*(mask - LOWLUMSCAN*(Y - 5.5*YY*Y)); + +} +#endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard.glsl b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard.glsl index 364acc4..7fa3129 100644 --- a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard.glsl +++ b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard.glsl @@ -22,14 +22,9 @@ Notes: This shader does scaling with a weighted linear filter for adjustable //#define FRAGMENT //#define VERTEX -//This can't be an option without slowing the shader down -//Comment this out for a coarser 3 pixel mask...which is currently broken -//on SNES Classic Edition due to Mali 400 gpu precision #define FINEMASK -//Some drivers don't return black with texture coordinates out of bounds -//SNES Classic is too slow to black these areas out when using fullscreen -//overlays. But you can uncomment the below to black them out if necessary //#define BLACK_OUT_BORDER +//#define VERTICAL // Compatibility #ifdefs needed for parameters #ifdef GL_ES @@ -49,7 +44,6 @@ Notes: This shader does scaling with a weighted linear filter for adjustable #ifdef PARAMETER_UNIFORM // All parameter floats need to have COMPAT_PRECISION in front of them uniform COMPAT_PRECISION float BLURSCALEX; -//uniform COMPAT_PRECISION float BLURSCALEY; uniform COMPAT_PRECISION float LOWLUMSCAN; uniform COMPAT_PRECISION float HILUMSCAN; uniform COMPAT_PRECISION float BRIGHTBOOST; @@ -57,7 +51,6 @@ uniform COMPAT_PRECISION float MASK_DARK; uniform COMPAT_PRECISION float MASK_FADE; #else #define BLURSCALEX 0.45 -//#define BLURSCALEY 0.20 #define LOWLUMSCAN 5.0 #define HILUMSCAN 10.0 #define BRIGHTBOOST 1.25 @@ -188,4 +181,4 @@ void main() FragColor.rgb = colour.rgb*mix(scanLineWeight*mask, scanLineWeightB, dot(colour.rgb,vec3(maskFade))); } -#endif \ No newline at end of file +#endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_720p_PI3.glsl b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard_vertical.glsl similarity index 59% rename from overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_720p_PI3.glsl rename to overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard_vertical.glsl index 4b92b8e..cf33ec3 100644 --- a/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_720p_PI3.glsl +++ b/overlays_shaders/all/retroarch/shaders/shaders/zfast_crt_standard_vertical.glsl @@ -1,5 +1,5 @@ /* - zfast_crt_720p - A very simple CRT shader (Integer Scaling Only version). + zfast_crt_standard_vertical - A simple, fast CRT shader for vertical games. Copyright (C) 2017 Greg Hogan (SoltanGris42) @@ -9,21 +9,25 @@ any later version. -Notes: This shader does high quality scaling along the x-axis using a sharper - variation of the algorithm here: - - http://www.iquilezles.org/www/articles/texture/texture.htm. - - Designed for the 720p output of the snes classic edition, it assumes that - the game is scaled vertically by an integer factor of 3 and applies a - simple scanline effect. For a more full featured and adjustable CRT shader - at 1080p reolutions or above you should use the ZFAST_CRT shader instead. +Notes: This shader does scaling with a weighted linear filter for adjustable + sharpness on the x and y axes based on the algorithm by Inigo Quilez here: + http://http://www.iquilezles.org/www/articles/texture/texture.htm + but modified to be somewhat sharper. Then a scanline effect that varies + based on pixel brighness is applied along with a monochrome aperture mask. + This shader runs at 60fps on the Raspberry Pi 3 hardware at 2mpix/s + resolutions (1920x1080 or 1600x1200). + + The vertical version adds a rotated aperture mask for vertical games + on horizontal monitors. */ //For testing compilation //#define FRAGMENT //#define VERTEX -#define BLACK_OUT_BORDER + +#define FINEMASK +//#define BLACK_OUT_BORDER +#define VERTICAL // Compatibility #ifdefs needed for parameters #ifdef GL_ES @@ -33,28 +37,28 @@ Notes: This shader does high quality scaling along the x-axis using a sharper #endif // Parameter lines go here: -#pragma parameter BLURSCALEX "Blur Amount X-Axis" 0.4 0.0 1.0 0.05 -#pragma parameter SCANMULT "Scanline Multiplier(Low)" 2.6 0.0 10.0 0.2 -#pragma parameter HIGHSCANAMOUNT "Scanline Amount (High)" 0.20 0.0 1.0 0.05 -#pragma parameter MASK_DARK "Mask Effect Amount" 0.15 0.0 1.0 0.05 +#pragma parameter BLURSCALEX "Blur Amount X-Axis" 0.30 0.0 1.0 0.05 +#pragma parameter LOWLUMSCAN "Scanline Darkness - Low" 6.0 0.0 10.0 0.5 +#pragma parameter HILUMSCAN "Scanline Darkness - High" 8.0 0.0 50.0 1.0 +#pragma parameter BRIGHTBOOST "Dark Pixel Brightness Boost" 1.25 0.5 1.5 0.05 +#pragma parameter MASK_DARK "Mask Effect Amount" 0.25 0.0 1.0 0.05 #pragma parameter MASK_FADE "Mask/Scanline Fade" 0.8 0.0 1.0 0.05 -#pragma parameter FAKEGAMMA "Fake CRT Gamma Correction" 0.0 0.0 1.0 0.05 #ifdef PARAMETER_UNIFORM // All parameter floats need to have COMPAT_PRECISION in front of them uniform COMPAT_PRECISION float BLURSCALEX; -uniform COMPAT_PRECISION float SCANMULT; -uniform COMPAT_PRECISION float HIGHSCANAMOUNT; +uniform COMPAT_PRECISION float LOWLUMSCAN; +uniform COMPAT_PRECISION float HILUMSCAN; +uniform COMPAT_PRECISION float BRIGHTBOOST; uniform COMPAT_PRECISION float MASK_DARK; uniform COMPAT_PRECISION float MASK_FADE; -uniform COMPAT_PRECISION float FAKEGAMMA; #else -#define BLURSCALEX 0.40 -#define SCANMULT 2.6 -#define HIGHSCANAMOUNT 0.20 -#define MASK_DARK 0.20 +#define BLURSCALEX 0.45 +#define LOWLUMSCAN 5.0 +#define HILUMSCAN 10.0 +#define BRIGHTBOOST 1.25 +#define MASK_DARK 0.25 #define MASK_FADE 0.8 -#define FAKEGAMMA 0.0 #endif #if defined(VERTEX) @@ -81,7 +85,6 @@ COMPAT_ATTRIBUTE vec4 TexCoord; COMPAT_VARYING vec4 COL0; COMPAT_VARYING vec4 TEX0; // out variables go here as COMPAT_VARYING whatever -COMPAT_VARYING vec2 gammaConst; COMPAT_VARYING float maskFade; COMPAT_VARYING vec2 invDims; @@ -102,17 +105,11 @@ void main() { gl_Position = MVPMatrix * VertexCoord; - //Terrible adjustment to texture coordinates. - //Trying to integer scale and center image... - - COMPAT_PRECISION float intScale = floor(OutSize.y/InputSize.y); - COMPAT_PRECISION float adjustTexCoord = OutSize.y/InputSize.y/intScale; - COMPAT_PRECISION vec2 pixelsToMove = vec2(0.5*(OutSize.y-intScale*InputSize.y)*OutSize.x/OutSize.y,0.5*(OutSize.y-intScale*InputSize.y)); - TEX0.xy = (TexCoord.xy)*adjustTexCoord - (pixelsToMove/TextureSize.xy)/intScale; + TEX0.xy = (TexCoord.xy); maskFade = 0.3333*MASK_FADE; - gammaConst = vec2(1.0-0.3*FAKEGAMMA,0.3*FAKEGAMMA); invDims = 1.0/TextureSize.xy; } + #elif defined(FRAGMENT) #if __VERSION__ >= 130 @@ -144,7 +141,6 @@ uniform COMPAT_PRECISION vec2 InputSize; uniform sampler2D Texture; COMPAT_VARYING vec4 TEX0; // in variables go here as COMPAT_VARYING whatever -COMPAT_VARYING vec2 gammaConst; COMPAT_VARYING float maskFade; COMPAT_VARYING vec2 invDims; @@ -155,30 +151,46 @@ COMPAT_VARYING vec2 invDims; #define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize #define OutSize vec4(OutputSize, 1.0 / OutputSize) +// delete all 'params.' or 'registers.' or whatever in the fragment + void main() { //This is just like "Quilez Scaling" but sharper COMPAT_PRECISION vec2 p = vTexCoord * TextureSize; - COMPAT_PRECISION vec2 c = floor(p) + 0.5; - COMPAT_PRECISION vec2 f = p - c; - p = (c + 4.0*f*f*f)*invDims; + COMPAT_PRECISION vec2 i = floor(p) + 0.50; + COMPAT_PRECISION vec2 f = p - i; + p = (i + 4.0*f*f*f)*invDims; p.x = mix( p.x , vTexCoord.x, BLURSCALEX); - - COMPAT_PRECISION vec3 colour = texture(Source, p).rgb; - COMPAT_PRECISION float scanLine = fract(gl_FragCoord.y * 0.333333); - scanLine = (HIGHSCANAMOUNT)*float( scanLine > 0.5); + COMPAT_PRECISION float Y = f.y*f.y; + COMPAT_PRECISION float YY = Y*Y; +#if defined(FINEMASK) +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract( gl_FragCoord.y*-0.4999); +#else COMPAT_PRECISION float whichmask = fract( gl_FragCoord.x*-0.4999); +#endif COMPAT_PRECISION float mask = 1.0 + float(whichmask < 0.5) * -MASK_DARK; +#else +#if defined(VERTICAL) + COMPAT_PRECISION float whichmask = fract(gl_FragCoord.y * -0.3333); +#else + COMPAT_PRECISION float whichmask = fract(gl_FragCoord.x * -0.3333); +#endif + COMPAT_PRECISION float mask = 1.0 + float(whichmask <= 0.33333) * -MASK_DARK; +#endif - colour.rgb *= mix( mask*(1.0-scanLine*SCANMULT), 1.0-scanLine, dot(colour.rgb,vec3(maskFade))); + COMPAT_PRECISION vec3 colour = texture(Source, p).rgb; + + COMPAT_PRECISION float scanLineWeight = (BRIGHTBOOST - LOWLUMSCAN*(Y - 2.05*YY)); + COMPAT_PRECISION float scanLineWeightB = 1.0 - HILUMSCAN*(YY-2.8*YY*Y); #if defined(BLACK_OUT_BORDER) -colour.rgb*=float(vTexCoord.x > 0.0)*float(vTexCoord.y > 0.0); //why doesn't the driver do the right thing? + colour.rgb*=float(tc.x > 0.0)*float(tc.y > 0.0); //why doesn't the driver do the right thing? #endif - FragColor.rgb = colour.rgb; - + FragColor.rgb = colour.rgb*mix(scanLineWeight*mask, scanLineWeightB, dot(colour.rgb,vec3(maskFade))); + } -#endif \ No newline at end of file +#endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_lcd_720p.glsl b/overlays_shaders/all/retroarch/shaders/shaders/zfast_lcd_720p.glsl deleted file mode 100644 index b4c6f54..0000000 --- a/overlays_shaders/all/retroarch/shaders/shaders/zfast_lcd_720p.glsl +++ /dev/null @@ -1,163 +0,0 @@ -/* - zfast_lcd_720p - A very simple LCD shader (Integer Scaling Only version). - - Copyright (C) 2017 Greg Hogan (SoltanGris42) - - This program is free software; you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by the Free - Software Foundation; either version 2 of the License, or (at your option) - any later version. - - -Notes: This shader just does nearest neighbor scaling of the game and then - darkens the border pixels to imitate an LCD screen. You can change the - amount of darkening and the thickness of the borders. You can also - do basic gamma adjustment. - -*/ - -//For testing compilation -//#define FRAGMENT -//#define VERTEX -#define GBAGAMMA - -//Some drivers don't return black with texture coordinates out of bounds -//SNES Classic is too slow to black these areas out when using fullscreen -//overlays. But you can uncomment the below to black them out if necessary -#define BLACK_OUT_BORDER - -// Compatibility #ifdefs needed for parameters -#ifdef GL_ES -#define COMPAT_PRECISION mediump -#else -#define COMPAT_PRECISION -#endif - -#pragma parameter BORDERTHICK "Border Thickness" 0.2 0 0.5 0.02 -#pragma parameter BORDERMULT "Border Multiplier" 0.7 0.0 1.5 0.05 -#ifdef PARAMETER_UNIFORM -uniform COMPAT_PRECISION float BORDERTHICK; -uniform COMPAT_PRECISION float BORDERMULT; -#else -#define BORDERTHICK 0.2 -#define BORDERMULT 0.7 -#endif - -#if defined(VERTEX) - -#if __VERSION__ >= 130 -#define COMPAT_VARYING out -#define COMPAT_ATTRIBUTE in -#define COMPAT_TEXTURE texture -#else -#define COMPAT_VARYING varying -#define COMPAT_ATTRIBUTE attribute -#define COMPAT_TEXTURE texture2D -#endif - -#ifdef GL_ES -#define COMPAT_PRECISION mediump -#else -#define COMPAT_PRECISION -#endif - -/* COMPATIBILITY - - GLSL compilers -*/ - -COMPAT_ATTRIBUTE vec4 VertexCoord; -COMPAT_ATTRIBUTE vec4 COLOR; -COMPAT_ATTRIBUTE vec4 TexCoord; -COMPAT_VARYING vec4 COL0; -COMPAT_VARYING vec4 TEX0; - -vec4 _oPosition1; -uniform mat4 MVPMatrix; -uniform COMPAT_PRECISION int FrameDirection; -uniform COMPAT_PRECISION int FrameCount; -uniform COMPAT_PRECISION vec2 OutputSize; -uniform COMPAT_PRECISION vec2 TextureSize; -uniform COMPAT_PRECISION vec2 InputSize; - -// compatibility #defines -#define vTexCoord TEX0.xy -#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize -#define OutSize vec4(OutputSize, 1.0 / OutputSize) - -void main() -{ - gl_Position = MVPMatrix * VertexCoord; - - //Terrible adjustment to texture coordinates. - //Trying to integer scale and center image... - - COMPAT_PRECISION float intScale = floor(OutSize.y/InputSize.y); - COMPAT_PRECISION float adjustTexCoord = OutSize.y/InputSize.y/intScale; - COMPAT_PRECISION vec2 pixelsToMove = vec2(0.5*(OutSize.y-intScale*InputSize.y)*OutSize.x/OutSize.y,0.5*(OutSize.y-intScale*InputSize.y)); - TEX0.xy = (TexCoord.xy)*adjustTexCoord - (pixelsToMove/TextureSize.xy)/intScale; -} - -#elif defined(FRAGMENT) - -#if __VERSION__ >= 130 -#define COMPAT_VARYING in -#define COMPAT_TEXTURE texture -out vec4 FragColor; -#else -#define COMPAT_VARYING varying -#define FragColor gl_FragColor -#define COMPAT_TEXTURE texture2D -#endif - -#ifdef GL_ES -#ifdef GL_FRAGMENT_PRECISION_HIGH -precision highp float; -#else -precision mediump float; -#endif -#define COMPAT_PRECISION mediump -#else -#define COMPAT_PRECISION -#endif - -uniform COMPAT_PRECISION int FrameDirection; -uniform COMPAT_PRECISION int FrameCount; -uniform COMPAT_PRECISION vec2 OutputSize; -uniform COMPAT_PRECISION vec2 TextureSize; -uniform COMPAT_PRECISION vec2 InputSize; -uniform sampler2D Texture; -COMPAT_VARYING vec4 TEX0; - -// compatibility #defines -#define Source Texture -#define vTexCoord TEX0.xy -#define texture(c, d) COMPAT_TEXTURE(c, d) -#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize -#define OutSize vec4(OutputSize, 1.0 / OutputSize) - -void main() -{ - COMPAT_PRECISION vec2 texcoordInPixels = TEX0.xy * TextureSize.xy; - COMPAT_PRECISION vec2 centerCoord = floor(texcoordInPixels.xy)+vec2(0.5,0.5); - texcoordInPixels.xy = fract(texcoordInPixels.xy); - - float edgeDist = min(texcoordInPixels.x,texcoordInPixels.y); - - vec2 tc = vec2( SourceSize.z*centerCoord.x , SourceSize.w*centerCoord.y); - - vec3 colour = texture2D(Texture, tc).rgb; - -#if defined(GBAGAMMA) - colour.rgb*=0.6+0.4*(colour.rgb); //fake gamma because the pi3 is too slow! -#endif - - if(edgeDist<=BORDERTHICK) - colour.rgb*=BORDERMULT; - -#if defined(BLACK_OUT_BORDER) -colour.rgb*=float(tc.x > 0.0)*float(tc.y > 0.0); //why doesn't the driver do the right thing? -#endif - - FragColor.rgba = vec4(colour.rgb , 1.0); -} -#endif diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_iqlut.png b/overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_iqlut.png new file mode 100644 index 0000000000000000000000000000000000000000..e1c3c1e4e51efe55662980bce7517d0a42643171 GIT binary patch literal 275 zcmV+u0qp*XP)7{S%)WzZHp_nPRr{6? zs=u%$tf_KvI$GU@CGsPeoQGsmS6g z6yil5BI&qlMS Z(_gZbAk4!(a8dvO002ovPDHLkV1h1db0q)( literal 0 HcmV?d00001 diff --git a/overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_scanlut.png b/overlays_shaders/all/retroarch/shaders/shaders/zfast_resources/zfast_scanlut.png new file mode 100644 index 0000000000000000000000000000000000000000..cd99bdb32c127d86a39a5973b2ad7d8e3f6c27a3 GIT binary patch literal 723 zcmV;^0xbQBP)axSwB=wFX#Af({{VXoDfmYx$pbF@4K$+x-RFOa~6@Db4tl>m{~;ZC?d?9f-tjm zUH5@&HET(oXj;Bcm2=|JmJWjDRJ8-P*tK^p5Zr7g4ahz4F zRb`V0-+XB1d_yoUZXz