From 74a298d9b3c1dd191aa4af66363c21cf52546a76 Mon Sep 17 00:00:00 2001 From: Crementif Date: Sun, 1 Oct 2017 14:44:14 +0200 Subject: [PATCH] Mario Kart 8 (improved) and Splatoon General Blur Fix - Mario Kart 8 now has the general blur fix, added to Quality&Enthusiast. Showcase + Fixed previous low radius + Added support for all resolutions by using general blur fix + Details: Used Horizontal&Vertical blur, 2 shaders added - Splatoon now has the general blur fix, added to Quality&Enthusiast. Showcase + Details: Used Horizontal&Vertical blur, 2 shaders added --- .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../4727ccdea05045d0_0000000000000079_ps.txt | 80 +++++------------- .../6dc0532bfaf19019_0000000000000079_ps.txt | 81 +++++-------------- .../4727ccdea05045d0_0000000000000079_ps.txt | 28 +++++++ .../6dc0532bfaf19019_0000000000000079_ps.txt | 29 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 29 +++++++ .../4dc5fdeced670c5e_0000000000000079_ps.txt | 28 +++++++ 34 files changed, 955 insertions(+), 118 deletions(-) create mode 100644 Enthusiast/MK8_2880p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Enthusiast/MK8_2880p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Enthusiast/MK8_4320p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Enthusiast/MK8_4320p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Enthusiast/MK8_5760p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Enthusiast/MK8_5760p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Quality/MK8_1080p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Quality/MK8_1080p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Quality/MK8_1080pUW/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Quality/MK8_1080pUW/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Quality/MK8_1440p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Quality/MK8_1440p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Quality/MK8_1800p/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Quality/MK8_1800p/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Quality/MK8_2160pUW/4727ccdea05045d0_0000000000000079_ps.txt create mode 100644 Quality/MK8_2160pUW/6dc0532bfaf19019_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt diff --git a/Enthusiast/MK8_2880p/4727ccdea05045d0_0000000000000079_ps.txt b/Enthusiast/MK8_2880p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Enthusiast/MK8_2880p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/MK8_2880p/6dc0532bfaf19019_0000000000000079_ps.txt b/Enthusiast/MK8_2880p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Enthusiast/MK8_2880p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/MK8_4320p/4727ccdea05045d0_0000000000000079_ps.txt b/Enthusiast/MK8_4320p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Enthusiast/MK8_4320p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/MK8_4320p/6dc0532bfaf19019_0000000000000079_ps.txt b/Enthusiast/MK8_4320p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Enthusiast/MK8_4320p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/MK8_5760p/4727ccdea05045d0_0000000000000079_ps.txt b/Enthusiast/MK8_5760p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Enthusiast/MK8_5760p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/MK8_5760p/6dc0532bfaf19019_0000000000000079_ps.txt b/Enthusiast/MK8_5760p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Enthusiast/MK8_5760p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1080p/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_1080p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Quality/MK8_1080p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1080p/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_1080p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Quality/MK8_1080p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1080pUW/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_1080pUW/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Quality/MK8_1080pUW/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1080pUW/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_1080pUW/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Quality/MK8_1080pUW/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1440p/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_1440p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Quality/MK8_1440p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1440p/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_1440p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Quality/MK8_1440p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1800p/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_1800p/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Quality/MK8_1800p/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_1800p/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_1800p/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Quality/MK8_1800p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_2160p/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_2160p/4727ccdea05045d0_0000000000000079_ps.txt index b1d49d6b..4865cfe2 100644 --- a/Quality/MK8_2160p/4727ccdea05045d0_0000000000000079_ps.txt +++ b/Quality/MK8_2160p/4727ccdea05045d0_0000000000000079_ps.txt @@ -1,66 +1,28 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader 4727ccdea05045d0 //horizontal blur -layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5357000 res 64x64x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; layout(location = 0) in vec4 passParameterSem0; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; -int clampFI32(int v) -{ - if (v == 0x7FFFFFFF) - return floatBitsToInt(1.0); - else if (v == 0xFFFFFFFF) - return floatBitsToInt(0.0); - return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); -} -float mul_nonIEEE(float a, float b) { if (a == 0.0 || b == 0.0) return 0.0; return a*b; } + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; void main() { - vec4 R0f = vec4(0.0); - vec4 R1f = vec4(0.0); - vec4 R2f = vec4(0.0); - vec4 R123f = vec4(0.0); - float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; - vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); - float PS0f = 0.0, PS1f = 0.0; - vec4 tempf = vec4(0.0); - float tempResultf; - int tempResulti; - ivec4 ARi = ivec4(0); - bool predResult = true; - vec3 cubeMapSTM; - int cubeMapFaceId; - R0f = passParameterSem0; - - R0f.z = (R0f.z - 0.0010416666666667 * 2.5); - R0f.y = (R0f.y + 0.0010416666666667 * 2.5); - - R1f.xyzw = (texture(textureUnitPS0, R0f.wx).xyzw); - R2f.xyzw = (texture(textureUnitPS0, R0f.yx).xyzw); - R0f.xyzw = (texture(textureUnitPS0, R0f.zx).xyzw); - // 0 - PV0f.x = R1f.w * intBitsToFloat(0x3e969697); - PV0f.y = R1f.z * intBitsToFloat(0x3e969697); - PV0f.z = R1f.y * intBitsToFloat(0x3e969697); - PV0f.w = R1f.x * intBitsToFloat(0x3e969697); - // 1 - R123f.x = (R2f.w * intBitsToFloat(0x3eb4b4b5) + PV0f.x); - PV1f.x = R123f.x; - R123f.y = (R2f.z * intBitsToFloat(0x3eb4b4b5) + PV0f.y); - PV1f.y = R123f.y; - R123f.z = (R2f.y * intBitsToFloat(0x3eb4b4b5) + PV0f.z); - PV1f.z = R123f.z; - R123f.w = (R2f.x * intBitsToFloat(0x3eb4b4b5) + PV0f.w); - PV1f.w = R123f.w; - // 2 - backupReg0f = R0f.x; - backupReg1f = R0f.y; - backupReg2f = R0f.z; - backupReg3f = R0f.w; - R0f.x = (backupReg0f * intBitsToFloat(0x3eb4b4b5) + PV1f.w); - R0f.y = (backupReg1f * intBitsToFloat(0x3eb4b4b5) + PV1f.z); - R0f.z = (backupReg2f * intBitsToFloat(0x3eb4b4b5) + PV1f.y); - R0f.w = (backupReg3f * intBitsToFloat(0x3eb4b4b5) + PV1f.x); - // export - passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); -} + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt index 6448d51e..bdd61599 100644 --- a/Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt +++ b/Quality/MK8_2160p/6dc0532bfaf19019_0000000000000079_ps.txt @@ -1,66 +1,29 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader 6dc0532bfaf19019 //vertical blur -layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5352800 res 64x64x1 dim 1 tm: 4 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; layout(location = 0) in vec4 passParameterSem0; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; -int clampFI32(int v) -{ -if( v == 0x7FFFFFFF ) - return floatBitsToInt(1.0); -else if( v == 0xFFFFFFFF ) - return floatBitsToInt(0.0); -return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); -} -float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; } + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; void main() { -vec4 R0f = vec4(0.0); -vec4 R1f = vec4(0.0); -vec4 R2f = vec4(0.0); -vec4 R123f = vec4(0.0); -float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; -vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); -float PS0f = 0.0, PS1f = 0.0; -vec4 tempf = vec4(0.0); -float tempResultf; -int tempResulti; -ivec4 ARi = ivec4(0); -bool predResult = true; -vec3 cubeMapSTM; -int cubeMapFaceId; -R0f = passParameterSem0; - -R0f.z = (R0f.z - 0.0018518518518519 * 2.5); -R0f.y = (R0f.y + 0.0018518518518519 * 2.5); - -R1f.xyzw = (texture(textureUnitPS0, R0f.xw).xyzw); -R2f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw); -R0f.xyzw = (texture(textureUnitPS0, R0f.xz).xyzw); -// 0 -PV0f.x = R1f.w * intBitsToFloat(0x3e969697); -PV0f.y = R1f.z * intBitsToFloat(0x3e969697); -PV0f.z = R1f.y * intBitsToFloat(0x3e969697); -PV0f.w = R1f.x * intBitsToFloat(0x3e969697); -// 1 -R123f.x = (R2f.w * intBitsToFloat(0x3eb4b4b5) + PV0f.x); -PV1f.x = R123f.x; -R123f.y = (R2f.z * intBitsToFloat(0x3eb4b4b5) + PV0f.y); -PV1f.y = R123f.y; -R123f.z = (R2f.y * intBitsToFloat(0x3eb4b4b5) + PV0f.z); -PV1f.z = R123f.z; -R123f.w = (R2f.x * intBitsToFloat(0x3eb4b4b5) + PV0f.w); -PV1f.w = R123f.w; -// 2 -backupReg0f = R0f.x; -backupReg1f = R0f.y; -backupReg2f = R0f.z; -backupReg3f = R0f.w; -R0f.x = (backupReg0f * intBitsToFloat(0x3eb4b4b5) + PV1f.w); -R0f.y = (backupReg1f * intBitsToFloat(0x3eb4b4b5) + PV1f.z); -R0f.z = (backupReg2f * intBitsToFloat(0x3eb4b4b5) + PV1f.y); -R0f.w = (backupReg3f * intBitsToFloat(0x3eb4b4b5) + PV1f.x); -// export -passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w); -} + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_2160pUW/4727ccdea05045d0_0000000000000079_ps.txt b/Quality/MK8_2160pUW/4727ccdea05045d0_0000000000000079_ps.txt new file mode 100644 index 00000000..4865cfe2 --- /dev/null +++ b/Quality/MK8_2160pUW/4727ccdea05045d0_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4727ccdea05045d0 +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/MK8_2160pUW/6dc0532bfaf19019_0000000000000079_ps.txt b/Quality/MK8_2160pUW/6dc0532bfaf19019_0000000000000079_ps.txt new file mode 100644 index 00000000..bdd61599 --- /dev/null +++ b/Quality/MK8_2160pUW/6dc0532bfaf19019_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 6dc0532bfaf19019 +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file diff --git a/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt new file mode 100644 index 00000000..9fe7817e --- /dev/null +++ b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -0,0 +1,29 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 45d85f1d25e7d0de +// Used for: Vertical Blur +const float blurFactor = 1.0; //Higher is less blur + + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(0.0, offset[i]) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(0.0, offset[i]) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} diff --git a/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt new file mode 100644 index 00000000..dff2978b --- /dev/null +++ b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -0,0 +1,28 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 4dc5fdeced670c5e +// Used for: Horizontal Blur +const float blurFactor = 1.0; //Higher is less blur + +// Implementation of http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/ +layout(binding = 0) uniform sampler2D textureUnitPS0; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +uniform float weight[] = float[](0.18571429, 0.28870130, 0.10363636, 0.01480519); +uniform float offset[] = float[](0.00000000, 1.42105263, 3.31578947, 5.21052632); + +ivec2 inputRes = textureSize(textureUnitPS0, 0); +vec2 outputRes = vec2(float(inputRes.x), float(inputRes.y)); +vec2 scale = outputRes * blurFactor; +void main() +{ + vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + vec4 R1f = texture(textureUnitPS0, R0f) * weight[0]; + for (int i = 1; i<4; i++) { + R1f += texture(textureUnitPS0, R0f + (vec2(offset[i], 0.0) / scale)) * weight[i]; + R1f += texture(textureUnitPS0, R0f - (vec2(offset[i], 0.0) / scale)) * weight[i]; + } + passPixelColor0 = R1f; +} \ No newline at end of file