Merge pull request #90 from Crementif/master

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_2880p/rules.txt

@@ -6,45 +6,34 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 5120
-overwriteHeight = 2880
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 5120
 overwriteHeight = 2880
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 2560
-overwriteHeight = 1440
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 2560
 overwriteHeight = 1440
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
 overwriteWidth = 1280
 overwriteHeight = 720
 
-[TextureRedefine] # quarter-res alpha (increased depth)
+[TextureRedefine] # half-res alpha (gamepad)
-width = 320
+width = 427
-height = 180
+height = 240
-formats = 0x816
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteFormat = 0x823
+overwriteWidth = 1280
+overwriteHeight = 720
+
+[TextureRedefine] # half-res alpha (multiplayer)
+width = 424
+height = 240
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
 overwriteWidth = 1280
 overwriteHeight = 720
 
@@ -65,17 +54,3 @@ width = 848
 height = 480
 overwriteWidth = 2560
 overwriteHeight = 1440
-
-[TextureRedefine] # half-res alpha (gamepad)
-width = 427
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720
-
-[TextureRedefine] # half-res alpha (multiplayer)
-width = 424
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720

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_4320p/rules.txt

@@ -6,47 +6,36 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 7680
-overwriteHeight = 4320
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 7680
 overwriteHeight = 4320
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 3840
-overwriteHeight = 2160
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 3840
 overwriteHeight = 2160
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
 overwriteWidth = 1920
 overwriteHeight = 1080
 
-[TextureRedefine] # quarter-res alpha (increased depth)
+[TextureRedefine] # half-res alpha (gamepad)
-width = 320
+width = 427
-height = 180
+height = 240
-formats = 0x816
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteFormat = 0x823
+overwriteWidth = 1280
-overwriteWidth = 1920
+overwriteHeight = 720
-overwriteHeight = 1080
+
+[TextureRedefine] # half-res alpha (multiplayer)
+width = 424
+height = 240
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
+overwriteWidth = 1280
+overwriteHeight = 720
 
 [TextureRedefine] # squid sisters
 width = 1024
@@ -65,17 +54,3 @@ width = 848
 height = 480
 overwriteWidth = 2560
 overwriteHeight = 1440
-
-[TextureRedefine] # half-res alpha (gamepad)
-width = 427
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720
-
-[TextureRedefine] # half-res alpha (multiplayer)
-width = 424
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720

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;
+}

Enthusiast/Splatoon_5760p/rules.txt

@@ -6,47 +6,36 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 10240
-overwriteHeight = 5760
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 10240
 overwriteHeight = 5760
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 5120
-overwriteHeight = 2880
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 5120
 overwriteHeight = 2880
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
 overwriteWidth = 2560
 overwriteHeight = 1440
 
-[TextureRedefine] # quarter-res alpha (increased depth)
+[TextureRedefine] # half-res alpha (gamepad)
-width = 320
+width = 427
-height = 180
+height = 240
-formats = 0x816
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteFormat = 0x823
+overwriteWidth = 1280
-overwriteWidth = 2560
+overwriteHeight = 720
-overwriteHeight = 1440
+
+[TextureRedefine] # half-res alpha (multiplayer)
+width = 424
+height = 240
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
+overwriteWidth = 1280
+overwriteHeight = 720
 
 [TextureRedefine] # squid sisters
 width = 1024
@@ -65,17 +54,3 @@ width = 848
 height = 480
 overwriteWidth = 2560
 overwriteHeight = 1440
-
-[TextureRedefine] # half-res alpha (gamepad)
-width = 427
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720
-
-[TextureRedefine] # half-res alpha (multiplayer)
-width = 424
-height = 240
-formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720

Enthusiast/SuperMario3DWorld_2880p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_2880p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_4320p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_4320p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_5760p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_5760p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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_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
+// shader 4727ccdea05045d0
-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
+// 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)
+
-{
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-	if (v == 0x7FFFFFFF)
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
-		return floatBitsToInt(1.0);
+
-	else if (v == 0xFFFFFFFF)
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
-		return floatBitsToInt(0.0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-	return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+vec2 scale = outputRes * blurFactor;
-}
-float mul_nonIEEE(float a, float b) { if (a == 0.0 || b == 0.0) return 0.0; return a*b; }
 void main()
 {
-	vec4 R0f = vec4(0.0);
+    vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
-	vec4 R1f = vec4(0.0);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-	vec4 R2f = vec4(0.0);
+    for (int i = 1; i<4; i++) {
-	vec4 R123f = vec4(0.0);
+        R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i];
-	float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+        R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i];
-	vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+    }
-	float PS0f = 0.0, PS1f = 0.0;
+    passPixelColor0 = R1f;
-	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);
 }

Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt

