griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
1a93dfe4fcea17fa8bed998e0e66b94de585f6fa
test2/source/blender/draw/intern/shaders/common_fxaa_lib.glsl
Clément Foucault 7e5bc58649 GPU: Change GLSL include directive 
This changes the include directive to use the standard C preprocessor
`#include` directive.

The regex to applied to all glsl sources is:
`pragma BLENDER_REQUIRE\((\w+\.glsl)\)`
`include "$1"`

This allow C++ linter to parse the code and allow easier codebase
traversal.

However there is a small catch. While it does work like a standard
include directive when the code is treated as C++, it doesn't when
compiled by our shader backends. In this case, we still use our
dependency concatenation approach instead of file injection.

This means that included files will always be prepended when compiled
to GLSL and a file cannot be appended more than once.

This is why all GLSL lib file should have the `#pragma once` directive
and always be included at the start of the file.

These requirements are actually already enforced by our code-style
in practice.

On the implementation, the source needed to be mutated to comment
the `#pragma once` and `#include`. This is needed to avoid GLSL
compiler error out as this is an extension that not all vendor
supports.

Rel #127983
Pull Request: https://projects.blender.org/blender/blender/pulls/128076
2024-10-04 15:48:22 +02:00

865 lines
31 KiB
GLSL
Raw Blame History

