[TPHD] Misc quality tweaks for high resolution , QL
TPHD QL tweaks aka, sunday gaming delayed
Resolution
* Sharper, unscaled blur fixed. See contrasty note
* Resolutions 4k and above scale sub viewports 75-> 50% of the main res.
7680x4320 is now 30 fps stable on a 1070, SSAA looks sweet.
* Added some off-aspect custom res with horizontal res x2. Good for SSAA
fixing shimmering as it's mostly horizontal in TPHD
Contrasty
* Sharper, unscaled blur fixed. Note, contrasty must be pre-selected at
start to override same shader in resolution folder
* Minor tweaks to cold setting
Fancy FX
*Added option to disable blur, just keeping other tweaks active.
Realized that half scaling sub-view port mostly replaces fancy fX :/
*Tweaked to somewhat scale, tries to emulate original look by default.
Ie 4x res = 4x blur "qualitative look" (not the same as nr of passes)
*Added "defocus" looks blurrier by scaling incorrectly, masked by more
draw passes. This is similar to the old default
Not happy about the results of moving blur from res folder, too many
drawbacks as quality of scaling really needs to be per-setting.
Will probably deprecate if things start to break again. Maybe global
variables in the future?
2019-01-21 00:13:06 +01:00
|
|
|
#version 420
|
|
|
|
#extension GL_ARB_texture_gather : enable
|
|
|
|
#extension GL_ARB_separate_shader_objects : enable
|
2020-01-18 18:11:34 +01:00
|
|
|
#ifdef VULKAN
|
|
|
|
#define ATTR_LAYOUT(__vkSet, __location) layout(set = __vkSet, location = __location)
|
|
|
|
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation, std140)
|
|
|
|
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(set = __vkSet, binding = __vkLocation)
|
|
|
|
#define SET_POSITION(_v) gl_Position = _v; gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0
|
|
|
|
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)
|
|
|
|
#define gl_VertexID gl_VertexIndex
|
|
|
|
#define gl_InstanceID gl_InstanceIndex
|
|
|
|
#else
|
|
|
|
#define ATTR_LAYOUT(__vkSet, __location) layout(location = __location)
|
|
|
|
#define UNIFORM_BUFFER_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation, std140)
|
|
|
|
#define TEXTURE_LAYOUT(__glLocation, __vkSet, __vkLocation) layout(binding = __glLocation)
|
|
|
|
#define SET_POSITION(_v) gl_Position = _v
|
|
|
|
#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale,gl_FragCoord.zw)
|
|
|
|
#endif
|
|
|
|
// This shader was automatically converted to be cross-compatible with Vulkan and OpenGL.
|
|
|
|
|
[TPHD] Misc quality tweaks for high resolution , QL
TPHD QL tweaks aka, sunday gaming delayed
Resolution
* Sharper, unscaled blur fixed. See contrasty note
* Resolutions 4k and above scale sub viewports 75-> 50% of the main res.
7680x4320 is now 30 fps stable on a 1070, SSAA looks sweet.
* Added some off-aspect custom res with horizontal res x2. Good for SSAA
fixing shimmering as it's mostly horizontal in TPHD
Contrasty
* Sharper, unscaled blur fixed. Note, contrasty must be pre-selected at
start to override same shader in resolution folder
* Minor tweaks to cold setting
Fancy FX
*Added option to disable blur, just keeping other tweaks active.
Realized that half scaling sub-view port mostly replaces fancy fX :/
*Tweaked to somewhat scale, tries to emulate original look by default.
Ie 4x res = 4x blur "qualitative look" (not the same as nr of passes)
*Added "defocus" looks blurrier by scaling incorrectly, masked by more
draw passes. This is similar to the old default
Not happy about the results of moving blur from res folder, too many
drawbacks as quality of scaling really needs to be per-setting.
Will probably deprecate if things start to break again. Maybe global
variables in the future?
2019-01-21 00:13:06 +01:00
|
|
|
// shader c14019840473ff86
|
|
|
|
//scale boxblur fx
|
|
|
|
|
2020-01-18 18:11:34 +01:00
|
|
|
TEXTURE_LAYOUT(0, 1, 0) uniform sampler2D textureUnitPS0;
|
|
|
|
TEXTURE_LAYOUT(1, 1, 1) uniform sampler2D textureUnitPS1;
|
[TPHD] Misc quality tweaks for high resolution , QL
TPHD QL tweaks aka, sunday gaming delayed
Resolution
* Sharper, unscaled blur fixed. See contrasty note
* Resolutions 4k and above scale sub viewports 75-> 50% of the main res.
7680x4320 is now 30 fps stable on a 1070, SSAA looks sweet.
* Added some off-aspect custom res with horizontal res x2. Good for SSAA
fixing shimmering as it's mostly horizontal in TPHD
Contrasty
* Sharper, unscaled blur fixed. Note, contrasty must be pre-selected at
start to override same shader in resolution folder
* Minor tweaks to cold setting
Fancy FX
*Added option to disable blur, just keeping other tweaks active.
Realized that half scaling sub-view port mostly replaces fancy fX :/
*Tweaked to somewhat scale, tries to emulate original look by default.
Ie 4x res = 4x blur "qualitative look" (not the same as nr of passes)
*Added "defocus" looks blurrier by scaling incorrectly, masked by more
draw passes. This is similar to the old default
Not happy about the results of moving blur from res folder, too many
drawbacks as quality of scaling really needs to be per-setting.
Will probably deprecate if things start to break again. Maybe global
variables in the future?
2019-01-21 00:13:06 +01:00
|
|
|
layout(location = 0) in vec4 passParameterSem0;
|
|
|
|
layout(location = 0) out vec4 passPixelColor0;
|
2020-01-18 18:11:34 +01:00
|
|
|
#ifdef VULKAN
|
|
|
|
layout(set = 1, binding = 2) uniform ufBlock
|
|
|
|
{
|
|
|
|
uniform vec4 uf_fragCoordScale;
|
|
|
|
};
|
|
|
|
#else
|
[TPHD] Misc quality tweaks for high resolution , QL
TPHD QL tweaks aka, sunday gaming delayed
Resolution
* Sharper, unscaled blur fixed. See contrasty note
* Resolutions 4k and above scale sub viewports 75-> 50% of the main res.
7680x4320 is now 30 fps stable on a 1070, SSAA looks sweet.
* Added some off-aspect custom res with horizontal res x2. Good for SSAA
fixing shimmering as it's mostly horizontal in TPHD
Contrasty
* Sharper, unscaled blur fixed. Note, contrasty must be pre-selected at
start to override same shader in resolution folder
* Minor tweaks to cold setting
Fancy FX
*Added option to disable blur, just keeping other tweaks active.
Realized that half scaling sub-view port mostly replaces fancy fX :/
*Tweaked to somewhat scale, tries to emulate original look by default.
Ie 4x res = 4x blur "qualitative look" (not the same as nr of passes)
*Added "defocus" looks blurrier by scaling incorrectly, masked by more
draw passes. This is similar to the old default
Not happy about the results of moving blur from res folder, too many
drawbacks as quality of scaling really needs to be per-setting.
Will probably deprecate if things start to break again. Maybe global
variables in the future?
2019-01-21 00:13:06 +01:00
|
|
|
uniform vec2 uf_fragCoordScale;
|
2020-01-18 18:11:34 +01:00
|
|
|
#endif
|
[TPHD] Misc quality tweaks for high resolution , QL
TPHD QL tweaks aka, sunday gaming delayed
Resolution
* Sharper, unscaled blur fixed. See contrasty note
* Resolutions 4k and above scale sub viewports 75-> 50% of the main res.
7680x4320 is now 30 fps stable on a 1070, SSAA looks sweet.
* Added some off-aspect custom res with horizontal res x2. Good for SSAA
fixing shimmering as it's mostly horizontal in TPHD
Contrasty
* Sharper, unscaled blur fixed. Note, contrasty must be pre-selected at
start to override same shader in resolution folder
* Minor tweaks to cold setting
Fancy FX
*Added option to disable blur, just keeping other tweaks active.
Realized that half scaling sub-view port mostly replaces fancy fX :/
*Tweaked to somewhat scale, tries to emulate original look by default.
Ie 4x res = 4x blur "qualitative look" (not the same as nr of passes)
*Added "defocus" looks blurrier by scaling incorrectly, masked by more
draw passes. This is similar to the old default
Not happy about the results of moving blur from res folder, too many
drawbacks as quality of scaling really needs to be per-setting.
Will probably deprecate if things start to break again. Maybe global
variables in the future?
2019-01-21 00:13:06 +01:00
|
|
|
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()
|
|
|
|
{
|
|
|
|
vec4 R0f = vec4(0.0);
|
|
|
|
vec4 R1f = vec4(0.0);
|
|
|
|
vec4 R2f = vec4(0.0);
|
|
|
|
vec4 R3f = vec4(0.0);
|
|
|
|
vec4 R123f = 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;
|
|
|
|
float scaler;
|
|
|
|
R0f = passParameterSem0;
|
|
|
|
scaler = uf_fragCoordScale.x;
|
|
|
|
R0f.w = (textureGather(textureUnitPS1, R0f.xy).y);
|
|
|
|
// 0
|
|
|
|
R1f.x = R0f.x + intBitsToFloat(0xba088889);
|
|
|
|
R1f.y = R0f.y + intBitsToFloat(0xba72b9d6);
|
|
|
|
R2f.z = R0f.x;
|
|
|
|
R2f.y = R0f.y + intBitsToFloat(0xba72b9d6);
|
|
|
|
PS0f = R2f.y;
|
|
|
|
// 1
|
|
|
|
R3f.x = R0f.x + intBitsToFloat(0xba088889);
|
|
|
|
R3f.y = R0f.y;
|
|
|
|
R1f.xyzw = (textureGather(textureUnitPS1, R1f.xy).xyzw);
|
|
|
|
R2f.yz = (textureGather(textureUnitPS1, R2f.zy).yz);
|
|
|
|
R3f.xy = (textureGather(textureUnitPS1, R3f.xy).xy);
|
|
|
|
// 0
|
|
|
|
PV0f.x = R2f.z + R3f.x;
|
|
|
|
PV0f.y = R1f.w + R0f.w;
|
|
|
|
PV0f.z = R1f.z + R3f.y;
|
|
|
|
PV0f.w = R1f.x + R2f.y;
|
|
|
|
// 1
|
|
|
|
R123f.x = (R1f.y * 2.0 + -(PV0f.x));
|
|
|
|
PV1f.x = R123f.x;
|
|
|
|
R123f.y = (R1f.y * 2.0 + -(PV0f.y));
|
|
|
|
PV1f.y = R123f.y;
|
|
|
|
R123f.z = (R1f.y * 2.0 + -(PV0f.z));
|
|
|
|
PV1f.z = R123f.z;
|
|
|
|
R123f.w = (R1f.y * 2.0 + -(PV0f.w));
|
|
|
|
PV1f.w = R123f.w;
|
|
|
|
// 2
|
|
|
|
PV0f.x = max(PV1f.x, -(PV1f.x));
|
|
|
|
PV0f.y = max(PV1f.y, -(PV1f.y));
|
|
|
|
PV0f.z = max(PV1f.z, -(PV1f.z));
|
|
|
|
PV0f.w = max(PV1f.w, -(PV1f.w));
|
|
|
|
// 3
|
|
|
|
PV1f.x = PV0f.x + intBitsToFloat(0xb400d959);
|
|
|
|
PV1f.y = PV0f.y + intBitsToFloat(0xb400d959);
|
|
|
|
PV1f.z = PV0f.z + intBitsToFloat(0xb400d959);
|
|
|
|
PV1f.w = PV0f.w + intBitsToFloat(0xb400d959);
|
|
|
|
// 4
|
|
|
|
R123f.x = intBitsToFloat(((PV1f.w >= 0.0)?(floatBitsToInt(1.0)):(0)));
|
|
|
|
PV0f.x = R123f.x;
|
|
|
|
R123f.y = intBitsToFloat(((PV1f.z >= 0.0)?(floatBitsToInt(1.0)):(0)));
|
|
|
|
PV0f.y = R123f.y;
|
|
|
|
R123f.z = intBitsToFloat(((PV1f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
|
|
|
|
PV0f.z = R123f.z;
|
|
|
|
R123f.w = intBitsToFloat(((PV1f.x >= 0.0)?(floatBitsToInt(1.0)):(0)));
|
|
|
|
PV0f.w = R123f.w;
|
|
|
|
// 5
|
|
|
|
tempf.x = dot(vec4(PV0f.x,PV0f.y,PV0f.z,PV0f.w),vec4(0.25*scaler,0.25*scaler,0.25*scaler,0.25*scaler));
|
|
|
|
PV1f.x = tempf.x;
|
|
|
|
PV1f.y = tempf.x;
|
|
|
|
PV1f.z = tempf.x;
|
|
|
|
PV1f.w = tempf.x;
|
|
|
|
// 6
|
|
|
|
R127f.z = PV1f.x * intBitsToFloat(0x3f400000);
|
|
|
|
PV0f.z = R127f.z;
|
|
|
|
// 7
|
|
|
|
R1f.x = (PV0f.z * intBitsToFloat(0xba088889) + R0f.x);
|
|
|
|
R1f.y = R0f.y;
|
|
|
|
R2f.z = R0f.x;
|
|
|
|
R2f.y = (PV0f.z * intBitsToFloat(0xba72b9d6) + R0f.y);
|
|
|
|
PS1f = R2f.y;
|
|
|
|
// 8
|
|
|
|
R3f.x = (R127f.z * intBitsToFloat(0x3a088889) + R0f.x);
|
|
|
|
R3f.y = R0f.y;
|
|
|
|
R0f.w = (R127f.z * intBitsToFloat(0x3a72b9d6) + R0f.y);
|
|
|
|
R1f.xyzw = (texture(textureUnitPS0, R1f.xy).xyzw);
|
|
|
|
R2f.xyzw = (texture(textureUnitPS0, R2f.zy).xyzw);
|
|
|
|
R3f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
|
|
|
|
R0f.xyzw = (texture(textureUnitPS0, R0f.xw).xyzw);
|
|
|
|
// 0
|
|
|
|
PV0f.x = R1f.w + R2f.w;
|
|
|
|
PV0f.y = R1f.z + R2f.z;
|
|
|
|
PV0f.z = R1f.y + R2f.y;
|
|
|
|
PV0f.w = R1f.x + R2f.x;
|
|
|
|
// 1
|
|
|
|
PV1f.x = R3f.w + PV0f.x;
|
|
|
|
PV1f.y = R3f.z + PV0f.y;
|
|
|
|
PV1f.z = R3f.y + PV0f.z;
|
|
|
|
PV1f.w = R3f.x + PV0f.w;
|
|
|
|
// 2
|
|
|
|
backupReg0f = R0f.y;
|
|
|
|
backupReg1f = R0f.x;
|
|
|
|
PV0f.x = R0f.w + PV1f.x;
|
|
|
|
PV0f.y = R0f.z + PV1f.y;
|
|
|
|
PV0f.z = backupReg0f + PV1f.z;
|
|
|
|
PV0f.w = backupReg1f + PV1f.w;
|
|
|
|
// 3
|
|
|
|
R0f.x = PV0f.w * 0.25;
|
|
|
|
R0f.y = PV0f.z * 0.25;
|
|
|
|
R0f.z = PV0f.y * 0.25;
|
|
|
|
R0f.w = PV0f.x * 0.25;
|
|
|
|
// export
|
|
|
|
passPixelColor0 = vec4(R0f.x, R0f.y, R0f.z, R0f.w);
|
|
|
|
}
|