From 6331abdc50907d27e922c3ec78060cbb1718790a Mon Sep 17 00:00:00 2001 From: getdls Date: Mon, 27 Nov 2017 23:05:06 +0100 Subject: [PATCH] [XCX] Colour banding fix, godray stencil, AA and brightness tweaks Add - God ray stencil scaling. Actually does improve quality.. just hard to notice Fix - Sky colour banding, increase depth + dithering Improve - Brightness truncation banding, increase depth + dithering Improve - AA "fix" edges was still using old logic --- .../59df1c7e1806366c_00000000000003c9_ps.txt | 2 +- .../810cde937ebbdf9f_000000000000000f_ps.txt | 127 ++++++++++++++++++ Source/XenobladeX/rules.txt | 10 +- .../3cc7e98f78c258b4_00000000000003ca_ps.txt | 17 ++- .../d936195db0dd8e7d_0000000000001e52_ps.txt | 16 ++- 5 files changed, 162 insertions(+), 10 deletions(-) create mode 100644 Source/XenobladeX/810cde937ebbdf9f_000000000000000f_ps.txt diff --git a/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt b/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt index 49d1cd0a..82f7b29a 100644 --- a/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt +++ b/Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt @@ -61,7 +61,7 @@ R0i = floatBitsToInt(passParameterSem0); R1i = floatBitsToInt(passParameterSem1); if( activeMaskStackC[1] == true ) { //R2i.xyzw = floatBitsToInt(textureGather(textureUnitPS0, intBitsToFloat(R0i.zw)).xyzw); // cemu bug? Review later -R0i.x = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).x); // edge blur/chromatic +//R0i.x = floatBitsToInt(texture(textureUnitPS0, intBitsToFloat(R1i.xy)).x); // edge blur/chromatic } if( activeMaskStackC[1] == true ) { activeMaskStack[1] = activeMaskStack[0]; diff --git a/Source/XenobladeX/810cde937ebbdf9f_000000000000000f_ps.txt b/Source/XenobladeX/810cde937ebbdf9f_000000000000000f_ps.txt new file mode 100644 index 00000000..708ef2ee --- /dev/null +++ b/Source/XenobladeX/810cde937ebbdf9f_000000000000000f_ps.txt @@ -0,0 +1,127 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +// shader 810cde937ebbdf9f // Tiny rand dithering fixing sky banding +// To-do incremental seed would be lovely... except from using previous pass as input I have no idea.. +uniform ivec4 uf_remappedPS[5]; +layout(location = 0) in vec4 passParameterSem0; +layout(location = 0) out vec4 passPixelColor0; +uniform vec2 uf_fragCoordScale; + +highp float lineRand(vec2 co) +{ + highp float a = 12.9898; + highp float b = 78.233; + highp float c = 43758.5453; + highp float dt = dot(co.xy, vec2(a, b)); + highp float sn = mod(dt, 3.14); + return fract(sin(sn) * c); +} + +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); +vec4 R1f = 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; +R0f.xy = R0f.xy - (lineRand(gl_FragCoord.xy)*0.015); +// 0 +backupReg0f = R0f.x; +backupReg0f = R0f.x; +backupReg1f = R0f.y; +backupReg1f = R0f.y; +backupReg2f = R0f.z; +backupReg2f = R0f.z; +tempf.x = dot(vec4(backupReg0f,backupReg1f,backupReg2f,-0.0),vec4(backupReg0f,backupReg1f,backupReg2f,0.0)); +PV0f.x = tempf.x; +PV0f.y = tempf.x; +PV0f.z = tempf.x; +PV0f.w = tempf.x; +R1f.w = 1.0; +PS0f = R1f.w; +// 1 +tempResultf = 1.0 / sqrt(PV0f.x); +PS1f = tempResultf; +// 2 +R127f.x = R0f.x * PS1f; +PV0f.x = R127f.x; +R127f.y = R0f.y * PS1f; +PV0f.y = R127f.y; +R127f.z = R0f.z * PS1f; +PV0f.z = R127f.z; +// 3 +tempf.x = dot(vec4(intBitsToFloat(uf_remappedPS[0].x),intBitsToFloat(uf_remappedPS[0].y),intBitsToFloat(uf_remappedPS[0].z),-0.0),vec4(PV0f.x,PV0f.y,PV0f.z,0.0)); +PV1f.x = tempf.x; +PV1f.y = tempf.x; +PV1f.z = tempf.x; +PV1f.w = tempf.x; +// 4 +PV0f.x = intBitsToFloat(uf_remappedPS[1].z) * R127f.z; +PV0f.w = max(PV1f.x, -(PV1f.x)); +// 5 +R123f.x = (intBitsToFloat(uf_remappedPS[1].y) * R127f.y + PV0f.x); +PV1f.x = R123f.x; +R127f.z = -(PV0f.w) + 1.0; +R127f.z = clamp(R127f.z, 0.0, 1.0); +PV1f.z = R127f.z; +// 6 +R123f.w = (intBitsToFloat(uf_remappedPS[1].x) * R127f.x + PV1f.x); +R123f.w = clamp(R123f.w, 0.0, 1.0); +PV0f.w = R123f.w; +tempResultf = log2(PV1f.z); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0f = tempResultf; +// 7 +PV1f.x = PS0f * intBitsToFloat(uf_remappedPS[2].w); +tempResultf = log2(PV0f.w); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1f = tempResultf; +// 8 +PV0f.y = PS1f * intBitsToFloat(uf_remappedPS[3].w); +R127f.w = exp2(PV1f.x); +PS0f = R127f.w; +// 9 +R127f.x = (R127f.z * intBitsToFloat(0x3f733333) + -(PS0f)); +PV1f.z = PS0f + -(intBitsToFloat(0x3f4ccccd)); +R126f.x = exp2(PV0f.y); +PS1f = R126f.x; +// 10 +PV0f.y = PV1f.z * intBitsToFloat(0x40a00000); +PV0f.y = clamp(PV0f.y, 0.0, 1.0); +// 11 +backupReg0f = R127f.w; +R127f.w = (R127f.x * PV0f.y + backupReg0f); +PV1f.w = R127f.w; +// 12 +R127f.y = (PV1f.w * intBitsToFloat(uf_remappedPS[2].y) + intBitsToFloat(uf_remappedPS[4].y)); +R127f.z = (PV1f.w * intBitsToFloat(uf_remappedPS[2].x) + intBitsToFloat(uf_remappedPS[4].x)); +// 13 +R123f.x = (R127f.w * intBitsToFloat(uf_remappedPS[2].z) + intBitsToFloat(uf_remappedPS[4].z)); +PV1f.x = R123f.x; +// 14 +R1f.x = (R126f.x * intBitsToFloat(uf_remappedPS[3].x) + R127f.z); +R1f.y = (R126f.x * intBitsToFloat(uf_remappedPS[3].y) + R127f.y); +R1f.z = (R126f.x * intBitsToFloat(uf_remappedPS[3].z) + PV1f.x); +// export +passPixelColor0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +} diff --git a/Source/XenobladeX/rules.txt b/Source/XenobladeX/rules.txt index c3e25e76..02d11f18 100644 --- a/Source/XenobladeX/rules.txt +++ b/Source/XenobladeX/rules.txt @@ -72,11 +72,11 @@ height = 288 overwriteWidth = overwriteHeight = -#[TextureRedefine] # "God rays" size (not quality), lens reflections. -#width = 256 -#height = 144 -#overwriteWidth = -#overwriteHeight = +[TextureRedefine] # "God rays" stencil res, lens reflections. +width = 256 +height = 144 +overwriteWidth = +overwriteHeight = [TextureRedefine]# Probe glow. Does not increase sample amount, only scales up width = 160 diff --git a/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt b/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt index c4dfeb33..b7768ffe 100644 --- a/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt +++ b/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt @@ -4,14 +4,25 @@ // To-do, .5 is daylight and 1.0 night is wiiu "correct" for nvidia // changes here in turn "breaks" bloom as they over or under expose depending on day/night -const float preExposure = 0.75; // old brigntess tweak. Truncates at around .45+ +const float preExposure = 0.65; // old brigntess tweak. Truncates at around .45+ const float gammaPostExposure = 0.9; // compensate pre exposure, but loss of contrast when positive. uniform ivec4 uf_remappedPS[1]; + layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf470a000 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: 0 layout(binding = 1) uniform sampler3D textureUnitPS1;// Tex1 addr 0x2603b000 res 16x16x16 dim 2 tm: 7 format 001a compSel: 0 1 2 3 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x10) Sampler1 ClampX/Y/Z: 2 2 2 border: 0 layout(location = 0) in vec4 passParameterSem0; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; +highp float lineRand(vec2 co) +{ + highp float a = 12.9898; + highp float b = 78.233; + highp float c = 43758.5453; + highp float dt = dot(co.xy, vec2(a, b)); + highp float sn = mod(dt, 3.14); + return fract(sin(sn) * c); +} + int clampFI32(int v) { if( v == 0x7FFFFFFF ) @@ -37,7 +48,9 @@ bool predResult = true; vec3 cubeMapSTM; int cubeMapFaceId; R0f = passParameterSem0; -R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) * preExposure; + +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) * (preExposure -(lineRand(gl_FragCoord.xy)*0.02)); +//R0f.xyz = R0f.xyz - (lineRand(gl_FragCoord.xy)*0.1); // 0 R127f.x = R0f.z * intBitsToFloat(uf_remappedPS[0].x); R127f.x = clamp(R127f.x, 0.0, 1.0); diff --git a/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt b/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt index 3e53c688..bfe2f33b 100644 --- a/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt +++ b/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt @@ -4,7 +4,7 @@ // cross fade brightness // To-do, .5 is daylight and 1.0 night is wiiu "correct" for nvidia // changes here in turn "breaks" bloom as they over or under expose depending on day/night -const float preExposure = 0.75; // old brigntess tweak. Truncates at around .45+ +const float preExposure = 0.65; // old brigntess tweak. Truncates at around .45+ const float gammaPostExposure = 0.9; // compensate pre exposure, but loss of contrast when positive. uniform ivec4 uf_remappedPS[1]; @@ -14,6 +14,17 @@ layout(binding = 2) uniform sampler3D textureUnitPS2;// Tex2 addr 0x2603b000 res layout(location = 0) in vec4 passParameterSem0; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; + +highp float lineRand(vec2 co) +{ + highp float a = 12.9898; + highp float b = 78.233; + highp float c = 43758.5453; + highp float dt = dot(co.xy, vec2(a, b)); + highp float sn = mod(dt, 3.14); + return fract(sin(sn) * c); +} + int clampFI32(int v) { if( v == 0x7FFFFFFF ) @@ -40,7 +51,8 @@ bool predResult = true; vec3 cubeMapSTM; int cubeMapFaceId; R0f = passParameterSem0; -R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) *preExposure; +R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) * (preExposure -(lineRand(gl_FragCoord.yx)*0.02)); +//R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz) *preExposure; // 0 backupReg0f = R0f.x; PV0f.x = backupReg0f * intBitsToFloat(uf_remappedPS[0].x);