From d3de96e30e4909912cdcebdf22148f07000ec541 Mon Sep 17 00:00:00 2001 From: NAVras-Z Date: Fri, 13 Oct 2017 11:52:35 +0800 Subject: [PATCH] [Splatoon] adapted some blur related shaders from BotW to Splatoon --- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- .../0457fe3efc9a772f_0000000000000079_ps.txt | 38 +++++++ .../34eaf9e211e76379_00000000000003c9_ps.txt | 102 ++++++++++++++++++ .../45d85f1d25e7d0de_0000000000000079_ps.txt | 44 ++++---- .../4dc5fdeced670c5e_0000000000000079_ps.txt | 48 +++++---- .../9fad3b3505a6d831_0000000000000079_ps.txt | 41 +++++++ .../cb0e6e8cbec4502a_0000000000000079_ps.txt | 21 +--- 48 files changed, 1920 insertions(+), 432 deletions(-) create mode 100644 Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt create mode 100644 Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt create mode 100644 Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt diff --git a/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..fc1dde29 --- /dev/null +++ b/Enthusiast/Splatoon_2880p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 2880 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.09502547, 0.17728101, 0.13421680, 0.08118479, 0.03910895, 0.01493251, 0.00448942, 0.00105364, 0.00019089, 0.00002632, 0.00000271, 0.00000020, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.47887324, 3.45070423, 5.42253521, 7.39436620, 9.36619718, 11.33802817, 13.30985915, 15.28169014, 17.25352113, 19.22535211, 21.19718310, 23.16901408 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<13; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Enthusiast/Splatoon_2880p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..63c1fa9c 100644 --- a/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_2880p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 2880 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.08123271, 0.15437530, 0.12585196, 0.08706739, 0.05105315, 0.02532582, 0.01060251, 0.00373415, 0.00110209, 0.00027128 ); +uniform float offset[] = float[]( 0.00000000, 1.48453608, 3.46391753, 5.44329897, 7.42268041, 9.40206186, 11.38144330, 13.36082474, 15.34020619, 17.31958763 ); -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; +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]; + } + +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/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..6671781a 100644 --- a/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_2880p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 2880 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.08123271, 0.15437530, 0.12585196, 0.08706739, 0.05105315, 0.02532582, 0.01060251, 0.00373415, 0.00110209, 0.00027128 ); +uniform float offset[] = float[]( 0.00000000, 1.48453608, 3.46391753, 5.44329897, 7.42268041, 9.40206186, 11.38144330, 13.36082474, 15.34020619, 17.31958763 ); -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 +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]; + } + +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 30 --reduce 30 37 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..b8f4f26d --- /dev/null +++ b/Enthusiast/Splatoon_2880p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 2880 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.09502547, 0.17728101, 0.13421680, 0.08118479, 0.03910895, 0.01493251, 0.00448942, 0.00105364, 0.00019089, 0.00002632, 0.00000271, 0.00000020, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.47887324, 3.45070423, 5.42253521, 7.39436620, 9.36619718, 11.33802817, 13.30985915, 15.28169014, 17.25352113, 19.22535211, 21.19718310, 23.16901408 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<13; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 9 --reduce 9 53 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_2880p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..7d5741c9 --- /dev/null +++ b/Enthusiast/Splatoon_4320p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 4320 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.07731484, 0.14762709, 0.12265258, 0.08781380, 0.05412785, 0.02868527, 0.01304628, 0.00508044, 0.00168915, 0.00047786, 0.00011455, 0.00002316, 0.00000393, 0.00000055, 0.00000006, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.48598131, 3.46728972, 5.44859813, 7.42990654, 9.41121495, 11.39252336, 13.37383178, 15.35514019, 17.33644860, 19.31775701, 21.29906542, 23.28037383, 25.26168224, 27.24299065, 29.22429907 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<16; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Enthusiast/Splatoon_4320p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..6bbe5aa5 100644 --- a/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_4320p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 4320 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.05721114, 0.11153873, 0.10071616, 0.08380551, 0.06425089, 0.04537556, 0.02951030, 0.01766751, 0.00973277, 0.00493097, 0.00229618, 0.00098211, 0.00038554, 0.00013879, 0.00004577, 0.00001382, 0.00000381 ); +uniform float offset[] = float[]( 0.00000000, 1.49230769, 3.48205128, 5.47179487, 7.46153846, 9.45128205, 11.44102564, 13.43076923, 15.42051282, 17.41025641, 19.40000000, 21.38974359, 23.37948718, 25.36923077, 27.35897436, 29.34871795, 31.33846154 ); -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; +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<17; 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]; + } + +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/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..0ae50a4a 100644 --- a/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_4320p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 4320 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.05721114, 0.11153873, 0.10071616, 0.08380551, 0.06425089, 0.04537556, 0.02951030, 0.01766751, 0.00973277, 0.00493097, 0.00229618, 0.00098211, 0.00038554, 0.00013879, 0.00004577, 0.00001382, 0.00000381 ); +uniform float offset[] = float[]( 0.00000000, 1.49230769, 3.48205128, 5.47179487, 7.46153846, 9.45128205, 11.44102564, 13.43076923, 15.42051282, 17.41025641, 19.40000000, 21.38974359, 23.37948718, 25.36923077, 27.35897436, 29.34871795, 31.33846154 ); -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 +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<17; 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]; + } + +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 65 --reduce 65 65 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..4f21399e --- /dev/null +++ b/Enthusiast/Splatoon_4320p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 4320 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.07731484, 0.14762709, 0.12265258, 0.08781380, 0.05412785, 0.02868527, 0.01304628, 0.00508044, 0.00168915, 0.00047786, 0.00011455, 0.00002316, 0.00000393, 0.00000055, 0.00000006, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.48598131, 3.46728972, 5.44859813, 7.42990654, 9.41121495, 11.39252336, 13.37383178, 15.35514019, 17.33644860, 19.31775701, 21.29906542, 23.28037383, 25.26168224, 27.24299065, 29.22429907 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<16; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 15 --reduce 15 77 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_4320p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..827d08cd --- /dev/null +++ b/Enthusiast/Splatoon_5760p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 5760 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.06731324, 0.12996513, 0.11288345, 0.08757379, 0.06065717, 0.03748843, 0.02065758, 0.01013916, 0.00442739, 0.00171752, 0.00059095, 0.00017999, 0.00004843, 0.00001148, 0.00000239, 0.00000044, 0.00000007, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.48936170, 3.47517730, 5.46099291, 7.44680851, 9.43262411, 11.41843972, 13.40425532, 15.39007092, 17.37588652, 19.36170213, 21.34751773, 23.33333333, 25.31914894, 27.30496454, 29.29078014, 31.27659574, 33.26241135 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<18; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt b/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Enthusiast/Splatoon_5760p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..24ecc2ed 100644 --- a/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_5760p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 5760 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.04202302, 0.08289284, 0.07843703, 0.07101047, 0.06150497, 0.05096469, 0.04039985, 0.03063492, 0.02222034, 0.01541512, 0.01022743, 0.00648881, 0.00393634, 0.00228295, 0.00126565, 0.00067063, 0.00033957, 0.00016428, 0.00007592, 0.00003351, 0.00001412, 0.00000568, 0.00000218, 0.00000080, 0.00000028, 0.00000009 ); +uniform float offset[] = float[]( 0.00000000, 1.49584488, 3.49030471, 5.48476454, 7.47922438, 9.47368421, 11.46814404, 13.46260388, 15.45706371, 17.45152355, 19.44598338, 21.44044321, 23.43490305, 25.42936288, 27.42382271, 29.41828255, 31.41274238, 33.40720222, 35.40166205, 37.39612188, 39.39058172, 41.38504155, 43.37950139, 45.37396122, 47.36842105, 49.36288089 ); -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; +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<26; 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]; + } + +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/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..8d112154 100644 --- a/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_5760p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 5760 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.04202302, 0.08289284, 0.07843703, 0.07101047, 0.06150497, 0.05096469, 0.04039985, 0.03063492, 0.02222034, 0.01541512, 0.01022743, 0.00648881, 0.00393634, 0.00228295, 0.00126565, 0.00067063, 0.00033957, 0.00016428, 0.00007592, 0.00003351, 0.00001412, 0.00000568, 0.00000218, 0.00000080, 0.00000028, 0.00000009 ); +uniform float offset[] = float[]( 0.00000000, 1.49584488, 3.49030471, 5.48476454, 7.47922438, 9.47368421, 11.46814404, 13.46260388, 15.45706371, 17.45152355, 19.44598338, 21.44044321, 23.43490305, 25.42936288, 27.42382271, 29.41828255, 31.41274238, 33.40720222, 35.40166205, 37.39612188, 39.39058172, 41.38504155, 43.37950139, 45.37396122, 47.36842105, 49.36288089 ); -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 +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<26; 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]; + } + +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 130 --reduce 130 101 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..da4b3260 --- /dev/null +++ b/Enthusiast/Splatoon_5760p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 5760 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.06731324, 0.12996513, 0.11288345, 0.08757379, 0.06065717, 0.03748843, 0.02065758, 0.01013916, 0.00442739, 0.00171752, 0.00059095, 0.00017999, 0.00004843, 0.00001148, 0.00000239, 0.00000044, 0.00000007, 0.00000001 ); +uniform float offset[] = float[]( 0.00000000, 1.48936170, 3.47517730, 5.46099291, 7.44680851, 9.43262411, 11.41843972, 13.40425532, 15.39007092, 17.37588652, 19.36170213, 21.34751773, 23.33333333, 25.31914894, 27.30496454, 29.29078014, 31.27659574, 33.26241135 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<18; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 18 --reduce 18 105 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Enthusiast/Splatoon_5760p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..63345e4a --- /dev/null +++ b/Quality/Splatoon_1080p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 1080 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<6; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Quality/Splatoon_1080p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..23cb8128 100644 --- a/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 1080 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.20064856, 0.30320227, 0.09647345 ); +uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 ); -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; +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<3; 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]; + } + +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/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..4c7003e7 100644 --- a/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 1080 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.20064856, 0.30320227, 0.09647345 ); +uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 ); -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 +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<3; 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]; + } + +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 9 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..d1aa277a --- /dev/null +++ b/Quality/Splatoon_1080p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 1080 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<6; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 3 --reduce 3 --linear 21 +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..63345e4a --- /dev/null +++ b/Quality/Splatoon_1080pUW/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 1080 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<6; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Quality/Splatoon_1080pUW/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..23cb8128 100644 --- a/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080pUW/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 1080 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.20064856, 0.30320227, 0.09647345 ); +uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 ); -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; +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<3; 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]; + } + +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/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..4c7003e7 100644 --- a/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080pUW/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 1080 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.20064856, 0.30320227, 0.09647345 ); +uniform float offset[] = float[]( 0.00000000, 1.41176471, 3.29411765 ); -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 +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<3; 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]; + } + +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 9 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..d1aa277a --- /dev/null +++ b/Quality/Splatoon_1080pUW/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 1080 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.15498264, 0.25904242, 0.12571176, 0.03308204, 0.00441094, 0.00026152 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630, 7.22222222, 9.14814815 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<6; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 3 --reduce 3 --linear 21 +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Quality/Splatoon_1080pUW/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..fb356115 --- /dev/null +++ b/Quality/Splatoon_1440p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 1440 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.13206230, 0.23145657, 0.13626880, 0.05184139, 0.01244193, 0.00181033, 0.00014982 ); +uniform float offset[] = float[]( 0.00000000, 1.45945946, 3.40540541, 5.35135135, 7.29729730, 9.24324324, 11.18918919 ); + +void main() +{ +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]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Quality/Splatoon_1440p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..067ef96b 100644 --- a/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Quality/Splatoon_1440p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 1440 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.15644460, 0.26148598, 0.12689761, 0.03339411 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630 ); -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; +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]; + } + +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/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..805d99b0 100644 --- a/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Quality/Splatoon_1440p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 1440 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.15644460, 0.26148598, 0.12689761, 0.03339411 ); +uniform float offset[] = float[]( 0.00000000, 1.44444444, 3.37037037, 5.29629630 ); -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 +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]; + } + +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 13 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..3a50efbf --- /dev/null +++ b/Quality/Splatoon_1440p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 1440 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.13206230, 0.23145657, 0.13626880, 0.05184139, 0.01244193, 0.00181033, 0.00014982 ); +uniform float offset[] = float[]( 0.00000000, 1.45945946, 3.40540541, 5.35135135, 7.29729730, 9.24324324, 11.18918919 ); + +void main() +{ +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]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 6 --reduce 6 25 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Quality/Splatoon_1440p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..9e3b805f --- /dev/null +++ b/Quality/Splatoon_1800p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 1800 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.11960420, 0.21450752, 0.13860486, 0.06270220, 0.01960345, 0.00414992, 0.00057699, 0.00005037, 0.00000258 ); +uniform float offset[] = float[]( 0.00000000, 1.46666667, 3.42222222, 5.37777778, 7.33333333, 9.28888889, 11.24444444, 13.20000000, 15.15555556 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<9; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Quality/Splatoon_1800p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..16404f45 100644 --- a/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Quality/Splatoon_1800p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 1800 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.12618160, 0.22395869, 0.13875701, 0.05806447, 0.01612902 ); +uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317 ); -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; +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]; + } + +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/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..cfad281d 100644 --- a/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Quality/Splatoon_1800p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 1800 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.12618160, 0.22395869, 0.13875701, 0.05806447, 0.01612902 ); +uniform float offset[] = float[]( 0.00000000, 1.46341463, 3.41463415, 5.36585366, 7.31707317 ); -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 +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]; + } + +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 12 --reduce 12 17 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..88c76a97 --- /dev/null +++ b/Quality/Splatoon_1800p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 1800 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.11960420, 0.21450752, 0.13860486, 0.06270220, 0.01960345, 0.00414992, 0.00057699, 0.00005037, 0.00000258 ); +uniform float offset[] = float[]( 0.00000000, 1.46666667, 3.42222222, 5.37777778, 7.33333333, 9.28888889, 11.24444444, 13.20000000, 15.15555556 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<9; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 6 --reduce 6 33 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Quality/Splatoon_1800p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } } diff --git a/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt b/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt new file mode 100644 index 00000000..84091aa4 --- /dev/null +++ b/Quality/Splatoon_2160p/0457fe3efc9a772f_0000000000000079_ps.txt @@ -0,0 +1,38 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 0457fe3efc9a772f +// Used for: Vertical Bloom 2160 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float w = data / 1.38461538 * uf_fragCoordScale.x; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.10807685, 0.19765286, 0.13814447, 0.07221188, 0.02803520, 0.00799803, 0.00165142, 0.00024167, 0.00002435, 0.00000162, 0.00000007 ); +uniform float offset[] = float[]( 0.00000000, 1.47272727, 3.43636364, 5.40000000, 7.36363636, 9.32727273, 11.29090909, 13.25454545, 15.21818182, 17.18181818, 19.14545455 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.x, passParameterSem0.w); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<11; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(0.0, offset[i]*w) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(0.0, offset[i]*w) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(0.0, o_offset[i]*w) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} diff --git a/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt b/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt new file mode 100644 index 00000000..77843360 --- /dev/null +++ b/Quality/Splatoon_2160p/34eaf9e211e76379_00000000000003c9_ps.txt @@ -0,0 +1,102 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 34eaf9e211e76379 // bloom pre-blur +uniform ivec4 uf_remappedPS[4]; +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c6000 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 +layout(binding = 1) uniform sampler2D textureUnitPS1;// Tex1 addr 0x156f2000 res 1280x720x1 dim 1 tm: 4 format 0806 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler1 ClampX/Y/Z: 2 2 2 border: 1 +layout(location = 0) in vec4 passParameterSem0; +layout(location = 1) in vec4 passParameterSem1; +layout(location = 2) in vec4 passParameterSem2; +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){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +vec4 R0f = vec4(0.0); +vec2 R1f = vec2(0.0); +vec4 R2f = vec4(0.0); +vec4 R3f = vec4(0.0); +vec4 R4f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R126f = vec4(0.0); +vec4 R127f = 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; +R1f = vec2((passParameterSem1.x + passParameterSem2.x)/2, (passParameterSem1.y + passParameterSem1.w)/2); //center point +vec2 res = vec2( passParameterSem2.x - passParameterSem1.x, passParameterSem1.w - passParameterSem1.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); +float count = 0.0; +for( int x=-r; x<=r; x++ ) { + for( int y=-r; y<=r; y++ ) { + if( pow(x,2) + pow(y,2) <= pow(r,2) ) { + R2f += texture( textureUnitPS0, R1f + vec2(x,y)*res ); + count += 1.0; + } + } + } +PV0f.yxwz = R2f/count; + +R0f.x = (texture(textureUnitPS1, R0f.xy).x); +// 0 +backupReg0f = R0f.x; + +R127f.w = (mul_nonIEEE(backupReg0f,intBitsToFloat(uf_remappedPS[0].z)) + intBitsToFloat(uf_remappedPS[0].w)); +R127f.w = clamp(R127f.w, 0.0, 1.0); +PS0f = R127f.w; +// 1 + +R127f.z = mul_nonIEEE(PS0f, intBitsToFloat(uf_remappedPS[1].z)); +PS1f = R127f.z; +// 2 + +// 3 +PV1f.x = max(PV0f.w, 0.0); +PV1f.y = max(PV0f.y, 0.0); +PV1f.z = max(PV0f.z, 0.0); +PV1f.w = max(PV0f.x, 0.0); +// 4 +R127f.x = min(PV1f.y, intBitsToFloat(0x461c4000)); +PV0f.x = R127f.x; +R127f.y = min(PV1f.w, intBitsToFloat(0x461c4000)); +PV0f.y = R127f.y; +R126f.z = min(PV1f.x, intBitsToFloat(0x461c4000)); +PV0f.z = R126f.z; +R126f.w = min(PV1f.z, intBitsToFloat(0x461c4000)); +PV0f.w = R126f.w; +// 5 +tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(intBitsToFloat(uf_remappedPS[2].x),intBitsToFloat(uf_remappedPS[2].y),intBitsToFloat(uf_remappedPS[2].z),intBitsToFloat(uf_remappedPS[2].w))); +tempf.x = clamp(tempf.x, 0.0, 1.0); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 6 +R123f.y = (mul_nonIEEE(R127f.w,R127f.z) + PV1f.x); +PV0f.y = R123f.y; +// 7 +PV1f.x = mul_nonIEEE(PV0f.y, intBitsToFloat(uf_remappedPS[3].z)); +// 8 +R2f.x = mul_nonIEEE(R127f.x, PV1f.x); +R2f.y = mul_nonIEEE(R127f.y, PV1f.x); +R2f.z = mul_nonIEEE(R126f.z, PV1f.x); +R2f.w = mul_nonIEEE(R126f.w, PV1f.x); +// export +passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +} diff --git a/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt index 9fe7817e..656e8aeb 100644 --- a/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt +++ b/Quality/Splatoon_2160p/45d85f1d25e7d0de_0000000000000079_ps.txt @@ -1,29 +1,35 @@ #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; +// shader 45d85f1d25e7d0de // vertical blur 2160 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4601800 res 320x180x1 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 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); +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.10621973, 0.19485826, 0.13789364, 0.07373992, 0.02961301, 0.00884599, 0.00193931 ); +uniform float offset[] = float[]( 0.00000000, 1.47368421, 3.43859649, 5.40350877, 7.36842105, 9.33333333, 11.29824561 ); -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; +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]; + } + +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/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt index dff2978b..22e96a23 100644 --- a/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt +++ b/Quality/Splatoon_2160p/4dc5fdeced670c5e_0000000000000079_ps.txt @@ -1,28 +1,38 @@ #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; +// shader 4dc5fdeced670c5e // horizontal blur 2160 +layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf45c5000 res 320x180x1 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 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); +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.10621973, 0.19485826, 0.13789364, 0.07373992, 0.02961301, 0.00884599, 0.00193931 ); +uniform float offset[] = float[]( 0.00000000, 1.47368421, 3.43859649, 5.40350877, 7.36842105, 9.33333333, 11.29824561 ); -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 +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]; + } + +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 16 --reduce 16 25 --linear +//game original py blurninja.py --expand 2 --reduce 2 5 --linear \ No newline at end of file diff --git a/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt b/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt new file mode 100644 index 00000000..5a73adc6 --- /dev/null +++ b/Quality/Splatoon_2160p/9fad3b3505a6d831_0000000000000079_ps.txt @@ -0,0 +1,41 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 9fad3b3505a6d831 +// Used for: Horizontal Bloom 2160 +// 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; + +float data = passParameterSem0.z - passParameterSem0.w; +float h = data / 1.38461538 * uf_fragCoordScale.y; + +uniform float o_weight[] = float[]( 0.22558594, 0.31420898, 0.06982422, 0.00317383 ); +uniform float o_offset[] = float[]( 0.00000000, 1.38461538, 3.23076923, 5.07692308 ); + +uniform float weight[] = float[]( 0.10807685, 0.19765286, 0.13814447, 0.07221188, 0.02803520, 0.00799803, 0.00165142, 0.00024167, 0.00002435, 0.00000162, 0.00000007 ); +uniform float offset[] = float[]( 0.00000000, 1.47272727, 3.43636364, 5.40000000, 7.36363636, 9.32727273, 11.29090909, 13.25454545, 15.21818182, 17.18181818, 19.14545455 ); + +void main() +{ +vec2 R0f = vec2(passParameterSem0.w, passParameterSem0.x); + +vec4 R1f = texture( textureUnitPS0, R0f ) * weight[0]; +for (int i=1; i<11; i++) { + R1f += texture( textureUnitPS0, R0f + vec2(offset[i]*h, 0.0) ) * weight[i]; + R1f += texture( textureUnitPS0, R0f - vec2(offset[i]*h, 0.0) ) * weight[i]; + } + +vec4 R2f = texture( textureUnitPS0, R0f ) * o_weight[0]; +for (int i=1; i<4; i++) { + R2f += texture( textureUnitPS0, R0f + vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + R2f += texture( textureUnitPS0, R0f - vec2(o_offset[i]*h, 0.0) ) * o_weight[i]; + } + +passPixelColor0 = ( (uf_fragCoordScale.y == 1.0) ? R2f : R1f ); +} + +//py blurninja.py --expand 7 --reduce 7 41 --linear +// game original py blurninja.py --expand 0 --reduce 0 13 --linear \ No newline at end of file diff --git a/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt b/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt index 328aa41b..f36f837e 100644 --- a/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt +++ b/Quality/Splatoon_2160p/cb0e6e8cbec4502a_0000000000000079_ps.txt @@ -1,33 +1,22 @@ #version 420 #extension GL_ARB_texture_gather : enable -// shader cb0e6e8cbec4502a +// shader cb0e6e8cbec4502a // dof blur layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5c7b800 res 1280x720x1 dim 1 tm: 4 format 0816 compSel: 0 1 2 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler0 ClampX/Y/Z: 2 2 2 border: 1 layout(location = 0) in vec4 passParameterSem3; 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; } - void main() { -vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y+passParameterSem3.w)/2); //center point -ivec2 ires = textureSize(textureUnitPS0,0); -vec2 res = vec2( float(ires.x), float(ires.y) ); -int r = int(floor(2.0 / uf_fragCoordScale.y + 0.5)); +vec2 R0f = vec2((passParameterSem3.x + passParameterSem3.z)/2, (passParameterSem3.y + passParameterSem3.w)/2); //center point +vec2 res = vec2( passParameterSem3.x - passParameterSem3.z, passParameterSem3.w - passParameterSem3.y ) * uf_fragCoordScale; +int r = int(floor(1.0 / uf_fragCoordScale.y + 0.5)); vec4 R1f = vec4(0.0); float count = 0.0; for( int x=-r; x<=r; x++ ) { for( int y=-r; y<=r; y++ ) { if( pow(x,2) + pow(y,2) <= pow(r,2) ) { - R1f += texture( textureUnitPS0, R0f + vec2(x,y)/res ); + R1f += texture( textureUnitPS0, R0f + vec2(x,y)*res ); count += 1.0; } }