Add some shaders to dolphinfx folder

This is a first pack of shaders ported to dolphinfx specs. It includes: crt-hyllian, crt-easymode, zfast-crt, ddt, xbr, jinc2 and pixellate.
2025-06-18 03:35:46 -04:00 · 2024-06-11 14:51:55 -03:00
parent e6a11abedc
commit 7cf7a0a11f
7 changed files with 1567 additions and 0 deletions
--- a/data/resources/shaders/dolphinfx/crt/CRT-EASYMODE.glsl
+++ b/data/resources/shaders/dolphinfx/crt/CRT-EASYMODE.glsl
@ -0,0 +1,277 @@
+//    CRT Shader by EasyMode
+//    License: GPL
+
+//    A flat CRT shader ideally for 1080p or higher displays.
+
+//    Recommended Settings:
+
+//    Video
+//    - Aspect Ratio:  4:3
+//    - Integer Scale: Off
+
+//    Shader
+//    - Filter: Nearest
+//    - Scale:  Don't Care
+
+//    Example RGB Mask Parameter Settings:
+
+//    Aperture Grille (Default)
+//    - Dot Width:  1
+//    - Dot Height: 1
+//    - Stagger:    0
+
+//    Lottes' Shadow Mask
+//    - Dot Width:  2
+//    - Dot Height: 1
+//    - Stagger:    3
+
+
+/*
+[configuration]
+
+[OptionRangeFloat]
+GUIName = Sharpness Horizontal
+OptionName = SHARPNESS_H
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.5
+
+[OptionRangeFloat]
+GUIName = Sharpness Vertical
+OptionName = SHARPNESS_V
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Mask Strength
+OptionName = MASK_STRENGTH
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.01
+DefaultValue = 0.3
+
+[OptionRangeFloat]
+GUIName = Mask Dot Width
+OptionName = MASK_DOT_WIDTH
+MinValue = 1.0
+MaxValue = 100.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Mask Dot Height
+OptionName = MASK_DOT_HEIGHT
+MinValue = 1.0
+MaxValue = 100.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Mask Stagger
+OptionName = MASK_STAGGER
+MinValue = 0.0
+MaxValue = 100.0
+StepAmount = 1.0
+DefaultValue = 0.0
+
+[OptionRangeFloat]
+GUIName = Mask Size
+OptionName = MASK_SIZE
+MinValue = 1.0
+MaxValue = 100.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Scanline Strength
+OptionName = SCANLINE_STRENGTH
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Scanline Beam Width Min.
+OptionName = SCANLINE_BEAM_WIDTH_MIN
+MinValue = 0.5
+MaxValue = 5.0
+StepAmount = 0.5
+DefaultValue = 1.5
+
+[OptionRangeFloat]
+GUIName = Scanline Beam Width Max.
+OptionName = SCANLINE_BEAM_WIDTH_MAX
+MinValue = 0.5
+MaxValue = 5.0
+StepAmount = 0.5
+DefaultValue = 1.5
+
+[OptionRangeFloat]
+GUIName = Scanline Brightness Min.
+OptionName = SCANLINE_BRIGHT_MIN
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.35
+
+[OptionRangeFloat]
+GUIName = Scanline Brightness Max.
+OptionName = SCANLINE_BRIGHT_MAX
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.65
+
+[OptionRangeFloat]
+GUIName = Scanline Cutoff
+OptionName = SCANLINE_CUTOFF
+MinValue = 1.0
+MaxValue = 1000.0
+StepAmount = 1.0
+DefaultValue = 400.0
+
+[OptionRangeFloat]
+GUIName = Gamma Input
+OptionName = GAMMA_INPUT
+MinValue = 0.1
+MaxValue = 5.0
+StepAmount = 0.1
+DefaultValue = 2.0
+
+[OptionRangeFloat]
+GUIName = Gamma Output
+OptionName = GAMMA_OUTPUT
+MinValue = 0.1
+MaxValue = 5.0
+StepAmount = 0.1
+DefaultValue = 1.8
+
+[OptionRangeFloat]
+GUIName = Brightness Boost
+OptionName = BRIGHT_BOOST
+MinValue = 1.0
+MaxValue = 2.0
+StepAmount = 0.01
+DefaultValue = 1.2
+
+[OptionRangeFloat]
+GUIName = Dilation
+OptionName = DILATION
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[/configuration]
+*/
+
+#define FIX(c) max(abs(c), 1e-5)
+#define PI 3.141592653589
+
+#define TEX2D(c) dilate(SampleLocation(c))
+
+// Set to 0 to use linear filter and gain speed
+#define ENABLE_LANCZOS 1
+
+vec4 dilate(vec4 col)
+{
+    vec4 x = mix(vec4(1.0), col, GetOption(DILATION));
+
+    return col * x;
+}
+
+float curve_distance(float x, float sharp)
+{
+
+/*
+    apply half-circle s-curve to distance for sharper (more pixelated) interpolation
+    single line formula for Graph Toy:
+    0.5 - sqrt(0.25 - (x - step(0.5, x)) * (x - step(0.5, x))) * sign(0.5 - x)
+*/
+
+    float x_step = step(0.5, x);
+    float curve = 0.5 - sqrt(0.25 - (x - x_step) * (x - x_step)) * sign(0.5 - x);
+
+    return mix(x, curve, sharp);
+}
+
+mat4x4 get_color_matrix(vec2 co, vec2 dx)
+{
+    return mat4x4(TEX2D(co - dx), TEX2D(co), TEX2D(co + dx), TEX2D(co + 2.0 * dx));
+}
+
+vec3 filter_lanczos(vec4 coeffs, mat4x4 color_matrix)
+{
+    vec4 col        = color_matrix * coeffs;
+    vec4 sample_min = min(color_matrix[1], color_matrix[2]);
+    vec4 sample_max = max(color_matrix[1], color_matrix[2]);
+
+    col = clamp(col, sample_min, sample_max);
+
+    return col.rgb;
+}
+
+void main()
+{
+    vec2 vTexCoord = GetCoordinates();
+    vec2 nativeSize = 1.0 / GetInvNativePixelSize();
+    vec4 SourceSize = vec4(nativeSize, 1.0/nativeSize);
+
+    vec2 dx     = vec2(SourceSize.z, 0.0);
+    vec2 dy     = vec2(0.0, SourceSize.w);
+    vec2 pix_co = vTexCoord * SourceSize.xy - vec2(0.5, 0.5);
+    vec2 tex_co = (floor(pix_co) + vec2(0.5, 0.5)) * SourceSize.zw;
+    vec2 dist   = fract(pix_co);
+    float curve_x;
+    vec3 col, col2;
+
+#if ENABLE_LANCZOS
+    curve_x = curve_distance(dist.x, GetOption(SHARPNESS_H) * GetOption(SHARPNESS_H));
+
+    vec4 coeffs = PI * vec4(1.0 + curve_x, curve_x, 1.0 - curve_x, 2.0 - curve_x);
+
+    coeffs = FIX(coeffs);
+    coeffs = 2.0 * sin(coeffs) * sin(coeffs * 0.5) / (coeffs * coeffs);
+    coeffs /= dot(coeffs, vec4(1.0));
+
+    col  = filter_lanczos(coeffs, get_color_matrix(tex_co, dx));
+    col2 = filter_lanczos(coeffs, get_color_matrix(tex_co + dy, dx));
+#else
+    curve_x = curve_distance(dist.x, GetOption(SHARPNESS_H));
+
+    col  = mix(TEX2D(tex_co).rgb,      TEX2D(tex_co + dx).rgb,      curve_x);
+    col2 = mix(TEX2D(tex_co + dy).rgb, TEX2D(tex_co + dx + dy).rgb, curve_x);
+#endif
+
+    col = mix(col, col2, curve_distance(dist.y, GetOption(SHARPNESS_V)));
+    col = pow(col, vec3(GetOption(GAMMA_INPUT) / (GetOption(DILATION) + 1.0)));
+
+    float luma        = dot(vec3(0.2126, 0.7152, 0.0722), col);
+    float bright      = (max(col.r, max(col.g, col.b)) + luma) * 0.5;
+    float scan_bright = clamp(bright, GetOption(SCANLINE_BRIGHT_MIN), GetOption(SCANLINE_BRIGHT_MAX));
+    float scan_beam   = clamp(bright * GetOption(SCANLINE_BEAM_WIDTH_MAX), GetOption(SCANLINE_BEAM_WIDTH_MIN), GetOption(SCANLINE_BEAM_WIDTH_MAX));
+    float scan_weight = 1.0 - pow(cos(vTexCoord.y * 2.0 * PI * SourceSize.y) * 0.5 + 0.5, scan_beam) * GetOption(SCANLINE_STRENGTH);
+
+    float mask   = 1.0 - GetOption(MASK_STRENGTH);    
+    vec2 mod_fac = floor(vTexCoord * GetResolution().xy * SourceSize.xy / (SourceSize.xy * vec2(GetOption(MASK_SIZE), GetOption(MASK_DOT_HEIGHT) * GetOption(MASK_SIZE))));
+    int dot_no   = int(mod((mod_fac.x + mod(mod_fac.y, 2.0) * GetOption(MASK_STAGGER)) / GetOption(MASK_DOT_WIDTH), 3.0));
+    vec3 mask_weight;
+
+    if      (dot_no == 0) mask_weight = vec3(1.0,  mask, mask);
+    else if (dot_no == 1) mask_weight = vec3(mask, 1.0,  mask);
+    else                  mask_weight = vec3(mask, mask, 1.0);
+
+    if (SourceSize.y >= GetOption(SCANLINE_CUTOFF)) 
+        scan_weight = 1.0;
+
+    col2 = col.rgb;
+    col *= vec3(scan_weight);
+    col  = mix(col, col2, scan_bright);
+    col *= mask_weight;
+    col  = pow(col, vec3(1.0 / GetOption(GAMMA_OUTPUT)));
+
+    SetOutput(vec4(col * GetOption(BRIGHT_BOOST), 1.0));
+}
--- a/data/resources/shaders/dolphinfx/crt/CRT-HYLLIAN.glsl
+++ b/data/resources/shaders/dolphinfx/crt/CRT-HYLLIAN.glsl
@ -0,0 +1,504 @@
+//    Hyllian's CRT Shader
+
+//    Copyright (C) 2011-2024 Hyllian - sergiogdb@gmail.com
+
+//    Permission is hereby granted, free of charge, to any person obtaining a copy
+//    of this software and associated documentation files (the "Software"), to deal
+//    in the Software without restriction, including without limitation the rights
+//    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//    copies of the Software, and to permit persons to whom the Software is
+//    furnished to do so, subject to the following conditions:
+
+//    The above copyright notice and this permission notice shall be included in
+//    all copies or substantial portions of the Software.
+
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//    THE SOFTWARE.
+
+/*
+[configuration]
+
+[OptionRangeFloat]
+GUIName = HIGH RESOLUTION SCANLINES
+OptionName = SCANLINES_HIRES
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName =VERTICAL SCANLINES
+OptionName = VSCANLINES
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 0.0
+
+[OptionRangeFloat]
+GUIName = BEAM PROFILE
+OptionName = BEAM_PROFILE
+MinValue = 0.0
+MaxValue = 2.0
+StepAmount = 1.0
+DefaultValue = 0.0
+
+[OptionRangeFloat]
+GUIName = HORIZONTAL FILTER PROFILE
+OptionName = HFILTER_PROFILE
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = COLOR BOOST
+OptionName = COLOR_BOOST
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 1.40
+
+[OptionRangeFloat]
+GUIName = SHARPNESS HACK
+OptionName = SHARPNESS_HACK
+MinValue = 1.0
+MaxValue = 4.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = PHOSPHOR LAYOUT
+OptionName = PHOSPHOR_LAYOUT
+MinValue = 0.0
+MaxValue = 15.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = MASK INTENSITY
+OptionName = MASK_INTENSITY
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.65
+
+[OptionRangeFloat]
+GUIName = MIN BEAM WIDTH
+OptionName = BEAM_MIN_WIDTH
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.01
+DefaultValue = 0.86
+
+[OptionRangeFloat]
+GUIName = MAX BEAM WIDTH
+OptionName = BEAM_MAX_WIDTH
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.01
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = SCANLINES STRENGTH
+OptionName = SCANLINES_STRENGTH
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.01
+DefaultValue = 0.58
+
+[OptionRangeFloat]
+GUIName = MONITOR SUBPIXELS LAYOUT
+OptionName = MONITOR_SUBPIXELS
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 0.0
+
+[OptionRangeFloat]
+GUIName = ANTI RINGING
+OptionName = CRT_ANTI_RINGING
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = INPUT GAMMA
+OptionName = CRT_InputGamma
+MinValue = 1.0
+MaxValue = 3.0
+StepAmount = 0.05
+DefaultValue = 2.4
+
+[OptionRangeFloat]
+GUIName = OUTPUT GAMMA
+OptionName = CRT_OutputGamma
+MinValue = 1.0
+MaxValue = 3.0
+StepAmount = 0.05
+DefaultValue = 2.2
+
+[/configuration]
+*/
+
+
+#define GAMMA_IN(color)     pow(color, vec3(GetOption(CRT_InputGamma), GetOption(CRT_InputGamma), GetOption(CRT_InputGamma)))
+#define GAMMA_OUT(color)    pow(color, vec3(1.0 / GetOption(CRT_OutputGamma), 1.0 / GetOption(CRT_OutputGamma), 1.0 / GetOption(CRT_OutputGamma)))
+
+const vec3 Y = vec3(0.2627, 0.6780, 0.0593);
+
+
+//    A collection of CRT mask effects that work with LCD subpixel structures for
+//    small details
+
+//    author: hunterk
+//    license: public domain
+
+// Mask code pasted from subpixel_masks.h. Masks 3 and 4 added.
+vec3 mask_weights(vec2 coord, float mask_intensity, int phosphor_layout, float monitor_subpixels){
+   vec3 weights = vec3(1.,1.,1.);
+   float on = 1.;
+   float off = 1.-mask_intensity;
+   vec3 red     = monitor_subpixels==1.0 ? vec3(on,  off, off) : vec3(off, off, on );
+   vec3 green   = vec3(off, on,  off);
+   vec3 blue    = monitor_subpixels==1.0 ? vec3(off, off, on ) : vec3(on,  off, off);
+   vec3 magenta = vec3(on,  off, on );
+   vec3 yellow  = monitor_subpixels==1.0 ? vec3(on,  on,  off) : vec3(off, on,  on );
+   vec3 cyan    = monitor_subpixels==1.0 ? vec3(off, on,  on ) : vec3(on,  on,  off);
+   vec3 black   = vec3(off, off, off);
+   vec3 white   = vec3(on,  on,  on );
+   int w, z = 0;
+   
+   // This pattern is used by a few layouts, so we'll define it here
+   vec3 aperture_weights = mix(magenta, green, floor(mod(coord.x, 2.0)));
+   
+   if(phosphor_layout == 0) return weights;
+
+   else if(phosphor_layout == 1){
+      // classic aperture for RGB panels; good for 1080p, too small for 4K+
+      // aka aperture_1_2_bgr
+      weights  = aperture_weights;
+      return weights;
+   }
+
+   else if(phosphor_layout == 2){
+      // Classic RGB layout; good for 1080p and lower
+      vec3 bw3[3] = vec3[](red, green, blue);
+      
+      z = int(floor(mod(coord.x, 3.0)));
+      
+      weights = bw3[z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 3){
+      // black and white aperture; good for weird subpixel layouts and low brightness; good for 1080p and lower
+      vec3 bw3[3] = vec3[](black, white, black);
+      
+      z = int(floor(mod(coord.x, 3.0)));
+      
+      weights = bw3[z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 4){
+      // reduced TVL aperture for RGB panels. Good for 4k.
+      // aperture_2_4_rgb
+      
+      vec3 big_ap_rgb[4] = vec3[](red, yellow, cyan, blue);
+      
+      w = int(floor(mod(coord.x, 4.0)));
+      
+      weights = big_ap_rgb[w];
+      return weights;
+   }
+   
+   else if(phosphor_layout == 5){
+      // black and white aperture; good for weird subpixel layouts and low brightness; good for 4k 
+      vec3 bw4[4] = vec3[](black, black, white, white);
+      
+      z = int(floor(mod(coord.x, 4.0)));
+      
+      weights = bw4[z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 6){
+      // aperture_1_4_rgb; good for simulating lower 
+      vec3 ap4[4] = vec3[](red, green, blue, black);
+      
+      z = int(floor(mod(coord.x, 4.0)));
+      
+      weights = ap4[z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 7){
+      // 2x2 shadow mask for RGB panels; good for 1080p, too small for 4K+
+      // aka delta_1_2x1_bgr
+      vec3 inverse_aperture = mix(green, magenta, floor(mod(coord.x, 2.0)));
+      weights               = mix(aperture_weights, inverse_aperture, floor(mod(coord.y, 2.0)));
+      return weights;
+   }
+
+   else if(phosphor_layout == 8){
+      // delta_2_4x1_rgb
+      vec3 delta[2][4] = {
+         {red, yellow, cyan, blue},
+         {cyan, blue, red, yellow}
+      };
+      
+      w = int(floor(mod(coord.y, 2.0)));
+      z = int(floor(mod(coord.x, 4.0)));
+      
+      weights = delta[w][z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 9){
+      // delta_1_4x1_rgb; dunno why this is called 4x1 when it's obviously 4x2 /shrug
+      vec3 delta1[2][4] = {
+         {red,  green, blue, black},
+         {blue, black, red,  green}
+      };
+      
+      w = int(floor(mod(coord.y, 2.0)));
+      z = int(floor(mod(coord.x, 4.0)));
+      
+      weights = delta1[w][z];
+      return weights;
+   }
+   
+   else if(phosphor_layout == 10){
+      // delta_2_4x2_rgb
+      vec3 delta[4][4] = {
+         {red,  yellow, cyan, blue},
+         {red,  yellow, cyan, blue},
+         {cyan, blue,   red,  yellow},
+         {cyan, blue,   red,  yellow}
+      };
+      
+      w = int(floor(mod(coord.y, 4.0)));
+      z = int(floor(mod(coord.x, 4.0)));
+      
+      weights = delta[w][z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 11){
+      // slot mask for RGB panels; looks okay at 1080p, looks better at 4K
+      vec3 slotmask[4][6] = {
+         {red, green, blue,    red, green, blue,},
+         {red, green, blue,  black, black, black},
+         {red, green, blue,    red, green, blue,},
+         {black, black, black, red, green, blue,}
+      };
+      
+      w = int(floor(mod(coord.y, 4.0)));
+      z = int(floor(mod(coord.x, 6.0)));
+
+      // use the indexes to find which color to apply to the current pixel
+      weights = slotmask[w][z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 12){
+      // slot mask for RGB panels; looks okay at 1080p, looks better at 4K
+      vec3 slotmask[4][6] = {
+         {black,  white, black,   black,  white, black,},
+         {black,  white, black,  black, black, black},
+         {black,  white, black,  black,  white, black,},
+         {black, black, black,  black,  white, black,}
+      };
+      
+      w = int(floor(mod(coord.y, 4.0)));
+      z = int(floor(mod(coord.x, 6.0)));
+
+      // use the indexes to find which color to apply to the current pixel
+      weights = slotmask[w][z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 13){
+      // based on MajorPainInTheCactus' HDR slot mask
+      vec3 slot[4][8] = {
+         {red,   green, blue,  black, red,   green, blue,  black},
+         {red,   green, blue,  black, black, black, black, black},
+         {red,   green, blue,  black, red,   green, blue,  black},
+         {black, black, black, black, red,   green, blue,  black}
+      };
+      
+      w = int(floor(mod(coord.y, 4.0)));
+      z = int(floor(mod(coord.x, 8.0)));
+      
+      weights = slot[w][z];
+      return weights;
+   }
+
+   else if(phosphor_layout == 14){
+      // same as above but for RGB panels
+      vec3 slot2[4][10] = {
+         {red,   yellow, green, blue,  blue,  red,   yellow, green, blue,  blue },
+         {black, green,  green, blue,  blue,  red,   red,    black, black, black},
+         {red,   yellow, green, blue,  blue,  red,   yellow, green, blue,  blue },
+         {red,   red,    black, black, black, black, green,  green, blue,  blue }
+      };
+   
+      w = int(floor(mod(coord.y, 4.0)));
+      z = int(floor(mod(coord.x, 10.0)));
+      
+      weights = slot2[w][z];
+      return weights;
+   }
+   
+   else if(phosphor_layout == 15){
+      // slot_3_7x6_rgb
+      vec3 slot[6][14] = {
+         {red,   red,   yellow, green, cyan,  blue,  blue,  red,   red,   yellow, green,  cyan,  blue,  blue},
+         {red,   red,   yellow, green, cyan,  blue,  blue,  red,   red,   yellow, green,  cyan,  blue,  blue},
+         {red,   red,   yellow, green, cyan,  blue,  blue,  black, black, black,  black,  black, black, black},
+         {red,   red,   yellow, green, cyan,  blue,  blue,  red,   red,   yellow, green,  cyan,  blue,  blue},
+         {red,   red,   yellow, green, cyan,  blue,  blue,  red,   red,   yellow, green,  cyan,  blue,  blue},
+         {black, black, black,  black, black, black, black, black, red,   red,    yellow, green, cyan,  blue}
+      };
+      
+      w = int(floor(mod(coord.y, 6.0)));
+      z = int(floor(mod(coord.x, 14.0)));
+      
+      weights = slot[w][z];
+      return weights;
+   }
+
+
+   
+   else return weights;
+}
+
+// Horizontal cubic filter.
+// Some known filters use these values:
+
+//    B = 0.5, C = 0.0        =>  A sharp almost gaussian filter.
+//    B = 0.0, C = 0.0        =>  Hermite cubic filter.
+//    B = 1.0, C = 0.0        =>  Cubic B-Spline filter.
+//    B = 0.0, C = 0.5        =>  Catmull-Rom Spline filter.
+//    B = C = 1.0/3.0         =>  Mitchell-Netravali cubic filter.
+//    B = 0.3782, C = 0.3109  =>  Robidoux filter.
+//    B = 0.2620, C = 0.3690  =>  Robidoux Sharp filter.
+
+// For more info, see: http://www.imagemagick.org/Usage/img_diagrams/cubic_survey.gif
+
+mat4x4 get_hfilter_profile()
+{
+	float bf = 1.0;
+	float cf = 0.0;
+
+	if (GetOption(HFILTER_PROFILE) == 1) {bf = 1.0/3.0;     cf = 1.0/3.0;}
+
+        return mat4x4(            (-bf - 6.0*cf)/6.0,         (3.0*bf + 12.0*cf)/6.0,     (-3.0*bf - 6.0*cf)/6.0,             bf/6.0,
+                                        (12.0 - 9.0*bf - 6.0*cf)/6.0, (-18.0 + 12.0*bf + 6.0*cf)/6.0,                      0.0, (6.0 - 2.0*bf)/6.0,
+                                       -(12.0 - 9.0*bf - 6.0*cf)/6.0, (18.0 - 15.0*bf - 12.0*cf)/6.0,      (3.0*bf + 6.0*cf)/6.0,             bf/6.0,
+                                                   (bf + 6.0*cf)/6.0,                           -cf,                      0.0,               0.0);
+         
+         
+}
+
+
+#define scanlines_strength (4.0*profile.x)
+#define beam_min_width     profile.y
+#define beam_max_width     profile.z
+#define color_boost        profile.w
+
+
+vec4 get_beam_profile()
+{
+	vec4 bp = vec4(GetOption(SCANLINES_STRENGTH), GetOption(BEAM_MIN_WIDTH), GetOption(BEAM_MAX_WIDTH), GetOption(COLOR_BOOST));
+
+	if (BEAM_PROFILE == 1)  bp = vec4(0.58, 0.86, 1.00, 1.60); // Catmull-rom
+	if (BEAM_PROFILE == 2)  bp = vec4(0.58, 0.72, 1.00, 1.75); // Catmull-rom
+
+	return bp;
+}
+
+
+void main()
+{
+    vec2 vTexCoord = GetCoordinates();
+    vec2 SourceSize = 1.0 / GetInvNativePixelSize(); // This work with previous build.
+
+    vec4 profile = get_beam_profile();
+
+    vec2 TextureSize = mix(vec2(SourceSize.x * GetOption(SHARPNESS_HACK), SourceSize.y), vec2(SourceSize.x, SourceSize.y * GetOption(SHARPNESS_HACK)), GetOption(VSCANLINES));
+
+    vec2 dx = mix(vec2(1.0/TextureSize.x, 0.0), vec2(0.0, 1.0/TextureSize.y), GetOption(VSCANLINES));
+    vec2 dy = mix(vec2(0.0, 1.0/TextureSize.y), vec2(1.0/TextureSize.x, 0.0), GetOption(VSCANLINES));
+
+    vec2 pix_coord = vTexCoord.xy*TextureSize.xy - vec2(0.5, 0.5);
+
+    vec2 tc = ( (SCANLINES_HIRES > 0.5) ? (mix(vec2(floor(pix_coord.x), pix_coord.y), vec2(pix_coord.x, floor(pix_coord.y)), GetOption(VSCANLINES)) + vec2(0.5, 0.5)) : (floor(pix_coord) + vec2(0.5, 0.5)) )/TextureSize;
+
+    pix_coord = mix(pix_coord, pix_coord.yx, GetOption(VSCANLINES));
+
+    vec2 fp = fract(pix_coord);
+
+    vec3 c00 = GAMMA_IN(SampleLocation(tc     - dx     ).xyz);
+    vec3 c01 = GAMMA_IN(SampleLocation(tc              ).xyz);
+    vec3 c02 = GAMMA_IN(SampleLocation(tc     + dx     ).xyz);
+    vec3 c03 = GAMMA_IN(SampleLocation(tc + 2.0*dx     ).xyz);
+
+    vec3 c10 = (SCANLINES_HIRES > 0.5) ? c00 : GAMMA_IN(SampleLocation(tc     - dx +dy ).xyz);
+    vec3 c11 = (SCANLINES_HIRES > 0.5) ? c01 : GAMMA_IN(SampleLocation(tc          +dy ).xyz);
+    vec3 c12 = (SCANLINES_HIRES > 0.5) ? c02 : GAMMA_IN(SampleLocation(tc     + dx +dy ).xyz);
+    vec3 c13 = (SCANLINES_HIRES > 0.5) ? c03 : GAMMA_IN(SampleLocation(tc + 2.0*dx +dy ).xyz);
+
+    mat4x4 invX = get_hfilter_profile();
+
+    mat4x3 color_matrix0 = mat4x3(c00, c01, c02, c03);
+    mat4x3 color_matrix1 = mat4x3(c10, c11, c12, c13);
+    
+    vec4 invX_Px    = vec4(fp.x*fp.x*fp.x, fp.x*fp.x, fp.x, 1.0) * invX;
+    vec3 color0     = color_matrix0 * invX_Px;
+    vec3 color1     = color_matrix1 * invX_Px;
+
+    // Get min/max samples
+    vec3 min_sample0 = min(c01,c02);
+    vec3 max_sample0 = max(c01,c02);
+    vec3 min_sample1 = min(c11,c12);
+    vec3 max_sample1 = max(c11,c12);
+    
+    // Anti-ringing
+    vec3 aux = color0;
+    color0 = clamp(color0, min_sample0, max_sample0);
+    color0 = mix(aux, color0, GetOption(CRT_ANTI_RINGING) * step(0.0, (c00-c01)*(c02-c03)));
+    aux = color1;
+    color1 = clamp(color1, min_sample1, max_sample1);
+    color1 = mix(aux, color1, GetOption(CRT_ANTI_RINGING) * step(0.0, (c10-c11)*(c12-c13)));
+
+    float pos0 = fp.y;
+    float pos1 = 1 - fp.y;
+
+    vec3 lum0 = mix(vec3(beam_min_width), vec3(beam_max_width), color0);
+    vec3 lum1 = mix(vec3(beam_min_width), vec3(beam_max_width), color1);
+
+    vec3 d0 = scanlines_strength*pos0/(lum0*lum0+0.0000001);
+    vec3 d1 = scanlines_strength*pos1/(lum1*lum1+0.0000001);
+
+    d0 = exp(-d0*d0);
+    d1 = exp(-d1*d1);
+
+    vec3 color = (color0*d0+color1*d1);            
+
+    color  = GAMMA_OUT(color);
+
+    vec2 mask_coords =vTexCoord.xy * GetResolution().xy;
+
+    mask_coords = mix(mask_coords.xy, mask_coords.yx, GetOption(VSCANLINES));
+
+    color.rgb*=GAMMA_OUT(mask_weights(mask_coords,  GetOption(MASK_INTENSITY), int(GetOption(PHOSPHOR_LAYOUT)), GetOption(MONITOR_SUBPIXELS)));
+
+    SetOutput(vec4(color_boost*color, 1.0));
+}
--- a/data/resources/shaders/dolphinfx/crt/ZFAST-CRT-COMPOSITE.glsl
+++ b/data/resources/shaders/dolphinfx/crt/ZFAST-CRT-COMPOSITE.glsl
@ -0,0 +1,180 @@
+//    zfast_crt - A very simple CRT shader.
+
+//    Copyright (C) 2017 Greg Hogan (SoltanGris42)
+//	edited by metallic 77.
+//	ported to slang by gregoricavichioli & hunterk.
+//      ported to dolphinfx by Hyllian.
+
+//    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.
+
+
+/*
+[configuration]
+
+[OptionRangeFloat]
+GUIName = Curvature
+OptionName = Curvature
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Convergence X-Axis
+OptionName = blurx
+MinValue = -1.0
+MaxValue =  2.0
+StepAmount = 0.05
+DefaultValue = 0.85
+
+[OptionRangeFloat]
+GUIName = Convergence Y-Axis
+OptionName = blury
+MinValue = -1.0
+MaxValue =  1.0
+StepAmount = 0.05
+DefaultValue = -0.10
+
+[OptionRangeFloat]
+GUIName = Scanline Amount (Low)
+OptionName = HIGHSCANAMOUNT1
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.4
+
+[OptionRangeFloat]
+GUIName = Scanline Amount (High)
+OptionName = HIGHSCANAMOUNT2
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.3
+
+[OptionRangeFloat]
+GUIName = Mask Type
+OptionName = TYPE
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 1.0
+DefaultValue = 0.0
+
+[OptionRangeFloat]
+GUIName = Mask Effect Amount
+OptionName = MASK_DARK
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.3
+
+[OptionRangeFloat]
+GUIName = Mask/Scanline Fade
+OptionName = MASK_FADE
+MinValue = 0.0
+MaxValue = 1.0
+StepAmount = 0.05
+DefaultValue = 0.7
+
+[OptionRangeFloat]
+GUIName = Saturation
+OptionName = sat
+MinValue = 0.0
+MaxValue = 3.0
+StepAmount = 0.05
+DefaultValue = 1.0
+
+[OptionRangeFloat]
+GUIName = Flicker
+OptionName = FLICK
+MinValue = 0.0
+MaxValue = 50.0
+StepAmount = 1.0
+DefaultValue = 10.0
+
+[/configuration]
+*/
+
+#define pi 3.14159
+
+#define blur_y GetOption(blury)/(SourceSize.y*2.0)
+#define blur_x GetOption(blurx)/(SourceSize.x*2.0)
+#define iTimer (float(GetTime())*2.0)
+#define flicker GetOption(FLICK)/1000.0
+
+// Distortion of scanlines, and end of screen alpha.
+vec2 Warp(vec2 pos)
+{
+    pos  = pos*2.0-1.0;    
+    pos *= vec2(1.0 + (pos.y*pos.y)*0.03, 1.0 + (pos.x*pos.x)*0.05);
+    
+    return pos*0.5 + 0.5;
+}
+
+
+void main()
+{
+    vec2 vTexCoord  = GetCoordinates();
+    vec2 texSize = 1.0 / GetInvNativePixelSize();
+    vec4 SourceSize = vec4(texSize, 1.0 / texSize);
+    
+    float maskFade = 0.3333*GetOption(MASK_FADE);
+    float omega    = 2.0*pi*SourceSize.y;
+
+    vec2 pos,corn;
+    if (GetOption(Curvature) == 1.0) 
+{
+    pos = Warp(vTexCoord.xy);
+    corn = min(pos,vec2(1.0)-pos); // This is used to mask the rounded
+    corn.x = 0.00001/corn.x;           // corners later on
+   
+}
+
+     else pos = vTexCoord;    
+     float OGL2Pos = pos.y*SourceSize.y;
+     float cent = floor(OGL2Pos)+0.5;
+     float ycoord = cent*SourceSize.w; 
+     ycoord = mix(pos.y,ycoord,0.6);
+     pos = vec2(pos.x,ycoord);
+
+
+     vec3 sample1 = sin(iTimer)*flicker + SampleLocation(vec2(pos.x + blur_x, pos.y - blur_y)).rgb;
+     vec3 sample2 =                0.5*SampleLocation(pos).rgb;
+     vec3 sample3 = sin(iTimer)*flicker + SampleLocation(vec2(pos.x - blur_x, pos.y + blur_y)).rgb;
+    
+     vec3 colour = vec3 (sample1.r*0.5  + sample2.r, 
+                         sample1.g*0.25 + sample2.g + sample3.g*0.25, 
+                                          sample2.b + sample3.b*0.5);
+    
+     vec3 interl = colour;
+     vec3 lumweight=vec3(0.22,0.71,0.07);
+     float lumsat = dot(colour,lumweight);
+   
+     vec3 graycolour = vec3(lumsat);
+     colour = vec3(mix(graycolour,colour.rgb,sat));
+
+     float SCANAMOUNT = mix(GetOption(HIGHSCANAMOUNT1),GetOption(HIGHSCANAMOUNT2),max(max(colour.r,colour.g),colour.b));
+         
+
+    if (SourceSize.y > 400.0) {
+    colour ;
+    } 
+else {
+    colour *= SCANAMOUNT * sin(fract(OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
+    colour *= SCANAMOUNT * sin(fract(1.0-OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
+    colour *= SCANAMOUNT * sin(fract(1.0+OGL2Pos)*3.14159)+1.0-SCANAMOUNT;
+    }
+
+     float steps; if (GetOption(TYPE) == 0.0) steps = 0.5; else steps = 0.3333;
+     float whichmask = fract(vTexCoord.x*GetResolution().x*steps);
+     float mask = 1.0 + float(whichmask < steps) * (-GetOption(MASK_DARK));
+
+    colour.rgb = mix(mask*colour, colour, dot(colour.rgb,vec3(maskFade)));
+
+    if (GetOption(Curvature) == 1.0 && corn.y < corn.x || GetOption(Curvature) == 1.0 && corn.x < 0.00001 )
+    colour = vec3(0.0); 
+
+    SetOutput(vec4(colour.rgb, 1.0));
+}