@@ -1,66 +1,29 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 6dc0532bfaf19019 //vertical blur
+// shader 6dc0532bfaf19019
-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
+// 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)
+
-{
+uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519);
-if( v == 0x7FFFFFFF )
+uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632);
-	return floatBitsToInt(1.0);
+
-else if( v == 0xFFFFFFFF )
+ivec2 inputRes = textureSize(textureUnitPS0, 0);
-	return floatBitsToInt(0.0);
+vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y));
-return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));
+vec2 scale = outputRes * blurFactor;
-}
-float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }
 void main()
 {
-vec4 R0f = vec4(0.0);
+    vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
-vec4 R1f = vec4(0.0);
+    vec4 R1f = texture(textureUnitPS0, R0f) * weight[0];
-vec4 R2f = vec4(0.0);
+    for (int i = 1; i<4; i++) {
-vec4 R123f = vec4(0.0);
+        R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i];
-float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;
+        R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i];
-vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);
+    }
-float PS0f = 0.0, PS1f = 0.0;
+    passPixelColor0 = R1f;
-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);
 }

Quality/MK8_2160p/rules.txt

@@ -3,21 +3,11 @@ titleIds = 000500001010ec00,000500001010ed00,000500001010eb00,ffffffff85887bc1
 name = "Mario Kart 8 - 3840x2160"
 version = 2
 
-# Main Screen Resolution better color depth
-[TextureRedefine] 
-width = 1280
-height = 720
-formats = 0x19,0x1a
-overwriteFormat = 0x1f
-tileModesExcluded = 0x001
-overwriteWidth = 3840
-overwriteHeight = 2160
-
 # Main Screen Resolution
 [TextureRedefine]
 width = 1280
 height = 720
-formatsExcluded = 0x41A,0x431,0x19,0x1a # exclude the intro background texture, race end background
+formatsExcluded = 0x41A,0x431 # exclude the intro background texture, race end background
 overwriteWidth = 3840
 overwriteHeight = 2160
 

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_1080p/rules.txt

@@ -6,45 +6,20 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 1920
-overwriteHeight = 1080
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 1920
 overwriteHeight = 1080
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 960
-overwriteHeight = 540
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 960
 overwriteHeight = 540
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 480
-overwriteHeight = 270
-
-[TextureRedefine] # quarter-res alpha (increased depth)
-width = 320
-height = 180
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 480
 overwriteHeight = 270
 

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_1080pUW/rules.txt

@@ -6,45 +6,20 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 2560
-overwriteHeight = 1080
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 2560
 overwriteHeight = 1080
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 540
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 1280
 overwriteHeight = 540
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 640
-overwriteHeight = 270
-
-[TextureRedefine] # quarter-res alpha (increased depth)
-width = 320
-height = 180
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 640
 overwriteHeight = 270
 

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_1440p/rules.txt

@@ -6,45 +6,20 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 2560
-overwriteHeight = 1440
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 2560
 overwriteHeight = 1440
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1280
-overwriteHeight = 720
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 1280
 overwriteHeight = 720
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 640
-overwriteHeight = 360
-
-[TextureRedefine] # quarter-res alpha (increased depth)
-width = 320
-height = 180
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 640
 overwriteHeight = 360
 

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_1800p/rules.txt

@@ -6,45 +6,20 @@ version = 2
 [TextureRedefine] # tv
 width = 1280
 height = 720
-formatsExcluded = 0x816
-overwriteWidth = 3200
-overwriteHeight = 1800
-
-[TextureRedefine] # tv (increased depth)
-width = 1280
-height = 720
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 3200
 overwriteHeight = 1800
 
 [TextureRedefine] # half-res alpha
 width = 640
 height = 360
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 1600
-overwriteHeight = 900
-
-[TextureRedefine] # half-res alpha (increased depth)
-width = 640
-height = 360
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 1600
 overwriteHeight = 900
 
 [TextureRedefine] # quarter-res alpha
 width = 320
 height = 180
-formatsExcluded = 0x41A,0x431,0x816 # exclude obvious textures
+formatsExcluded = 0x41A,0x431 # exclude obvious textures
-overwriteWidth = 800
-overwriteHeight = 450
-
-[TextureRedefine] # quarter-res alpha (increased depth)
-width = 320
-height = 180
-formats = 0x816
-overwriteFormat = 0x823
 overwriteWidth = 800
 overwriteHeight = 450
 

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;
+}

Quality/SuperMario3DWorld_1080p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1080p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1440p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1440p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1800p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_1800p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_2160p/0457fe3efc9a772f_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// Used for: Horizontal Blur (Captain Toad Treasure Tracker)
+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 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/SuperMario3DWorld_2160p/9fad3b3505a6d831_0000000000000079_ps.txt

@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// Used for: Vertical Blur (Captain Toad Treasure Tracker)
+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 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;
+}