/// tip:"Requires MSAA off for best results" /***************************************** * FXAA 3.11 Implementation - effendiian * ------------------------------------- * FXAA implementation based off of the * work by Timothy Lottes in the Nvidia white paper: * https://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf * * Also used these resources: * - https://catlikecoding.com/unity/tutorials/advanced-rendering/fxaa/ * - https://blog.codinghorror.com/fast-approximate-anti-aliasing-fxaa/ *****************************************/ // Turn off FXAA. // #define FXAA 0 // Turn on FXAA. #define FXAA 1 // Turn on split screen between no-FXAA and FXAA. // #define FXAA 2 /* / FXAA setting, defined via preprocessor variables */ #ifndef FXAA_PRESET #define FXAA_PRESET 5 #define FXAA_DEBUG_SKIPPED 0 #define FXAA_DEBUG_PASSTHROUGH 0 #define FXAA_DEBUG_HORZVERT 0 #define FXAA_DEBUG_PAIR 0 #define FXAA_DEBUG_NEGPOS 0 #define FXAA_DEBUG_OFFSET 0 #define FXAA_DEBUG_HIGHLIGHT 0 #define FXAA_LUMINANCE 1 #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 0) #define FXAA_EDGE_THRESHOLD (1.0/4.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/12.0) #define FXAA_SEARCH_STEPS 2 #define FXAA_SEARCH_ACCELERATION 4 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 1 #define FXAA_SUBPIX_CAP (2.0/3.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 1) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/16.0) #define FXAA_SEARCH_STEPS 4 #define FXAA_SEARCH_ACCELERATION 3 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 2) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 8 #define FXAA_SEARCH_ACCELERATION 2 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 3) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 16 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 4) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 24 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 5) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 32 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #define FXAA_SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_SUBPIX_TRIM)) // -------------------------------------- // Helper functions. // -------------------------------------- // --------------------- // Conversion functions. // ToVec2 vec2 ToVec2( float value ) { return vec2(value, value); } // ToVec3 vec3 ToVec3( float value ) { return vec3(value, value, value); } vec3 ToVec3( vec2 vector, float z ) { return vec3(vector.x, vector.y, z); } vec3 ToVec3( vec2 vector ) { return ToVec3(vector, 0.0); } // ToVec4 vec4 ToVec4( vec2 vector, float z, float w ) { return vec4(vector.x, vector.y, z, w); } vec4 ToVec4( vec2 vector, float z ) { return ToVec4(vector, z, 0.0); } vec4 ToVec4( vec2 vector ) { return ToVec4(vector, 0.0); } vec4 ToVec4( vec3 vector, float w ) { return vec4(vector.x, vector.y, vector.z, w); } vec4 ToVec4( vec3 vector ) { return ToVec4(vector, 0.0); } vec4 ToVec4( float value, float w ) { return vec4(value, value, value, w); } vec4 ToVec4( float value ) { return ToVec4(value, 0.0); } // --------------------- // Texture sampler functions. // Return sampled image from a point + offset texel space. vec4 TextureOffset( sampler2D tex, vec2 uv, vec2 offset ) { // Return color from the specified location. return texture(tex, uv + offset); } // --------------------- // Grayscale functions. // Return grayscaled image based off of the selected color channel. vec3 Grayscale( vec3 color, int index ) { int selectedChannel = clamp(index, 0, 2); // [0]r, [1]g, [2]b. return ToVec3(color[selectedChannel]); } // Return grayscaled image based off of the selected color channel. vec4 Grayscale( vec4 color, int index ) { int selectedChannel = clamp(index, 0, 3); // [0]r, [1]g, [2]b, [3]a. return ToVec4(color[selectedChannel]); } // Default to green color channel when no index is supplied. vec3 Grayscale( vec3 color ) { return Grayscale(color, 1); } vec4 Grayscale( vec4 color ) { return Grayscale(color, 1); } // --------------------- // Luminance functions. // Map RGB to Luminance linearly. float LinearRGBLuminance( vec3 color ) { // Weights for relative luma from here: https://en.wikipedia.org/wiki/Luma_(video) vec3 weight = vec3(0.2126729, 0.7151522, 0.0721750); // Get the dot product: // - color.r * weight.r + color.g * weight.g + color.b * weight*b. return dot(color, weight); } // Luminance based off of the original specification. float FXAALuminance( vec3 color ) { #if FXAA_LUMINANCE == 0 return LinearRGBLuminance( color ); #else return color.g * (0.587/0.299) + color.r; #endif } // --------------------- // Vertical/Horizontal Edge Test functions. float FXAAVerticalEdge( float lumaO, float lumaN, float lumaE, float lumaS, float lumaW, float lumaNW, float lumaNE, float lumaSW, float lumaSE ) { // Slices to calculate. float top = (0.25 * lumaNW) + (-0.5 * lumaN) + (0.25 * lumaNE); float middle = (0.50 * lumaW ) + (-1.0 * lumaO) + (0.50 * lumaE ); float bottom = (0.25 * lumaSW) + (-0.5 * lumaS) + (0.25 * lumaSE); // Return value. return abs(top) + abs(middle) + abs(bottom); } float FXAAHorizontalEdge( float lumaO, float lumaN, float lumaE, float lumaS, float lumaW, float lumaNW, float lumaNE, float lumaSW, float lumaSE ) { // Slices to calculate. float top = (0.25 * lumaNW) + (-0.5 * lumaW) + (0.25 * lumaSW); float middle = (0.50 * lumaN ) + (-1.0 * lumaO) + (0.50 * lumaS ); float bottom = (0.25 * lumaNE) + (-0.5 * lumaE) + (0.25 * lumaSE); // Return value. return abs(top) + abs(middle) + abs(bottom); } // ------------------------ // FXAA specific functions. // ------------------------ // Entry point for the FXAA process. vec3 applyFXAA(sampler2D textureSource, vec2 textureDimensions, vec2 pixelPosition, vec2 screenResolution) { // Normalized pixel coordinates (from 0 to 1). vec2 uv = pixelPosition / screenResolution; // Calculate distance between pixels in texture space. vec2 texel = vec2(1.0, 1.0) / textureDimensions; // Caculate the luminance. // float luma = FXAALuminance(rgbO.xyz); // float luma = LinearRGBLuminance(clamp(rgbO.xyz, 0.0, 1.0)); //------------------------- // 1. LOCAL CONTRAST CHECK // Sample textures from cardinal directions. vec3 rgbN = TextureOffset(textureSource, uv, vec2(0, -texel.y)).rgb; // NORTH vec3 rgbW = TextureOffset(textureSource, uv, vec2(-texel.x, 0)).rgb; // WEST vec3 rgbO = TextureOffset(textureSource, uv, vec2(0, 0)).rgb; // ORIGIN vec3 rgbE = TextureOffset(textureSource, uv, vec2(texel.x, 0)).rgb; // EAST vec3 rgbS = TextureOffset(textureSource, uv, vec2(0, texel.y)).rgb; // SOUTH #if FXAA == 0 return rgbO; // Skip FXAA if it is off. #endif // Calculate the luminance for each sampled value. float lumaN = FXAALuminance(rgbN); float lumaW = FXAALuminance(rgbW); float lumaO = FXAALuminance(rgbO); float lumaE = FXAALuminance(rgbE); float lumaS = FXAALuminance(rgbS); // Calculate the minimum luma range. float minLuma = min( lumaO, min( min( lumaN, lumaW ), min( lumaS, lumaE ) ) ); float maxLuma = max( lumaO, max( max( lumaN, lumaW ), max( lumaS, lumaE ) ) ); float localContrast = maxLuma - minLuma; // Check for early exit. if(localContrast < max( FXAA_EDGE_THRESHOLD_MIN, maxLuma * FXAA_EDGE_THRESHOLD )) { #if FXAA_DEBUG_SKIPPED return vec3(0); #else return rgbO; #endif } //------------------------- // 2. SUB-PIXEL ALIASING TEST // Calculate the pixel contrast ratio. // - Sub-pixel aliasing is detected by taking the ratio of the // pixel contrast over the local contrast. This ratio nears 1.0 // in the presence of single pixel dots and otherwise falls off // towards 0.0 as more pixels contribute to an edge. This ratio // is transformed into the amount of lowpass filter to blend in // at the end of the algorithm. #if FXAA_SUBPIX > 0 // Calculate sum of local samples for the lowpass. vec3 rgbL = (rgbN + rgbW + rgbO + rgbE + rgbS); #if FXAA_SUBPIX_FASTER // Average the lowpass now since this skips the addition of the diagonal neighbors (NW, NE, SW, SE). rgbL *= (1.0/5.0); #endif // Calculate the lowpass luma. // - Lowpass luma is calculated as the average between the luma of neigboring pixels. float lumaL = (lumaN + lumaW + lumaS + lumaE) * 0.25; // Calculate the pixel contrast. // - Pixel contrast is the abs() difference between origin pixel luma and lowpass luma of neighbors. float pixelContrast = abs(lumaL - lumaO); // Remember: // - pixel contrast is the origin - lowpass(neighbors). // - local contrast is the min(origin + neighbors) - max(origin + neighbors) < threshold. // Calculate the ratio between the pixelContrast and localContrast. float contrastRatio = pixelContrast / localContrast; float lowpassBlend = 0.0; // Default is zero. Will be changed depending on subpixel level. #if FXAA_SUBPIX == 1 // Normal subpixel aliasing. Set based on FXAA algorithm for subpixel aliasing. lowpassBlend = max( 0.0, contrastRatio - FXAA_SUBPIX_TRIM ) * FXAA_SUBPIX_TRIM_SCALE; lowpassBlend = min( FXAA_SUBPIX_CAP, lowpassBlend ); #elif FXAA_SUBPIX == 2 // Full force subpixel aliasing. Set blend to ratio. lowpassBlend = contrastRatio; #endif #endif // Show selected pixels if debug mode is active. #if FXAA_DEBUG_PASSTHROUGH #if FXAA_SUBPIX > 0 return vec3(localContrast, lowpassBlend, 0.0); #else return vec3(localContrast, 0.0, 0.0); #endif #endif //------------------------- // 3. VERTICAL & HORIZONTAL EDGE TEST // Sample the additional diagonal neighbors. vec3 rgbNW = TextureOffset(textureSource, uv, vec2(-texel.x, -texel.y)).rgb; // NORTH-WEST vec3 rgbNE = TextureOffset(textureSource, uv, vec2(texel.x, -texel.y)).rgb; // NORTH-EAST vec3 rgbSW = TextureOffset(textureSource, uv, vec2(-texel.x, texel.y)).rgb; // SOUTH-WEST vec3 rgbSE = TextureOffset(textureSource, uv, vec2(texel.x, texel.y)).rgb; // SOUTH-EAST // Average additional neighbors when sub-pix aliasing is on and it isn't in 'fast' mode. #if FXAA_SUBPIX > 0 #if FXAA_SUBPIX_FASTER == 0 // Add missing neighbors and average them. rgbL += (rgbNW + rgbNE + rgbSW + rgbSE); rgbL *= (1.0/9.0); #endif #endif // Calculate luma for additional neighbors. float lumaNW = FXAALuminance(rgbNW); float lumaNE = FXAALuminance(rgbNE); float lumaSW = FXAALuminance(rgbSW); float lumaSE = FXAALuminance(rgbSE); // Calculate the vertical and horizontal edges. (Uses algorithm from FXAA white paper). float edgeVert = FXAAVerticalEdge(lumaO, lumaN, lumaE, lumaS, lumaW, lumaNW, lumaNE, lumaSW, lumaSE); float edgeHori = FXAAHorizontalEdge(lumaO, lumaN, lumaE, lumaS, lumaW, lumaNW, lumaNE, lumaSW, lumaSE); // Check if edge is horizontal. bool isHorizontal = edgeHori >= edgeVert; #if FXAA_DEBUG_HORZVERT if(isHorizontal) { return vec3(1.0, 0.75, 0.0); } else { return vec3(0.10, 0.10, 1.0); } #endif //------------------------- // 4. FIND HIGHEST CONTRAST PAIR 90deg TO EDGE // Contain the appropriate sign for the top left. float edgeSign = isHorizontal ? -texel.y : -texel.x; // Note, if isHorizontal == true, -texel.y is applied (not -texel.x). // Calculate the gradients. The luma used changes based on the horizontal edge status. float gradientNeg = isHorizontal ? abs(lumaN - lumaO) : abs(lumaW - lumaO); float gradientPos = isHorizontal ? abs(lumaS - lumaO) : abs(lumaE - lumaO); // Calculate the luma based on its direction. // It is an average of the origin and the luma in the respective direction. float lumaNeg = isHorizontal ? ((lumaN + lumaO) * 0.5) : ((lumaW + lumaO) * 0.5); float lumaPos = isHorizontal ? ((lumaS + lumaO) * 0.5) : ((lumaE + lumaO) * 0.5); // Select the highest gradient pair. bool isNegative = (gradientNeg >= gradientPos); float gradientHighest = isNegative ? gradientNeg : gradientPos; // Assign higher pair. float lumaHighest = isNegative ? lumaNeg : lumaPos; // If gradient pair in the negative direction is higher, flip the edge sign. if(isNegative) { edgeSign *= -1.0; } #if FXAA_DEBUG_PAIR return isHorizontal ? vec3(0.0, gradientHighest, lumaHighest) : vec3(0.0, lumaHighest, gradientHighest); #endif //------------------------- // 5. END-OF-EDGE SEARCH // Select starting point. vec2 pointN = vec2(0.0, 0.0); pointN.x = uv.x + (isHorizontal ? 0.0 : edgeSign * 0.5); pointN.y = uv.y + (isHorizontal ? edgeSign * 0.5 : 0.0); // Assign search limiting values. gradientHighest *= FXAA_SEARCH_THRESHOLD; // Prepare variables for search. vec2 pointP = pointN; // Start at the same point. vec2 pointOffset = isHorizontal ? vec2(texel.x, 0.0) : vec2(0.0, texel.y); float lumaNegEnd = lumaNeg; float lumaPosEnd = lumaPos; bool searchNeg = false; bool searchPos = false; // Apply values based on FXAA flags. if(FXAA_SEARCH_ACCELERATION == 1) { pointN += pointOffset * vec2(-1.0); pointP += pointOffset * vec2(1.0); // pointOffset *= vec2(1.0); } else if(FXAA_SEARCH_ACCELERATION == 2) { pointN += pointOffset * vec2(-1.5); pointP += pointOffset * vec2(1.5); pointOffset *= vec2(2.0); } else if(FXAA_SEARCH_ACCELERATION == 3) { pointN += pointOffset * vec2(-2.0); pointP += pointOffset * vec2(2.0); pointOffset *= vec2(3.0); } else if(FXAA_SEARCH_ACCELERATION == 4) { pointN += pointOffset * vec2(-2.5); pointP += pointOffset * vec2(2.5); pointOffset *= vec2(4.0); } // Perform the end-of-edge search. for(int i = 0; i < FXAA_SEARCH_STEPS; i++) { if(FXAA_SEARCH_ACCELERATION == 1) { if(!searchNeg) { lumaNegEnd = FXAALuminance(texture(textureSource, pointN).rgb); } if(!searchPos) { lumaPosEnd = FXAALuminance(texture(textureSource, pointP).rgb); } } else { if(!searchNeg) { lumaNegEnd = FXAALuminance(textureGrad(textureSource, pointN, pointOffset, pointOffset).rgb); } if(!searchPos) { lumaPosEnd = FXAALuminance(textureGrad(textureSource, pointP, pointOffset, pointOffset).rgb); } } // Search for significant change in luma compared to current highest pair. #if 0 // original searchNeg = searchNeg || (abs(lumaNegEnd - lumaNeg) >= gradientNeg); searchPos = searchPos || (abs(lumaPosEnd - lumaPos) >= gradientPos); #else // iradicator's fix searchNeg = searchNeg || (abs(lumaNegEnd - lumaHighest) >= gradientHighest); searchPos = searchPos || (abs(lumaPosEnd - lumaHighest) >= gradientHighest); #endif // Display debug information regarding edges. #if FXAA_DEBUG_NEGPOS if(searchNeg) { return vec3(abs(lumaNegEnd - gradientNeg), 0.0, 0.0); } else if(searchPos) { return vec3(0.0, 0.0, abs(lumaPosEnd - gradientPos)); } #endif // Determine if search is over early. if(searchNeg && searchPos) { break; } // If still searching, increment offset. if(!searchNeg) { pointN -= pointOffset; } if(!searchPos) { pointP += pointOffset; } } //------------------------- // 6. SUB-PIXEL SHIFT // Determine if sub-pixel center falls on positive or negative side. float distanceNeg = isHorizontal ? uv.x - pointN.x : uv.y - pointN.y; float distancePos = isHorizontal ? pointP.x - uv.x : pointP.y - uv.y; bool isCloserToNegative = distanceNeg < distancePos; // Assign respective luma. float lumaEnd = isCloserToNegative ? lumaNegEnd : lumaPosEnd; // Check if pixel is in area that receives no filtering. if( ((lumaO - lumaNeg) < 0.0) == ((lumaEnd - lumaNeg) < 0.0) ) { edgeSign = 0.0; } // Compute sub-pixel offset and filter span. float filterSpanLength = (distancePos + distanceNeg); float filterDistance = isCloserToNegative ? distanceNeg : distancePos; float subpixelOffset = ( 0.5 + ( filterDistance * (-1.0 / filterSpanLength) ) ) * edgeSign; #if FXAA_DEBUG_OFFSET if(subpixelOffset < 0.0) { return isHorizontal ? vec3(1.0, 0.0, 0.0) : vec3(1.0, 0.7, 0.1); // neg-horizontal (red) : neg-vertical (gold) } if(subpixelOffset > 0.0) { return isHorizontal ? vec3(0.0, 0.0, 1.0) : vec3(0.1, 0.3, 1.0); // pos-horizontal (blue) : pos-vertical (skyblue) } #endif // Resample using the subpixel offset. vec3 rgbOffset = textureLod(textureSource, vec2( uv.x + (isHorizontal ? 0.0 : subpixelOffset), uv.y + (isHorizontal ? subpixelOffset : 0.0)), 0.0).rgb; // return vec3((lumaN + lumaS + lumaE + lumaW + lumaNW + lumaNE + lumaSW + lumaSE) * (1.0/9.0)); #if FXAA_DEBUG_HIGHLIGHT return isHorizontal ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 1.0, 0.0); #endif // Return the FXAA effect. #if FXAA_SUBPIX == 0 return vec3(rgbOffset); #else return mix(rgbOffset, rgbL, lowpassBlend); #endif } // ------------------------ // Main function. // ------------------------ void mainImage( out vec4 fragColor, in vec2 fragCoord ) { #if (FXAA == 2) vec2 uv = fragCoord/iResolution.xy; // Normalized pixel coordinates (from 0 to 1) vec3 resultFXAA = vec3(1.0); float speed = 0.45; vec2 extents = vec2(0.1, 0.8); float divisor = ( ((sin(iTime * speed) * 0.5) + 0.5) * extents.y ) + extents.x; float increment = 0.005; float divNeg = divisor - increment; float divPos = divisor + increment; if(uv.x >= divNeg && uv.x <= divPos) { resultFXAA = vec3(0.1); } if(uv.x < divNeg) { resultFXAA = mix(texture(iChannel0, vec2(uv.x, uv.y)).xyz, vec3(0.9, 0.9, 0.9), 0.1); } if(uv.x > divPos) { resultFXAA = applyFXAA(iChannel0, iChannelResolution[0].xy, fragCoord, iResolution.xy); } #else // Calculuate the FXAA value for the whole screen. vec3 resultFXAA = applyFXAA(iChannel0, iChannelResolution[0].xy, fragCoord, iResolution.xy); #endif // Return the sampled pixel. fragColor = ToVec4(resultFXAA, 1.0); }