/* SPDX-FileCopyrightText: 2014-2015 NVIDIA Corporation
* SPDX-FileCopyrightText: 2017-2022 Blender Authors
*
* SPDX-License-Identifier: BSD-3-Clause AND GPL-2.0-or-later */
#pragma once
/* ---------------------------------------------------------------------------------
* File: es3-kepler\FXAA/FXAA3_11.h
* SDK Version: v3.00
* Email: <gameworks@nvidia.com>
* Site: http://developer.nvidia.com/
* --------------------------------------------------------------------------------- */
/* BLENDER MODIFICATIONS:
*
* - (#B1#) Compute luma on the fly using BT. 709 luma function
* - (#B2#) main function instead of #include, due to lack of
* ARB_shading_language_include in 3.3
* - (#B3#) version and extension directives
* - removed "FXAA Console" algorithm support and shader parameters
* - removed HLSL support shims
* - (#B4#) change luma sampling to compute, not use A channel
* (this also removes GATHER4_ALPHA support)
* - removed all the console shaders (only remaining algorithm is "FXAA PC
* Quality")
*
* Note that this file doesn't follow the coding style guidelines.
*/
/*============================================================================
FXAA QUALITY - TUNING KNOBS
------------------------------------------------------------------------------
NOTE: the other tuning knobs are now in the shader function inputs!
============================================================================*/
#ifndef FXAA_QUALITY__PRESET
/*
* Choose the quality preset.
* This needs to be compiled into the shader as it effects code.
* Best option to include multiple presets is to
* in each shader define the preset, then include this file.
*
* OPTIONS
* -----------------------------------------------------------------------
* 10 to 15 - default medium dither (10=fastest, 15=highest quality)
* 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)
* 39 - no dither, very expensive
*
* NOTES
* -----------------------------------------------------------------------
* 12 = slightly faster than FXAA 3.9 and higher edge quality (default)
* 13 = about same speed as FXAA 3.9 and better than 12
* 23 = closest to FXAA 3.9 visually and performance wise
* _ = the lowest digit is directly related to performance
* _ = the highest digit is directly related to style
*/
# define FXAA_QUALITY__PRESET 12
#endif
/*============================================================================
FXAA QUALITY - PRESETS
============================================================================*/
/*============================================================================
FXAA QUALITY - MEDIUM DITHER PRESETS
============================================================================*/
#if (FXAA_QUALITY__PRESET == 10)
# define FXAA_QUALITY__PS 3
# define FXAA_QUALITY__P0 1.5
# define FXAA_QUALITY__P1 3.0
# define FXAA_QUALITY__P2 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 11)
# define FXAA_QUALITY__PS 4
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 3.0
# define FXAA_QUALITY__P3 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 12)
# define FXAA_QUALITY__PS 5
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 4.0
# define FXAA_QUALITY__P4 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 13)
# define FXAA_QUALITY__PS 6
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 4.0
# define FXAA_QUALITY__P5 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 14)
# define FXAA_QUALITY__PS 7
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 4.0
# define FXAA_QUALITY__P6 12.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 15)
# define FXAA_QUALITY__PS 8
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 4.0
# define FXAA_QUALITY__P7 12.0
#endif
/*============================================================================
FXAA QUALITY - LOW DITHER PRESETS
============================================================================*/
#if (FXAA_QUALITY__PRESET == 20)
# define FXAA_QUALITY__PS 3
# define FXAA_QUALITY__P0 1.5
# define FXAA_QUALITY__P1 2.0
# define FXAA_QUALITY__P2 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 21)
# define FXAA_QUALITY__PS 4
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 22)
# define FXAA_QUALITY__PS 5
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 23)
# define FXAA_QUALITY__PS 6
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 24)
# define FXAA_QUALITY__PS 7
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 3.0
# define FXAA_QUALITY__P6 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 25)
# define FXAA_QUALITY__PS 8
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 4.0
# define FXAA_QUALITY__P7 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 26)
# define FXAA_QUALITY__PS 9
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 2.0
# define FXAA_QUALITY__P7 4.0
# define FXAA_QUALITY__P8 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 27)
# define FXAA_QUALITY__PS 10
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 2.0
# define FXAA_QUALITY__P7 2.0
# define FXAA_QUALITY__P8 4.0
# define FXAA_QUALITY__P9 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 28)
# define FXAA_QUALITY__PS 11
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 2.0
# define FXAA_QUALITY__P7 2.0
# define FXAA_QUALITY__P8 2.0
# define FXAA_QUALITY__P9 4.0
# define FXAA_QUALITY__P10 8.0
#endif
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PRESET == 29)
# define FXAA_QUALITY__PS 12
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.5
# define FXAA_QUALITY__P2 2.0
# define FXAA_QUALITY__P3 2.0
# define FXAA_QUALITY__P4 2.0
# define FXAA_QUALITY__P5 2.0
# define FXAA_QUALITY__P6 2.0
# define FXAA_QUALITY__P7 2.0
# define FXAA_QUALITY__P8 2.0
# define FXAA_QUALITY__P9 2.0
# define FXAA_QUALITY__P10 4.0
# define FXAA_QUALITY__P11 8.0
#endif
/*============================================================================
FXAA QUALITY - EXTREME QUALITY
============================================================================*/
#if (FXAA_QUALITY__PRESET == 39)
# define FXAA_QUALITY__PS 12
# define FXAA_QUALITY__P0 1.0
# define FXAA_QUALITY__P1 1.0
# define FXAA_QUALITY__P2 1.0
# define FXAA_QUALITY__P3 1.0
# define FXAA_QUALITY__P4 1.0
# define FXAA_QUALITY__P5 1.5
# define FXAA_QUALITY__P6 2.0
# define FXAA_QUALITY__P7 2.0
# define FXAA_QUALITY__P8 2.0
# define FXAA_QUALITY__P9 2.0
# define FXAA_QUALITY__P10 4.0
# define FXAA_QUALITY__P11 8.0
#endif
#define FxaaSat(x) clamp(x, 0.0, 1.0)
#ifdef FXAA_ALPHA
# define FxaaTexTop(t, p) textureLod(t, p, 0.0).aaaa
# define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o).aaaa
# define FxaaLuma(rgba) rgba.a
#else
# define FxaaTexTop(t, p) textureLod(t, p, 0.0)
# define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)
/* (#B1#) */
float FxaaLuma(vec4 rgba)
{
/* NOTE: sqrt because the sampled colors are in a linear color-space!
* this approximates a perceptual conversion, which is good enough for the
* algorithm */
return sqrt(dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)));
}
#endif
/*============================================================================
FXAA3 QUALITY - PC
============================================================================*/
/*--------------------------------------------------------------------------*/
vec4 FxaaPixelShader(
/*
* Use no perspective interpolation here (turn off perspective interpolation).
* {xy} = center of pixel */
vec2 pos,
/*
* Input color texture.
* {rgb_} = color in linear or perceptual color space */
sampler2D tex,
/*
* Only used on FXAA Quality.
* This must be from a constant/uniform.
* {x_} = 1.0/screenWidthInPixels
* {_y} = 1.0/screenHeightInPixels */
vec2 fxaaQualityRcpFrame,
/*
* Only used on FXAA Quality.
* This used to be the FXAA_QUALITY__SUBPIX define.
* It is here now to allow easier tuning.
* Choose the amount of sub-pixel aliasing removal.
* This can effect sharpness.
* 1.00 - upper limit (softer)
* 0.75 - default amount of filtering
* 0.50 - lower limit (sharper, less sub-pixel aliasing removal)
* 0.25 - almost off
* 0.00 - completely off */
float fxaaQualitySubpix,
/*
* Only used on FXAA Quality.
* This used to be the FXAA_QUALITY__EDGE_THRESHOLD define.
* It is here now to allow easier tuning.
* The minimum amount of local contrast required to apply algorithm.
* 0.333 - too little (faster)
* 0.250 - low quality
* 0.166 - default
* 0.125 - high quality
* 0.063 - overkill (slower) */
float fxaaQualityEdgeThreshold,
/*
* Only used on FXAA Quality.
* This used to be the FXAA_QUALITY__EDGE_THRESHOLD_MIN define.
* It is here now to allow easier tuning.
* Trims the algorithm from processing darks.
* 0.0833 - upper limit (default, the start of visible unfiltered edges)
* 0.0625 - high quality (faster)
* 0.0312 - visible limit (slower) */
float fxaaQualityEdgeThresholdMin)
{
/*--------------------------------------------------------------------------*/
vec2 posM;
posM.x = pos.x;
posM.y = pos.y;
vec4 rgbyM = FxaaTexTop(tex, posM);
float lumaM = FxaaLuma(rgbyM); /* (#B4#) */
float lumaS = FxaaLuma(FxaaTexOff(tex, posM, ivec2(0, 1), fxaaQualityRcpFrame.xy));
float lumaE = FxaaLuma(FxaaTexOff(tex, posM, ivec2(1, 0), fxaaQualityRcpFrame.xy));
float lumaN = FxaaLuma(FxaaTexOff(tex, posM, ivec2(0, -1), fxaaQualityRcpFrame.xy));
float lumaW = FxaaLuma(FxaaTexOff(tex, posM, ivec2(-1, 0), fxaaQualityRcpFrame.xy));
/*--------------------------------------------------------------------------*/
float maxSM = max(lumaS, lumaM);
float minSM = min(lumaS, lumaM);
float maxESM = max(lumaE, maxSM);
float minESM = min(lumaE, minSM);
float maxWN = max(lumaN, lumaW);
float minWN = min(lumaN, lumaW);
float rangeMax = max(maxWN, maxESM);
float rangeMin = min(minWN, minESM);
float rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
float range = rangeMax - rangeMin;
float rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
bool earlyExit = range < rangeMaxClamped;
/*--------------------------------------------------------------------------*/
if (earlyExit) {
return rgbyM;
}
/*--------------------------------------------------------------------------*/
float lumaNW = FxaaLuma(FxaaTexOff(tex, posM, ivec2(-1, -1), fxaaQualityRcpFrame.xy));
float lumaSE = FxaaLuma(FxaaTexOff(tex, posM, ivec2(1, 1), fxaaQualityRcpFrame.xy));
float lumaNE = FxaaLuma(FxaaTexOff(tex, posM, ivec2(1, -1), fxaaQualityRcpFrame.xy));
float lumaSW = FxaaLuma(FxaaTexOff(tex, posM, ivec2(-1, 1), fxaaQualityRcpFrame.xy));
/*--------------------------------------------------------------------------*/
float lumaNS = lumaN + lumaS;
float lumaWE = lumaW + lumaE;
float subpixRcpRange = 1.0 / range;
float subpixNSWE = lumaNS + lumaWE;
float edgeHorz1 = (-2.0 * lumaM) + lumaNS;
float edgeVert1 = (-2.0 * lumaM) + lumaWE;
/*--------------------------------------------------------------------------*/
float lumaNESE = lumaNE + lumaSE;
float lumaNWNE = lumaNW + lumaNE;
float edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
float edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
/*--------------------------------------------------------------------------*/
float lumaNWSW = lumaNW + lumaSW;
float lumaSWSE = lumaSW + lumaSE;
float edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
float edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
float edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
float edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
float edgeHorz = abs(edgeHorz3) + edgeHorz4;
float edgeVert = abs(edgeVert3) + edgeVert4;
/*--------------------------------------------------------------------------*/
float subpixNWSWNESE = lumaNWSW + lumaNESE;
float lengthSign = fxaaQualityRcpFrame.x;
bool horzSpan = edgeHorz >= edgeVert;
float subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
/*--------------------------------------------------------------------------*/
if (!horzSpan) {
lumaN = lumaW;
}
if (!horzSpan) {
lumaS = lumaE;
}
if (horzSpan) {
lengthSign = fxaaQualityRcpFrame.y;
}
float subpixB = (subpixA * (1.0 / 12.0)) - lumaM;
/*--------------------------------------------------------------------------*/
float gradientN = lumaN - lumaM;
float gradientS = lumaS - lumaM;
float lumaNN = lumaN + lumaM;
float lumaSS = lumaS + lumaM;
bool pairN = abs(gradientN) >= abs(gradientS);
float gradient = max(abs(gradientN), abs(gradientS));
if (pairN) {
lengthSign = -lengthSign;
}
float subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
/*--------------------------------------------------------------------------*/
vec2 posB;
posB.x = posM.x;
posB.y = posM.y;
vec2 offNP;
offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
offNP.y = (horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
if (!horzSpan) {
posB.x += lengthSign * 0.5;
}
if (horzSpan) {
posB.y += lengthSign * 0.5;
}
/*--------------------------------------------------------------------------*/
vec2 posN;
posN.x = posB.x - offNP.x * FXAA_QUALITY__P0;
posN.y = posB.y - offNP.y * FXAA_QUALITY__P0;
vec2 posP;
posP.x = posB.x + offNP.x * FXAA_QUALITY__P0;
posP.y = posB.y + offNP.y * FXAA_QUALITY__P0;
float subpixD = ((-2.0) * subpixC) + 3.0;
float lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
float subpixE = subpixC * subpixC;
float lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
/*--------------------------------------------------------------------------*/
if (!pairN) {
lumaNN = lumaSS;
}
float gradientScaled = gradient * 1.0 / 4.0;
float lumaMM = lumaM - lumaNN * 0.5;
float subpixF = subpixD * subpixE;
bool lumaMLTZero = lumaMM < 0.0;
/*--------------------------------------------------------------------------*/
lumaEndN -= lumaNN * 0.5;
lumaEndP -= lumaNN * 0.5;
bool doneN = abs(lumaEndN) >= gradientScaled;
bool doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P1;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P1;
}
bool doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P1;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P1;
}
/*--------------------------------------------------------------------------*/
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P2;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P2;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P2;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P2;
}
/*--------------------------------------------------------------------------*/
#if (FXAA_QUALITY__PS > 3)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P3;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P3;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P3;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P3;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 4)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P4;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P4;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P4;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P4;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 5)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P5;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P5;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P5;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P5;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 6)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P6;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P6;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P6;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P6;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 7)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P7;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P7;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P7;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P7;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 8)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P8;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P8;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P8;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P8;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 9)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P9;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P9;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P9;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P9;
}
/*--------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 10)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P10;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P10;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P10;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P10;
}
/*-------------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 11)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P11;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P11;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P11;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P11;
}
/*-----------------------------------------------------------------------*/
# if (FXAA_QUALITY__PS > 12)
if (doneNP) {
if (!doneN) {
lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
}
if (!doneP) {
lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
}
if (!doneN) {
lumaEndN = lumaEndN - lumaNN * 0.5;
}
if (!doneP) {
lumaEndP = lumaEndP - lumaNN * 0.5;
}
doneN = abs(lumaEndN) >= gradientScaled;
doneP = abs(lumaEndP) >= gradientScaled;
if (!doneN) {
posN.x -= offNP.x * FXAA_QUALITY__P12;
}
if (!doneN) {
posN.y -= offNP.y * FXAA_QUALITY__P12;
}
doneNP = (!doneN) || (!doneP);
if (!doneP) {
posP.x += offNP.x * FXAA_QUALITY__P12;
}
if (!doneP) {
posP.y += offNP.y * FXAA_QUALITY__P12;
}
/*-----------------------------------------------------------------------*/
}
# endif
/*-------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
# endif
/*--------------------------------------------------------------------------*/
}
#endif
/*--------------------------------------------------------------------------*/
}
/*--------------------------------------------------------------------------*/
float dstN = posM.x - posN.x;
float dstP = posP.x - posM.x;
if (!horzSpan) {
dstN = posM.y - posN.y;
}
if (!horzSpan) {
dstP = posP.y - posM.y;
}
/*--------------------------------------------------------------------------*/
bool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
float spanLength = (dstP + dstN);
bool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
float spanLengthRcp = 1.0 / spanLength;
/*--------------------------------------------------------------------------*/
bool directionN = dstN < dstP;
float dst = min(dstN, dstP);
bool goodSpan = directionN ? goodSpanN : goodSpanP;
float subpixG = subpixF * subpixF;
float pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
float subpixH = subpixG * fxaaQualitySubpix;
/*--------------------------------------------------------------------------*/
float pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
float pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
if (!horzSpan) {
posM.x += pixelOffsetSubpix * lengthSign;
}
if (horzSpan) {
posM.y += pixelOffsetSubpix * lengthSign;
}
return FxaaTexTop(tex, posM);
}
/*==========================================================================*/
Reference in New Issue View Git Blame Copy Permalink