From c10123ff26c0a4e31855947707afb0223c6fcec8 Mon Sep 17 00:00:00 2001 From: alexkiri Date: Thu, 5 Oct 2017 17:57:30 +0300 Subject: [PATCH] FXAA pack improvements; Integrated Contrasty, better FXAA, less blurry(#92) Pull request #92 * Added resolution independent FXAA for BotW * Renamed to give FXAA priority over base graphics packs * Updated FXAA implementation. Integrated Contrasty. * Sharper default settings, to make it look better at native res. Contrasty isn't on by default, you can change it by editing `f14bb57cd5c9cb77_00000000000003c9_ps.txt` and changing ``` #define ENABLE_CONTRASTY 0 ``` to ``` #define ENABLE_CONTRASTY 1 ``` in the graphic pack. --- .../0f2b9ee517917425_00000000000003c9_ps.txt | 242 +++++++++++++--- .../f14bb57cd5c9cb77_00000000000003c9_ps.txt | 272 +++++++++++++++--- 2 files changed, 428 insertions(+), 86 deletions(-) diff --git a/Enhancement/BreathOfTheWild_0FXAA/0f2b9ee517917425_00000000000003c9_ps.txt b/Enhancement/BreathOfTheWild_0FXAA/0f2b9ee517917425_00000000000003c9_ps.txt index 2011f09a..f7796635 100644 --- a/Enhancement/BreathOfTheWild_0FXAA/0f2b9ee517917425_00000000000003c9_ps.txt +++ b/Enhancement/BreathOfTheWild_0FXAA/0f2b9ee517917425_00000000000003c9_ps.txt @@ -3,7 +3,16 @@ // shader 0f2b9ee517917425 //replaces broken aa in inventory screen with fxaa. //original shader dumped using cemu 1.9.1, BotW 1.3.1 -//credit goes to https://gist.github.com/sakrist/7912905 +//credit for fxaa implementation http://blog.simonrodriguez.fr/articles/30-07-2016_implementing_fxaa.html + +#define ENABLE_FXAA 1 + +const float EDGE_THRESHOLD_MIN = 0.04; +const float EDGE_THRESHOLD_MAX = 0.125; +const float SUBPIXEL_QUALITY = 0.5; +const float[] QUALITY = {1.5, 2.0, 2.0, 2.0, 2.0, 4.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0}; +const int ITERATIONS = 12; + uniform ivec4 uf_remappedPS[2]; layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf49b1800 res 1280x720x1 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 0x38784000 res 1280x720x1 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 @@ -11,60 +20,205 @@ layout(location = 0) in vec4 passParameterSem2; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; -const float FXAA_SPAN_MAX = 8.0; -const float FXAA_REDUCE_MUL = 1.0 / 8.0; -const float FXAA_REDUCE_MIN = 1.0 / 128.0; -const ivec2 res = textureSize(textureUnitPS0,0); -const vec2 frameBufSize = vec2( float(res.x), float(res.y) ); +float rgb2luma(vec3 rgb) { + return sqrt(dot(rgb, vec3(0.299, 0.587, 0.114))); +} void main(void) { vec2 texCoords = passParameterSem2.xy; - vec3 rgbNW = texture2D(textureUnitPS0, texCoords + (vec2(-1.0, -1.0) / frameBufSize)).xyz; - vec3 rgbNE = texture2D(textureUnitPS0, texCoords + (vec2(1.0, -1.0) / frameBufSize)).xyz; - vec3 rgbSW = texture2D(textureUnitPS0, texCoords + (vec2(-1.0, 1.0) / frameBufSize)).xyz; - vec3 rgbSE = texture2D(textureUnitPS0, texCoords + (vec2(1.0, 1.0) / frameBufSize)).xyz; - vec3 rgbM = texture2D(textureUnitPS0, texCoords).xyz; + vec3 colorCenter = texture(textureUnitPS0, texCoords).rgb; + passPixelColor0.rgb = colorCenter; - vec3 luma = vec3(0.299, 0.587, 0.114); - float lumaNW = dot(rgbNW, luma); - float lumaNE = dot(rgbNE, luma); - float lumaSW = dot(rgbSW, luma); - float lumaSE = dot(rgbSE, luma); - float lumaM = dot(rgbM, luma); +#if (ENABLE_FXAA == 1) + ivec2 texSize = textureSize(textureUnitPS0, 0); + vec2 framebufferSize = vec2(float(texSize.x), float(texSize.y)); + vec2 invFramebufferSize = vec2(1.0 / framebufferSize.x, 1.0 / framebufferSize.y); + + // Luma at the current fragment + float lumaCenter = rgb2luma(colorCenter); - float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE))); - float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE))); + // Luma at the four direct neighbours of the current fragment. + float lumaDown = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(0, -1)).rgb); + float lumaUp = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(0, 1)).rgb); + float lumaLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, 0)).rgb); + float lumaRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, 0)).rgb); - vec2 dir; - dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE)); - dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE)); + // Find the maximum and minimum luma around the current fragment. + float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight))); + float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight))); - float dirReduce = max( - (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), - FXAA_REDUCE_MIN); + // Compute the delta. + float lumaRange = lumaMax - lumaMin; - float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce); + // If the luma variation is lower that a threshold (or if we are in a really dark area), we are not on an edge, don't perform any AA. + if (lumaRange > max(EDGE_THRESHOLD_MIN, lumaMax*EDGE_THRESHOLD_MAX)) { + // Query the 4 remaining corners lumas. + float lumaDownLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, -1)).rgb); + float lumaUpRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, 1)).rgb); + float lumaUpLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, 1)).rgb); + float lumaDownRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, -1)).rgb); - dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX), - max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), - dir * rcpDirMin)) / frameBufSize; + // Combine the four edges lumas (using intermediary variables for future computations with the same values). + float lumaDownUp = lumaDown + lumaUp; + float lumaLeftRight = lumaLeft + lumaRight; - vec3 rgbA = (1.0 / 2.0) * ( - texture2D(textureUnitPS0, texCoords.xy + dir * (1.0 / 3.0 - 0.5)).xyz + - texture2D(textureUnitPS0, texCoords.xy + dir * (2.0 / 3.0 - 0.5)).xyz); - vec3 rgbB = rgbA * (1.0 / 2.0) + (1.0 / 4.0) * ( - texture2D(textureUnitPS0, texCoords.xy + dir * (0.0 / 3.0 - 0.5)).xyz + - texture2D(textureUnitPS0, texCoords.xy + dir * (3.0 / 3.0 - 0.5)).xyz); - float lumaB = dot(rgbB, luma); + // Same for corners + float lumaLeftCorners = lumaDownLeft + lumaUpLeft; + float lumaDownCorners = lumaDownLeft + lumaDownRight; + float lumaRightCorners = lumaDownRight + lumaUpRight; + float lumaUpCorners = lumaUpRight + lumaUpLeft; - if ((lumaB < lumaMin) || (lumaB > lumaMax)) { - passPixelColor0.xyz = rgbA; - } - else { - passPixelColor0.xyz = rgbB; + // Compute an estimation of the gradient along the horizontal and vertical axis. + float edgeHorizontal = abs(-2.0 * lumaLeft + lumaLeftCorners) + abs(-2.0 * lumaCenter + lumaDownUp) * 2.0 + abs(-2.0 * lumaRight + lumaRightCorners); + float edgeVertical = abs(-2.0 * lumaUp + lumaUpCorners) + abs(-2.0 * lumaCenter + lumaLeftRight) * 2.0 + abs(-2.0 * lumaDown + lumaDownCorners); + + // Is the local edge horizontal or vertical ? + bool isHorizontal = (edgeHorizontal >= edgeVertical); + + // Select the two neighboring texels lumas in the opposite direction to the local edge. + float luma1 = isHorizontal ? lumaDown : lumaLeft; + float luma2 = isHorizontal ? lumaUp : lumaRight; + // Compute gradients in this direction. + float gradient1 = luma1 - lumaCenter; + float gradient2 = luma2 - lumaCenter; + + // Which direction is the steepest ? + bool is1Steepest = abs(gradient1) >= abs(gradient2); + + // Gradient in the corresponding direction, normalized. + float gradientScaled = 0.25*max(abs(gradient1), abs(gradient2)); + + // Choose the step size (one pixel) according to the edge direction. + float stepLength = isHorizontal ? invFramebufferSize.y : invFramebufferSize.x; + + // Average luma in the correct direction. + float lumaLocalAverage = 0.0; + + if (is1Steepest) { + // Switch the direction + stepLength = -stepLength; + lumaLocalAverage = 0.5*(luma1 + lumaCenter); + } + else { + lumaLocalAverage = 0.5*(luma2 + lumaCenter); + } + + // Shift UV in the correct direction by half a pixel. + vec2 currentUv = texCoords; + if (isHorizontal) { + currentUv.y += stepLength * 0.5; + } + else { + currentUv.x += stepLength * 0.5; + } + + // Compute offset (for each iteration step) in the right direction. + vec2 offset = isHorizontal ? vec2(invFramebufferSize.x, 0.0) : vec2(0.0, invFramebufferSize.y); + // Compute UVs to explore on each side of the edge, orthogonally. The QUALITY allows us to step faster. + vec2 uv1 = currentUv - offset; + vec2 uv2 = currentUv + offset; + + // Read the lumas at both current extremities of the exploration segment, and compute the delta wrt to the local average luma. + float lumaEnd1 = rgb2luma(texture(textureUnitPS0, uv1).rgb); + float lumaEnd2 = rgb2luma(texture(textureUnitPS0, uv2).rgb); + lumaEnd1 -= lumaLocalAverage; + lumaEnd2 -= lumaLocalAverage; + + // If the luma deltas at the current extremities are larger than the local gradient, we have reached the side of the edge. + bool reached1 = abs(lumaEnd1) >= gradientScaled; + bool reached2 = abs(lumaEnd2) >= gradientScaled; + bool reachedBoth = reached1 && reached2; + + // If the side is not reached, we continue to explore in this direction. + if (!reached1) { + uv1 -= offset; + } + if (!reached2) { + uv2 += offset; + } + + // If both sides have not been reached, continue to explore. + if (!reachedBoth) { + for (int i = 2; i < ITERATIONS; i++) { + // If needed, read luma in 1st direction, compute delta. + if (!reached1) { + lumaEnd1 = rgb2luma(texture(textureUnitPS0, uv1).rgb); + lumaEnd1 = lumaEnd1 - lumaLocalAverage; + } + // If needed, read luma in opposite direction, compute delta. + if (!reached2) { + lumaEnd2 = rgb2luma(texture(textureUnitPS0, uv2).rgb); + lumaEnd2 = lumaEnd2 - lumaLocalAverage; + } + // If the luma deltas at the current extremities is larger than the local gradient, we have reached the side of the edge. + reached1 = abs(lumaEnd1) >= gradientScaled; + reached2 = abs(lumaEnd2) >= gradientScaled; + reachedBoth = reached1 && reached2; + + // If the side is not reached, we continue to explore in this direction, with a variable quality. + if (!reached1) { + uv1 -= offset * QUALITY[i]; + } + if (!reached2) { + uv2 += offset * QUALITY[i]; + } + + // If both sides have been reached, stop the exploration. + if (reachedBoth) { break; } + } + } + + // Compute the distances to each extremity of the edge. + float distance1 = isHorizontal ? (texCoords.x - uv1.x) : (texCoords.y - uv1.y); + float distance2 = isHorizontal ? (uv2.x - texCoords.x) : (uv2.y - texCoords.y); + + // In which direction is the extremity of the edge closer ? + bool isDirection1 = distance1 < distance2; + float distanceFinal = min(distance1, distance2); + + // Length of the edge. + float edgeThickness = (distance1 + distance2); + + // UV offset: read in the direction of the closest side of the edge. + float pixelOffset = -distanceFinal / edgeThickness + 0.5; + + // Is the luma at center smaller than the local average ? + bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage; + + // If the luma at center is smaller than at its neighbour, the delta luma at each end should be positive (same variation). + // (in the direction of the closer side of the edge.) + bool correctVariation = ((isDirection1 ? lumaEnd1 : lumaEnd2) < 0.0) != isLumaCenterSmaller; + + // If the luma variation is incorrect, do not offset. + float finalOffset = correctVariation ? pixelOffset : 0.0; + + // Sub-pixel shifting + // Full weighted average of the luma over the 3x3 neighborhood. + float lumaAverage = (1.0 / 12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners); + // Ratio of the delta between the global average and the center luma, over the luma range in the 3x3 neighborhood. + float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter) / lumaRange, 0.0, 1.0); + float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1; + // Compute a sub-pixel offset based on this delta. + float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * SUBPIXEL_QUALITY; + + // Pick the biggest of the two offsets. + finalOffset = max(finalOffset, subPixelOffsetFinal); + + // Compute the final UV coordinates. + vec2 finalUv = texCoords; + if (isHorizontal) { + finalUv.y += finalOffset * stepLength; + } + else { + finalUv.x += finalOffset * stepLength; + } + + // Read the color at the new UV coordinates, and use it. + vec3 finalColor = texture(textureUnitPS0, finalUv).rgb; + passPixelColor0.rgb = finalColor; } +#endif + + passPixelColor0.a = 1.0; } -void oldmain() { - passPixelColor0 = texture(textureUnitPS0, passParameterSem2.xy); -} diff --git a/Enhancement/BreathOfTheWild_0FXAA/f14bb57cd5c9cb77_00000000000003c9_ps.txt b/Enhancement/BreathOfTheWild_0FXAA/f14bb57cd5c9cb77_00000000000003c9_ps.txt index 897b77b6..fd448f48 100644 --- a/Enhancement/BreathOfTheWild_0FXAA/f14bb57cd5c9cb77_00000000000003c9_ps.txt +++ b/Enhancement/BreathOfTheWild_0FXAA/f14bb57cd5c9cb77_00000000000003c9_ps.txt @@ -2,8 +2,32 @@ #extension GL_ARB_texture_gather : enable // shader f14bb57cd5c9cb77 //replaces broken aa everywhere with fxaa +//also includes vibrance logic from Contrasty //original shader dumped using cemu 1.9.1, BotW 1.3.1 -//credit goes to https://gist.github.com/sakrist/7912905 +//credit for fxaa implementation http://blog.simonrodriguez.fr/articles/30-07-2016_implementing_fxaa.html +//Credit to bestminr for vibrance logic + +#define ENABLE_FXAA 1 +#define ENABLE_CONTRASTY 0 + +const float EDGE_THRESHOLD_MIN = 0.04; +const float EDGE_THRESHOLD_MAX = 0.125; +const float SUBPIXEL_QUALITY = 0.5; +const float[] QUALITY = {1.5, 2.0, 2.0, 2.0, 2.0, 4.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0}; +const int ITERATIONS = 12; + +/*Gamma, exposure, vibrance and crushContrast can be modified */ +const float gamma = 0.81; // 1.0 is neutral Botw is already colour graded at this stage +const float exposure = 1.17; // 1.0 is neutral +const float vibrance = 0.008; // 0.0 is neutral +const float crushContrast = 0.004; // 0.0 is neutral. Use small increments, loss of shadow detail + +//Uncomment below and in body to scale 16-235 not recommended */ +/* +const float floor = 16.0 / 255; +const float scale = 255.0/(235.0-16.0); +*/ + uniform ivec4 uf_remappedPS[4]; layout(binding = 0) uniform sampler2D textureUnitPS0;// Tex0 addr 0xf4713800 res 1280x720x1 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 0x387f8000 res 1280x720x1 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 @@ -11,56 +35,220 @@ layout(location = 0) in vec4 passParameterSem2; layout(location = 0) out vec4 passPixelColor0; uniform vec2 uf_fragCoordScale; -const float FXAA_SPAN_MAX = 8.0; -const float FXAA_REDUCE_MUL = 1.0 / 8.0; -const float FXAA_REDUCE_MIN = 1.0 / 128.0; -const ivec2 res = textureSize(textureUnitPS0,0); -const vec2 frameBufSize = vec2( float(res.x), float(res.y) ); +float rgb2luma(vec3 rgb) { + return sqrt(dot(rgb, vec3(0.299, 0.587, 0.114))); +} void main(void) { vec2 texCoords = passParameterSem2.xy; - vec3 rgbNW = texture2D(textureUnitPS0, texCoords + (vec2(-1.0, -1.0) / frameBufSize)).xyz; - vec3 rgbNE = texture2D(textureUnitPS0, texCoords + (vec2(1.0, -1.0) / frameBufSize)).xyz; - vec3 rgbSW = texture2D(textureUnitPS0, texCoords + (vec2(-1.0, 1.0) / frameBufSize)).xyz; - vec3 rgbSE = texture2D(textureUnitPS0, texCoords + (vec2(1.0, 1.0) / frameBufSize)).xyz; - vec3 rgbM = texture2D(textureUnitPS0, texCoords).xyz; + vec3 colorCenter = texture(textureUnitPS0, texCoords).rgb; + passPixelColor0.rgb = colorCenter; - vec3 luma = vec3(0.299, 0.587, 0.114); - float lumaNW = dot(rgbNW, luma); - float lumaNE = dot(rgbNE, luma); - float lumaSW = dot(rgbSW, luma); - float lumaSE = dot(rgbSE, luma); - float lumaM = dot(rgbM, luma); +#if (ENABLE_FXAA == 1) + ivec2 texSize = textureSize(textureUnitPS0, 0); + vec2 framebufferSize = vec2(float(texSize.x), float(texSize.y)); + vec2 invFramebufferSize = vec2(1.0 / framebufferSize.x, 1.0 / framebufferSize.y); + + // Luma at the current fragment + float lumaCenter = rgb2luma(colorCenter); - float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE))); - float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE))); + // Luma at the four direct neighbours of the current fragment. + float lumaDown = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(0, -1)).rgb); + float lumaUp = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(0, 1)).rgb); + float lumaLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, 0)).rgb); + float lumaRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, 0)).rgb); - vec2 dir; - dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE)); - dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE)); + // Find the maximum and minimum luma around the current fragment. + float lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight))); + float lumaMax = max(lumaCenter, max(max(lumaDown, lumaUp), max(lumaLeft, lumaRight))); - float dirReduce = max( - (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), - FXAA_REDUCE_MIN); + // Compute the delta. + float lumaRange = lumaMax - lumaMin; - float rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce); + // If the luma variation is lower that a threshold (or if we are in a really dark area), we are not on an edge, don't perform any AA. + if (lumaRange > max(EDGE_THRESHOLD_MIN, lumaMax*EDGE_THRESHOLD_MAX)) { + // Query the 4 remaining corners lumas. + float lumaDownLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, -1)).rgb); + float lumaUpRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, 1)).rgb); + float lumaUpLeft = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(-1, 1)).rgb); + float lumaDownRight = rgb2luma(textureOffset(textureUnitPS0, texCoords, ivec2(1, -1)).rgb); - dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX), - max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), - dir * rcpDirMin)) / frameBufSize; + // Combine the four edges lumas (using intermediary variables for future computations with the same values). + float lumaDownUp = lumaDown + lumaUp; + float lumaLeftRight = lumaLeft + lumaRight; - vec3 rgbA = (1.0 / 2.0) * ( - texture2D(textureUnitPS0, texCoords.xy + dir * (1.0 / 3.0 - 0.5)).xyz + - texture2D(textureUnitPS0, texCoords.xy + dir * (2.0 / 3.0 - 0.5)).xyz); - vec3 rgbB = rgbA * (1.0 / 2.0) + (1.0 / 4.0) * ( - texture2D(textureUnitPS0, texCoords.xy + dir * (0.0 / 3.0 - 0.5)).xyz + - texture2D(textureUnitPS0, texCoords.xy + dir * (3.0 / 3.0 - 0.5)).xyz); - float lumaB = dot(rgbB, luma); + // Same for corners + float lumaLeftCorners = lumaDownLeft + lumaUpLeft; + float lumaDownCorners = lumaDownLeft + lumaDownRight; + float lumaRightCorners = lumaDownRight + lumaUpRight; + float lumaUpCorners = lumaUpRight + lumaUpLeft; - if ((lumaB < lumaMin) || (lumaB > lumaMax)) { - passPixelColor0.xyz = rgbA; + // Compute an estimation of the gradient along the horizontal and vertical axis. + float edgeHorizontal = abs(-2.0 * lumaLeft + lumaLeftCorners) + abs(-2.0 * lumaCenter + lumaDownUp) * 2.0 + abs(-2.0 * lumaRight + lumaRightCorners); + float edgeVertical = abs(-2.0 * lumaUp + lumaUpCorners) + abs(-2.0 * lumaCenter + lumaLeftRight) * 2.0 + abs(-2.0 * lumaDown + lumaDownCorners); + + // Is the local edge horizontal or vertical ? + bool isHorizontal = (edgeHorizontal >= edgeVertical); + + // Select the two neighboring texels lumas in the opposite direction to the local edge. + float luma1 = isHorizontal ? lumaDown : lumaLeft; + float luma2 = isHorizontal ? lumaUp : lumaRight; + // Compute gradients in this direction. + float gradient1 = luma1 - lumaCenter; + float gradient2 = luma2 - lumaCenter; + + // Which direction is the steepest ? + bool is1Steepest = abs(gradient1) >= abs(gradient2); + + // Gradient in the corresponding direction, normalized. + float gradientScaled = 0.25*max(abs(gradient1), abs(gradient2)); + + // Choose the step size (one pixel) according to the edge direction. + float stepLength = isHorizontal ? invFramebufferSize.y : invFramebufferSize.x; + + // Average luma in the correct direction. + float lumaLocalAverage = 0.0; + + if (is1Steepest) { + // Switch the direction + stepLength = -stepLength; + lumaLocalAverage = 0.5*(luma1 + lumaCenter); + } + else { + lumaLocalAverage = 0.5*(luma2 + lumaCenter); + } + + // Shift UV in the correct direction by half a pixel. + vec2 currentUv = texCoords; + if (isHorizontal) { + currentUv.y += stepLength * 0.5; + } + else { + currentUv.x += stepLength * 0.5; + } + + // Compute offset (for each iteration step) in the right direction. + vec2 offset = isHorizontal ? vec2(invFramebufferSize.x, 0.0) : vec2(0.0, invFramebufferSize.y); + // Compute UVs to explore on each side of the edge, orthogonally. The QUALITY allows us to step faster. + vec2 uv1 = currentUv - offset; + vec2 uv2 = currentUv + offset; + + // Read the lumas at both current extremities of the exploration segment, and compute the delta wrt to the local average luma. + float lumaEnd1 = rgb2luma(texture(textureUnitPS0, uv1).rgb); + float lumaEnd2 = rgb2luma(texture(textureUnitPS0, uv2).rgb); + lumaEnd1 -= lumaLocalAverage; + lumaEnd2 -= lumaLocalAverage; + + // If the luma deltas at the current extremities are larger than the local gradient, we have reached the side of the edge. + bool reached1 = abs(lumaEnd1) >= gradientScaled; + bool reached2 = abs(lumaEnd2) >= gradientScaled; + bool reachedBoth = reached1 && reached2; + + // If the side is not reached, we continue to explore in this direction. + if (!reached1) { + uv1 -= offset; + } + if (!reached2) { + uv2 += offset; + } + + // If both sides have not been reached, continue to explore. + if (!reachedBoth) { + for (int i = 2; i < ITERATIONS; i++) { + // If needed, read luma in 1st direction, compute delta. + if (!reached1) { + lumaEnd1 = rgb2luma(texture(textureUnitPS0, uv1).rgb); + lumaEnd1 = lumaEnd1 - lumaLocalAverage; + } + // If needed, read luma in opposite direction, compute delta. + if (!reached2) { + lumaEnd2 = rgb2luma(texture(textureUnitPS0, uv2).rgb); + lumaEnd2 = lumaEnd2 - lumaLocalAverage; + } + // If the luma deltas at the current extremities is larger than the local gradient, we have reached the side of the edge. + reached1 = abs(lumaEnd1) >= gradientScaled; + reached2 = abs(lumaEnd2) >= gradientScaled; + reachedBoth = reached1 && reached2; + + // If the side is not reached, we continue to explore in this direction, with a variable quality. + if (!reached1) { + uv1 -= offset * QUALITY[i]; + } + if (!reached2) { + uv2 += offset * QUALITY[i]; + } + + // If both sides have been reached, stop the exploration. + if (reachedBoth) { break; } + } + } + + // Compute the distances to each extremity of the edge. + float distance1 = isHorizontal ? (texCoords.x - uv1.x) : (texCoords.y - uv1.y); + float distance2 = isHorizontal ? (uv2.x - texCoords.x) : (uv2.y - texCoords.y); + + // In which direction is the extremity of the edge closer ? + bool isDirection1 = distance1 < distance2; + float distanceFinal = min(distance1, distance2); + + // Length of the edge. + float edgeThickness = (distance1 + distance2); + + // UV offset: read in the direction of the closest side of the edge. + float pixelOffset = -distanceFinal / edgeThickness + 0.5; + + // Is the luma at center smaller than the local average ? + bool isLumaCenterSmaller = lumaCenter < lumaLocalAverage; + + // If the luma at center is smaller than at its neighbour, the delta luma at each end should be positive (same variation). + // (in the direction of the closer side of the edge.) + bool correctVariation = ((isDirection1 ? lumaEnd1 : lumaEnd2) < 0.0) != isLumaCenterSmaller; + + // If the luma variation is incorrect, do not offset. + float finalOffset = correctVariation ? pixelOffset : 0.0; + + // Sub-pixel shifting + // Full weighted average of the luma over the 3x3 neighborhood. + float lumaAverage = (1.0 / 12.0) * (2.0 * (lumaDownUp + lumaLeftRight) + lumaLeftCorners + lumaRightCorners); + // Ratio of the delta between the global average and the center luma, over the luma range in the 3x3 neighborhood. + float subPixelOffset1 = clamp(abs(lumaAverage - lumaCenter) / lumaRange, 0.0, 1.0); + float subPixelOffset2 = (-2.0 * subPixelOffset1 + 3.0) * subPixelOffset1 * subPixelOffset1; + // Compute a sub-pixel offset based on this delta. + float subPixelOffsetFinal = subPixelOffset2 * subPixelOffset2 * SUBPIXEL_QUALITY; + + // Pick the biggest of the two offsets. + finalOffset = max(finalOffset, subPixelOffsetFinal); + + // Compute the final UV coordinates. + vec2 finalUv = texCoords; + if (isHorizontal) { + finalUv.y += finalOffset * stepLength; + } + else { + finalUv.x += finalOffset * stepLength; + } + + // Read the color at the new UV coordinates, and use it. + vec3 finalColor = texture(textureUnitPS0, finalUv).rgb; + passPixelColor0.rgb = finalColor; } - else { - passPixelColor0.xyz = rgbB; - } -} \ No newline at end of file +#endif + +#if (ENABLE_CONTRASTY == 1) + vec3 fColour = (passPixelColor0.xyz); + fColour = max(vec3(0.0), fColour - vec3(crushContrast)); + 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); + // vibrance + fColour = mix(fColour, mix(fColour, lightness, -vibrance), sat); + //vec3 fColour = (fColour.xyz - floor) * scale; // Not recommended 0-255->16-235.. + passPixelColor0 = vec4(fColour.x, fColour.y, fColour.z, 1.0); +#endif + + passPixelColor0.a = 1.0; +}