From a7da90fb8be73b79048b4ce06776db2dfaa62f06 Mon Sep 17 00:00:00 2001
From: Michael <goldtextwitch@outlook.com>
Date: Sat, 7 Oct 2017 09:49:32 -0700
Subject: [PATCH 1/4] [BotW] apply SM3DW bloom fix

Renamed shaders, but it does fix the bloom.
---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Enthusiast/BreathOfTheWild_2880p/rules.txt    |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Enthusiast/BreathOfTheWild_4320p/rules.txt    |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Enthusiast/BreathOfTheWild_5760p/rules.txt    |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_1080p/rules.txt       |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_1080pUW/rules.txt     |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_1440p/rules.txt       |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_1440pUW/rules.txt     |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_1800p/rules.txt       |  1 -
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_2160p/rules.txt       |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 Quality/BreathOfTheWild_2160pUW/rules.txt     |  3 ---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 .../6279271034da8f93_0000000000000079_ps.txt  | 27 +++++++++++++++++++
 32 files changed, 594 insertions(+), 28 deletions(-)
 create mode 100644 Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
 create mode 100644 Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt

diff --git a/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_2880p/rules.txt b/Enthusiast/BreathOfTheWild_2880p/rules.txt
index 3b1551e2..4d1c75f6 100644
--- a/Enthusiast/BreathOfTheWild_2880p/rules.txt
+++ b/Enthusiast/BreathOfTheWild_2880p/rules.txt
@@ -61,7 +61,6 @@ overwriteHeight = 1152
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 1280
 overwriteHeight = 720
 
@@ -80,14 +79,12 @@ overwriteHeight = 720
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 720
 overwriteHeight = 360
 
 [TextureRedefine] # O
 width = 80
 height = 45
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 320
 overwriteHeight = 180
 
diff --git a/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_4320p/rules.txt b/Enthusiast/BreathOfTheWild_4320p/rules.txt
index b8755c10..a5644cd6 100644
--- a/Enthusiast/BreathOfTheWild_4320p/rules.txt
+++ b/Enthusiast/BreathOfTheWild_4320p/rules.txt
@@ -61,7 +61,6 @@ overwriteHeight = 1728
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 1920
 overwriteHeight = 1080
 
@@ -80,13 +79,11 @@ overwriteHeight = 1080
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 960
 overwriteHeight = 540
 
 [TextureRedefine] # O
 width = 80
-formats = 0x001		#Scale depth masking, not bloom
 height = 45
 overwriteWidth = 480
 overwriteHeight = 270
diff --git a/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Enthusiast/BreathOfTheWild_5760p/rules.txt b/Enthusiast/BreathOfTheWild_5760p/rules.txt
index 67b7b34a..176a472b 100644
--- a/Enthusiast/BreathOfTheWild_5760p/rules.txt
+++ b/Enthusiast/BreathOfTheWild_5760p/rules.txt
@@ -61,7 +61,6 @@ overwriteHeight = 2304
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 2560
 overwriteHeight = 1440
 
@@ -80,14 +79,12 @@ overwriteHeight = 1440
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 1281
 overwriteHeight = 721
 
 [TextureRedefine] # O
 width = 80
 height = 45
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 640
 overwriteHeight = 360
 
diff --git a/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1080p/rules.txt b/Quality/BreathOfTheWild_1080p/rules.txt
index f56a6283..947a2b44 100644
--- a/Quality/BreathOfTheWild_1080p/rules.txt
+++ b/Quality/BreathOfTheWild_1080p/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 541
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 480
 overwriteHeight = 270
 
@@ -86,13 +85,11 @@ overwriteHeight = 270
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 240
 overwriteHeight = 135
 
 [TextureRedefine] # O
 width = 80
-formats = 0x001		#Scale depth masking, not bloom
 height = 45
 overwriteWidth = 120
 overwriteHeight = 68
diff --git a/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1080pUW/rules.txt b/Quality/BreathOfTheWild_1080pUW/rules.txt
index 8c0e3cef..d0c9f0bf 100644
--- a/Quality/BreathOfTheWild_1080pUW/rules.txt
+++ b/Quality/BreathOfTheWild_1080pUW/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 541
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 640
 overwriteHeight = 270
 
@@ -86,13 +85,11 @@ overwriteHeight = 270
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 320
 overwriteHeight = 135
 
 [TextureRedefine] # O
 width = 80
