@thenick775/mgba-wasm 2.4.0 → 2.5.0-beta.1

package/dist/mgba.data

@@ -0,0 +1,3480 @@
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+uniform vec2 outputSize;
+
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+void main() {
+  vec3 c = texture2D(tex, texCoord).rgb;
+
+  // gamma-ish shaping the original shader intended
+  c = pow(c * vec3(0.8), vec3(1.8)) + vec3(0.16);
+
+  // Stripe mask aligned to OUTPUT pixels (stable across scale factors)
+  float x = mod(floor(gl_FragCoord.x), 3.0);
+  vec3 maskX =
+    (x < 0.5) ? vec3(0.2, 0.2, 1.0) :
+    (x < 1.5) ? vec3(0.2, 1.0, 0.2) :
+                vec3(1.0, 0.2, 0.2);
+
+  float y = mod(floor(gl_FragCoord.y), 4.0);
+  vec3 maskY = (y < 3.5) ? vec3(1.0) : vec3(0.8);
+
+  c *= (maskX * maskY);
+
+  gl_FragColor = vec4(c, 1.0);
+}
+[shader]
+name=AGB-001
+author=endrift
+description=A glorious recreation of the original Game Boy Advance
+passes=1
+
+[pass.0]
+fragmentShader=agb001.fs
+blend=1
+width=-3
+height=-4
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform float reflectionBrightness;
+uniform vec2 reflectionDistance;
+uniform float lightBrightness;
+
+const float speed = 2.0;
+const float decay = 2.0;
+const float coeff = 2.5;
+
+void main() {
+	float sp = pow(speed, lightBrightness);
+	float dc = pow(decay, -lightBrightness);
+	float s = (sp - dc) / (sp + dc);
+	vec2 radius = (texCoord.st - vec2(0.5, 0.5)) * vec2(coeff * s);
+	radius = pow(abs(radius), vec2(4.0));
+	vec3 bleed = vec3(0.12, 0.14, 0.19);
+	bleed += (dot(radius, radius) + vec3(0.02, 0.03, 0.05)) * vec3(0.14, 0.18, 0.2);
+
+	vec4 color = texture2D(tex, texCoord);
+	color.rgb += pow(bleed, pow(vec3(lightBrightness), vec3(-0.5)));
+
+	vec4 reflection = texture2D(tex, texCoord - reflectionDistance);
+	color.rgb += reflection.rgb * reflectionBrightness;
+	color.a = 1.0;
+	gl_FragColor = color;
+}
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+const vec3 kArrayX0 = vec3(0.2, 0.2, 1.0);
+const vec3 kArrayX1 = vec3(0.2, 1.0, 0.2);
+const vec3 kArrayX2 = vec3(1.0, 0.2, 0.2);
+const vec3 kArrayY0 = vec3(1.0, 1.0, 1.0);
+const vec3 kArrayY1 = vec3(1.0, 1.0, 1.0);
+const vec3 kArrayY2 = vec3(1.0, 1.0, 1.0);
+const vec3 kArrayY3 = vec3(0.9, 0.9, 0.9);
+
+
+void main() {
+	vec4 color = texture2D(tex, texCoord);
+	// WebGL1-safe: precomputed constant LUTs (no runtime array writes)
+	color.rgb = pow(color.rgb, vec3(1.6, 1.6, 1.6));
+	int xi = int(mod(texCoord.s * texSize.x * 3.0, 3.0));
+	vec3 ax = (xi == 0) ? kArrayX0 : ((xi == 1) ? kArrayX1 : kArrayX2);
+	int yi = int(mod(texCoord.t * texSize.y * 4.0, 4.0));
+	vec3 ay = (yi == 0) ? kArrayY0 : ((yi == 1) ? kArrayY1 : ((yi == 2) ? kArrayY2 : kArrayY3));
+	color.rgb *= ax;
+	color.rgb *= ay;
+	color.a = 0.8;
+	gl_FragColor = color;
+}
+[shader]
+name=AGS-001
+author=endrift
+description=A pristine recreation of the illuminated Game Boy Advance SP
+passes=2
+
+[pass.0]
+fragmentShader=ags001.fs
+blend=1
+width=-3
+height=-4
+
+[pass.1]
+fragmentShader=ags001-light.fs
+width=-3
+height=-4
+
+[pass.1.uniform.lightBrightness]
+type=float
+default=1
+readableName=Light brightness
+
+[pass.1.uniform.reflectionBrightness]
+type=float
+default=0.07
+readableName=Reflection brightness
+
+[pass.1.uniform.reflectionDistance]
+type=float2
+default[0]=0
+default[1]=0.025
+readableName=Reflection distance
+// Shader that replicates the LCD Colorspace from a Nintendo DS Lite --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 DSL_sRGB = mat4(
+	0.93, 0.025, 0.008, 0.0,  //red channel
+	0.14, 0.90, -0.03, 0.0,  //green channel
+	-0.07, 0.075, 1.022, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.935   //alpha channel
+); 
+
+const mat4 DSL_DCI = mat4(
+	0.76, 0.055, 0.0225, 0.0,  //red channel
+	0.27, 0.875, 0.0225, 0.0,  //green channel
+	-0.03, 0.07, 0.955, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   0.97  //alpha channel
+); 
+
+const mat4 DSL_Rec2020 = mat4(
+	0.585, 0.09, 0.0225, 0.0,  //red channel
+	0.3725, 0.825, 0.035, 0.0,  //green channel
+	0.0425, 0.085, 0.9425, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   1.0  //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = DSL_sRGB;
+	else if (color_mode == 2) profile = DSL_DCI;
+	else if (color_mode == 3) profile = DSL_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=Nintendo DS Lite Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the LCD Colorspace from a Nintendo DS Lite.
+passes=1
+
+[pass.0]
+fragmentShader=dslite-color.fs
+vertexShader=dslite-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+/*
+   fish shader
+   
+   algorithm and original implementation by Miloslav "drummyfish" Ciz
+   (tastyfish@seznam.cz)
+
+   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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float similarity_threshold;
+
+vec4 texel_fetch(sampler2D t, ivec2 c)   // because GLSL TexelFetch is not supported
+  {
+    return texture2D(t, (2.0 * vec2(c) + vec2(1.0,1.0)) / (2.0 * texSize));
+  }
+
+float pixel_brightness(vec4 pixel)
+  {
+    return 0.21 * pixel.x + 0.72 * pixel.y + 0.07 * pixel.z;
+  }
+
+bool pixel_is_brighter(vec4 pixel1, vec4 pixel2)
+  {
+    return pixel_brightness(pixel1) > pixel_brightness(pixel2);
+  }
+
+vec3 pixel_to_yuv(vec4 pixel)
+  {
+    float y = 0.299 * pixel.x + 0.587 * pixel.y + 0.114 * pixel.z;
+    return vec3(y, 0.492 * (pixel.z - y), 0.877 * (pixel.x - y));
+  }
+
+bool yuvs_are_similar(vec3 yuv1, vec3 yuv2)
+  {
+    vec3 yuv_difference = abs(yuv1 - yuv2);
+    return yuv_difference.x <= similarity_threshold && yuv_difference.y <= similarity_threshold && yuv_difference.z <= similarity_threshold;
+  }
+
+bool pixels_are_similar(vec4 pixel1, vec4 pixel2)
+  {
+    vec3 yuv1 = pixel_to_yuv(pixel1);
+    vec3 yuv2 = pixel_to_yuv(pixel2);
+
+    return yuvs_are_similar(yuv1, yuv2);
+  }
+
+vec4 interpolate_nondiagonal(vec4 neighbour1, vec4 neighbour2)
+  {
+    if (pixels_are_similar(neighbour1,neighbour2))
+      return mix(neighbour1,neighbour2,0.5);
+    else
+      return pixel_is_brighter(neighbour1, neighbour2) ? neighbour1 : neighbour2;
+  }
+
+vec4 mix3(vec4 value1, vec4 value2, vec4 value3)
+  {
+    return (value1 + value2 + value3) / 3.0;
+  }
+
+vec4 straight_line(vec4 p0, vec4 p1, vec4 p2, vec4 p3)
+  {
+    return pixel_is_brighter(p2,p0) ? mix(p2,p3,0.5) : mix(p0,p1,0.5);
+  }
+
+vec4 corner(vec4 p0, vec4 p1, vec4 p2, vec4 p3)
+  {
+    return pixel_is_brighter(p1,p0) ? mix3(p1,p2,p3) : mix3(p0,p1,p2);
+  }
+
+vec4 interpolate_diagonal(vec4 a, vec4 b, vec4 c, vec4 d)
+  {
+    // a b
+    // c d
+
+    vec3 a_yuv = pixel_to_yuv(a);
+    vec3 b_yuv = pixel_to_yuv(b);
+    vec3 c_yuv = pixel_to_yuv(c);
+    vec3 d_yuv = pixel_to_yuv(d);
+
+    bool ad = yuvs_are_similar(a_yuv,d_yuv);
+    bool bc = yuvs_are_similar(b_yuv,c_yuv);
+    bool ab = yuvs_are_similar(a_yuv,b_yuv);
+    bool cd = yuvs_are_similar(c_yuv,d_yuv);
+    bool ac = yuvs_are_similar(a_yuv,c_yuv);
+    bool bd = yuvs_are_similar(b_yuv,d_yuv);
+
+    if (ad && cd && ab)                                          // all pixels are equal?
+      return( mix(mix(a,b,0.5), mix(c,d,0.5), 0.5) );
+
+    else if (ac && cd && ! ab)                                   // corner 1?
+      return corner(b,a,d,c);
+    else if (bd && cd && ! ab)                                   // corner 2?
+      return corner(a,b,c,d);
+    else if (ac && ab && ! bd)                                   // corner 3?
+      return corner(d,c,b,a);
+    else if (ab && bd && ! ac)                                   // corner 4?
+      return corner(c,a,d,b);
+
+    else if (ad && (!bc || pixel_is_brighter(b,a)))              // diagonal line 1?
+      return mix(a,d,0.5);
+    else if (bc && (!ad || pixel_is_brighter(a,b)))              // diagonal line 2?
+      return mix(b,c,0.5);
+
+    else if (ab)                                                 // horizontal line 1?
+      return straight_line(a,b,c,d);
+    else if (cd)                                                 // horizontal line 2?
+      return straight_line(c,d,a,b);
+
+    else if (ac)                                                 // vertical line 1?
+      return straight_line(a,c,b,d);
+    else if (bd)                                                 // vertical line 2?
+      return straight_line(b,d,a,c);
+
+    return( mix(mix(a,b,0.5), mix(c,d,0.5), 0.5) );
+  }
+
+void main()
+  {
+    ivec2 pixel_coords2 = ivec2(vec2(texCoord) * vec2(texSize) * 2.0);
+    ivec2 pixel_coords = pixel_coords2 / 2;
+
+    bool x_even = (pixel_coords2.x - (pixel_coords2.x / 2) * 2) == 0;
+    bool y_even = (pixel_coords2.y - (pixel_coords2.y / 2) * 2) == 0;
+
+    if (x_even)
+      {
+        if (y_even)
+          {
+
+            gl_FragColor = interpolate_diagonal(
+              texel_fetch(tex, pixel_coords + ivec2(-1,-1)),
+              texel_fetch(tex, pixel_coords + ivec2(0,-1)),
+              texel_fetch(tex, pixel_coords + ivec2(-1,0)),
+              texel_fetch(tex, pixel_coords + ivec2(0,0))
+              );
+
+          }
+        else
+          {
+            gl_FragColor = interpolate_nondiagonal
+              (
+                texel_fetch(tex, pixel_coords + ivec2(-1,0)),
+                texel_fetch(tex, pixel_coords)
+              );
+          }
+      }
+    else if (y_even)
+      {
+        gl_FragColor = interpolate_nondiagonal
+          (
+            texel_fetch(tex, pixel_coords + ivec2(0,-1)),
+            texel_fetch(tex, pixel_coords)
+          );
+      }
+    else
+      gl_FragColor = texel_fetch(tex, pixel_coords);
+  }
+[shader]
+name=fish
+author=Drummyfish
+description=Attempts to keep thin lines thin.
+passes=1
+
+[pass.0]
+fragmentShader=fish.fs
+integerScaling=1
+
+[pass.0.uniform.similarity_threshold]
+type=float
+default=0.2
+readableName=Similarity Threshold
+min=0
+max=1
+// Shader that replicates the LCD Colorspace from a Gameboy Micro (OXY-001) --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 GBM_sRGB = mat4(
+	0.8025, 0.10, 0.1225, 0.0,  //red channel
+	0.31, 0.6875, 0.1125, 0.0,  //green channel
+	-0.1125, 0.2125, 0.765, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.9   //alpha channel
+); 
+
+const mat4 GBM_DCI = mat4(
+	0.6675, 0.125, 0.13, 0.0,  //red channel
+	0.3825, 0.675, 0.1475, 0.0,  //green channel
+	-0.05, 0.20, 0.7225, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.96   //alpha channel
+); 
+
+const mat4 GBM_Rec2020 = mat4(
+	0.525, 0.15, 0.13, 0.0,  //red channel
+	0.43, 0.65, 0.155, 0.0,  //green channel
+	0.045, 0.20, 0.715, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  1.0   //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = GBM_sRGB;
+	else if (color_mode == 2) profile = GBM_DCI;
+	else if (color_mode == 3) profile = GBM_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=GB Micro Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the LCD Colorspace from a Gameboy Micro (OXY-001).
+passes=1
+
+[pass.0]
+fragmentShader=gb-micro-color.fs
+vertexShader=gb-micro-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the LCD Colorspace from Gameboy Advance --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+uniform float darken_screen;
+const float target_gamma = 2.0;
+const float display_gamma = 2.0;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma + darken_screen)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 GBA_sRGB = mat4(
+	0.80, 0.135, 0.195, 0.0,  //red channel
+	0.275, 0.64, 0.155, 0.0,  //green channel
+	-0.075, 0.225, 0.65, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.93   //alpha channel
+); 
+
+const mat4 GBA_DCI = mat4(
+	0.685, 0.16, 0.20, 0.0,  //red channel
+	0.34, 0.629, 0.19, 0.0,  //green channel
+	-0.025, 0.211, 0.61, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.975  //alpha channel
+); 
+
+const mat4 GBA_Rec2020 = mat4(
+	0.555, 0.1825, 0.20, 0.0,  //red channel
+	0.395, 0.61, 0.195, 0.0,  //green channel
+	0.05, 0.2075, 0.605, 0.0,  //blue channel
+	0.0,   0.0,  0.0,   1.0  //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = GBA_sRGB;
+	else if (color_mode == 2) profile = GBA_DCI;
+	else if (color_mode == 3) profile = GBA_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=GBA Color
+author=Pokefan531 and hunterk
+description=Modifies the color output to simulate the GBA LCD characteristics.
+passes=1
+
+[pass.0]
+fragmentShader=gba-color.fs
+vertexShader=gba-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.darken_screen]
+type=float
+default=0.5
+min=0
+max=1
+readableName=Darken Screen
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the LCD Colorspace from Gameboy Color --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+uniform float lighten_screen;
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma - lighten_screen)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 GBC_sRGB = mat4(
+	0.905, 0.10, 0.1575, 0.0,  //red channel
+	0.195, 0.65, 0.1425, 0.0,  //green channel
+	-0.10, 0.25, 0.70, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.91   //alpha channel
+); 
+
+const mat4 GBC_DCI = mat4(
+	0.76, 0.125, 0.16, 0.0,  //red channel
+	0.27, 0.6375, 0.18, 0.0,  //green channel
+	-0.03, 0.2375, 0.66, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.97  //alpha channel
+); 
+
+const mat4 GBC_Rec2020 = mat4(
+	0.61, 0.155, 0.16, 0.0,  //red channel
+	0.345, 0.615, 0.1875, 0.0,  //green channel
+	0.045, 0.23, 0.6525, 0.0,  //blue channel
+	0.0,  0.0,  0.0,   1.0  //alpha channel
+);
+
+void main() {
+	if (color_mode == 1) profile = GBC_sRGB;
+	else if (color_mode == 2) profile = GBC_DCI;
+	else if (color_mode == 3) profile = GBC_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=GBC Color
+author=Pokefan531 and hunterk
+description=Modifies the color output to simulate the GBA LCD characteristics.
+passes=1
+
+[pass.0]
+fragmentShader=gbc-color.fs
+vertexShader=gbc-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.lighten_screen]
+type=float
+default=1.0
+min=0
+max=1
+readableName=External Lighten Screen
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+/**
+ * This shader creates a backlight bleeding effect,
+ * and an internal reflection or ghosting effect.
+ */
+ 
+varying vec2 texCoord;
+uniform sampler2D tex;
+
+/**
+ * Determines the color of the backlight bleed.
+ * Lower values produce less, dimmer light.
+ * Higher values produce brighter or more colorful light.
+ * You'll normally want each of these numbers to be close
+ * to 1, and not normally lower than 0.
+ */
+uniform vec3 LightColor;
+
+/**
+ * Affects the shape of the backlight bleed glow.
+ * Lower values cause the light bleed to fade out quickly
+ * from the edges.
+ * Higher values cause the light bleed to fade out more
+ * softly and gradually toward the center.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float LightSoftness;
+
+/**
+ * Lower values result in a less visible or intense
+ * backlight bleed.
+ * Higher values make the backlight bleed more pronounced.
+ * You'll normally want this to be a number close to 0,
+ * and not normally higher than 1.
+ */
+uniform float LightIntensity;
+
+/**
+ * Lower values cause the internal reflection or ghosting
+ * effect to be less visible.
+ * Higher values cause the effect to be brighter and more
+ * visible.
+ * You'll normally want this to be a number close to 0,
+ * and not normally higher than 1.
+ */
+uniform float ReflectionBrightness;
+
+/**
+ * Lower values have the internal reflection or ghosting
+ * effect appear offset by a lesser distance.
+ * Higher values have the effect offset by a greater
+ * distance.
+ * You'll normally want each of these numbers to be close
+ * to 0, and not normally higher than 1.
+ */
+uniform vec2 ReflectionDistance;
+
+#define M_PI 3.1415926535897932384626433832795
+
+/**
+ * Helper to compute backlight bleed intensity
+ * for a texCoord input.
+ */
+float getLightIntensity(vec2 coord) {
+    vec2 coordCentered = coord - vec2(0.5, 0.5);
+    float coordDistCenter = (
+        length(coordCentered) / sqrt(0.5)
+    );
+    vec2 coordQuadrant = vec2(
+        1.0 - (1.5 * min(coord.x, 1.0 - coord.x)),
+        1.0 - (1.5 * min(coord.y, 1.0 - coord.y))
+    );
+    float lightIntensityEdges = (
+        pow(coordQuadrant.x, 5.0) +
+        pow(coordQuadrant.y, 5.0)
+    );
+    float lightIntensity = (
+        (1.0 - LightSoftness) * lightIntensityEdges +
+        LightSoftness * coordDistCenter
+    );
+    return clamp(lightIntensity, 0.0, 1.0);
+}
+
+/**
+ * Helper to convert an intensity value into a white
+ * gray color with that intensity. A radial distortion
+ * effect with subtle chromatic abberation is applied that
+ * makes it look a little more like a real old or cheap
+ * backlight, and also helps to reduce color banding.
+ */
+vec3 getWhiteVector(float intensity) {
+    const float DeformAmount = 0.0025;
+    vec2 texCoordCentered = texCoord - vec2(0.5, 0.5);
+    float radians = atan(texCoordCentered.y, texCoordCentered.x);
+    float rot = pow(2.0, 4.0 + floor(6.0 * length(texCoordCentered)));
+    float deformRed = cos(rot * radians + (2.0 / 3.0 * M_PI));
+    float deformGreen = cos(rot * radians);
+    float deformBlue = cos(rot * radians + (4.0 / 3.0 * M_PI));
+    return clamp(vec3(
+        intensity + (deformRed * DeformAmount),
+        intensity + (deformGreen * DeformAmount),
+        intensity + (deformBlue * DeformAmount)
+    ), 0.0, 1.0);
+}
+
+void main() {
+    vec3 colorSource = texture2D(tex, texCoord).rgb;
+    vec3 lightWhiteVector = getWhiteVector(getLightIntensity(texCoord));
+    vec3 colorLight = LightColor * lightWhiteVector;
+    vec3 colorReflection = texture2D(tex, texCoord - ReflectionDistance).rgb;
+    vec3 colorResult = (
+        colorSource +
+        (colorLight * LightIntensity) +
+        (colorReflection * ReflectionBrightness)
+    );
+    gl_FragColor = vec4(
+        colorResult,
+        1.0
+    );
+}
+/**
+ * This shader imitates the GameBoy Color subpixel
+ * arrangement.
+ */
+
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+/**
+ * Adds a base color to everything.
+ * Lower values make black colors darker.
+ * Higher values make black colors lighter.
+ * You'll normally want each of these numbers to be close
+ * to 0, and not normally higher than 1.
+ */
+uniform vec3 BaseColor;
+
+/**
+ * Modifies the contrast or saturation of the image.
+ * Lower values make the image more gray and higher values
+ * make it more colorful.
+ * A value of 1 represents a normal, baseline level of
+ * contrast.
+ * You'll normally want this to be somewhere around 1.
+ */
+uniform float SourceContrast;
+
+/**
+ * Modifies the luminosity of the image.
+ * Lower values make the image darker and higher values make
+ * it lighter.
+ * A value of 1 represents normal, baseline luminosity.
+ * You'll normally want this to be somewhere around 1.
+ */
+uniform float SourceLuminosity;
+
+/**
+ * Lower values look more like a sharp, unshaded image.
+ * Higher values look more like an LCD display with subpixels.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelBlendAmount;
+
+/**
+ * Lower values make subpixels darker.
+ * Higher values make them lighter and over-bright.
+ * A value of 1 represents a normal, baseline gamma value.
+ * You'll normally want this to be somewhere around 1.
+ */
+uniform float SubpixelGamma;
+
+/**
+ * Higher values allow subpixels to be more blended-together
+ * and brighter.
+ * Lower values keep subpixel colors more separated.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelColorBleed;
+
+/**
+ * Determines the distance between subpixels.
+ * Lower values put the red, green, and blue subpixels
+ * within a single pixel closer together.
+ * Higher values put them farther apart.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelSpread;
+
+/**
+ * Determines the vertical offset of subpixels within
+ * a pixel.
+ * Lower values put the red, green, and blue subpixels
+ * within a single pixel higher up.
+ * Higher values put them further down.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelVerticalOffset;
+
+/**
+ * Lower values make the subpixels horizontally thinner,
+ * and higher values make them thicker.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelLightWidth;
+
+/**
+ * Lower values make the subpixels vertically taller,
+ * and higher values make them shorter.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelLightHeight;
+
+/**
+ * Lower values make the subpixels sharper and more
+ * individually distinct.
+ * Higher values add an increasingly intense glowing
+ * effect around each subpixel.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelLightGlow;
+
+/**
+ * Scale the size of pixels up or down.
+ * Useful for looking at larger than 8x8 subpixel sizes.
+ * You'll normally want this number to be exactly 1,
+ * meaning that every group of 3 subpixels corresponds
+ * to one pixel in the display.
+ */
+uniform float SubpixelScale;
+
+/**
+ * GBC subpixels are roughly rectangular shaped, but
+ * with a rectangular gap in the lower-right corner.
+ * Lower values make the lower-right gap in each GBC
+ * subpixel less distinct. A value of 0 results in no
+ * gap being shown at all.
+ * Higher values make the gap more distinct.
+ * You'll normally want this to be a number from 0 to 1.
+ */
+uniform float SubpixelTabHeight;
+
+/**
+ * The following three uniforms decide the base colors
+ * of each of the subpixels.
+ * 
+ * Default subpixel colors are based on this resource:
+ * https://gbcc.dev/technology/
+ * R: #FF7145 (1.00, 0.44, 0.27)
+ * G: #C1D650 (0.75, 0.84, 0.31)
+ * B: #3BCEFF (0.23, 0.81, 1.00)
+ */ 
+uniform vec3 SubpixelColorRed; // vec3(1.00, 0.38, 0.22);
+uniform vec3 SubpixelColorGreen; // vec3(0.60, 0.88, 0.30);
+uniform vec3 SubpixelColorBlue; // vec3(0.23, 0.65, 1.00);
+
+/**
+ * Helper to get luminosity of an RGB color.
+ * Used with HCL color space related code.
+ */
+float getColorLumosity(in vec3 rgb) {
+    return (
+        (rgb.r * (5.0 / 16.0)) +
+        (rgb.g * (9.0 / 16.0)) +
+        (rgb.b * (2.0 / 16.0))
+    );
+}
+
+/**
+ * Helper to convert RGB color to HCL. (Hue, Chroma, Luma)
+ */
+vec3 convertRgbToHcl(in vec3 rgb) {
+    float xMin = min(rgb.r, min(rgb.g, rgb.b));
+    float xMax = max(rgb.r, max(rgb.g, rgb.b));
+    float c = xMax - xMin;
+    float l = getColorLumosity(rgb);
+    float h = mod((
+        c == 0 ? 0.0 :
+        xMax == rgb.r ? ((rgb.g - rgb.b) / c) :
+        xMax == rgb.g ? ((rgb.b - rgb.r) / c) + 2.0 :
+        xMax == rgb.b ? ((rgb.r - rgb.g) / c) + 4.0 :
+        0.0
+    ), 6.0);
+    return vec3(h, c, l);
+}
+
+/**
+ * Helper to convert HCL color to RGB. (Hue, Chroma, Luma)
+ */
+vec3 convertHclToRgb(in vec3 hcl) {
+    vec3 rgb;
+    float h = mod(hcl.x, 6.0);
+    float c = hcl.y;
+    float l = hcl.z;
+    float x = c * (1.0 - abs(mod(h, 2.0) - 1.0));
+    if(h <= 1.0) {
+        rgb = vec3(c, x, 0.0);
+    }
+    else if(h <= 2.0) {
+        rgb = vec3(x, c, 0.0);
+    }
+    else if(h <= 3.0) {
+        rgb = vec3(0.0, c, x);
+    }
+    else if(h <= 4.0) {
+        rgb = vec3(0.0, x, c);
+    }
+    else if(h <= 5.0) {
+        rgb = vec3(x, 0.0, c);
+    }
+    else {
+        rgb = vec3(c, 0.0, x);
+    }
+    float lRgb = getColorLumosity(rgb);
+    float m = l - lRgb;
+    return clamp(vec3(m, m, m) + rgb, 0.0, 1.0);
+}
+
+/**
+ * Helper to check if a point is contained within
+ * a rectangular area.
+ */
+bool getPointInRect(
+    vec2 point,
+    vec2 rectTopLeft,
+    vec2 rectBottomRight
+) {
+    return (
+        point.x >= rectTopLeft.x &&
+        point.y >= rectTopLeft.y &&
+        point.x <= rectBottomRight.x &&
+        point.y <= rectBottomRight.y
+    );
+}
+
+/**
+ * Helper to get the nearest offset vector from a
+ * point to a line segment.
+ * (The length of this offset vector is the nearest
+ * distance from the point to the line segment.)
+ * Thank you to https://stackoverflow.com/a/1501725
+ */
+vec2 getPointLineDistance(
+    vec2 point,
+    vec2 line0,
+    vec2 line1
+) {
+    vec2 lineDelta = line0 - line1;
+    float lineLengthSq = dot(lineDelta, lineDelta);
+    if(lineLengthSq <= 0) {
+        return line0 - point;
+    }
+    float t = (
+        dot(point - line0, line1 - line0) / lineLengthSq
+    );
+    vec2 projection = (
+        line0 + clamp(t, 0.0, 1.0) * (line1 - line0)
+    );
+    return projection - point;
+}
+
+/**
+ * Helper to get the nearest offset vector from a
+ * point to a rectangle.
+ * Returns (0, 0) for points within the rectangle.
+ */
+vec2 getPointRectDistance(
+    vec2 point,
+    vec2 rectTopLeft,
+    vec2 rectBottomRight
+) {
+    if(getPointInRect(point, rectTopLeft, rectBottomRight)) {
+        return vec2(0.0, 0.0);
+    }
+    vec2 rectTopRight = vec2(rectBottomRight.x, rectTopLeft.y);
+    vec2 rectBottomLeft = vec2(rectTopLeft.x, rectBottomRight.y);
+    vec2 v0 = getPointLineDistance(point, rectTopLeft, rectTopRight);
+    vec2 v1 = getPointLineDistance(point, rectBottomLeft, rectBottomRight);
+    vec2 v2 = getPointLineDistance(point, rectTopLeft, rectBottomLeft);
+    vec2 v3 = getPointLineDistance(point, rectTopRight, rectBottomRight);
+    float v0LengthSq = dot(v0, v0);
+    float v1LengthSq = dot(v1, v1);
+    float v2LengthSq = dot(v2, v2);
+    float v3LengthSq = dot(v3, v3);
+    float minLengthSq = min(
+        min(v0LengthSq, v1LengthSq),
+        min(v2LengthSq, v3LengthSq)
+    );
+    if(minLengthSq == v0LengthSq) {
+        return v0;
+    }
+    else if(minLengthSq == v1LengthSq) {
+        return v1;
+    }
+    else if(minLengthSq == v2LengthSq) {
+        return v2;
+    }
+    else {
+        return v3;
+    }
+}
+
+/**
+ * Helper to get the nearest offset vector from a
+ * point to a subpixel.
+ * GBC subpixels are roughly rectangular in shape,
+ * but have a rectangular gap in their bottom-left
+ * corner.
+ * Returns (0, 0) for points within the subpixel.
+ */
+vec2 getPointSubpixelDistance(
+    vec2 point,
+    vec2 subpixelCenter,
+    vec2 subpixelSizeHalf
+) {
+    float rectLeft = subpixelCenter.x - subpixelSizeHalf.x;
+    float rectRight = subpixelCenter.x + subpixelSizeHalf.x;
+    float rectTop = subpixelCenter.y - subpixelSizeHalf.y;
+    float rectBottom = subpixelCenter.y + subpixelSizeHalf.y;
+    vec2 offsetLeft = getPointRectDistance(
+        point,
+        vec2(rectLeft, rectTop + SubpixelTabHeight),
+        vec2(subpixelCenter.x, rectBottom)
+    );
+    vec2 offsetRight = getPointRectDistance(
+        point,
+        vec2(subpixelCenter.x, rectTop),
+        vec2(rectRight, rectBottom)
+    );
+    float offsetLeftLengthSq = dot(offsetLeft, offsetLeft);
+    float offsetRightLengthSq = dot(offsetRight, offsetRight);
+    if(offsetLeftLengthSq <= offsetRightLengthSq) {
+        return offsetLeft;
+    }
+    else {
+        return offsetRight;
+    }
+}
+
+/**
+ * Helper to get the intensity of light from a
+ * subpixel.
+ * The pixelPosition argument represents a
+ * fragment's position within a pixel.
+ * Spread represents the subpixel's horizontal
+ * position within the pixel.
+ */
+float getSubpixelIntensity(
+    vec2 pixelPosition,
+    float spread
+) {
+    vec2 subpixelCenter = vec2(
+        0.5 + (spread * SubpixelSpread),
+        1.0 - SubpixelVerticalOffset
+    );
+    vec2 subpixelSizeHalf = 0.5 * vec2(
+        SubpixelLightWidth,
+        SubpixelLightHeight
+    );
+    vec2 offset = getPointSubpixelDistance(
+        pixelPosition,
+        subpixelCenter,
+        subpixelSizeHalf
+    );
+    if(SubpixelLightGlow <= 0) {
+        return dot(offset, offset) <= 0.0 ? 1.0 : 0.0;
+    }
+    else {
+        float dist = length(offset);
+        float glow = max(0.0,
+            1.0 - (dist / SubpixelLightGlow)
+        );
+        return glow;
+    }
+}
+
+/**
+ * Helper to apply SubpixelColorBleed to the intensity
+ * value computed for a fragment and subpixel.
+ * Subpixel color bleed allows subpixel colors to be
+ * more strongly coerced to more accurately represent
+ * the underlying pixel color.
+ */
+float applySubpixelBleed(
+    float subpixelIntensity,
+    float colorSourceChannel
+) {
+    return subpixelIntensity * (
+        SubpixelColorBleed +
+        ((1.0 - SubpixelColorBleed) * colorSourceChannel)
+    );
+}
+
+void main() {
+    // Get base color of the pixel, adjust based on
+    // contrast and luminosity settings.
+    vec3 colorSource = texture2D(tex, texCoord).rgb;
+    vec3 colorSourceHcl = convertRgbToHcl(colorSource);
+    vec3 colorSourceAdjusted = convertHclToRgb(vec3(
+        colorSourceHcl.x,
+        colorSourceHcl.y * SourceContrast,
+        colorSourceHcl.z * SourceLuminosity
+    ));
+    // Determine how much each subpixel's light should
+    // affect this fragment.
+    vec2 pixelPosition = (
+        mod(texCoord * texSize * SubpixelScale, 1.0)
+    );
+    float subpixelIntensityRed = applySubpixelBleed(
+        getSubpixelIntensity(pixelPosition, -1.0),
+        colorSourceAdjusted.r
+    );
+    float subpixelIntensityGreen = applySubpixelBleed(
+        getSubpixelIntensity(pixelPosition, +0.0),
+        colorSourceAdjusted.g
+    );
+    float subpixelIntensityBlue = applySubpixelBleed(
+        getSubpixelIntensity(pixelPosition, +1.0),
+        colorSourceAdjusted.b
+    );
+    vec3 subpixelLightColor = SubpixelGamma * (
+        (subpixelIntensityRed * SubpixelColorRed) +
+        (subpixelIntensityGreen * SubpixelColorGreen) +
+        (subpixelIntensityBlue * SubpixelColorBlue)
+    );
+    // Compute final color
+    vec3 colorResult = clamp(
+        subpixelLightColor * colorSourceAdjusted, 0.0, 1.0
+    );
+    vec3 colorResultBlended = (
+        ((1.0 - SubpixelBlendAmount) * colorSourceAdjusted) +
+        (SubpixelBlendAmount * colorResult)
+    );
+    colorResultBlended = BaseColor + (
+        (colorResultBlended * (vec3(1.0, 1.0, 1.0) - BaseColor))
+    );
+    gl_FragColor = vec4(
+        colorResultBlended,
+        1.0
+    );
+}
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>
+[shader]
+name=gbc-lcd
+author=Sophie Kirschner
+description=Imitates the GameBoy Color LCD screen subpixel arrangement, with an optional backlight effect.
+passes=2
+
+[pass.0]
+integerScaling=1
+fragmentShader=gbc-lcd.fs
+blend=1
+
+[pass.1]
+fragmentShader=gbc-lcd-light.fs
+
+[pass.0.uniform.BaseColor]
+type=float3
+default[0]=0.130
+default[1]=0.128
+default[2]=0.101
+readableName=Screen base color
+
+[pass.0.uniform.SubpixelColorRed]
+type=float3
+default[0]=1.00
+default[1]=0.38
+default[2]=0.22
+readableName=Red subpixel color
+
+[pass.0.uniform.SubpixelColorGreen]
+type=float3
+default[0]=0.60
+default[1]=0.88
+default[2]=0.30
+readableName=Green subpixel color
+
+[pass.0.uniform.SubpixelColorBlue]
+type=float3
+default[0]=0.23
+default[1]=0.65
+default[2]=1.00
+readableName=Blue subpixel color
+
+[pass.0.uniform.SourceContrast]
+type=float
+default=0.85
+readableName=Screen contrast
+
+[pass.0.uniform.SourceLuminosity]
+type=float
+default=0.88
+readableName=Screen luminosity
+
+[pass.0.uniform.SubpixelBlendAmount]
+type=float
+default=1.0
+readableName=Subpixel effect amount
+
+[pass.0.uniform.SubpixelColorBleed]
+type=float
+default=0.31
+readableName=Subpixel color bleeding
+
+[pass.0.uniform.SubpixelSpread]
+type=float
+default=0.333
+readableName=Subpixel spread X
+
+[pass.0.uniform.SubpixelVerticalOffset]
+type=float
+default=0.48
+readableName=Subpixel offset Y
+
+[pass.0.uniform.SubpixelGamma]
+type=float
+default=1.040
+readableName=Subpixel brightness
+
+[pass.0.uniform.SubpixelLightWidth]
+type=float
+default=0.220
+readableName=Subpixel width
+
+[pass.0.uniform.SubpixelLightHeight]
+type=float
+default=0.850
+readableName=Subpixel height
+
+[pass.0.uniform.SubpixelLightGlow]
+type=float
+default=0.195
+readableName=Subpixel glow size
+
+[pass.0.uniform.SubpixelTabHeight]
+type=float
+default=0.175
+readableName=Subpixel tab shaping
+
+[pass.0.uniform.SubpixelScale]
+type=float
+default=1.0
+readableName=Subpixel scale
+
+[pass.1.uniform.LightColor]
+type=float3
+default[0]=1.000
+default[1]=0.968
+default[2]=0.882
+readableName=Backlight color
+
+[pass.1.uniform.LightIntensity]
+type=float
+default=0.06
+readableName=Backlight intensity
+
+[pass.1.uniform.LightSoftness]
+type=float
+default=0.67
+readableName=Backlight softness
+
+[pass.1.uniform.ReflectionDistance]
+type=float2
+default[0]=0
+default[1]=0.025
+readableName=Internal reflection distance
+
+[pass.1.uniform.ReflectionBrightness]
+type=float
+default=0.032
+readableName=Internal reflection brightness
+/* MIT License
+*
+* Copyright (c) 2015-2023 Lior Halphon
+*
+* 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.
+*/
+/* Based on this (really good) article: http://blog.pkh.me/p/19-butchering-hqx-scaling-filters.html */
+
+/* The colorspace used by the HQnx filters is not really YUV, despite the algorithm description claims it is. It is
+   also not normalized. Therefore, we shall call the colorspace used by HQnx "HQ Colorspace" to avoid confusion. */
+
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+float _bit(float v, int i)
+{
+	// v is an integer value stored as float
+	float p = exp2(float(i)); // 2^i, GLSL ES 1.00-friendly
+	return floor(mod(floor(v / p), 2.0));
+}
+
+bool _matchMask(float pattern, int mask, int ref)
+{
+	// (pattern & mask) == ref, implemented without bitwise ops.
+	float m = float(mask);
+	float r = float(ref);
+	float mism = 0.0;
+	for (int i = 0; i < 8; ++i)
+	{
+		float mb = _bit(m, i);
+		if (mb > 0.5)
+		{
+			float pb = _bit(pattern, i);
+			float rb = _bit(r, i);
+			mism += abs(pb - rb);
+		}
+	}
+	return mism < 0.5;
+}
+
+vec3 rgb_to_hq_colospace(vec4 rgb)
+{
+	return vec3(
+		0.250 * rgb.r + 0.250 * rgb.g + 0.250 * rgb.b,
+		0.250 * rgb.r - 0.000 * rgb.g - 0.250 * rgb.b,
+	   -0.125 * rgb.r + 0.250 * rgb.g - 0.125 * rgb.b
+	);
+}
+
+bool is_different(vec4 a, vec4 b)
+{
+	vec3 diff = abs(rgb_to_hq_colospace(a) - rgb_to_hq_colospace(b));
+	return diff.x > 0.018 || diff.y > 0.002 || diff.z > 0.005;
+}
+
+// WebGL1: no bitwise ops in GLSL ES 1.00
+
+vec4 interp_2px(vec4 c1, float w1, vec4 c2, float w2)
+{
+	return (c1 * w1 + c2 * w2) / (w1 + w2);
+}
+
+vec4 interp_3px(vec4 c1, float w1, vec4 c2, float w2, vec4 c3, float w3)
+{
+	return (c1 * w1 + c2 * w2 + c3 * w3) / (w1 + w2 + w3);
+}
+
+vec4 scale(sampler2D image, vec2 position, vec2 input_resolution)
+{
+	// o = offset, the width of a pixel
+	vec2 o = vec2(1.0, 1.0) / input_resolution;
+
+	/* We always calculate the top left pixel.  If we need a different pixel, we flip the image */
+
+	// p = the position within a pixel [0...1]
+	vec2 p = fract(position * input_resolution);
+
+	if (p.x > 0.5) o.x = -o.x;
+	if (p.y > 0.5) o.y = -o.y;
+
+	vec4 w0 = texture2D(image, position + vec2( -o.x, -o.y));
+	vec4 w1 = texture2D(image, position + vec2(  0.0, -o.y));
+	vec4 w2 = texture2D(image, position + vec2(  o.x, -o.y));
+	vec4 w3 = texture2D(image, position + vec2( -o.x,  0.0));
+	vec4 w4 = texture2D(image, position + vec2(  0.0,  0.0));
+	vec4 w5 = texture2D(image, position + vec2(  o.x,  0.0));
+	vec4 w6 = texture2D(image, position + vec2( -o.x,  o.y));
+	vec4 w7 = texture2D(image, position + vec2(  0.0,  o.y));
+	vec4 w8 = texture2D(image, position + vec2(  o.x,  o.y));
+
+	float pattern = 0.0;
+	if (is_different(w0, w4)) pattern += 1.0;
+	if (is_different(w1, w4)) pattern += 2.0;
+	if (is_different(w2, w4)) pattern += 4.0;
+	if (is_different(w3, w4)) pattern += 8.0;
+	if (is_different(w5, w4)) pattern += 16.0;
+	if (is_different(w6, w4)) pattern += 32.0;
+	if (is_different(w7, w4)) pattern += 64.0;
+	if (is_different(w8, w4)) pattern += 128.0;
+
+	// NOTE: hex literals (0x..) are not GLSL ES 1.00. Converted to decimal.
+
+	if ((_matchMask(pattern, 191, 55) || _matchMask(pattern, 219, 19)) && is_different(w1, w5))
+	{
+		return interp_2px(w4, 3.0, w3, 1.0);
+	}
+	if ((_matchMask(pattern, 219, 73) || _matchMask(pattern, 239, 109)) && is_different(w7, w3))
+	{
+		return interp_2px(w4, 3.0, w1, 1.0);
+	}
+	if ((_matchMask(pattern, 11, 11) || _matchMask(pattern, 254, 74) || _matchMask(pattern, 254, 26)) && is_different(w3, w1))
+	{
+		return w4;
+	}
+	if ((_matchMask(pattern, 111, 42) || _matchMask(pattern, 91, 10) || _matchMask(pattern, 191, 58) || _matchMask(pattern, 223, 90) ||
+		 _matchMask(pattern, 159, 138) || _matchMask(pattern, 207, 138) || _matchMask(pattern, 239, 78) || _matchMask(pattern, 63, 14) ||
+		 _matchMask(pattern, 251, 90) || _matchMask(pattern, 187, 138) || _matchMask(pattern, 127, 90) || _matchMask(pattern, 175, 138) ||
+		 _matchMask(pattern, 235, 138)) && is_different(w3, w1))
+	{
+		return interp_2px(w4, 3.0, w0, 1.0);
+	}
+	if (_matchMask(pattern, 11, 8))
+	{
+		return interp_3px(w4, 2.0, w0, 1.0, w1, 1.0);
+	}
+	if (_matchMask(pattern, 11, 2))
+	{
+		return interp_3px(w4, 2.0, w0, 1.0, w3, 1.0);
+	}
+	if (_matchMask(pattern, 47, 47))
+	{
+		return interp_3px(w4, 4.0, w3, 1.0, w1, 1.0);
+	}
+	if (_matchMask(pattern, 191, 55) || _matchMask(pattern, 219, 19))
+	{
+		return interp_3px(w4, 5.0, w1, 2.0, w3, 1.0);
+	}
+	if (_matchMask(pattern, 219, 73) || _matchMask(pattern, 239, 109))
+	{
+		return interp_3px(w4, 5.0, w3, 2.0, w1, 1.0);
+	}
+	if (_matchMask(pattern, 27, 3) || _matchMask(pattern, 79, 67) || _matchMask(pattern, 139, 131) || _matchMask(pattern, 107, 67))
+	{
+		return interp_2px(w4, 3.0, w3, 1.0);
+	}
+	if (_matchMask(pattern, 75, 9) || _matchMask(pattern, 139, 137) || _matchMask(pattern, 31, 25) || _matchMask(pattern, 59, 25))
+	{
+		return interp_2px(w4, 3.0, w1, 1.0);
+	}
+	if (_matchMask(pattern, 126, 42) || _matchMask(pattern, 239, 171) || _matchMask(pattern, 191, 143) || _matchMask(pattern, 126, 14))
+	{
+		return interp_3px(w4, 2.0, w3, 3.0, w1, 3.0);
+	}
+	if (_matchMask(pattern, 251, 106) || _matchMask(pattern, 111, 110) || _matchMask(pattern, 63, 62) || _matchMask(pattern, 251, 250) ||
+		_matchMask(pattern, 223, 222) || _matchMask(pattern, 223, 30))
+	{
+		return interp_2px(w4, 3.0, w0, 1.0);
+	}
+	if (_matchMask(pattern, 10, 0) || _matchMask(pattern, 79, 75) || _matchMask(pattern, 159, 27) || _matchMask(pattern, 47, 11) ||
+		_matchMask(pattern, 190, 10) || _matchMask(pattern, 238, 10) || _matchMask(pattern, 126, 10) || _matchMask(pattern, 235, 75) ||
+		_matchMask(pattern, 59, 27))
+	{
+		return interp_3px(w4, 2.0, w3, 1.0, w1, 1.0);
+	}
+
+	return interp_3px(w4, 6.0, w3, 1.0, w1, 1.0);
+}
+
+void main()
+{
+	gl_FragColor = scale(tex, texCoord, texSize);
+}
+[shader]
+name=hq2x
+author=Lior Halphon
+description="High Quality" 2x scaling
+passes=1
+
+[pass.0]
+fragmentShader=hq2x.fs
+blend=0
+width=-2
+height=-2
+/*
+   LCD Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float boundBrightness;
+
+void main()
+{
+	vec4 color = texture2D(tex, texCoord);
+
+	if (int(mod(texCoord.s * texSize.x * 3.0, 3.0)) == 0 ||
+		int(mod(texCoord.t * texSize.y * 3.0, 3.0)) == 0)
+	{
+		color.rgb *= vec3(1.0, 1.0, 1.0) * boundBrightness;
+	}
+
+	gl_FragColor = color;
+}
+[shader]
+name=LCD
+author=Dominus Iniquitatis
+description=Simple LCD emulation.
+passes=1
+
+[pass.0]
+fragmentShader=lcd.fs
+blend=1
+width=-3
+height=-3
+
+[pass.0.uniform.boundBrightness]
+type=float
+readableName=Bound brightness
+default=0.9
+min=0.0
+max=1.0
+[shader]
+name=Motion Blur
+author=Dominus Iniquitatis
+description=Simple motion blur.
+passes=1
+
+[pass.0]
+fragmentShader=motion_blur.fs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.amount]
+type=float
+readableName=Amount
+default=0.3
+min=0.0
+max=1.0
+/*
+   Motion Blur Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float amount;
+
+void main()
+{
+	vec4 color = texture2D(tex, texCoord);
+	color.a = 1.0 - amount;
+
+	gl_FragColor = color;
+}
+[shader]
+name=Nintendo DS Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the LCD Colorspace from a Nintendo DS Phat.
+passes=1
+
+[pass.0]
+fragmentShader=nds-color.fs
+vertexShader=nds-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the LCD Colorspace from a Nintendo DS Phat --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 NDS_sRGB = mat4(
+	0.835, 0.10, 0.105, 0.0,  //red channel
+	0.27, 0.6375, 0.175, 0.0,  //green channel
+	-0.105, 0.2625, 0.72, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   0.905   //alpha channel
+); 
+
+const mat4 NDS_DCI = mat4(
+	0.70, 0.125, 0.12, 0.0,  //red channel
+	0.34, 0.625, 0.20, 0.0,  //green channel
+	-0.04, 0.25, 0.68, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   0.96  //alpha channel
+); 
+
+const mat4 NDS_Rec2020 = mat4(
+	0.555, 0.1475, 0.1175, 0.0,  //red channel
+	0.39, 0.6075, 0.2075, 0.0,  //green channel
+	0.055, 0.245, 0.675, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   1.0  //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = NDS_sRGB;
+	else if (color_mode == 2) profile = NDS_DCI;
+	else if (color_mode == 3) profile = NDS_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=NSO GBA Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the Nintendo Switch Online's GBA color filter.
+passes=1
+
+[pass.0]
+fragmentShader=nso-gba-color.fs
+vertexShader=nso-gba-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.darken_screen]
+type=float
+default=0.8
+min=0
+max=1
+readableName=Darken Screen
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the LCD Colorspace from Gameboy Advance --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+uniform float darken_screen;
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma + darken_screen)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 GBA_sRGB = mat4(
+	0.865, 0.0575, 0.0575, 0.0,  //red channel
+	0.1225, 0.925, 0.1225, 0.0,  //green channel
+	0.0125, 0.0125, 0.82, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  1.0   //alpha channel
+);
+
+const mat4 GBA_DCI = mat4(
+	0.72, 0.0875, 0.0725, 0.0,  //red channel
+	0.2675, 0.9, 0.185, 0.0,  //green channel
+	0.0125, 0.0125, 0.7425, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  1.0   //alpha channel
+);
+
+const mat4 GBA_Rec2020 = mat4(
+	0.57, 0.115, 0.0725, 0.0,  //red channel
+	0.3825, 0.8625, 0.195, 0.0,  //green channel
+	0.0475, 0.0225, 0.7325, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  1.0   //alpha channel
+);
+
+void main() {
+	if (color_mode == 1) profile = GBA_sRGB;
+	else if (color_mode == 2) profile = GBA_DCI;
+	else if (color_mode == 3) profile = GBA_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=NSO GBC Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the Nintendo Switch Online's GBC color filter.
+passes=1
+
+[pass.0]
+fragmentShader=nso-gbc-color.fs
+vertexShader=nso-gbc-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.lighten_screen]
+type=float
+default=0.0
+min=0
+max=1
+readableName=Lighten Screen
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the Nintendo Switch Online's GBC color filter --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+uniform float lighten_screen;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(1.24, 0.8, 0.7, 1.0)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 GBC_sRGB = mat4(
+	0.84, 0.105, 0.15, 0.0,  //red channel
+	0.265, 0.67, 0.30, 0.0,  //green channel
+	0.0, 0.24, 0.525, 0.0,  //blue channel
+	0.175,  0.18,  0.18,  0.85   //alpha channel
+); 
+
+const mat4 GBC_DCI = mat4(
+	0.84, 0.105, 0.15, 0.0,  //red channel
+	0.265, 0.67, 0.30, 0.0,  //green channel
+	0.0, 0.24, 0.525, 0.0,  //blue channel
+	0.175,  0.18,  0.18,  1.0   //alpha channel
+); 
+
+const mat4 GBC_Rec2020 = mat4(
+	0.84, 0.105, 0.15, 0.0,  //red channel
+	0.265, 0.67, 0.30, 0.0,  //green channel
+	0.0, 0.24, 0.525, 0.0,  //blue channel
+	0.175,  0.18,  0.18,  1.0   //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = GBC_sRGB;
+	else if (color_mode == 2) profile = GBC_DCI;
+	else if (color_mode == 3) profile = GBC_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=OmniScale
+author=Lior Halphon
+description=Resolution-indepedent scaler inspired by the hqx family scalers
+passes=1
+
+[pass.0]
+fragmentShader=omniscale.fs
+blend=0
+/* MIT License
+*
+* Copyright (c) 2015-2023 Lior Halphon
+*
+* 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.
+*/
+/* OmniScale is derived from the pattern based design of HQnx, but with the following general differences:
+	- The actual output calculating was completely redesigned as resolution independent graphic generator. This allows
+	  scaling to any factor.
+	- HQnx approximations that were good enough for a 2x/3x/4x factor were refined, creating smoother gradients.
+	- "Quarters" can be interpolated in more ways than in the HQnx filters
+	- If a pattern does not provide enough information to determine the suitable scaling interpolation, up to 16 pixels
+	  per quarter are sampled (in contrast to the usual 9) in order to determine the best interpolation.
+ */
+
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+uniform vec2 outputSize;
+
+float _bit(float v, int i)
+{
+	// v is an integer value stored as float
+	float p = exp2(float(i)); // 2^i, GLSL ES 1.00-friendly
+	return floor(mod(floor(v / p), 2.0));
+}
+
+bool _matchMask(float pattern, int mask, int ref)
+{
+	// (pattern & mask) == ref, implemented without bitwise ops.
+	float m = float(mask);
+	float r = float(ref);
+	float mism = 0.0;
+	for (int i = 0; i < 15; ++i)
+	{
+		float mb = _bit(m, i);
+		if (mb > 0.5)
+		{
+			float pb = _bit(pattern, i);
+			float rb = _bit(r, i);
+			mism += abs(pb - rb);
+		}
+	}
+	return mism < 0.5;
+}
+
+/* We use the same colorspace as the HQ algorithms. */
+vec3 rgb_to_hq_colospace(vec4 rgb)
+{
+	return vec3(
+		0.250 * rgb.r + 0.250 * rgb.g + 0.250 * rgb.b,
+		0.250 * rgb.r - 0.000 * rgb.g - 0.250 * rgb.b,
+	   -0.125 * rgb.r + 0.250 * rgb.g - 0.125 * rgb.b
+	);
+}
+
+bool is_different(vec4 a, vec4 b)
+{
+	vec3 diff = abs(rgb_to_hq_colospace(a) - rgb_to_hq_colospace(b));
+	return diff.x > 0.018 || diff.y > 0.002 || diff.z > 0.005;
+}
+
+// WebGL1: no bitwise ops in GLSL ES 1.00
+
+vec4 scale(sampler2D image, vec2 position, vec2 input_resolution, vec2 output_resolution)
+{
+	// o = offset, the width of a pixel
+	vec2 o = vec2(1.0, 1.0) / input_resolution;
+
+	/* We always calculate the top left quarter.  If we need a different quarter, we flip our co-ordinates */
+
+	// p = the position within a pixel [0...1]
+	vec2 p = fract(position * input_resolution);
+
+	if (p.x > 0.5)
+	{
+		o.x = -o.x;
+		p.x = 1.0 - p.x;
+	}
+	if (p.y > 0.5)
+	{
+		o.y = -o.y;
+		p.y = 1.0 - p.y;
+	}
+
+	vec4 w0 = texture2D(image, position + vec2(-o.x, -o.y));
+	vec4 w1 = texture2D(image, position + vec2( 0.0, -o.y));
+	vec4 w2 = texture2D(image, position + vec2( o.x, -o.y));
+	vec4 w3 = texture2D(image, position + vec2(-o.x,  0.0));
+	vec4 w4 = texture2D(image, position + vec2( 0.0,  0.0));
+	vec4 w5 = texture2D(image, position + vec2( o.x,  0.0));
+	vec4 w6 = texture2D(image, position + vec2(-o.x,  o.y));
+	vec4 w7 = texture2D(image, position + vec2( 0.0,  o.y));
+	vec4 w8 = texture2D(image, position + vec2( o.x,  o.y));
+
+	float pattern = 0.0;
+	if (is_different(w0, w4)) pattern += 1.0;
+	if (is_different(w1, w4)) pattern += 2.0;
+	if (is_different(w2, w4)) pattern += 4.0;
+	if (is_different(w3, w4)) pattern += 8.0;
+	if (is_different(w5, w4)) pattern += 16.0;
+	if (is_different(w6, w4)) pattern += 32.0;
+	if (is_different(w7, w4)) pattern += 64.0;
+	if (is_different(w8, w4)) pattern += 128.0;
+
+	// NOTE: hex literals (0x..) are not GLSL ES 1.00. Converted to decimal.
+
+	if ((_matchMask(pattern, 191, 55) || _matchMask(pattern, 219, 19)) && is_different(w1, w5))
+	{
+		return mix(w4, w3, 0.5 - p.x);
+	}
+	if ((_matchMask(pattern, 219, 73) || _matchMask(pattern, 239, 109)) && is_different(w7, w3))
+	{
+		return mix(w4, w1, 0.5 - p.y);
+	}
+	if ((_matchMask(pattern, 11, 11) || _matchMask(pattern, 254, 74) || _matchMask(pattern, 254, 26)) && is_different(w3, w1))
+	{
+		return w4;
+	}
+	if ((_matchMask(pattern, 111, 42) || _matchMask(pattern, 91, 10) || _matchMask(pattern, 191, 58) || _matchMask(pattern, 223, 90) ||
+		 _matchMask(pattern, 159, 138) || _matchMask(pattern, 207, 138) || _matchMask(pattern, 239, 78) || _matchMask(pattern, 63, 14) ||
+		 _matchMask(pattern, 251, 90) || _matchMask(pattern, 187, 138) || _matchMask(pattern, 127, 90) || _matchMask(pattern, 175, 138) ||
+		 _matchMask(pattern, 235, 138)) && is_different(w3, w1))
+	{
+		return mix(w4, mix(w4, w0, 0.5 - p.x), 0.5 - p.y);
+	}
+	if (_matchMask(pattern, 11, 8))
+	{
+		return mix(mix(w0 * 0.375 + w1 * 0.25 + w4 * 0.375, w4 * 0.5 + w1 * 0.5, p.x * 2.0), w4, p.y * 2.0);
+	}
+	if (_matchMask(pattern, 11, 2))
+	{
+		return mix(mix(w0 * 0.375 + w3 * 0.25 + w4 * 0.375, w4 * 0.5 + w3 * 0.5, p.y * 2.0), w4, p.x * 2.0);
+	}
+	if (_matchMask(pattern, 47, 47))
+	{
+		float dist = length(p - vec2(0.5));
+		float pixel_size = length(1.0 / (output_resolution / input_resolution));
+		if (dist < 0.5 - pixel_size / 2.0)
+		{
+			return w4;
+		}
+		vec4 r;
+		if (is_different(w0, w1) || is_different(w0, w3))
+		{
+			r = mix(w1, w3, p.y - p.x + 0.5);
+		}
+		else
+		{
+			r = mix(mix(w1 * 0.375 + w0 * 0.25 + w3 * 0.375, w3, p.y * 2.0), w1, p.x * 2.0);
+		}
+
+		if (dist > 0.5 + pixel_size / 2.0)
+		{
+			return r;
+		}
+		return mix(w4, r, (dist - 0.5 + pixel_size / 2.0) / pixel_size);
+	}
+	if (_matchMask(pattern, 191, 55) || _matchMask(pattern, 219, 19))
+	{
+		float dist = p.x - 2.0 * p.y;
+		float pixel_size = length(1.0 / (output_resolution / input_resolution)) * sqrt(5.0);
+		if (dist > pixel_size / 2.0)
+		{
+			return w1;
+		}
+		vec4 r = mix(w3, w4, p.x + 0.5);
+		if (dist < -pixel_size / 2.0)
+		{
+			return r;
+		}
+		return mix(r, w1, (dist + pixel_size / 2.0) / pixel_size);
+	}
+	if (_matchMask(pattern, 219, 73) || _matchMask(pattern, 239, 109))
+	{
+		float dist = p.y - 2.0 * p.x;
+		float pixel_size = length(1.0 / (output_resolution / input_resolution)) * sqrt(5.0);
+		if (dist > pixel_size / 2.0)
+		{
+			return w3;
+		}
+		vec4 r = mix(w1, w4, p.x + 0.5);
+		if (dist < -pixel_size / 2.0)
+		{
+			return r;
+		}
+		return mix(r, w3, (dist + pixel_size / 2.0) / pixel_size);
+	}
+	if (_matchMask(pattern, 191, 143) || _matchMask(pattern, 126, 14))
+	{
+		float dist = p.x + 2.0 * p.y;
+		float pixel_size = length(1.0 / (output_resolution / input_resolution)) * sqrt(5.0);
+
+		if (dist > 1.0 + pixel_size / 2.0)
+		{
+			return w4;
+		}
+
+		vec4 r;
+		if (is_different(w0, w1) || is_different(w0, w3))
+		{
+			r = mix(w1, w3, p.y - p.x + 0.5);
+		}
+		else
+		{
+			r = mix(mix(w1 * 0.375 + w0 * 0.25 + w3 * 0.375, w3, p.y * 2.0), w1, p.x * 2.0);
+		}
+
+		if (dist < 1.0 - pixel_size / 2.0)
+		{
+			return r;
+		}
+
+		return mix(r, w4, (dist + pixel_size / 2.0 - 1.0) / pixel_size);
+	}
+
+	if (_matchMask(pattern, 126, 42) || _matchMask(pattern, 239, 171))
+	{
+		float dist = p.y + 2.0 * p.x;
+		float pixel_size = length(1.0 / (output_resolution / input_resolution)) * sqrt(5.0);
+
+		if (dist > 1.0 + pixel_size / 2.0)
+		{
+			return w4;
+		}
+
+		vec4 r;
+
+		if (is_different(w0, w1) || is_different(w0, w3))
+		{
+			r = mix(w1, w3, p.y - p.x + 0.5);
+		}
+		else
+		{
+			r = mix(mix(w1 * 0.375 + w0 * 0.25 + w3 * 0.375, w3, p.y * 2.0), w1, p.x * 2.0);
+		}
+
+		if (dist < 1.0 - pixel_size / 2.0)
+		{
+			return r;
+		}
+
+		return mix(r, w4, (dist + pixel_size / 2.0 - 1.0) / pixel_size);
+	}
+
+	if (_matchMask(pattern, 27, 3) || _matchMask(pattern, 79, 67) || _matchMask(pattern, 139, 131) || _matchMask(pattern, 107, 67))
+	{
+		return mix(w4, w3, 0.5 - p.x);
+	}
+
+	if (_matchMask(pattern, 75, 9) || _matchMask(pattern, 139, 137) || _matchMask(pattern, 31, 25) || _matchMask(pattern, 59, 25))
+	{
+		return mix(w4, w1, 0.5 - p.y);
+	}
+
+	if (_matchMask(pattern, 251, 106) || _matchMask(pattern, 111, 110) || _matchMask(pattern, 63, 62) || _matchMask(pattern, 251, 250) ||
+		_matchMask(pattern, 223, 222) || _matchMask(pattern, 223, 30))
+	{
+		return mix(w4, w0, (1.0 - p.x - p.y) / 2.0);
+	}
+
+	if (_matchMask(pattern, 79, 75) || _matchMask(pattern, 159, 27) || _matchMask(pattern, 47, 11) ||
+		_matchMask(pattern, 190, 10) || _matchMask(pattern, 238, 10) || _matchMask(pattern, 126, 10) || _matchMask(pattern, 235, 75) ||
+		_matchMask(pattern, 59, 27))
+	{
+		float dist = p.x + p.y;
+		float pixel_size = length(1.0 / (output_resolution / input_resolution));
+
+		if (dist > 0.5 + pixel_size / 2.0)
+		{
+			return w4;
+		}
+
+		vec4 r;
+		if (is_different(w0, w1) || is_different(w0, w3))
+		{
+			r = mix(w1, w3, p.y - p.x + 0.5);
+		}
+		else
+		{
+			r = mix(mix(w1 * 0.375 + w0 * 0.25 + w3 * 0.375, w3, p.y * 2.0), w1, p.x * 2.0);
+		}
+
+		if (dist < 0.5 - pixel_size / 2.0)
+		{
+			return r;
+		}
+
+		return mix(r, w4, (dist + pixel_size / 2.0 - 0.5) / pixel_size);
+	}
+
+	if (_matchMask(pattern, 11, 1))
+	{
+		return mix(mix(w4, w3, 0.5 - p.x), mix(w1, (w1 + w3) / 2.0, 0.5 - p.x), 0.5 - p.y);
+	}
+
+	if (_matchMask(pattern, 11, 0))
+	{
+		return mix(mix(w4, w3, 0.5 - p.x), mix(w1, w0, 0.5 - p.x), 0.5 - p.y);
+	}
+
+	float dist = p.x + p.y;
+	float pixel_size = length(1.0 / (output_resolution / input_resolution));
+
+	if (dist > 0.5 + pixel_size / 2.0)
+	{
+		return w4;
+	}
+
+	/* We need more samples to "solve" this diagonal */
+	vec4 x0 = texture2D(image, position + vec2(-o.x * 2.0, -o.y * 2.0));
+	vec4 x1 = texture2D(image, position + vec2(-o.x       , -o.y * 2.0));
+	vec4 x2 = texture2D(image, position + vec2( 0.0       , -o.y * 2.0));
+	vec4 x3 = texture2D(image, position + vec2( o.x       , -o.y * 2.0));
+	vec4 x4 = texture2D(image, position + vec2(-o.x * 2.0, -o.y       ));
+	vec4 x5 = texture2D(image, position + vec2(-o.x * 2.0,  0.0       ));
+	vec4 x6 = texture2D(image, position + vec2(-o.x * 2.0,  o.y       ));
+
+	if (is_different(x0, w4)) pattern += exp2(8.0);
+	if (is_different(x1, w4)) pattern += exp2(9.0);
+	if (is_different(x2, w4)) pattern += exp2(10.0);
+	if (is_different(x3, w4)) pattern += exp2(11.0);
+	if (is_different(x4, w4)) pattern += exp2(12.0);
+	if (is_different(x5, w4)) pattern += exp2(13.0);
+	if (is_different(x6, w4)) pattern += exp2(14.0);
+
+	float diagonal_bias = -7.0;
+	for (int i = 0; i < 15; ++i)
+	{
+		diagonal_bias += _bit(pattern, i);
+	}
+
+	if (diagonal_bias <= 0.0)
+	{
+		vec4 r = mix(w1, w3, p.y - p.x + 0.5);
+		if (dist < 0.5 - pixel_size / 2.0)
+		{
+			return r;
+		}
+		return mix(r, w4, (dist + pixel_size / 2.0 - 0.5) / pixel_size);
+	}
+
+	return w4;
+}
+
+void main()
+{
+	gl_FragColor = scale(tex, texCoord, texSize, outputSize);
+}
+[shader]
+name=Pixelate
+author=endrift
+description=Only scale up the screen at an integer ratio
+passes=1
+
+[pass.0]
+blend=1
+integerScaling=1
+[shader]
+name=Scale2x
+author=singron
+description=AdvanceMAME's Scale2x algorithm
+passes=1
+
+[pass.0]
+fragmentShader=scale2x.fs
+blend=1
+width=-2
+height=-2
+/* Shader implementation of Scale2x is adapted from https://gist.github.com/singron/3161079 */
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+void main() {
+    // o = offset, the width of a pixel
+    vec2 o = 1.0 / texSize;
+
+    // texel arrangement
+    // A B C
+    // D E F
+    // G H I
+    vec4 B = texture2D(tex, texCoord + vec2(  0.0,  o.y));
+    vec4 D = texture2D(tex, texCoord + vec2( -o.x,  0.0));
+    vec4 E = texture2D(tex, texCoord + vec2(  0.0,  0.0));
+    vec4 F = texture2D(tex, texCoord + vec2(  o.x,  0.0));
+    vec4 H = texture2D(tex, texCoord + vec2(  0.0, -o.y));
+    vec2 p = texCoord * texSize;
+    // p = the texCoord within a pixel [0...1]
+    p = fract(p);
+	if (p.x > .5) {
+		if (p.y > .5) {
+			// Top Right
+			gl_FragColor = B == F && B != D && F != H ? F : E;
+		} else {
+			// Bottom Right
+			gl_FragColor = H == F && D != H && B != F ? F : E;
+		}
+	} else {
+		if (p.y > .5) {
+			// Top Left
+			gl_FragColor = D == B && B != F && D != H ? D : E;
+		} else {
+			// Bottom Left
+			gl_FragColor = D == H && D != B && H != F ? D : E;
+		}
+	}
+}
+[shader]
+name=Scale4x
+author=singron, endrift
+description=AdvanceMAME's Scale4x algorithm
+passes=1
+
+[pass.0]
+fragmentShader=scale4x.fs
+blend=1
+width=-4
+height=-4
+/* Shader implementation of Scale2x is adapted from https://gist.github.com/singron/3161079 */
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+vec4 scale2x(vec4 pixels[5], vec2 p) {
+    // texel arrangement
+    // x 0 x
+    // 1 2 3
+    // x 4 x
+    // p = the texCoord within a pixel [0...1]
+    p = fract(p);
+	if (p.x > .5) {
+		if (p.y > .5) {
+			// Top Right
+			return pixels[0] == pixels[3] && pixels[0] != pixels[1] && pixels[3] != pixels[4] ? pixels[3] : pixels[2];
+		} else {
+			// Bottom Right
+			return pixels[4] == pixels[3] && pixels[1] != pixels[4] && pixels[0] != pixels[3] ? pixels[3] : pixels[2];
+		}
+	} else {
+		if (p.y > .5) {
+			// Top Left
+			return pixels[1] == pixels[0] && pixels[0] != pixels[3] && pixels[1] != pixels[4] ? pixels[1] : pixels[2];
+		} else {
+			// Bottom Left
+			return pixels[1] == pixels[4] && pixels[1] != pixels[0] && pixels[4] != pixels[3] ? pixels[1] : pixels[2];
+		}
+	}
+}
+
+vec4 scaleNeighborhood(vec2 p, vec2 x, vec2 o) {
+	vec4 neighborhood[5];
+    neighborhood[0] = texture2D(tex, texCoord + x + vec2( 0.0,  o.y));
+    neighborhood[1] = texture2D(tex, texCoord + x + vec2(-o.x,  0.0));
+    neighborhood[2] = texture2D(tex, texCoord + x + vec2( 0.0,  0.0));
+    neighborhood[3] = texture2D(tex, texCoord + x + vec2( o.x,  0.0));
+    neighborhood[4] = texture2D(tex, texCoord + x + vec2( 0.0, -o.y));
+	return scale2x(neighborhood, p + x * texSize);
+}
+
+void main() {
+    // o = offset, the width of a pixel
+    vec2 o = 1.0 / texSize;
+
+    vec2 p = texCoord * texSize;
+	vec4 pixels[5];
+	pixels[0] = scaleNeighborhood(p, vec2(       0.0,  o.y / 2.0), o);
+	pixels[1] = scaleNeighborhood(p, vec2(-o.x / 2.0,        0.0), o);
+	pixels[2] = scaleNeighborhood(p, vec2(       0.0,        0.0), o);
+	pixels[3] = scaleNeighborhood(p, vec2( o.x / 2.0,        0.0), o);
+	pixels[4] = scaleNeighborhood(p, vec2(       0.0, -o.y / 2.0), o);
+	gl_FragColor = scale2x(pixels, p * 2.0);
+}
+[shader]
+name=Scanlines
+author=Dominus Iniquitatis
+description=Simple scanlines.
+passes=1
+
+[pass.0]
+fragmentShader=scanlines.fs
+blend=1
+width=-2
+height=-2
+
+[pass.0.uniform.lineBrightness]
+type=float
+readableName=Line brightness
+default=0.5
+min=0.0
+max=1.0
+/*
+   Scanlines Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float lineBrightness;
+
+void main() {
+  vec4 color = texture2D(tex, texCoord);
+
+  // Compute the Y coordinate in pixel space
+  float y = texCoord.y * texSize.y;
+
+  // Use floor and mod to get even/odd row
+  if (mod(floor(y), 2.0) < 1.0) {
+    color.rgb *= lineBrightness;
+  }
+
+  gl_FragColor = color;
+}
+[shader]
+name=Soften
+author=Dominus Iniquitatis
+description=Soft image blurring.
+passes=1
+
+[pass.0]
+fragmentShader=soften.fs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.amount]
+type=float
+readableName=Amount
+default=0.5
+min=0.0
+max=1.0
+/*
+   Soften Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float amount;
+
+vec2 GetTexelSize()
+{
+	return vec2(1.0 / texSize.x, 1.0 / texSize.y);
+}
+
+void main()
+{
+	vec4 color = texture2D(tex, texCoord);
+
+	vec4 northColor = texture2D(tex, texCoord + vec2(0.0, GetTexelSize().y));
+	vec4 southColor = texture2D(tex, texCoord - vec2(0.0, GetTexelSize().y));
+	vec4 eastColor = texture2D(tex, texCoord + vec2(GetTexelSize().x, 0.0));
+	vec4 westColor = texture2D(tex, texCoord - vec2(GetTexelSize().x, 0.0));
+
+	if (abs(length(color) - length(northColor)) > 0.0)
+	{
+		color = mix(color, northColor, amount / 4.0);
+	}
+
+	if (abs(length(color) - length(southColor)) > 0.0)
+	{
+		color = mix(color, southColor, amount / 4.0);
+	}
+
+	if (abs(length(color) - length(eastColor)) > 0.0)
+	{
+		color = mix(color, eastColor, amount / 4.0);
+	}
+
+	if (abs(length(color) - length(westColor)) > 0.0)
+	{
+		color = mix(color, westColor, amount / 4.0);
+	}
+
+	gl_FragColor = color;
+}
+[shader]
+name=GBA SP 101 Color
+author=Pokefan531 and hunterk
+description=Shader that replicates the LCD Colorspace from a Gameboy SP 101 (backlit version).
+passes=1
+
+[pass.0]
+fragmentShader=sp101-color.fs
+vertexShader=sp101-color.vs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.color_mode]
+type=int
+default=1
+min=1
+max=3
+readableName=Color Profile (1=sRGB, 2=DCI, 3=Rec2020)
+// Shader that replicates the LCD Colorspace from a Gameboy SP 101 (backlit version) --
+varying vec2 texCoord;
+varying mat4 profile;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+const float target_gamma = 2.2;
+const float display_gamma = 2.2;
+
+void main() {
+	// bring out our stored luminance value
+	float lum = profile[3].w;
+
+	// our adjustments need to happen in linear gamma
+	vec4 screen = pow(texture2D(tex, texCoord), vec4(target_gamma)).rgba;
+
+	screen = clamp(screen * lum, 0.0, 1.0);
+	screen = profile * screen;
+	gl_FragColor = pow(screen, vec4(1.0 / display_gamma));
+}
+uniform int color_mode;
+attribute vec4 position;
+varying vec2 texCoord;
+varying mat4 profile;
+
+const mat4 SP1_sRGB = mat4(
+	0.96, 0.0325, 0.001, 0.0,  //red channel
+	0.11, 0.89, -0.03, 0.0,  //green channel
+	-0.07, 0.0775, 1.029, 0.0,  //blue channel
+	0.0,  0.0,  0.0,  0.935   //alpha channel
+); 
+
+const mat4 SP1_DCI = mat4(
+	0.805, 0.0675, 0.017, 0.0,  //red channel
+	0.24, 0.86, 0.02, 0.0,  //green channel
+	-0.045, 0.0725, 0.963, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   0.955  //alpha channel
+); 
+
+const mat4 SP1_Rec2020 = mat4(
+	0.625, 0.10, 0.015, 0.0,  //red channel
+	0.35, 0.82, 0.0325, 0.0,  //green channel
+	0.025, 0.08, 0.9525, 0.0,  //blue channel
+	0.0,   0.0,   0.0,   1.0  //alpha channel
+); 
+
+void main() {
+	if (color_mode == 1) profile = SP1_sRGB;
+	else if (color_mode == 2) profile = SP1_DCI;
+	else if (color_mode == 3) profile = SP1_Rec2020;
+
+	gl_Position = position;
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+}
+[shader]
+name=TV Mode
+author=Dominus Iniquitatis
+description=Scanlines along with a subtle blurring.
+passes=1
+
+[pass.0]
+fragmentShader=tv.fs
+blend=1
+width=-2
+height=-2
+
+[pass.0.uniform.lineBrightness]
+type=float
+readableName=Line brightness
+default=0.75
+min=0.0
+max=1.0
+
+[pass.0.uniform.blurring]
+type=float
+readableName=Blurring
+default=1.0
+min=0.0
+max=1.0
+/*
+   TV Mode Shader
+
+   Copyright (C) 2022 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float lineBrightness;
+uniform float blurring;
+
+void main()
+{
+    vec4 c = texture2D(tex, texCoord);
+    vec4 n = texture2D(tex, texCoord + vec2(1.0 / texSize.x * 0.5, 0.0));
+
+    vec4 color = mix(c, (c + n) / 2.0, blurring);
+    color.a = c.a;
+
+	if (int(mod(texCoord.t * texSize.y * 2.0, 2.0)) == 0)
+	{
+		color.rgb *= lineBrightness;
+	}
+
+	gl_FragColor = color;
+}
+[shader]
+name=VBA Pixelate
+author=Dominus Iniquitatis
+description=VisualBoyAdvance-style pixelation.
+passes=1
+
+[pass.0]
+fragmentShader=vba_pixelate.fs
+blend=1
+width=-2
+height=-2
+
+[pass.0.uniform.boundBrightness]
+type=float
+readableName=Bound brightness
+default=0.5
+min=0.0
+max=1.0
+/*
+   VBA Pixelate Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float boundBrightness;
+
+void main()
+{
+    vec4 color = texture2D(tex, texCoord);
+
+    float x = floor(texCoord.s * texSize.x);
+    float y = floor(texCoord.t * texSize.y);
+
+    bool onVerticalLine = mod(x, 2.0) == 0.0;
+    bool onHorizontalLine = mod(y, 2.0) == 0.0;
+
+    if (onVerticalLine || onHorizontalLine)
+    {
+        color.rgb *= boundBrightness;
+    }
+
+    gl_FragColor = color;
+}[shader]
+name=Vignette
+author=Dominus Iniquitatis
+description=Configurable vignette effect.
+passes=1
+
+[pass.0]
+fragmentShader=vignette.fs
+blend=1
+width=-1
+height=-1
+
+[pass.0.uniform.intensity]
+type=float
+readableName=Intensity
+default=1.0
+min=0.0
+max=1.0
+/*
+   Vignette Shader
+
+   Copyright (C) 2017 Dominus Iniquitatis - zerosaiko@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.
+*/
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+varying vec2 texCoord;
+
+uniform float intensity;
+
+void main()
+{
+	vec4 color = texture2D(tex, texCoord);
+	color = mix(color, vec4(0.0, 0.0, 0.0, 1.0), length(texCoord - 0.5) * intensity);
+
+	gl_FragColor = color;
+}
+[shader]
+name=Wii U
+author=Prof. 9
+description=Uses the color palette from the Wii U Virtual Console. Enable bilinear filtering to further mimic Wii U output.
+passes=1
+
+[pass.0]
+fragmentShader=wiiu.fs
+blend=1
+width=-4
+height=-4
+varying vec2 texCoord;
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+float wiiuLut31(float x) {
+	int i = int(floor(x * 31.0 + 0.5));
+
+	if (i < 0) i = 0;
+	if (i > 31) i = 31;
+
+	if (i == 0)  return   0.0 / 255.0;
+	if (i == 1)  return   6.0 / 255.0;
+	if (i == 2)  return  12.0 / 255.0;
+	if (i == 3)  return  18.0 / 255.0;
+	if (i == 4)  return  24.0 / 255.0;
+	if (i == 5)  return  31.0 / 255.0;
+	if (i == 6)  return  37.0 / 255.0;
+	if (i == 7)  return  43.0 / 255.0;
+	if (i == 8)  return  49.0 / 255.0;
+	if (i == 9)  return  55.0 / 255.0;
+	if (i == 10) return  61.0 / 255.0;
+	if (i == 11) return  67.0 / 255.0;
+	if (i == 12) return  73.0 / 255.0;
+	if (i == 13) return  79.0 / 255.0;
+	if (i == 14) return  86.0 / 255.0;
+	if (i == 15) return  92.0 / 255.0;
+	if (i == 16) return  98.0 / 255.0;
+	if (i == 17) return 104.0 / 255.0;
+	if (i == 18) return 111.0 / 255.0;
+	if (i == 19) return 117.0 / 255.0;
+	if (i == 20) return 123.0 / 255.0;
+	if (i == 21) return 129.0 / 255.0;
+	if (i == 22) return 135.0 / 255.0;
+	if (i == 23) return 141.0 / 255.0;
+	if (i == 24) return 148.0 / 255.0;
+	if (i == 25) return 154.0 / 255.0;
+	if (i == 26) return 159.0 / 255.0;
+	if (i == 27) return 166.0 / 255.0;
+	if (i == 28) return 172.0 / 255.0;
+	if (i == 29) return 178.0 / 255.0;
+	if (i == 30) return 184.0 / 255.0;
+	// i == 31
+	return 191.0 / 255.0;
+}
+
+void main() {
+	vec4 color = texture2D(tex, texCoord);
+
+	color.r = wiiuLut31(color.r);
+	color.g = wiiuLut31(color.g);
+	color.b = wiiuLut31(color.b);
+
+	gl_FragColor = color;
+}
+[shader]
+name=xBR-lv2
+author=Hyllian
+description=xBR-lv2 upsampling filter
+passes=1
+
+[pass.0]
+integerScaling=1
+vertexShader=xbr.vs
+fragmentShader=xbr.fs
+
+[pass.0.uniform.XBR_Y_WEIGHT]
+type=float
+default=48
+readableName=Y Weight
+min=0
+max=100
+
+[pass.0.uniform.XBR_EQ_THRESHOLD]
+type=float
+readableName=Eq Threshold
+default=25.0
+min=0.0
+max=50.0
+
+[pass.0.uniform.XBR_SCALE]
+type=float
+readableName=xBR Scale
+default=4.0
+min=1.0
+max=5.0
+
+[pass.0.uniform.XBR_LV2_COEFFICIENT]
+type=float
+readableName=Lv2 Coefficient
+default=2.0
+min=1.0
+max=3.0
+/*
+   Hyllian's xBR-lv2 Shader
+   
+   Copyright (C) 2011-2015 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.
+
+
+   Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
+*/
+
+uniform float XBR_Y_WEIGHT;
+uniform float XBR_EQ_THRESHOLD;
+uniform float XBR_SCALE;
+uniform float XBR_LV2_COEFFICIENT;
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+varying vec2 texCoord;
+varying vec4 TEX1;
+varying vec4 TEX2;
+varying vec4 TEX3;
+varying vec4 TEX4;
+varying vec4 TEX5;
+varying vec4 TEX6;
+varying vec4 TEX7;
+
+const vec4 Ao = vec4( 1.0, -1.0, -1.0,  1.0 );
+const vec4 Bo = vec4( 1.0,  1.0, -1.0, -1.0 );
+const vec4 Co = vec4( 1.5,  0.5, -0.5,  0.5 );
+const vec4 Ax = vec4( 1.0, -1.0, -1.0,  1.0 );
+const vec4 Bx = vec4( 0.5,  2.0, -0.5, -2.0 );
+const vec4 Cx = vec4( 1.0,  1.0, -0.5,  0.0 );
+const vec4 Ay = vec4( 1.0, -1.0, -1.0,  1.0 );
+const vec4 By = vec4( 2.0,  0.5, -2.0, -0.5 );
+const vec4 Cy = vec4( 2.0,  0.0, -1.0,  0.5 );
+const vec4 Ci = vec4( 0.25, 0.25, 0.25, 0.25 );
+
+const vec3 Y = vec3(0.2126, 0.7152, 0.0722);
+
+vec4 df4(vec4 A, vec4 B) {
+	return abs(A - B);
+}
+
+float c_df(vec3 c1, vec3 c2) {
+	vec3 d = abs(c1 - c2);
+	return d.r + d.g + d.b;
+}
+
+bvec4 eq4(vec4 A, vec4 B) {
+	return lessThan(df4(A, B), vec4(XBR_EQ_THRESHOLD));
+}
+
+bvec4 and4(bvec4 A, bvec4 B) {
+	return bvec4(A.x && B.x, A.y && B.y, A.z && B.z, A.w && B.w);
+}
+
+bvec4 nand4(bvec4 A, bvec4 B) {
+	return bvec4(!(A.x && B.x), !(A.y && B.y), !(A.z && B.z), !(A.w && B.w));
+}
+
+vec4 weighted_distance(vec4 a, vec4 b, vec4 c, vec4 d, vec4 e, vec4 f, vec4 g, vec4 h) {
+	return (df4(a,b) + df4(a,c) + df4(d,e) + df4(d,f) + 4.0 * df4(g,h));
+}
+
+float lum(vec3 rgb) {
+	return dot(rgb, Y) * XBR_Y_WEIGHT;
+}
+
+void main() {
+	// fractional position inside the source pixel (in source-pixel space)
+	vec2 fp = fract(texCoord * texSize);
+
+	// Sample neighborhood
+	vec3 A1 = texture2D(tex, TEX1.xw).rgb;
+	vec3 B1 = texture2D(tex, TEX1.yw).rgb;
+	vec3 C1 = texture2D(tex, TEX1.zw).rgb;
+
+	vec3 A  = texture2D(tex, TEX2.xw).rgb;
+	vec3 B  = texture2D(tex, TEX2.yw).rgb;
+	vec3 C  = texture2D(tex, TEX2.zw).rgb;
+
+	vec3 D  = texture2D(tex, TEX3.xw).rgb;
+	vec3 E  = texture2D(tex, TEX3.yw).rgb;
+	vec3 F  = texture2D(tex, TEX3.zw).rgb;
+
+	vec3 G  = texture2D(tex, TEX4.xw).rgb;
+	vec3 H  = texture2D(tex, TEX4.yw).rgb;
+	vec3 I  = texture2D(tex, TEX4.zw).rgb;
+
+	vec3 G5 = texture2D(tex, TEX5.xw).rgb;
+	vec3 H5 = texture2D(tex, TEX5.yw).rgb;
+	vec3 I5 = texture2D(tex, TEX5.zw).rgb;
+
+	vec3 A0 = texture2D(tex, TEX6.xy).rgb;
+	vec3 D0 = texture2D(tex, TEX6.xz).rgb;
+	vec3 G0 = texture2D(tex, TEX6.xw).rgb;
+
+	vec3 C4 = texture2D(tex, TEX7.xy).rgb;
+	vec3 F4 = texture2D(tex, TEX7.xz).rgb;
+	vec3 I4 = texture2D(tex, TEX7.xw).rgb;
+
+	// Replace mat4x3/transpose with explicit luma packing (GLSL ES 1.00 safe)
+	vec4 b = vec4(lum(B),  lum(D),  lum(H),  lum(F));
+	vec4 c = vec4(lum(C),  lum(A),  lum(G),  lum(I));
+	vec4 e = vec4(lum(E),  lum(E),  lum(E),  lum(E));
+	vec4 d = b.yzwx;
+	vec4 f = b.wxyz;
+	vec4 g = c.zwxy;
+	vec4 h = b.zwxy;
+	vec4 i = c.wxyz;
+
+	vec4 i4v = vec4(lum(I4), lum(C1), lum(A0), lum(G5));
+	vec4 i5v = vec4(lum(I5), lum(C4), lum(A1), lum(G0));
+	vec4 h5v = vec4(lum(H5), lum(F4), lum(B1), lum(D0));
+	vec4 f4v = h5v.yzwx;
+
+	// Edge detection math
+	vec4 fx      = (Ao * fp.y + Bo * fp.x);
+	vec4 fx_left = (Ax * fp.y + Bx * fp.x);
+	vec4 fx_up   = (Ay * fp.y + By * fp.x);
+
+	bvec4 interp_restriction_lv0 = and4(notEqual(e, f), notEqual(e, h));
+	bvec4 interp_restriction_lv1 = interp_restriction_lv0;
+
+	bvec4 interp_restriction_lv2_left = and4(notEqual(e, g), notEqual(d, g));
+	bvec4 interp_restriction_lv2_up   = and4(notEqual(e, c), notEqual(b, c));
+
+	vec4 delta  = vec4(1.0 / XBR_SCALE);
+	vec4 deltaL = vec4(0.5 / XBR_SCALE, 1.0 / XBR_SCALE, 0.5 / XBR_SCALE, 1.0 / XBR_SCALE);
+	vec4 deltaU = deltaL.yxwz;
+
+	vec4 fx45i = clamp((fx      + delta  - Co - Ci) / (2.0 * delta ), 0.0, 1.0);
+	vec4 fx45  = clamp((fx      + delta  - Co     ) / (2.0 * delta ), 0.0, 1.0);
+	vec4 fx30  = clamp((fx_left + deltaL - Co     ) / (2.0 * deltaL), 0.0, 1.0);
+	vec4 fx60  = clamp((fx_up   + deltaU - Co     ) / (2.0 * deltaU), 0.0, 1.0);
+
+	vec4 wd1 = weighted_distance(e, c, g, i, h5v, f4v, h, f);
+	vec4 wd2 = weighted_distance(h, d, i5v, f, i4v, b, e, i);
+
+	bvec4 edri = and4(lessThanEqual(wd1, wd2), interp_restriction_lv0);
+	bvec4 edr  = and4(lessThan(wd1, wd2),      interp_restriction_lv1);
+
+	bvec4 edr_left = and4(
+		lessThanEqual((XBR_LV2_COEFFICIENT * df4(f, g)), df4(h, c)),
+		interp_restriction_lv2_left
+	);
+	bvec4 edr_up = and4(
+		greaterThanEqual(df4(f, g), (XBR_LV2_COEFFICIENT * df4(h, c))),
+		interp_restriction_lv2_up
+	);
+
+	edr      = and4(edr, nand4(edri.yzwx, edri.wxyz));
+	edr_left = and4(and4(edr_left, edr), eq4(e, c));
+	edr_up   = and4(and4(edr_up,   edr), eq4(e, g));
+
+	fx45  *= vec4(edr);
+	fx30  *= vec4(edr_left);
+	fx60  *= vec4(edr_up);
+	fx45i *= vec4(edri);
+
+	vec4 px = vec4(lessThanEqual(df4(e, f), df4(e, h)));
+
+	vec4 maximos = max(max(fx30, fx60), max(fx45, fx45i));
+
+	vec3 res1 = E;
+	res1 = mix(res1, mix(H, F, px.x), maximos.x);
+	res1 = mix(res1, mix(B, D, px.z), maximos.z);
+
+	vec3 res2 = E;
+	res2 = mix(res1, mix(F, B, px.y), maximos.y);
+	res2 = mix(res1, mix(D, H, px.w), maximos.w);
+
+	vec3 res = mix(res1, res2, step(c_df(E, res1), c_df(E, res2)));
+
+	gl_FragColor = vec4(res, 1.0);
+}/*
+   Hyllian's xBR-lv3 Shader
+   
+   Copyright (C) 2011-2015 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.
+
+   Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
+*/
+
+attribute vec4 position;
+
+uniform vec2 texSize;
+
+varying vec2 texCoord;
+varying vec4 TEX1;
+varying vec4 TEX2;
+varying vec4 TEX3;
+varying vec4 TEX4;
+varying vec4 TEX5;
+varying vec4 TEX6;
+varying vec4 TEX7;
+
+void main() {
+	gl_Position = position;
+
+	vec2 ps = vec2(1.0) / texSize;
+	float dx = ps.x;
+	float dy = ps.y;
+
+	// A1 B1 C1
+	// A0  A  B  C C4
+	// D0  D  E  F F4
+	// G0  G  H  I I4
+	//    G5 H5 I5
+
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+
+	// IMPORTANT: use 0.0 (float literal) for strict GLSL ES 1.00 compilers
+	TEX1 = texCoord.xxxy + vec4(-dx, 0.0,  dx, -2.0 * dy); // A1 B1 C1
+	TEX2 = texCoord.xxxy + vec4(-dx, 0.0,  dx, -1.0 * dy); //  A  B  C
+	TEX3 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  0.0      ); //  D  E  F
+	TEX4 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  1.0 * dy); //  G  H  I
+	TEX5 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  2.0 * dy); // G5 H5 I5
+	TEX6 = texCoord.xyyy + vec4(-2.0 * dx, -dy, 0.0,  dy); // A0 D0 G0
+	TEX7 = texCoord.xyyy + vec4( 2.0 * dx, -dy, 0.0,  dy); // C4 F4 I4
+}[shader]
+name=xBR-lv3
+author=Hyllian
+description=xBR-lv3 upsampling filter
+passes=1
+
+[pass.0]
+integerScaling=1
+vertexShader=xbr.vs
+fragmentShader=xbr.fs
+
+[pass.0.uniform.XBR_Y_WEIGHT]
+type=float
+default=48
+readableName=Y Weight
+min=0
+max=100
+
+[pass.0.uniform.XBR_EQ_THRESHOLD]
+type=float
+readableName=Eq Threshold
+default=10.0
+min=0.0
+max=50.0
+
+[pass.0.uniform.XBR_EQ_THRESHOLD2]
+type=float
+readableName=Eq Threshold2
+default=2.0
+min=0.0
+max=4.0
+
+[pass.0.uniform.XBR_LV2_COEFFICIENT]
+type=float
+readableName=Lv2 Coefficient
+default=2.0
+min=1.0
+max=3.0
+/*
+   Hyllian's xBR-lv3 Shader
+   
+   Copyright (C) 2011-2015 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.
+
+
+   Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
+*/
+
+uniform float XBR_Y_WEIGHT;
+uniform float XBR_EQ_THRESHOLD;
+uniform float XBR_EQ_THRESHOLD2;
+uniform float XBR_LV2_COEFFICIENT;
+
+uniform sampler2D tex;
+uniform vec2 texSize;
+
+varying vec2 texCoord;
+varying vec4 TEX1;
+varying vec4 TEX2;
+varying vec4 TEX3;
+varying vec4 TEX4;
+varying vec4 TEX5;
+varying vec4 TEX6;
+varying vec4 TEX7;
+
+const mat3 yuv = mat3(
+	0.299,  0.587,  0.114,
+   -0.169, -0.331,  0.499,
+	0.499, -0.418, -0.0813
+);
+
+// keep same delta
+const vec4 delta = vec4(0.4, 0.4, 0.4, 0.4);
+
+vec4 df4(vec4 A, vec4 B) {
+	return abs(A - B);
+}
+
+float c_df(vec3 c1, vec3 c2) {
+	vec3 d = abs(c1 - c2);
+	return d.r + d.g + d.b;
+}
+
+bvec4 eq4(vec4 A, vec4 B) {
+	return lessThan(df4(A, B), vec4(XBR_EQ_THRESHOLD));
+}
+
+bvec4 eq24(vec4 A, vec4 B) {
+	return lessThan(df4(A, B), vec4(XBR_EQ_THRESHOLD2));
+}
+
+bvec4 and4(bvec4 A, bvec4 B) {
+	return bvec4(A.x && B.x, A.y && B.y, A.z && B.z, A.w && B.w);
+}
+
+bvec4 or4(bvec4 A, bvec4 B) {
+	return bvec4(A.x || B.x, A.y || B.y, A.z || B.z, A.w || B.w);
+}
+
+vec4 weighted_distance(vec4 a, vec4 b, vec4 c, vec4 d, vec4 e, vec4 f, vec4 g, vec4 h) {
+	return (df4(a,b) + df4(a,c) + df4(d,e) + df4(d,f) + 4.0 * df4(g,h));
+}
+
+void main() {
+	bvec4 edr, edr_left, edr_up, edr3_left, edr3_up, px;
+	bvec4 interp_restriction_lv1, interp_restriction_lv2_left, interp_restriction_lv2_up;
+	bvec4 interp_restriction_lv3_left, interp_restriction_lv3_up;
+	bvec4 nc, nc30, nc60, nc45, nc15, nc75;
+	vec4 fx, fx_left, fx_up, fx3_left, fx3_up;
+	vec3 res1, res2, pix1, pix2;
+	float blend1, blend2;
+
+	// IMPORTANT: initialize to avoid undefined reads on some compilers
+	pix1 = vec3(0.0);
+	pix2 = vec3(0.0);
+	blend1 = 0.0;
+	blend2 = 0.0;
+
+	vec2 fp = fract(texCoord * texSize);
+
+	vec3 A1 = texture2D(tex, TEX1.xw).rgb;
+	vec3 B1 = texture2D(tex, TEX1.yw).rgb;
+	vec3 C1 = texture2D(tex, TEX1.zw).rgb;
+
+	vec3 A  = texture2D(tex, TEX2.xw).rgb;
+	vec3 B  = texture2D(tex, TEX2.yw).rgb;
+	vec3 C  = texture2D(tex, TEX2.zw).rgb;
+
+	vec3 D  = texture2D(tex, TEX3.xw).rgb;
+	vec3 E  = texture2D(tex, TEX3.yw).rgb;
+	vec3 F  = texture2D(tex, TEX3.zw).rgb;
+
+	vec3 G  = texture2D(tex, TEX4.xw).rgb;
+	vec3 H  = texture2D(tex, TEX4.yw).rgb;
+	vec3 I  = texture2D(tex, TEX4.zw).rgb;
+
+	vec3 G5 = texture2D(tex, TEX5.xw).rgb;
+	vec3 H5 = texture2D(tex, TEX5.yw).rgb;
+	vec3 I5 = texture2D(tex, TEX5.zw).rgb;
+
+	vec3 A0 = texture2D(tex, TEX6.xy).rgb;
+	vec3 D0 = texture2D(tex, TEX6.xz).rgb;
+	vec3 G0 = texture2D(tex, TEX6.xw).rgb;
+
+	vec3 C4 = texture2D(tex, TEX7.xy).rgb;
+	vec3 F4 = texture2D(tex, TEX7.xz).rgb;
+	vec3 I4 = texture2D(tex, TEX7.xw).rgb;
+
+	// Replace mat4x3 + transpose with explicit dot products (GLSL ES 1.00 safe)
+	// Original: transpose(mat4x3(...)) * (XBR_Y_WEIGHT * yuv[0])
+	vec3 Yw = (XBR_Y_WEIGHT * yuv[0]);
+
+	vec4 b = vec4(dot(B,  Yw), dot(D,  Yw), dot(H,  Yw), dot(F,  Yw));
+	vec4 c = vec4(dot(C,  Yw), dot(A,  Yw), dot(G,  Yw), dot(I,  Yw));
+	vec4 e = vec4(dot(E,  Yw), dot(E,  Yw), dot(E,  Yw), dot(E,  Yw));
+	vec4 d = b.yzwx;
+	vec4 f = b.wxyz;
+	vec4 g = c.zwxy;
+	vec4 h = b.zwxy;
+	vec4 i = c.wxyz;
+
+	vec4 i4v = vec4(dot(I4, Yw), dot(C1, Yw), dot(A0, Yw), dot(G5, Yw));
+	vec4 i5v = vec4(dot(I5, Yw), dot(C4, Yw), dot(A1, Yw), dot(G0, Yw));
+	vec4 h5v = vec4(dot(H5, Yw), dot(F4, Yw), dot(B1, Yw), dot(D0, Yw));
+	vec4 f4v = h5v.yzwx;
+
+	vec4 c1 = i4v.yzwx;
+	vec4 g0 = i5v.wxyz;
+	vec4 b1 = h5v.zwxy;
+	vec4 d0 = h5v.wxyz;
+
+	// same constants as original
+	vec4 Ao = vec4( 1.0, -1.0, -1.0,  1.0 );
+	vec4 Bo = vec4( 1.0,  1.0, -1.0, -1.0 );
+	vec4 Co = vec4( 1.5,  0.5, -0.5,  0.5 );
+	vec4 Ax = vec4( 1.0, -1.0, -1.0,  1.0 );
+	vec4 Bx = vec4( 0.5,  2.0, -0.5, -2.0 );
+	vec4 Cx = vec4( 1.0,  1.0, -0.5,  0.0 );
+	vec4 Ay = vec4( 1.0, -1.0, -1.0,  1.0 );
+	vec4 By = vec4( 2.0,  0.5, -2.0, -0.5 );
+	vec4 Cy = vec4( 2.0,  0.0, -1.0,  0.5 );
+
+	vec4 Az = vec4( 6.0, -2.0, -6.0,  2.0 );
+	vec4 Bz = vec4( 2.0,  6.0, -2.0, -6.0 );
+	vec4 Cz = vec4( 5.0,  3.0, -3.0, -1.0 );
+	vec4 Aw = vec4( 2.0, -6.0, -2.0,  6.0 );
+	vec4 Bw = vec4( 6.0,  2.0, -6.0, -2.0 );
+	vec4 Cw = vec4( 5.0, -1.0, -3.0,  3.0 );
+
+	fx       = (Ao * fp.y + Bo * fp.x);
+	fx_left  = (Ax * fp.y + Bx * fp.x);
+	fx_up    = (Ay * fp.y + By * fp.x);
+	fx3_left = (Az * fp.y + Bz * fp.x);
+	fx3_up   = (Aw * fp.y + Bw * fp.x);
+
+	// Keep CORNER_* behavior EXACTLY. Default path is CORNER_C branch (the else).
+#ifdef CORNER_A
+	interp_restriction_lv1 = and4(notEqual(e, f), notEqual(e, h));
+#elif defined(CORNER_B)
+	interp_restriction_lv1 = ((e!=f) && (e!=h)  &&  ( !eq4(f,b) && !eq4(h,d) || eq4(e,i) && !eq4(f,i4v) && !eq4(h,i5v) || eq4(e,g) || eq4(e,c) ) );
+#elif defined(CORNER_D)
+	interp_restriction_lv1 = ((e!=f) && (e!=h)  &&  ( !eq4(f,b) && !eq4(h,d) || eq4(e,i) && !eq4(f,i4v) && !eq4(h,i5v) || eq4(e,g) || eq4(e,c) ) && (f!=f4v && f!=i || h!=h5v && h!=i || h!=g || f!=c || eq4(b,c1) && eq4(d,g0)));
+#else
+	interp_restriction_lv1 = and4(
+		and4(notEqual(e, f), notEqual(e, h)),
+		or4(
+			or4(
+				and4(not(eq4(f,b)), not(eq4(f,c))),
+				and4(not(eq4(h,d)), not(eq4(h,g)))
+			),
+			or4(
+				and4(
+					eq4(e,i),
+					or4(
+						and4(not(eq4(f,f4v)), not(eq4(f,i4v))),
+						and4(not(eq4(h,h5v)), not(eq4(h,i5v)))
+					)
+				),
+				or4(eq4(e,g), eq4(e,c))
+			)
+		)
+	);
+#endif
+
+	interp_restriction_lv2_left = and4(notEqual(e, g), notEqual(d, g));
+	interp_restriction_lv2_up   = and4(notEqual(e, c), notEqual(b, c));
+	interp_restriction_lv3_left = and4(eq24(g, g0), not(eq24(d0, g0)));
+	interp_restriction_lv3_up   = and4(eq24(c, c1), not(eq24(b1, c1)));
+
+	vec4 fx45 = smoothstep(Co - delta, Co + delta, fx);
+	vec4 fx30 = smoothstep(Cx - delta, Cx + delta, fx_left);
+	vec4 fx60 = smoothstep(Cy - delta, Cy + delta, fx_up);
+	vec4 fx15 = smoothstep(Cz - delta, Cz + delta, fx3_left);
+	vec4 fx75 = smoothstep(Cw - delta, Cw + delta, fx3_up);
+
+	edr = and4(
+		lessThan(
+			weighted_distance(e, c, g, i, h5v, f4v, h, f),
+			weighted_distance(h, d, i5v, f, i4v, b, e, i)
+		),
+		interp_restriction_lv1
+	);
+
+	edr_left = and4(lessThanEqual((XBR_LV2_COEFFICIENT * df4(f,g)), df4(h,c)), interp_restriction_lv2_left);
+	edr_up   = and4(greaterThanEqual(df4(f,g), (XBR_LV2_COEFFICIENT * df4(h,c))), interp_restriction_lv2_up);
+	edr3_left = interp_restriction_lv3_left;
+	edr3_up   = interp_restriction_lv3_up;
+
+	nc45 = and4(edr, bvec4(fx45));
+	nc30 = and4(edr, and4(edr_left, bvec4(fx30)));
+	nc60 = and4(edr, and4(edr_up,   bvec4(fx60)));
+	nc15 = and4(and4(edr, edr_left), and4(edr3_left, bvec4(fx15)));
+	nc75 = and4(and4(edr, edr_up),   and4(edr3_up,   bvec4(fx75)));
+
+	px = lessThanEqual(df4(e, f), df4(e, h));
+
+	nc = bvec4(
+		(nc75.x || nc15.x || nc30.x || nc60.x || nc45.x),
+		(nc75.y || nc15.y || nc30.y || nc60.y || nc45.y),
+		(nc75.z || nc15.z || nc30.z || nc60.z || nc45.z),
+		(nc75.w || nc15.w || nc30.w || nc60.w || nc45.w)
+	);
+
+	vec4 final45 = vec4(nc45) * fx45;
+	vec4 final30 = vec4(nc30) * fx30;
+	vec4 final60 = vec4(nc60) * fx60;
+	vec4 final15 = vec4(nc15) * fx15;
+	vec4 final75 = vec4(nc75) * fx75;
+
+	vec4 maximo = max(max(max(final15, final75), max(final30, final60)), final45);
+
+	if (nc.x) { pix1 = px.x ? F : H; blend1 = maximo.x; }
+	else if (nc.y) { pix1 = px.y ? B : F; blend1 = maximo.y; }
+	else if (nc.z) { pix1 = px.z ? D : B; blend1 = maximo.z; }
+	else if (nc.w) { pix1 = px.w ? H : D; blend1 = maximo.w; }
+
+	if (nc.w) { pix2 = px.w ? H : D; blend2 = maximo.w; }
+	else if (nc.z) { pix2 = px.z ? D : B; blend2 = maximo.z; }
+	else if (nc.y) { pix2 = px.y ? B : F; blend2 = maximo.y; }
+	else if (nc.x) { pix2 = px.x ? F : H; blend2 = maximo.x; }
+
+	res1 = mix(E, pix1, blend1);
+	res2 = mix(E, pix2, blend2);
+
+	vec3 res = mix(res1, res2, step(c_df(E, res1), c_df(E, res2)));
+
+	gl_FragColor = vec4(res, 1.0);
+}/*
+   Hyllian's xBR-lv3 Shader
+   
+   Copyright (C) 2011-2015 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.
+
+   Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
+*/
+
+attribute vec4 position;
+
+uniform vec2 texSize;
+
+varying vec2 texCoord;
+varying vec4 TEX1;
+varying vec4 TEX2;
+varying vec4 TEX3;
+varying vec4 TEX4;
+varying vec4 TEX5;
+varying vec4 TEX6;
+varying vec4 TEX7;
+
+void main() {
+	gl_Position = position;
+
+	vec2 ps = vec2(1.0) / texSize;
+	float dx = ps.x;
+	float dy = ps.y;
+
+	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);
+
+	// use 0.0 (float literals) for strict GLSL ES 1.00 compilers
+	TEX1 = texCoord.xxxy + vec4(-dx, 0.0,  dx, -2.0 * dy); // A1 B1 C1
+	TEX2 = texCoord.xxxy + vec4(-dx, 0.0,  dx, -1.0 * dy); //  A  B  C
+	TEX3 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  0.0      ); //  D  E  F
+	TEX4 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  1.0 * dy); //  G  H  I
+	TEX5 = texCoord.xxxy + vec4(-dx, 0.0,  dx,  2.0 * dy); // G5 H5 I5
+	TEX6 = texCoord.xyyy + vec4(-2.0 * dx, -dy, 0.0,  dy); // A0 D0 G0
+	TEX7 = texCoord.xyyy + vec4( 2.0 * dx, -dy, 0.0,  dy); // C4 F4 I4
+}