Mario Kart 8 (improved) and Splatoon General Blur Fix

- Mario Kart 8 now has the general blur fix, added to Quality&Enthusiast. Showcase
 + Fixed previous low radius
 + Added support for all resolutions by using general blur fix
 + Details: Used Horizontal&Vertical blur, 2 shaders added

- Splatoon now has the general blur fix, added to Quality&Enthusiast. Showcase
 + Details: Used Horizontal&Vertical blur, 2 shaders added

Enthusiast/MK8_2880p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/MK8_2880p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/MK8_4320p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/MK8_4320p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/MK8_5760p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/MK8_5760p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1080p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1080p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1080pUW/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1080pUW/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1440p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1440p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1800p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_1800p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_2160p/4727ccdea05045d0_0000000000000079_ps.txt

@@ -1,66 +1,28 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 4727ccdea05045d0 //horizontal blur
-layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5357000 res 64x64x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-	if (v == 0x7FFFFFFF)
-		return floatBitsToInt(1.0);
-	else if (v == 0xFFFFFFFF)
-		return floatBitsToInt(0.0);
-	return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b) { if (a == 0.0 || b == 0.0) return 0.0; return a*b; }
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
 void main()
 {
-	vec4 R0f = vec4(0.0);
-	vec4 R1f = vec4(0.0);
-	vec4 R2f = vec4(0.0);
-	vec4 R123f = vec4(0.0);
-	float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-	vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-	float PS0f = 0.0, PS1f = 0.0;
-	vec4 tempf = vec4(0.0);
-	float tempResultf;
-	int tempResulti;
-	ivec4 ARi = ivec4(0);
-	bool predResult = true;
-	vec3 cubeMapSTM;
-	int cubeMapFaceId;
-	R0f = passParameterSem0;
-
-	R0f.z = (R0f.z - 0.0010416666666667 * 2.5);
-	R0f.y = (R0f.y + 0.0010416666666667 * 2.5);
-
-	R1f.xyzw = (texture(textureUnitPS0, R0f.wx).xyzw);
-	R2f.xyzw = (texture(textureUnitPS0, R0f.yx).xyzw);
-	R0f.xyzw = (texture(textureUnitPS0, R0f.zx).xyzw);
-	// 0
-	PV0f.x = R1f.w * intBitsToFloat(0x3e969697);
-	PV0f.y = R1f.z * intBitsToFloat(0x3e969697);
-	PV0f.z = R1f.y * intBitsToFloat(0x3e969697);
-	PV0f.w = R1f.x * intBitsToFloat(0x3e969697);
-	// 1
-	R123f.x = (R2f.w * intBitsToFloat(0x3eb4b4b5) + PV0f.x);
-	PV1f.x = R123f.x;
-	R123f.y = (R2f.z * intBitsToFloat(0x3eb4b4b5) + PV0f.y);
-	PV1f.y = R123f.y;
-	R123f.z = (R2f.y * intBitsToFloat(0x3eb4b4b5) + PV0f.z);
-	PV1f.z = R123f.z;
-	R123f.w = (R2f.x * intBitsToFloat(0x3eb4b4b5) + PV0f.w);
-	PV1f.w = R123f.w;
-	// 2
-	backupReg0f = R0f.x;
-	backupReg1f = R0f.y;
-	backupReg2f = R0f.z;
-	backupReg3f = R0f.w;
-	R0f.x = (backupReg0f * intBitsToFloat(0x3eb4b4b5) + PV1f.w);
-	R0f.y = (backupReg1f * intBitsToFloat(0x3eb4b4b5) + PV1f.z);
-	R0f.z = (backupReg2f * intBitsToFloat(0x3eb4b4b5) + PV1f.y);
-	R0f.w = (backupReg3f * intBitsToFloat(0x3eb4b4b5) + PV1f.x);
-	// export
-	passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
-}
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -1,66 +1,29 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 6dc0532bfaf19019 //vertical blur
-layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5352800 res 64x64x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
 layout(location = 0) in vec4 passParameterSem0;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
-int clampFI32(int v)
-{
-if( v == 0x7FFFFFFF )
-	return floatBitsToInt(1.0);
-else if( v == 0xFFFFFFFF )
-	return floatBitsToInt(0.0);
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
 void main()
 {
-vec4 R0f = vec4(0.0);
-vec4 R1f = vec4(0.0);
-vec4 R2f = vec4(0.0);
-vec4 R123f = vec4(0.0);
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
-float PS0f = 0.0, PS1f = 0.0;
-vec4 tempf = vec4(0.0);
-float tempResultf;
-int tempResulti;
-ivec4 ARi = ivec4(0);
-bool predResult = true;
-vec3 cubeMapSTM;
-int cubeMapFaceId;
-R0f = passParameterSem0;
-
-R0f.z = (R0f.z - 0.0018518518518519 * 2.5);
-R0f.y = (R0f.y + 0.0018518518518519 * 2.5);
-
-R1f.xyzw = (texture(textureUnitPS0, R0f.xw).xyzw);
-R2f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
-R0f.xyzw = (texture(textureUnitPS0, R0f.xz).xyzw);
-// 0
-PV0f.x = R1f.w * intBitsToFloat(0x3e969697);
-PV0f.y = R1f.z * intBitsToFloat(0x3e969697);
-PV0f.z = R1f.y * intBitsToFloat(0x3e969697);
-PV0f.w = R1f.x * intBitsToFloat(0x3e969697);
-// 1
-R123f.x = (R2f.w * intBitsToFloat(0x3eb4b4b5) + PV0f.x);
-PV1f.x = R123f.x;
-R123f.y = (R2f.z * intBitsToFloat(0x3eb4b4b5) + PV0f.y);
-PV1f.y = R123f.y;
-R123f.z = (R2f.y * intBitsToFloat(0x3eb4b4b5) + PV0f.z);
-PV1f.z = R123f.z;
-R123f.w = (R2f.x * intBitsToFloat(0x3eb4b4b5) + PV0f.w);
-PV1f.w = R123f.w;
-// 2
-backupReg0f = R0f.x;
-backupReg1f = R0f.y;
-backupReg2f = R0f.z;
-backupReg3f = R0f.w;
-R0f.x = (backupReg0f * intBitsToFloat(0x3eb4b4b5) + PV1f.w);
-R0f.y = (backupReg1f * intBitsToFloat(0x3eb4b4b5) + PV1f.z);
-R0f.z = (backupReg2f * intBitsToFloat(0x3eb4b4b5) + PV1f.y);
-R0f.w = (backupReg3f * intBitsToFloat(0x3eb4b4b5) + PV1f.x);
-// export
-passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
-}
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_2160pUW/4727ccdea05045d0_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4727ccdea05045d0
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/MK8_2160pUW/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 6dc0532bfaf19019
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt

@@ -0,0 +1,29 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 45d85f1d25e7d0de
+// Used for: Vertical Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}

Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt

@@ -0,0 +1,28 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 4dc5fdeced670c5e
+// Used for: Horizontal Blur
+const float blurFactor = 1.0; //Higher is less blur
+
+// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
+layout(binding = 0) uniform sampler2D textureUnitPS0;
+layout(location = 0) in vec4 passParameterSem0;
+layout(location = 0) out vec4 passPixelColor0;
+uniform vec2 uf_fragCoordScale;
+
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
+
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
+vec2 scale = outputRes * blurFactor;
+void main()
+{
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
+    for (int i = 1; i<4; i++) {
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
+    }
+    passPixelColor0 = R1f;
+}