-formats = 0x001		#Scale depth masking, not bloom
 height = 45
 overwriteWidth = 160
 overwriteHeight = 68
diff --git a/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1440p/rules.txt b/Quality/BreathOfTheWild_1440p/rules.txt
index c249eefb..863300b2 100644
--- a/Quality/BreathOfTheWild_1440p/rules.txt
+++ b/Quality/BreathOfTheWild_1440p/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 721
 [TextureRedefine] #q-res1, main bloom, AO
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 640
 overwriteHeight = 360
 
@@ -86,14 +85,12 @@ overwriteHeight = 360
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 320
 overwriteHeight = 180
 
 [TextureRedefine] # O
 width = 80
 height = 45
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 160
 overwriteHeight = 90
 
diff --git a/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1440pUW/rules.txt b/Quality/BreathOfTheWild_1440pUW/rules.txt
index 270db41e..2b10305f 100644
--- a/Quality/BreathOfTheWild_1440pUW/rules.txt
+++ b/Quality/BreathOfTheWild_1440pUW/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 721
 [TextureRedefine] #q-res1, main bloom, AO
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 860
 overwriteHeight = 360
 
@@ -86,14 +85,12 @@ overwriteHeight = 360
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 430
 overwriteHeight = 180
 
 [TextureRedefine] # O
 width = 80
 height = 45
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 215
 overwriteHeight = 90
 
diff --git a/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1800p/rules.txt b/Quality/BreathOfTheWild_1800p/rules.txt
index f622931a..ae66c4ff 100644
--- a/Quality/BreathOfTheWild_1800p/rules.txt
+++ b/Quality/BreathOfTheWild_1800p/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 901
 [TextureRedefine] #q-res1 Main bloom pass, AO 
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 800
 overwriteHeight = 450
 
diff --git a/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_2160p/rules.txt b/Quality/BreathOfTheWild_2160p/rules.txt
index 492a6e4c..d524b931 100644
--- a/Quality/BreathOfTheWild_2160p/rules.txt
+++ b/Quality/BreathOfTheWild_2160p/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 1082
 [TextureRedefine] #q-res1 Main bloom pass, AO 
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 960
 overwriteHeight = 540
 
@@ -86,14 +85,12 @@ overwriteHeight = 540
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 480
 overwriteHeight = 270
 
 [TextureRedefine] # O
 width = 80
 height = 45
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 240
 overwriteHeight = 135
 
diff --git a/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_2160pUW/rules.txt b/Quality/BreathOfTheWild_2160pUW/rules.txt
index 29f5ebcd..3b403a8a 100644
--- a/Quality/BreathOfTheWild_2160pUW/rules.txt
+++ b/Quality/BreathOfTheWild_2160pUW/rules.txt
@@ -67,7 +67,6 @@ overwriteHeight = 1082
 [TextureRedefine] #q-res1
 width = 320
 height = 180
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 1280
 overwriteHeight = 540
 
@@ -86,13 +85,11 @@ overwriteHeight = 540
 [TextureRedefine] #o-res1
 width = 160
 height = 90
-formats = 0x001		#Scale depth masking, not bloom
 overwriteWidth = 640
 overwriteHeight = 270
 
 [TextureRedefine] # O
 width = 80
-formats = 0x001		#Scale depth masking, not bloom
 height = 45
 overwriteWidth = 320
 overwriteHeight = 136
diff --git a/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
new file mode 100644
index 00000000..ee3c4370
--- /dev/null
+++ b/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 9fad3b3505a6d831
+// 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 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;
+}
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt
new file mode 100644
index 00000000..bd2a9eba
--- /dev/null
+++ b/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt
@@ -0,0 +1,27 @@
+#version 420
+#extension GL_ARB_texture_gather : enable
+// shader 0457fe3efc9a772f
+// 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 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;
+}
\ No newline at end of file

From 48f4caef67b35c0ad1f7e11315e3d1e207e9bb0b Mon Sep 17 00:00:00 2001
From: Michael <goldtextwitch@outlook.com>
Date: Sat, 7 Oct 2017 17:08:21 -0700
Subject: [PATCH 2/4] Push NAVras' 1440p shaders

---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 50 ++++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 50 ++++++++++++-------
 2 files changed, 64 insertions(+), 36 deletions(-)

