mirror of
https://github.com/cemu-project/cemu_graphic_packs.git
synced 2024-11-22 09:39:17 +01:00
b95bd222d2
Also removed the version indicator in Windwaker's contrasty file since any updates to that number would remove all the configuration set by the user for that pack.
289 lines
9.7 KiB
Plaintext
289 lines
9.7 KiB
Plaintext
#version 420
|
|
#extension GL_ARB_texture_gather : enable
|
|
// shader ff71dcd2ad4defdc
|
|
//AA ps
|
|
|
|
uniform vec2 uf_fragCoordScale;
|
|
|
|
const float hazeFactor = 0.1;
|
|
|
|
const float gamma = $gamma; // 1.0 is neutral Botw is already colour graded at this stage
|
|
const float exposure = $exposure; // 1.0 is neutral
|
|
const float vibrance = $vibrance; // 0.0 is neutral
|
|
const float crushContrast = $crushContrast; // 0.0 is neutral. Use small increments, loss of shadow detail
|
|
const float contrastCurve = $contrastCurve;
|
|
|
|
|
|
vec3 RGB_Lift = vec3($redShadows, $greenShadows , $blueSadows); // [0.000 to 2.000] Adjust shadows for Red, Green and Blue.
|
|
vec3 RGB_Gamma = vec3($redMid ,$greenMid, $blueMid); // [0.000 to 2.000] Adjust midtones for Red, Green and Blue
|
|
vec3 RGB_Gain = vec3($redHilight, $greenHilight, $blueHilight); // [0.000 to 2.000] Adjust highlights for Red, Green and Blue
|
|
//lumasharpen
|
|
const float sharp_mix = $sharp_mix;
|
|
const float sharp_strength = 2.0;
|
|
const float sharp_clamp = 0.75;
|
|
const float offset_bias = 1.0;
|
|
float Sigmoid (float x) {
|
|
|
|
return 1.0 / (1.0 + (exp(-(x - 0.5) * 5.5)));
|
|
}
|
|
|
|
|
|
#define px (1.0/1920.0*uf_fragCoordScale.x)
|
|
#define py (1.0/1080.0*uf_fragCoordScale.y)
|
|
#define CoefLuma vec3(0.2126, 0.7152, 0.0722)
|
|
|
|
float lumasharping(sampler2D tex, vec2 pos) {
|
|
vec4 colorInput = texture(tex, pos);
|
|
|
|
vec3 ori = colorInput.rgb;
|
|
|
|
// -- Combining the strength and luma multipliers --
|
|
vec3 sharp_strength_luma = (CoefLuma * sharp_strength);
|
|
|
|
// -- Gaussian filter --
|
|
// [ .25, .50, .25] [ 1 , 2 , 1 ]
|
|
// [ .50, 1, .50] = [ 2 , 4 , 2 ]
|
|
// [ .25, .50, .25] [ 1 , 2 , 1 ]
|
|
|
|
vec3 blur_ori = texture(tex, pos + vec2(px, -py) * 0.5 * offset_bias).rgb; // South East
|
|
blur_ori += texture(tex, pos + vec2(-px, -py) * 0.5 * offset_bias).rgb; // South West
|
|
blur_ori += texture(tex, pos + vec2(px, py) * 0.5 * offset_bias).rgb; // North East
|
|
blur_ori += texture(tex, pos + vec2(-px, py) * 0.5 * offset_bias).rgb; // North West
|
|
|
|
blur_ori *= 0.25; // ( /= 4) Divide by the number of texture fetches
|
|
|
|
// -- Calculate the sharpening --
|
|
vec3 sharp = ori - blur_ori; //Subtracting the blurred image from the original image
|
|
|
|
// -- Adjust strength of the sharpening and clamp it--
|
|
vec4 sharp_strength_luma_clamp = vec4(sharp_strength_luma * (0.5 / sharp_clamp), 0.5); //Roll part of the clamp into the dot
|
|
|
|
float sharp_luma = clamp((dot(vec4(sharp, 1.0), sharp_strength_luma_clamp)), 0.0, 1.0); //Calculate the luma, adjust the strength, scale up and clamp
|
|
sharp_luma = (sharp_clamp * 2.0) * sharp_luma - sharp_clamp; //scale down
|
|
|
|
return sharp_luma;
|
|
}
|
|
|
|
vec3 LiftGammaGainPass(vec3 colorInput)
|
|
{ //reshade BSD https://reshade.me , Alexkiri port
|
|
vec3 color = colorInput;
|
|
color = color * (1.5 - 0.5 * RGB_Lift) + 0.5 * RGB_Lift - 0.5;
|
|
color = clamp(color, 0.0, 1.0);
|
|
color *= RGB_Gain;
|
|
color = pow(color, 1.0 / RGB_Gamma);
|
|
return clamp(color, 0.0, 1.0);
|
|
}
|
|
|
|
vec3 contrasty(vec3 colour){
|
|
vec3 fColour = (colour.xyz);
|
|
//fColour = LiftGammaGainPass(fColour);
|
|
|
|
fColour = clamp(exposure * fColour, 0.0, 1.0);
|
|
fColour = pow(fColour, vec3(1.0 / gamma));
|
|
float luminance = fColour.r*0.299 + fColour.g*0.587 + fColour.b*0.114;
|
|
float mn = min(min(fColour.r, fColour.g), fColour.b);
|
|
float mx = max(max(fColour.r, fColour.g), fColour.b);
|
|
float sat = (1.0 - (mx - mn)) * (1.0 - mx) * luminance * 5.0;
|
|
vec3 lightness = vec3((mn + mx) / 2.0);
|
|
fColour = LiftGammaGainPass(fColour);
|
|
// vibrance
|
|
fColour = mix(fColour, mix(fColour, lightness, -vibrance), sat);
|
|
fColour = max(vec3(0.0), fColour - vec3(crushContrast));
|
|
return fColour;
|
|
}
|
|
|
|
|
|
const float resScale = 2.0;
|
|
uniform ivec4 uf_remappedPS[4];
|
|
layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf5807800 res 1920x1080x1 dim 1 tm: 4 format 0019 compSel: 0 1 2 3 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 0xf4000800 res 1920x1080x1 dim 1 tm: 4 format 0001 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 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){ 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 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;
|
|
bool activeMaskStack[2];
|
|
bool activeMaskStackC[3];
|
|
activeMaskStack[0] = false;
|
|
activeMaskStackC[0] = false;
|
|
activeMaskStackC[1] = false;
|
|
activeMaskStack[0] = true;
|
|
activeMaskStackC[0] = true;
|
|
activeMaskStackC[1] = true;
|
|
vec3 cubeMapSTM;
|
|
int cubeMapFaceId;
|
|
R0f = passParameterSem2;
|
|
if( activeMaskStackC[1] == true ) {
|
|
R1f.xyzw = (textureGather(textureUnitPS1, R0f.xy).wzxy);
|
|
R2f.xyzw = (texture(textureUnitPS0, R0f.xy).xyzw);
|
|
}
|
|
if( activeMaskStackC[1] == true ) {
|
|
activeMaskStack[1] = activeMaskStack[0];
|
|
activeMaskStackC[2] = activeMaskStackC[1];
|
|
// 0
|
|
PV0f.x = R1f.y + R1f.x;
|
|
R127f.y = intBitsToFloat(uf_remappedPS[0].z) * 0.25;
|
|
PV0f.z = R1f.w + -(R1f.x);
|
|
PV0f.w = R1f.z + -(R1f.y);
|
|
R127f.z = mul_nonIEEE(R2f.x, intBitsToFloat(uf_remappedPS[1].x));
|
|
PS0f = R127f.z;
|
|
// 1
|
|
R127f.x = PV0f.w + -(PV0f.z);
|
|
PV1f.x = R127f.x;
|
|
R126f.y = PV0f.w + PV0f.z;
|
|
PV1f.y = R126f.y;
|
|
PV1f.z = R1f.z + PV0f.x;
|
|
R127f.w = min(R1f.z, R1f.x);
|
|
R126f.w = min(R1f.w, R1f.y);
|
|
PS1f = R126f.w;
|
|
// 2
|
|
PV0f.x = R1f.w + PV1f.z;
|
|
PV0f.y = max(PV1f.x, -(PV1f.x));
|
|
PV0f.z = max(PV1f.y, -(PV1f.y));
|
|
PV0f.w = max(R1f.z, R1f.x);
|
|
PS0f = max(R1f.w, R1f.y);
|
|
// 3
|
|
PV1f.x = min(PV0f.z, PV0f.y);
|
|
R123f.y = (mul_nonIEEE(R2f.y,intBitsToFloat(uf_remappedPS[1].y)) + R127f.z);
|
|
PV1f.y = R123f.y;
|
|
R127f.z = min(R127f.w, R126f.w);
|
|
PV1f.z = R127f.z;
|
|
R123f.w = (mul_nonIEEE(R127f.y,PV0f.x) + intBitsToFloat(uf_remappedPS[0].w));
|
|
PV1f.w = R123f.w;
|
|
R127f.w = max(PV0f.w, PS0f);
|
|
PS1f = R127f.w;
|
|
// 4
|
|
PV0f.x = mul_nonIEEE(PS1f, intBitsToFloat(uf_remappedPS[2].x));
|
|
PV0f.y = max(PV1f.y, PS1f);
|
|
PV0f.z = min(PV1f.y, PV1f.z);
|
|
PV0f.w = max(PV1f.w, PV1f.x);
|
|
R4f.z = -(PV1f.z) + PS1f;
|
|
PS0f = R4f.z;
|
|
// 5
|
|
R3f.x = max(PV0f.x, intBitsToFloat(uf_remappedPS[2].y));
|
|
R3f.y = -(PV0f.z) + PV0f.y;
|
|
R4f.w = R127f.z + R127f.w;
|
|
PS1f = 1.0 / PV0f.w;
|
|
// 6
|
|
PV0f.x = mul_nonIEEE(R127f.x, PS1f); //p
|
|
PV0f.y = mul_nonIEEE(R126f.y, PS1f);
|
|
// 7
|
|
PV1f.z = max(PV0f.x, -(intBitsToFloat(uf_remappedPS[0].y))); //p
|
|
PV1f.w = max(PV0f.y, -(intBitsToFloat(uf_remappedPS[0].y)));
|
|
// 8
|
|
R1f.x = min(PV1f.w, intBitsToFloat(uf_remappedPS[0].y));
|
|
R1f.y = min(PV1f.z, intBitsToFloat(uf_remappedPS[0].y));
|
|
// 9
|
|
predResult = (R3f.y > R3f.x);
|
|
activeMaskStack[1] = predResult;
|
|
activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true;
|
|
}
|
|
else {
|
|
activeMaskStack[1] = false;
|
|
activeMaskStackC[2] = false;
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
// 0
|
|
R3f.x = (mul_nonIEEE(R1f.x,-(intBitsToFloat(uf_remappedPS[3].z) / resScale)) + R0f.x);
|
|
R3f.y = (mul_nonIEEE(R1f.y,-(intBitsToFloat(uf_remappedPS[3].w) / resScale)) + R0f.y);
|
|
R0f.z = (mul_nonIEEE(R1f.x,intBitsToFloat(uf_remappedPS[3].z)) + R0f.x); //leave out, looks better on avg
|
|
R0f.w = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[3].w)) + R0f.y);//leave out, looks better on avg
|
|
R4f.x = (mul_nonIEEE(R1f.x,-(intBitsToFloat(uf_remappedPS[3].x) / resScale)) + R0f.x);
|
|
PS0f = R4f.x;
|
|
// 1
|
|
R4f.y = (mul_nonIEEE(R1f.y,-(intBitsToFloat(uf_remappedPS[3].y)/resScale)) + R0f.y);
|
|
R3f.z = (mul_nonIEEE(R1f.x,intBitsToFloat(uf_remappedPS[3].x) / resScale) + R0f.x);
|
|
R3f.w = (mul_nonIEEE(R1f.y,intBitsToFloat(uf_remappedPS[3].y) / resScale) + R0f.y);
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
R1f.xyzw = (texture(textureUnitPS0, R0f.zw).xyzw);
|
|
R0f.xyzw = (texture(textureUnitPS0, R3f.xy).xyzw);
|
|
R2f.xyzw = (texture(textureUnitPS0, R4f.xy).xyzw);
|
|
R3f.xyzw = (texture(textureUnitPS0, R3f.zw).xyzw);
|
|
}
|
|
if( activeMaskStackC[2] == true ) {
|
|
// 0
|
|
R127f.xyz = vec3(R0f.x,R0f.w,R0f.z) + vec3(R1f.x,R1f.w,R1f.z);
|
|
PV0f.x = R127f.x;
|
|
PV0f.y = R127f.y;
|
|
PV0f.z = R127f.z;
|
|
R127f.w = R0f.y + R1f.y;
|
|
PV0f.w = R127f.w;
|
|
// 1
|
|
PV1f.x = R2f.x + PV0f.x;
|
|
PV1f.y = R2f.w + PV0f.y;
|
|
PV1f.z = R2f.z + PV0f.z;
|
|
PV1f.w = R2f.y + PV0f.w;
|
|
// 2
|
|
R126f.x = R3f.x + PV1f.x;
|
|
R126f.x /= 2.0;
|
|
PV0f.x = R126f.x;
|
|
R126f.y = R3f.w + PV1f.y;
|
|
R126f.y /= 2.0;
|
|
PV0f.y = R126f.y;
|
|
R126f.z = R3f.z + PV1f.z;
|
|
R126f.z /= 2.0;
|
|
PV0f.z = R126f.z;
|
|
R126f.w = R3f.y + PV1f.w;
|
|
R126f.w /= 2.0;
|
|
PV0f.w = R126f.w;
|
|
// 3
|
|
backupReg0f = R127f.y;
|
|
R123f.x = (mul_nonIEEE(PV0f.x,intBitsToFloat(uf_remappedPS[1].x)) + -(R4f.w));
|
|
PV1f.x = R123f.x;
|
|
R127f.yzw = vec3(R127f.z,R127f.w,R127f.x) + vec3(-(PV0f.z),-(PV0f.w),-(PV0f.x));
|
|
R127f.x = backupReg0f + -(PV0f.y);
|
|
PS1f = R127f.x;
|
|
// 4
|
|
R123f.w = (mul_nonIEEE(R126f.w,intBitsToFloat(uf_remappedPS[1].y)) + PV1f.x);
|
|
PV0f.w = R123f.w;
|
|
// 5
|
|
PV1f.z = max(PV0f.w, -(PV0f.w));
|
|
// 6
|
|
PV0f.y = -(R4f.z) + PV1f.z;
|
|
// 7
|
|
R123f.x = intBitsToFloat(((PV0f.y >= 0.0)?(floatBitsToInt(1.0)):(0)));
|
|
PV1f.x = R123f.x;
|
|
// 8
|
|
R2f.x = (mul_nonIEEE(R127f.w,PV1f.x) + R126f.x)/2.0;
|
|
R2f.y = (mul_nonIEEE(R127f.z,PV1f.x) + R126f.w)/2.0;
|
|
R2f.z = (mul_nonIEEE(R127f.y,PV1f.x) + R126f.z)/2.0;
|
|
R2f.w = (mul_nonIEEE(R127f.x,PV1f.x) + R126f.y)/2.0;
|
|
}
|
|
activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true;
|
|
// export
|
|
|
|
R2f.xyz = contrasty(R2f.xyz);
|
|
R2f.xyz = mix(R2f.xyz, smoothstep(0.0, 1.0, R2f.xyz), contrastCurve);
|
|
float smask = lumasharping(textureUnitPS1, passParameterSem2.xy);
|
|
vec3 temp3 = R2f.xyz;
|
|
R2f.xyz = mix(R2f.xyz, (temp3.xyz += (smask)), sharp_mix);
|
|
|
|
passPixelColor0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w);
|
|
}
|