[BotW] apply SM3DW bloom fix

Renamed shaders, but it does fix the bloom.

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

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

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
 

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

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

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

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

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

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
 

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

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

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

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

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

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

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

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

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
 

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

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

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
 

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

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

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
 

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

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

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
 

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

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

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

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

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