diff --git a/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..4b48c426 100644
--- a/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,41 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1440
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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 ires = textureSize(textureUnitPS0,0);
+//vec2 res = vec2( float(ires.x), float(ires.y) );
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767 );
+uniform float offset[] = float[]( 0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 4 --reduce 4 17 --linear
diff --git a/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..92079e9d 100644
--- a/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,41 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 2560
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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 ires = textureSize(textureUnitPS0,0);
+//vec2 res = vec2( float(ires.x), float(ires.y) );
+
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767 );
+uniform float offset[] = float[]( 0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 4 --reduce 4 17 --linear

From 14353778a9e67a738d62071267e8e417023e75f0 Mon Sep 17 00:00:00 2001
From: Michael <goldtextwitch@outlook.com>
Date: Sat, 7 Oct 2017 18:30:59 -0700
Subject: [PATCH 3/4] Add 2160p shader edit

---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 2 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..7cc7869c 100644
--- a/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_2160p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 2160
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12537086, 0.22251971, 0.13786547, 0.05769140, 0.01602539, 0.00287352, 0.00031864, 0.00002045 );
+uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317, 9.26829268, 11.21951220, 13.17073171 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<8; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..e2c011b1 100644
--- a/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_2160p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 3840
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12537086, 0.22251971, 0.13786547, 0.05769140, 0.01602539, 0.00287352, 0.00031864, 0.00002045 );
+uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317, 9.26829268, 11.21951220, 13.17073171 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<8; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 6 --reduce 6 29 --linear
+//game original --expand 2 --reduce 2 9 --linear

From df950f92d589586f4031eaa5211654e0d78a0a4a Mon Sep 17 00:00:00 2001
From: NAVras-Z <zhuangyzj@gmail.com>
Date: Sun, 8 Oct 2017 12:24:22 +0800
Subject: [PATCH 4/4] workaround upscaled blur pixelation (#97)

the old way used in menu blur is kinda hacky (cuz i found the games's original blur is
linear sampled 5x5, not jump lines), and seems to have some negative effect when used on bloom (pixelation)
so back to increasing taps, however as the image size goes up, it becomes quite harder/impossible to get the same blurry result for some reason. 5x5 menu blur ends up in 100 taps in 10k to get the similar blur, and 9x9 used in bloom is even blurrier... so i give up trying to get the same blur by increasing a lot taps, but just scale linearly to fix pixelation first and wait for a better solution.
also the texturesize() returns weird value when mipmap is present, so changed to calculate the image size from the data passed from vertex shader (as we already figured out what blur is used so offset is known).
---
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  |  5 --
 .../6279271034da8f93_0000000000000079_ps.txt  |  4 +-
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 45 ++++++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 48 ++++++++++++-------
 .../12d8627fe9906695_0000000000000079_ps.txt  | 36 +++++++-------
 .../6279271034da8f93_0000000000000079_ps.txt  | 39 ++++++++-------
 20 files changed, 496 insertions(+), 332 deletions(-)

diff --git a/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..2659e331 100644
--- a/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_2880p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 2880
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.11011604, 0.20071416, 0.13842356, 0.07060718, 0.02643049, 0.00717399, 0.00138786, 0.00018683, 0.00001693, 0.00000098 );
+uniform float offset[] = float[]( 0.00000000, 1.47169811, 3.43396226, 5.39622642, 7.35849057, 9.32075472, 11.28301887, 13.24528302, 15.20754717, 17.16981132 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<10; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..47e31a3f 100644
--- a/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_2880p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 5120
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.11011604, 0.20071416, 0.13842356, 0.07060718, 0.02643049, 0.00717399, 0.00138786, 0.00018683, 0.00001693, 0.00000098 );
+uniform float offset[] = float[]( 0.00000000, 1.47169811, 3.43396226, 5.39622642, 7.35849057, 9.32075472, 11.28301887, 13.24528302, 15.20754717, 17.16981132 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<10; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 8 --reduce 8 37 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..b8791186 100644
--- a/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_4320p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 4320
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.08679764, 0.16377778, 0.12975631, 0.08523885, 0.04634210, 0.02079453, 0.00767262, 0.00231673, 0.00056902, 0.00011284, 0.00001790, 0.00000225, 0.00000022, 0.00000002 );
+uniform float offset[] = float[]( 0.00000000, 1.48235294, 3.45882353, 5.43529412, 7.41176471, 9.38823529, 11.36470588, 13.34117647, 15.31764706, 17.29411765, 19.27058824, 21.24705882, 23.22352941, 25.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<14; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..0e684559 100644
--- a/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_4320p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 7680
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.08679764, 0.16377778, 0.12975631, 0.08523885, 0.04634210, 0.02079453, 0.00767262, 0.00231673, 0.00056902, 0.00011284, 0.00001790, 0.00000225, 0.00000022, 0.00000002 );
+uniform float offset[] = float[]( 0.00000000, 1.48235294, 3.45882353, 5.43529412, 7.41176471, 9.38823529, 11.36470588, 13.34117647, 15.31764706, 17.29411765, 19.27058824, 21.24705882, 23.22352941, 25.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<14; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 14 --reduce 14 57 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..5db57049 100644
--- a/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_5760p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 5760
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.05842515, 0.11378184, 0.10229613, 0.08445599, 0.06401931, 0.04454418, 0.02843975, 0.01665463, 0.00894132, 0.00439816, 0.00198084, 0.00081621, 0.00030743, 0.00010575, 0.00003318, 0.00000949, 0.00000247, 0.00000058, 0.00000013, 0.00000002 );
+uniform float offset[] = float[]( 0.00000000, 1.49197861, 3.48128342, 5.47058824, 7.45989305, 9.44919786, 11.43850267, 13.42780749, 15.41711230, 17.40641711, 19.39572193, 21.38502674, 23.37433155, 25.36363636, 27.35294118, 29.34224599, 31.33155080, 33.32085561, 35.31016043, 37.29946524 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<20; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt b/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..e61de54b 100644
--- a/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Enthusiast/BreathOfTheWild_5760p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 10240
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.05842515, 0.11378184, 0.10229613, 0.08445599, 0.06401931, 0.04454418, 0.02843975, 0.01665463, 0.00894132, 0.00439816, 0.00198084, 0.00081621, 0.00030743, 0.00010575, 0.00003318, 0.00000949, 0.00000247, 0.00000058, 0.00000013, 0.00000002 );
+uniform float offset[] = float[]( 0.00000000, 1.49197861, 3.48128342, 5.47058824, 7.45989305, 9.44919786, 11.43850267, 13.42780749, 15.41711230, 17.40641711, 19.39572193, 21.38502674, 23.37433155, 25.36363636, 27.35294118, 29.34224599, 31.33155080, 33.32085561, 35.31016043, 37.29946524 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<20; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 29 --reduce 29 129 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..a9e4bfeb 100644
--- a/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1080p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+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];
+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]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..c9d0fa93 100644
--- a/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1080p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 1920
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+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];
+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]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 3 --reduce 3 13 --linear
+//game original --expand 2 --reduce 2 9 --linear
\ No newline at end of file
diff --git a/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..a9e4bfeb 100644
--- a/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1080pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+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];
+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]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..db3df026 100644
--- a/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1080pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 2560
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767 );
+uniform float offset[] = float[]( 0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 4 --reduce 4 17 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
index 4b48c426..96a3dfeb 100644
--- a/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440p/12d8627fe9906695_0000000000000079_ps.txt
@@ -7,9 +7,6 @@ layout(location = 1) in vec4 passParameterSem1;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-//ivec2 ires = textureSize(textureUnitPS0,0);
-//vec2 res = vec2( float(ires.x), float(ires.y) );
-
 float data = passParameterSem0.z - passParameterSem0.w;
 float h = data / 1.38461538 * uf_fragCoordScale.y;
 
@@ -37,5 +34,3 @@ for (int i=1; i<2; i++) {
 
 passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
-
-//py blurninja.py --expand 4 --reduce 4 17 --linear
diff --git a/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
index 92079e9d..db3df026 100644
--- a/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440p/6279271034da8f93_0000000000000079_ps.txt
@@ -7,9 +7,6 @@ layout(location = 1) in vec4 passParameterSem1;
 layout(location = 0) out vec4 passPixelColor0;
 uniform vec2 uf_fragCoordScale;
 
-//ivec2 ires = textureSize(textureUnitPS0,0);
-//vec2 res = vec2( float(ires.x), float(ires.y) );
-
 float data = passParameterSem0.z - passParameterSem0.w;
 float w = data / 1.38461538 * uf_fragCoordScale.x;
 
@@ -39,3 +36,4 @@ passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
 }
 
 //py blurninja.py --expand 4 --reduce 4 17 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..96a3dfeb 100644
--- a/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1440
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.16122494, 0.26575540, 0.12180456, 0.02865990, 0.00316767 );
+uniform float offset[] = float[]( 0.00000000, 1.44000000, 3.36000000, 5.28000000, 7.20000000 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<5; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..b7c204e7 100644
--- a/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1440pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 3440
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12858845, 0.22686677, 0.13719611, 0.05487844, 0.01422774, 0.00231288, 0.00022383 );
+uniform float offset[] = float[]( 0.00000000, 1.46153846, 3.41025641, 5.35897436, 7.30769231, 9.25641026, 11.20512821 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 7 --reduce 7 25 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..7a33de92 100644
--- a/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1800p/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1800
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.13583460, 0.23632042, 0.13504024, 0.04857179, 0.01068579, 0.00136997, 0.00009448 );
+uniform float offset[] = float[]( 0.00000000, 1.45714286, 3.40000000, 5.34285714, 7.28571429, 9.22857143, 11.17142857 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..44d8d503 100644
--- a/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_1800p/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 3200
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.13583460, 0.23632042, 0.13504024, 0.04857179, 0.01068579, 0.00136997, 0.00009448 );
+uniform float offset[] = float[]( 0.00000000, 1.45714286, 3.40000000, 5.34285714, 7.28571429, 9.22857143, 11.17142857 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<7; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 5 --reduce 5 25 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..7cc7869c 100644
--- a/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_2160pUW/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,36 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 2160
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.12537086, 0.22251971, 0.13786547, 0.05769140, 0.01602539, 0.00287352, 0.00031864, 0.00002045 );
+uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317, 9.26829268, 11.21951220, 13.17073171 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<8; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*h) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*h) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
diff --git a/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..47e31a3f 100644
--- a/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_2160pUW/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,39 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 5120
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
+
+uniform float weight[] = float[]( 0.11011604, 0.20071416, 0.13842356, 0.07060718, 0.02643049, 0.00717399, 0.00138786, 0.00018683, 0.00001693, 0.00000098 );
+uniform float offset[] = float[]( 0.00000000, 1.47169811, 3.43396226, 5.39622642, 7.35849057, 9.32075472, 11.28301887, 13.24528302, 15.20754717, 17.16981132 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0];
+for (int i=1; i<10; i++) {
+	R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*w, 0.0) ) * weight[i];
+	R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*w, 0.0) ) * weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	}
+
+passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f );
+}
+
+//py blurninja.py --expand 8 --reduce 8 37 --linear
+//game original --expand 2 --reduce 2 9 --linear
diff --git a/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt b/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
index ee3c4370..2009693d 100644
--- a/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_Switch/12d8627fe9906695_0000000000000079_ps.txt
@@ -1,27 +1,27 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 9fad3b3505a6d831
-// 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;
+// shader 12d8627fe9906695 // vertical bloom 1080
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4240800 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float h = data / 1.38461538 * uf_fragCoordScale.y;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w);
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*h) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*h) ) * o_weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+passPixelColor0 = R2f;
+}
diff --git a/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt b/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt
index bd2a9eba..8cd2745e 100644
--- a/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt
+++ b/Quality/BreathOfTheWild_Switch/6279271034da8f93_0000000000000079_ps.txt
@@ -1,27 +1,30 @@
 #version 420
 #extension GL_ARB_texture_gather : enable
-// shader 0457fe3efc9a772f
-// 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;
+// shader 6279271034da8f93 // horizontal bloom 1920
+layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4247000 res 96x96x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1
 layout(location = 0) in vec4 passParameterSem0;
+layout(location = 1) in vec4 passParameterSem1;
 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);
+float data = passParameterSem0.z - passParameterSem0.w;
+float w = data / 1.38461538 * uf_fragCoordScale.x;
+
+uniform float o_weight[] = float[]( 0.29411765, 0.35294118 );
+uniform float o_offset[] = float[]( 0.00000000, 1.33333333 );
 
-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];
+vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x);
+
+vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0];
+for (int i=1; i<2; i++) {
+	R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
+	R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*w, 0.0) ) * o_weight[i];
 	}
-	passPixelColor0 = R1f;
-}
\ No newline at end of file
+
+passPixelColor0 = R2f;
+}
+
+
+//game original --expand 2 --reduce 2 9 --linear
\ No newline at end of file